1 /*
2 * Copyright (c) 2007, Stefan Walter
3 * Copyright (c) 2013, Red Hat Inc.
4 *
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * * Redistributions of source code must retain the above
12 * copyright notice, this list of conditions and the
13 * following disclaimer.
14 * * Redistributions in binary form must reproduce the
15 * above copyright notice, this list of conditions and
16 * the following disclaimer in the documentation and/or
17 * other materials provided with the distribution.
18 * * The names of contributors to this software may not be
19 * used to endorse or promote products derived from this
20 * software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
28 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
29 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
32 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
33 * DAMAGE.
34 *
35 *
36 * CONTRIBUTORS
37 * Stef Walter <stef@memberwebs.com>
38 */
39
40 #include "config.h"
41
42 #include "attrs.h"
43 #include "buffer.h"
44 #include "constants.h"
45 #include "debug.h"
46 #include "log.h"
47 #include "p11-kit.h"
48 #include "virtual.h"
49
50 #include <sys/types.h>
51 #include <stdlib.h>
52 #include <stdio.h>
53 #include <string.h>
54 #include <errno.h>
55 #include <stdarg.h>
56
57 bool p11_log_force = false;
58 bool p11_log_output = true;
59
60 typedef struct {
61 p11_virtual virt;
62 CK_X_FUNCTION_LIST *lower;
63 p11_destroyer destroyer;
64 } LogData;
65
66 #define LOG_FLAG(buf, flags, had, flag) \
67 if ((flags & flag) == flag) { \
68 p11_buffer_add (buf, had ? " | " : " = ", 3); \
69 p11_buffer_add (buf, #flag, -1); \
70 had++; \
71 }
72
73 static void
log_CKM(p11_buffer * buf,CK_MECHANISM_TYPE v)74 log_CKM (p11_buffer *buf,
75 CK_MECHANISM_TYPE v)
76 {
77 char temp[32];
78 const char *string;
79
80 string = p11_constant_name (p11_constant_mechanisms, v);
81 if (string == NULL) {
82 snprintf (temp, sizeof (temp), "CKM_0x%08lX", v);
83 p11_buffer_add (buf, temp, -1);
84 } else {
85 p11_buffer_add (buf, string, -1);
86 }
87 }
88
89 static void
log_CKS(p11_buffer * buf,CK_STATE v)90 log_CKS (p11_buffer *buf,
91 CK_STATE v)
92 {
93 char temp[32];
94 const char *string;
95
96 string = p11_constant_name (p11_constant_states, v);
97 if (string == NULL) {
98 snprintf (temp, sizeof (temp), "CKS_0x%08lX", v);
99 p11_buffer_add (buf, temp, -1);
100 } else {
101 p11_buffer_add (buf, string, -1);
102 }
103 }
104
105 static void
log_CKU(p11_buffer * buf,CK_USER_TYPE v)106 log_CKU (p11_buffer *buf,
107 CK_USER_TYPE v)
108 {
109 char temp[32];
110 const char *string;
111
112 string = p11_constant_name (p11_constant_users, v);
113 if (string == NULL) {
114 snprintf (temp, sizeof (temp), "CKU_0x%08lX", v);
115 p11_buffer_add (buf, temp, -1);
116 } else {
117 p11_buffer_add (buf, string, -1);
118 }
119 }
120
121 static void
log_CKR(p11_buffer * buf,CK_RV v)122 log_CKR (p11_buffer *buf,
123 CK_RV v)
124 {
125 char temp[32];
126 const char *string;
127
128 string = p11_constant_name (p11_constant_returns, v);
129 if (string == NULL) {
130 snprintf (temp, sizeof (temp), "CKR_0x%08lX", v);
131 p11_buffer_add (buf, temp, -1);
132 } else {
133 p11_buffer_add (buf, string, -1);
134 }
135 }
136
137 static void
log_some_bytes(p11_buffer * buf,CK_BYTE_PTR arr,CK_ULONG num)138 log_some_bytes (p11_buffer *buf,
139 CK_BYTE_PTR arr,
140 CK_ULONG num)
141 {
142 CK_ULONG i;
143 char temp[128];
144 char *p, *e;
145 CK_BYTE ch;
146
147 if(!arr) {
148 p11_buffer_add (buf, "NULL", 4);
149 return;
150 } else if (num == (CK_ULONG)-1) {
151 p11_buffer_add (buf, "????", 4);
152 return;
153 }
154
155 temp[0] = '\"';
156 p = temp + 1;
157 e = temp + (sizeof (temp) - 8);
158
159 for(i = 0; i < num && p < e; ++i, ++p) {
160 ch = arr[i];
161 if (ch == '\t') {
162 p[0] = '\\'; p[1] = 't';
163 ++p;
164 } else if (ch == '\n') {
165 p[0] = '\\'; p[1] = 'n';
166 ++p;
167 } else if (ch == '\r') {
168 p[0] = '\\'; p[1] = 'r';
169 ++p;
170 } else if (ch >= 32 && ch < 127) {
171 *p = ch;
172 } else {
173 p[0] = '\\';
174 p[1] = 'x';
175 sprintf(p + 2, "%02X", ch);
176 p += 3;
177 }
178 }
179
180 *p = 0;
181 if (p >= e)
182 strcpy (e, "...");
183 strcat (p, "\"");
184 p11_buffer_add (buf, temp, -1);
185 }
186
187 static void
log_pointer(p11_buffer * buf,const char * pref,const char * name,CK_VOID_PTR val,CK_RV status)188 log_pointer (p11_buffer *buf,
189 const char *pref,
190 const char *name,
191 CK_VOID_PTR val,
192 CK_RV status)
193 {
194 char temp[32];
195
196 if (status != CKR_OK)
197 return;
198
199 p11_buffer_add (buf, pref, -1);
200 p11_buffer_add (buf, name, -1);
201 p11_buffer_add (buf, " = ", 3);
202 if (val == NULL) {
203 p11_buffer_add (buf, "NULL\n", 5);
204 } else {
205 snprintf (temp, sizeof (temp), "0x%08lX\n", (unsigned long)(size_t)val);
206 p11_buffer_add (buf, temp, -1);
207 }
208 }
209
210 static void
log_attribute_types(p11_buffer * buf,const char * pref,const char * name,CK_ATTRIBUTE_PTR arr,CK_ULONG num,CK_RV status)211 log_attribute_types (p11_buffer *buf,
212 const char *pref,
213 const char *name,
214 CK_ATTRIBUTE_PTR arr,
215 CK_ULONG num,
216 CK_RV status)
217 {
218 const char *string;
219 char temp[32];
220 CK_ULONG i;
221
222 if (status == CKR_BUFFER_TOO_SMALL) {
223 arr = NULL;
224 status = CKR_OK;
225 }
226 if (status != CKR_OK)
227 return;
228
229 p11_buffer_add (buf, pref, -1);
230 p11_buffer_add (buf, name, -1);
231 p11_buffer_add (buf, " = ", 3);
232 if (arr == NULL) {
233 snprintf (temp, sizeof (temp), "(%lu) NONE\n", num);
234 p11_buffer_add (buf, temp, -1);
235 } else {
236 snprintf (temp, sizeof (temp), "(%lu) [ ", num);
237 p11_buffer_add (buf, temp, -1);
238 for (i = 0; i < num; i++) {
239 if (i > 0)
240 p11_buffer_add (buf, ", ", 2);
241 string = p11_constant_name (p11_constant_types, arr[i].type);
242 if (string != NULL) {
243 p11_buffer_add (buf, string, -1);
244 } else {
245 snprintf (temp, sizeof (temp), "CKA_0x%08lX", arr[i].type);
246 p11_buffer_add (buf, temp, -1);
247 }
248 }
249
250 p11_buffer_add (buf, " ]\n", 3);
251 }
252 }
253
254 static void
log_attribute_array(p11_buffer * buf,const char * pref,const char * name,CK_ATTRIBUTE_PTR arr,CK_ULONG num,CK_RV status)255 log_attribute_array (p11_buffer *buf,
256 const char *pref,
257 const char *name,
258 CK_ATTRIBUTE_PTR arr,
259 CK_ULONG num,
260 CK_RV status)
261 {
262 char temp[32];
263
264 if (status == CKR_BUFFER_TOO_SMALL) {
265 arr = NULL;
266 status = CKR_OK;
267 }
268 if (status != CKR_OK)
269 return;
270
271 p11_buffer_add (buf, pref, -1);
272 p11_buffer_add (buf, name, -1);
273 p11_buffer_add (buf, " = ", 3);
274 if (arr == NULL) {
275 snprintf (temp, sizeof (temp), "(%lu) NONE\n", num);
276 p11_buffer_add (buf, temp, -1);
277 } else {
278 p11_attrs_format (buf, arr, num);
279 p11_buffer_add (buf, "\n", 1);
280 }
281 }
282
283 static void
log_bool(p11_buffer * buf,const char * pref,const char * name,CK_BBOOL val,CK_RV status)284 log_bool (p11_buffer *buf,
285 const char *pref,
286 const char *name,
287 CK_BBOOL val,
288 CK_RV status)
289 {
290 if (status == CKR_OK) {
291 p11_buffer_add (buf, pref, -1);
292 p11_buffer_add (buf, name, -1);
293 p11_buffer_add (buf, " = ", 3);
294 p11_buffer_add (buf, val ? "CK_TRUE" : "CK_FALSE", -1);
295 p11_buffer_add (buf, "\n", 1);
296 }
297 }
298
299 static void
log_byte_array(p11_buffer * buf,const char * pref,const char * name,CK_BYTE_PTR arr,CK_ULONG_PTR num,CK_RV status)300 log_byte_array (p11_buffer *buf,
301 const char *pref,
302 const char *name,
303 CK_BYTE_PTR arr,
304 CK_ULONG_PTR num,
305 CK_RV status)
306 {
307 char temp[32];
308
309 if (status == CKR_BUFFER_TOO_SMALL) {
310 arr = NULL;
311 status = CKR_OK;
312 }
313
314 if (status != CKR_OK)
315 return;
316 p11_buffer_add (buf, pref, -1);
317 p11_buffer_add (buf, name, -1);
318 p11_buffer_add (buf, " = ", 3);
319 if (num == NULL) {
320 p11_buffer_add (buf, "(?) NOTHING\n", -1);
321 } else if (arr == NULL) {
322 snprintf (temp, sizeof (temp), "(%lu) NOTHING\n", *num);
323 p11_buffer_add (buf, temp, -1);
324 } else {
325 snprintf (temp, sizeof (temp), "(%lu) ", *num);
326 p11_buffer_add (buf, temp, -1);
327 log_some_bytes (buf, arr, *num);
328 p11_buffer_add (buf, "\n", 1);
329 }
330 }
331
332 static void
log_info(p11_buffer * buf,const char * pref,const char * name,CK_INFO_PTR info,CK_RV status)333 log_info (p11_buffer *buf,
334 const char *pref,
335 const char *name,
336 CK_INFO_PTR info,
337 CK_RV status)
338 {
339 char temp[32];
340
341 if (status != CKR_OK)
342 return;
343 if (info == NULL) {
344 log_pointer (buf, pref, name, info, status);
345 } else {
346 p11_buffer_add (buf, pref, -1);
347 p11_buffer_add (buf, name, -1);
348 p11_buffer_add (buf, " = {\n", 5);
349 p11_buffer_add (buf, "\tcryptokiVersion: ", -1);
350 snprintf (temp, sizeof (temp), "%u.%u", (unsigned int)info->cryptokiVersion.major,
351 (unsigned int)info->cryptokiVersion.minor);
352 p11_buffer_add (buf, temp, -1);
353 p11_buffer_add (buf, "\n\tmanufacturerID: \"", -1);
354 p11_buffer_add (buf, info->manufacturerID, p11_kit_space_strlen (info->manufacturerID, sizeof (info->manufacturerID)));
355 p11_buffer_add (buf, "\"\n\tflags: ", -1);
356 snprintf (temp, sizeof (temp), "%lX", info->flags);
357 p11_buffer_add (buf, temp, -1);
358 p11_buffer_add (buf, "\n\tlibraryDescription: \"", -1);
359 p11_buffer_add (buf, info->libraryDescription, p11_kit_space_strlen (info->libraryDescription, sizeof (info->libraryDescription)));
360 p11_buffer_add (buf, "\"\n\tlibraryVersion: ", -1);
361 snprintf (temp, sizeof (temp), "%u.%u", (unsigned int)info->libraryVersion.major,
362 (unsigned int)info->libraryVersion.minor);
363 p11_buffer_add (buf, temp, -1);
364 p11_buffer_add (buf, "\n }\n", -1);
365 }
366 }
367
368 static void
log_pInitArgs(p11_buffer * buf,const char * pref,const char * name,CK_VOID_PTR pInitArgs,CK_RV status)369 log_pInitArgs (p11_buffer *buf,
370 const char *pref,
371 const char *name,
372 CK_VOID_PTR pInitArgs,
373 CK_RV status)
374 {
375 char temp[32];
376 int had = 0;
377
378 if (status != CKR_OK)
379 return;
380 if (pInitArgs == NULL)
381 log_pointer (buf, pref, name, pInitArgs, status);
382 else {
383 CK_C_INITIALIZE_ARGS *args = (CK_C_INITIALIZE_ARGS*)pInitArgs;
384 p11_buffer_add (buf, pref, -1);
385 p11_buffer_add (buf, name, -1);
386 p11_buffer_add (buf, " = {\n", 5);
387 p11_buffer_add (buf, "\tCreateMutex: ", -1);
388 snprintf (temp, sizeof (temp), "0x%08lX", (unsigned long)(size_t)args->CreateMutex);
389 p11_buffer_add (buf, temp, -1);
390 p11_buffer_add (buf, "\n\tDestroyMutex: ", -1);
391 snprintf (temp, sizeof (temp), "0x%08lX", (unsigned long)(size_t)args->DestroyMutex);
392 p11_buffer_add (buf, temp, -1);
393 p11_buffer_add (buf, "\n\tLockMutex: ", -1);
394 snprintf (temp, sizeof (temp), "0x%08lX", (unsigned long)(size_t)args->LockMutex);
395 p11_buffer_add (buf, temp, -1);
396 p11_buffer_add (buf, "\n\tUnlockMutex: ", -1);
397 snprintf (temp, sizeof (temp), "0x%08lX", (unsigned long)(size_t)args->UnlockMutex);
398 p11_buffer_add (buf, temp, -1);
399 p11_buffer_add (buf, "\n\tflags: ", -1);
400 snprintf (temp, sizeof (temp), "%lX", args->flags);
401 LOG_FLAG (buf, args->flags, had, CKF_OS_LOCKING_OK);
402 p11_buffer_add (buf, "\n\treserved: ", -1);
403 snprintf (temp, sizeof (temp), "0x%08lX", (unsigned long)(size_t)args->pReserved);
404 p11_buffer_add (buf, temp, -1);
405 p11_buffer_add (buf, "\n }\n", -1);
406 }
407 }
408
409 static void
log_mechanism_info(p11_buffer * buf,const char * pref,const char * name,CK_MECHANISM_INFO_PTR info,CK_RV status)410 log_mechanism_info (p11_buffer *buf,
411 const char *pref,
412 const char *name,
413 CK_MECHANISM_INFO_PTR info,
414 CK_RV status)
415 {
416 char temp[32];
417 int had = 0;
418
419 if (status != CKR_OK)
420 return;
421 if (info == NULL) {
422 log_pointer (buf, pref, name, info, status);
423 } else {
424 p11_buffer_add (buf, pref, -1);
425 p11_buffer_add (buf, name, -1);
426 p11_buffer_add (buf, " = {\n", 5);
427 p11_buffer_add (buf, "\tulMinKeySize: ", -1);
428 snprintf (temp, sizeof (temp), "%lu", info->ulMinKeySize);
429 p11_buffer_add (buf, temp, -1);
430 p11_buffer_add (buf, "\n\tulMaxKeySize: ", -1);
431 snprintf (temp, sizeof (temp), "%lu", info->ulMaxKeySize);
432 p11_buffer_add (buf, temp, -1);
433 p11_buffer_add (buf, "\n\tflags: ", -1);
434 snprintf (temp, sizeof (temp), "%lX", info->flags);
435 p11_buffer_add (buf, temp, -1);
436 LOG_FLAG (buf, info->flags, had, CKF_HW);
437 LOG_FLAG (buf, info->flags, had, CKF_ENCRYPT);
438 LOG_FLAG (buf, info->flags, had, CKF_DECRYPT);
439 LOG_FLAG (buf, info->flags, had, CKF_DIGEST);
440 LOG_FLAG (buf, info->flags, had, CKF_SIGN);
441 LOG_FLAG (buf, info->flags, had, CKF_SIGN_RECOVER);
442 LOG_FLAG (buf, info->flags, had, CKF_VERIFY);
443 LOG_FLAG (buf, info->flags, had, CKF_VERIFY_RECOVER);
444 LOG_FLAG (buf, info->flags, had, CKF_GENERATE);
445 LOG_FLAG (buf, info->flags, had, CKF_GENERATE_KEY_PAIR);
446 LOG_FLAG (buf, info->flags, had, CKF_WRAP);
447 LOG_FLAG (buf, info->flags, had, CKF_UNWRAP);
448 LOG_FLAG (buf, info->flags, had, CKF_DERIVE);
449 LOG_FLAG (buf, info->flags, had, CKF_EXTENSION);
450 p11_buffer_add (buf, "\n }\n", -1);
451 }
452 }
453
454 static void
log_mechanism(p11_buffer * buf,const char * pref,const char * name,CK_MECHANISM_PTR mech,CK_RV status)455 log_mechanism (p11_buffer *buf,
456 const char *pref,
457 const char *name,
458 CK_MECHANISM_PTR mech,
459 CK_RV status)
460 {
461 char temp[32];
462
463 if (status != CKR_OK)
464 return;
465 p11_buffer_add (buf, pref, -1);
466 p11_buffer_add (buf, name, -1);
467 p11_buffer_add (buf, " = {\n", 5);
468 p11_buffer_add (buf, "\tmechanism: ", -1);
469 log_CKM (buf, mech->mechanism);
470 p11_buffer_add (buf, "\n\tpParameter: ", -1);
471 snprintf (temp, sizeof (temp), "(%lu) ", mech->ulParameterLen);
472 p11_buffer_add (buf, temp, -1);
473 log_some_bytes (buf, mech->pParameter, mech->ulParameterLen);
474 p11_buffer_add (buf, "\n }\n", -1);
475 }
476
477 static void
log_mechanism_type(p11_buffer * buf,const char * pref,const char * name,CK_MECHANISM_TYPE val,CK_RV status)478 log_mechanism_type (p11_buffer *buf,
479 const char *pref,
480 const char *name,
481 CK_MECHANISM_TYPE val,
482 CK_RV status)
483 {
484 if (status != CKR_OK)
485 return;
486 p11_buffer_add (buf, pref, -1);
487 p11_buffer_add (buf, name, -1);
488 p11_buffer_add (buf, " = ", 3);
489 log_CKM (buf, val);
490 p11_buffer_add (buf, "\n", 1);
491 }
492
493 static void
log_mechanism_type_array(p11_buffer * buf,const char * pref,const char * name,CK_MECHANISM_TYPE_PTR arr,CK_ULONG_PTR num,CK_RV status)494 log_mechanism_type_array (p11_buffer *buf,
495 const char *pref,
496 const char *name,
497 CK_MECHANISM_TYPE_PTR arr,
498 CK_ULONG_PTR num,
499 CK_RV status)
500 {
501 char temp[32];
502 CK_ULONG i;
503
504 if (status == CKR_BUFFER_TOO_SMALL) {
505 arr = NULL;
506 status = CKR_OK;
507 }
508 if (status != CKR_OK)
509 return;
510
511 p11_buffer_add (buf, pref, -1);
512 p11_buffer_add (buf, name, -1);
513 p11_buffer_add (buf, " = ", 3);
514 if (num == NULL) {
515 p11_buffer_add (buf, "(?) NO-VALUES\n", -1);
516 } else if (arr == NULL) {
517 snprintf (temp, sizeof (temp), "(%lu) NO-VALUES\n", *num);
518 p11_buffer_add (buf, temp, -1);
519 } else {
520 snprintf (temp, sizeof (temp), "(%lu) [ ", *num);
521 p11_buffer_add (buf, temp, -1);
522 for(i = 0; i < *num; ++i) {
523 if (i > 0)
524 p11_buffer_add (buf, ", ", 2);
525 log_CKM (buf, arr[i]);
526 }
527 p11_buffer_add (buf, " ]\n", 3);
528 }
529 }
530
531 static void
log_session_info(p11_buffer * buf,const char * pref,const char * name,CK_SESSION_INFO_PTR info,CK_RV status)532 log_session_info (p11_buffer *buf,
533 const char *pref,
534 const char *name,
535 CK_SESSION_INFO_PTR info,
536 CK_RV status)
537 {
538 char temp[32];
539 int had = 0;
540
541 if (status != CKR_OK)
542 return;
543 if (info == NULL) {
544 log_pointer (buf, pref, name, info, status);
545 } else {
546 p11_buffer_add (buf, pref, -1);
547 p11_buffer_add (buf, name, -1);
548 p11_buffer_add (buf, " = {\n", 5);
549 p11_buffer_add (buf, "\tslotID: ", -1);
550 snprintf (temp, sizeof (temp), "SL%lu", info->slotID);
551 p11_buffer_add (buf, temp, -1);
552 p11_buffer_add (buf, "\n\tstate: ", -1);
553 log_CKS (buf, info->state);
554 p11_buffer_add (buf, "\n\tflags: ", -1);
555 snprintf (temp, sizeof (temp), "%lX", info->flags);
556 p11_buffer_add (buf, temp, -1);
557 LOG_FLAG (buf, info->flags, had, CKF_SERIAL_SESSION);
558 LOG_FLAG (buf, info->flags, had, CKF_RW_SESSION);
559 p11_buffer_add (buf, "\n\tulDeviceError: ", -1);
560 snprintf (temp, sizeof (temp), "%lu", info->ulDeviceError);
561 p11_buffer_add (buf, temp, -1);
562 p11_buffer_add (buf, "\n }\n", -1);
563 }
564 }
565
566 static void
log_slot_info(p11_buffer * buf,const char * pref,const char * name,CK_SLOT_INFO_PTR info,CK_RV status)567 log_slot_info (p11_buffer *buf,
568 const char *pref,
569 const char *name,
570 CK_SLOT_INFO_PTR info,
571 CK_RV status)
572 {
573 char temp[32];
574 int had = 0;
575
576 if (status != CKR_OK)
577 return;
578 if (info == NULL) {
579 log_pointer (buf, pref, name, info, status);
580 } else {
581 p11_buffer_add (buf, pref, -1);
582 p11_buffer_add (buf, name, -1);
583 p11_buffer_add (buf, " = {\n", 5);
584 p11_buffer_add (buf, "\tslotDescription: \"", -1);
585 p11_buffer_add (buf, info->slotDescription, p11_kit_space_strlen (info->slotDescription, sizeof (info->slotDescription)));
586 p11_buffer_add (buf, "\"\n\tmanufacturerID: \"", -1);
587 p11_buffer_add (buf, info->manufacturerID, p11_kit_space_strlen (info->manufacturerID, sizeof (info->manufacturerID)));
588 p11_buffer_add (buf, "\"\n\tflags: ", -1);
589 snprintf (temp, sizeof (temp), "%lu", info->flags);
590 p11_buffer_add (buf, temp, -1);
591 LOG_FLAG (buf, info->flags, had, CKF_TOKEN_PRESENT);
592 LOG_FLAG (buf, info->flags, had, CKF_REMOVABLE_DEVICE);
593 LOG_FLAG (buf, info->flags, had, CKF_HW_SLOT);
594 p11_buffer_add (buf, "\n\thardwareVersion: ", -1);
595 snprintf (temp, sizeof (temp), "%u.%u", (unsigned int)info->hardwareVersion.major,
596 (unsigned int)info->hardwareVersion.minor);
597 p11_buffer_add (buf, temp, -1);
598 p11_buffer_add (buf, "\n\tfirmwareVersion: ", -1);
599 snprintf (temp, sizeof (temp), "%u.%u", (unsigned int)info->firmwareVersion.major,
600 (unsigned int)info->firmwareVersion.minor);
601 p11_buffer_add (buf, temp, -1);
602 p11_buffer_add (buf, "\n }\n", -1);
603 }
604 }
605
606 static void
log_string(p11_buffer * buf,const char * pref,const char * name,CK_UTF8CHAR_PTR str,const CK_RV status)607 log_string (p11_buffer *buf,
608 const char *pref,
609 const char *name,
610 CK_UTF8CHAR_PTR str,
611 const CK_RV status)
612 {
613 if (status != CKR_OK)
614 return;
615 if (str == NULL) {
616 log_pointer (buf, pref, name, str, status);
617 } else {
618 p11_buffer_add (buf, pref, -1);
619 p11_buffer_add (buf, name, -1);
620 p11_buffer_add (buf, " = \"", 4);
621 p11_buffer_add (buf, str, -1);
622 p11_buffer_add (buf, "\"\n", 2);
623 }
624 }
625
626 static void
log_token_number(p11_buffer * buf,CK_ULONG number)627 log_token_number (p11_buffer *buf,
628 CK_ULONG number)
629 {
630 char temp[32];
631
632 if (number == 0) {
633 p11_buffer_add (buf, "CK_UNAVAILABLE_INFORMATION", -1);
634 } else if (number == (CK_ULONG)-1) {
635 p11_buffer_add (buf, "CK_EFFECTIVELY_INFINITE", -1);
636 } else {
637 snprintf (temp, sizeof (temp), "%lu", number);
638 p11_buffer_add (buf, temp, -1);
639 }
640 }
641
642 static void
log_token_info(p11_buffer * buf,const char * pref,const char * name,CK_TOKEN_INFO_PTR info,CK_RV status)643 log_token_info (p11_buffer *buf,
644 const char *pref,
645 const char *name,
646 CK_TOKEN_INFO_PTR info,
647 CK_RV status)
648 {
649 char temp[32];
650 int had = 0;
651
652 if (status != CKR_OK)
653 return;
654 if (info == NULL) {
655 log_pointer (buf, pref, name, info, status);
656 } else {
657 p11_buffer_add (buf, pref, -1);
658 p11_buffer_add (buf, name, -1);
659 p11_buffer_add (buf, " = {\n", 5);
660 p11_buffer_add (buf, "\tlabel: \"", -1);
661 p11_buffer_add (buf, info->label, p11_kit_space_strlen (info->label, sizeof (info->label)));
662 p11_buffer_add (buf, "\"\n\tmanufacturerID: \"", -1);
663 p11_buffer_add (buf, info->manufacturerID, p11_kit_space_strlen (info->manufacturerID, sizeof (info->manufacturerID)));
664 p11_buffer_add (buf, "\"\n\tmodel: \"", -1);
665 p11_buffer_add (buf, info->model, p11_kit_space_strlen (info->model, sizeof (info->model)));
666 p11_buffer_add (buf, "\"\n\tserialNumber: \"", -1);
667 p11_buffer_add (buf, info->serialNumber, p11_kit_space_strlen (info->serialNumber, sizeof (info->serialNumber)));
668 p11_buffer_add (buf, "\"\n\tflags: ", -1);
669 snprintf (temp, sizeof (temp), "%lu", info->flags);
670 p11_buffer_add (buf, temp, -1);
671 LOG_FLAG (buf, info->flags, had, CKF_RNG);
672 LOG_FLAG (buf, info->flags, had, CKF_WRITE_PROTECTED);
673 LOG_FLAG (buf, info->flags, had, CKF_LOGIN_REQUIRED);
674 LOG_FLAG (buf, info->flags, had, CKF_USER_PIN_INITIALIZED);
675 LOG_FLAG (buf, info->flags, had, CKF_RESTORE_KEY_NOT_NEEDED);
676 LOG_FLAG (buf, info->flags, had, CKF_CLOCK_ON_TOKEN);
677 LOG_FLAG (buf, info->flags, had, CKF_PROTECTED_AUTHENTICATION_PATH);
678 LOG_FLAG (buf, info->flags, had, CKF_DUAL_CRYPTO_OPERATIONS);
679 LOG_FLAG (buf, info->flags, had, CKF_TOKEN_INITIALIZED);
680 LOG_FLAG (buf, info->flags, had, CKF_SECONDARY_AUTHENTICATION);
681 LOG_FLAG (buf, info->flags, had, CKF_USER_PIN_COUNT_LOW);
682 LOG_FLAG (buf, info->flags, had, CKF_USER_PIN_FINAL_TRY);
683 LOG_FLAG (buf, info->flags, had, CKF_USER_PIN_LOCKED);
684 LOG_FLAG (buf, info->flags, had, CKF_USER_PIN_TO_BE_CHANGED);
685 LOG_FLAG (buf, info->flags, had, CKF_SO_PIN_COUNT_LOW);
686 LOG_FLAG (buf, info->flags, had, CKF_SO_PIN_FINAL_TRY);
687 LOG_FLAG (buf, info->flags, had, CKF_SO_PIN_LOCKED);
688 LOG_FLAG (buf, info->flags, had, CKF_SO_PIN_TO_BE_CHANGED);
689 if (!had) {
690 snprintf (temp, sizeof (temp), "%lu", info->flags);
691 p11_buffer_add (buf, temp, -1);
692 }
693
694 p11_buffer_add (buf, "\n\tulMaxSessionCount: ", -1);
695 log_token_number (buf, info->ulMaxSessionCount);
696 p11_buffer_add (buf, "\n\tulSessionCount: ", -1);
697 snprintf (temp, sizeof (temp), "%lu", info->ulSessionCount);
698 p11_buffer_add (buf, temp, -1);
699 p11_buffer_add (buf, "\n\tulMaxRwSessionCount: ", -1);
700 log_token_number (buf, info->ulMaxSessionCount);
701 p11_buffer_add (buf, "\n\tulRwSessionCount: ", -1);
702 snprintf (temp, sizeof (temp), "%lu", info->ulRwSessionCount);
703 p11_buffer_add (buf, temp, -1);
704 p11_buffer_add (buf, "\n\tulMaxPinLen: ", -1);
705 snprintf (temp, sizeof (temp), "%lu", info->ulMaxPinLen);
706 p11_buffer_add (buf, temp, -1);
707 p11_buffer_add (buf, "\n\tulMinPinLen: ", -1);
708 snprintf (temp, sizeof (temp), "%lu", info->ulMinPinLen);
709 p11_buffer_add (buf, temp, -1);
710 p11_buffer_add (buf, "\n\tulTotalPublicMemory: ", -1);
711 log_token_number (buf, info->ulMaxSessionCount);
712 p11_buffer_add (buf, "\n\tulFreePublicMemory: ", -1);
713 log_token_number (buf, info->ulMaxSessionCount);
714 p11_buffer_add (buf, "\n\tulTotalPrivateMemory: ", -1);
715 log_token_number (buf, info->ulMaxSessionCount);
716 p11_buffer_add (buf, "\n\tulFreePrivateMemory: ", -1);
717 log_token_number (buf, info->ulMaxSessionCount);
718 p11_buffer_add (buf, "\n\tulFreePrivateMemory: ", -1);
719 log_token_number (buf, info->ulMaxSessionCount);
720 p11_buffer_add (buf, "\n\thardwareVersion: ", -1);
721 snprintf (temp, sizeof (temp), "%u.%u", (unsigned int)info->hardwareVersion.major,
722 (unsigned int)info->hardwareVersion.minor);
723 p11_buffer_add (buf, temp, -1);
724 p11_buffer_add (buf, "\n\tfirmwareVersion: ", -1);
725 snprintf (temp, sizeof (temp), "%u.%u", (unsigned int)info->firmwareVersion.major,
726 (unsigned int)info->firmwareVersion.minor);
727 p11_buffer_add (buf, temp, -1);
728 p11_buffer_add (buf, "\n\tutcTime: ", -1);
729 p11_buffer_add (buf, (info->flags & CKF_CLOCK_ON_TOKEN) ? (const char*)info->utcTime : "", sizeof (info->utcTime));
730 p11_buffer_add (buf, "\n }\n", -1);
731 }
732 }
733
734 static void
log_ulong(p11_buffer * buf,const char * pref,const char * name,CK_ULONG val,const char * npref,CK_RV status)735 log_ulong (p11_buffer *buf,
736 const char *pref,
737 const char *name,
738 CK_ULONG val,
739 const char* npref,
740 CK_RV status)
741 {
742 char temp[32];
743
744 if (!npref)
745 npref = "";
746 if (status == CKR_OK) {
747 p11_buffer_add (buf, pref, -1);
748 p11_buffer_add (buf, name, -1);
749 p11_buffer_add (buf, " = ", 3);
750 p11_buffer_add (buf, npref, -1);
751 snprintf (temp, sizeof (temp), "%lu", val);
752 p11_buffer_add (buf, temp, -1);
753 p11_buffer_add (buf, "\n", 1);
754 }
755 }
756
757 static void
log_ulong_array(p11_buffer * buf,const char * pref,const char * name,CK_ULONG_PTR arr,CK_ULONG_PTR num,const char * npref,CK_RV status)758 log_ulong_array (p11_buffer *buf,
759 const char *pref,
760 const char *name,
761 CK_ULONG_PTR arr,
762 CK_ULONG_PTR num,
763 const char *npref,
764 CK_RV status)
765 {
766 char temp[32];
767 CK_ULONG i;
768
769 if (status == CKR_BUFFER_TOO_SMALL) {
770 arr = NULL;
771 status = CKR_OK;
772 }
773
774 if (status != CKR_OK)
775 return;
776 if (npref == NULL)
777 npref = "";
778 p11_buffer_add (buf, pref, -1);
779 p11_buffer_add (buf, name, -1);
780 p11_buffer_add (buf, " = ", 3);
781 if (num == NULL) {
782 p11_buffer_add (buf, "(?) NO-VALUES\n", -1);
783 } else if (arr == NULL) {
784 snprintf (temp, sizeof (temp), "(%lu) NO-VALUES\n", *num);
785 p11_buffer_add (buf, temp, -1);
786 } else {
787 snprintf (temp, sizeof (temp), "(%lu) [ ", *num);
788 p11_buffer_add (buf, temp, -1);
789 for (i = 0; i < *num; ++i) {
790 if (i > 0)
791 p11_buffer_add (buf, ", ", 2);
792 p11_buffer_add (buf, npref, -1);
793 snprintf (temp, sizeof (temp), "%lu", arr[i]);
794 p11_buffer_add (buf, temp, -1);
795 }
796 p11_buffer_add (buf, " ]\n", 3);
797 }
798 }
799
800 static void
log_ulong_pointer(p11_buffer * buf,const char * pref,const char * name,CK_ULONG_PTR val,const char * npref,CK_RV status)801 log_ulong_pointer (p11_buffer *buf,
802 const char *pref,
803 const char *name,
804 CK_ULONG_PTR val,
805 const char *npref,
806 CK_RV status)
807 {
808 char temp[32];
809
810 if (status != CKR_OK)
811 return;
812 if (npref == NULL)
813 npref = "";
814 p11_buffer_add (buf, pref, -1);
815 p11_buffer_add (buf, name, -1);
816 p11_buffer_add (buf, " = ", 3);
817 if (val == NULL) {
818 p11_buffer_add (buf, "NULL\n", 5);
819 } else {
820 snprintf (temp, sizeof (temp), "0x%08lX", (unsigned long)(size_t)val);
821 p11_buffer_add (buf, temp, -1);
822 p11_buffer_add (buf, " = ", 3);
823 p11_buffer_add (buf, npref, -1);
824 snprintf (temp, sizeof (temp), "%lu", *val);
825 p11_buffer_add (buf, temp, -1);
826 p11_buffer_add (buf, "\n", 1);
827 }
828 }
829
830 static void
log_user_type(p11_buffer * buf,const char * pref,const char * name,CK_USER_TYPE val,CK_RV status)831 log_user_type (p11_buffer *buf,
832 const char *pref,
833 const char *name,
834 CK_USER_TYPE val,
835 CK_RV status)
836 {
837 if (status != CKR_OK)
838 return;
839 p11_buffer_add (buf, pref, -1);
840 p11_buffer_add (buf, name, -1);
841 p11_buffer_add (buf, " = ", 3);
842 log_CKU (buf, val);
843 p11_buffer_add (buf, "\n", 1);
844 }
845
846 static void
flush_buffer(p11_buffer * buf)847 flush_buffer (p11_buffer *buf)
848 {
849 if (p11_log_output) {
850 fwrite (buf->data, 1, buf->len, stderr);
851 fflush (stderr);
852 }
853 p11_buffer_reset (buf, 128);
854 }
855
856 #define BEGIN_CALL(name) \
857 { \
858 LogData *_log = (LogData *)self; \
859 const char* _name = "C_" #name; \
860 p11_buffer _buf; \
861 CK_X_##name _func = _log->lower->C_##name; \
862 CK_RV _ret = CKR_OK; \
863 p11_buffer_init_null (&_buf, 128); \
864 return_val_if_fail (_func != NULL, CKR_DEVICE_ERROR); \
865 p11_buffer_add (&_buf, _name, -1); \
866 p11_buffer_add (&_buf, "\n", 1); \
867 self = _log->lower;
868
869 #define PROCESS_CALL(args) \
870 flush_buffer (&_buf); \
871 _ret = (_func) args;
872
873 #define DONE_CALL \
874 p11_buffer_add (&_buf, _name, -1); \
875 p11_buffer_add (&_buf, " = ", 3); \
876 log_CKR (&_buf, _ret); \
877 p11_buffer_add (&_buf, "\n", 1); \
878 flush_buffer (&_buf); \
879 p11_buffer_uninit (&_buf); \
880 return _ret; \
881 }
882
883 #define LIN " IN: "
884 #define LOUT " OUT: "
885
886 #define IN_ATTRIBUTE_ARRAY(a, n) \
887 log_attribute_types (&_buf, LIN, #a, a, n, CKR_OK);
888
889 #define IN_BOOL(a) \
890 log_bool (&_buf, LIN, #a, a, CKR_OK);
891
892 #define IN_BYTE_ARRAY(a, n) \
893 log_byte_array (&_buf, LIN, #a, a, &n, CKR_OK);
894
895 #define IN_HANDLE(a) \
896 log_ulong (&_buf, LIN, #a, a, "H", CKR_OK);
897
898 #define IN_INIT_ARGS(a) \
899 log_pInitArgs (&_buf, LIN, #a, a, CKR_OK);
900
901 #define IN_POINTER(a) \
902 log_pointer (&_buf, LIN, #a, a, CKR_OK);
903
904 #define IN_MECHANISM(a) \
905 log_mechanism (&_buf, LIN, #a, a, CKR_OK);
906
907 #define IN_MECHANISM_TYPE(a) \
908 log_mechanism_type (&_buf, LIN, #a, a, CKR_OK);
909
910 #define IN_SESSION(a) \
911 log_ulong (&_buf, LIN, #a, a, "S", CKR_OK);
912
913 #define IN_SLOT_ID(a) \
914 log_ulong (&_buf, LIN, #a, a, "SL", CKR_OK);
915
916 #define IN_STRING(a) \
917 log_string (&_buf, LIN, #a, a, CKR_OK);
918
919 #define IN_ULONG(a) \
920 log_ulong (&_buf, LIN, #a, a, NULL, CKR_OK);
921
922 #define IN_ULONG_PTR(a) \
923 log_ulong_pointer (&_buf, LIN, #a, a, NULL, CKR_OK);
924
925 #define IN_USER_TYPE(a) \
926 log_user_type (&_buf, LIN, #a, a, CKR_OK);
927
928 #define OUT_ATTRIBUTE_ARRAY(a, n) \
929 log_attribute_array (&_buf, LOUT, #a, a, n, _ret);
930
931 #define OUT_BYTE_ARRAY(a, n) \
932 log_byte_array(&_buf, LOUT, #a, a, n, _ret);
933
934 #define OUT_HANDLE(a) \
935 log_ulong_pointer (&_buf, LOUT, #a, a, "H", _ret);
936
937 #define OUT_HANDLE_ARRAY(a, n) \
938 log_ulong_array (&_buf, LOUT, #a, a, n, "H", _ret);
939
940 #define OUT_INFO(a) \
941 log_info (&_buf, LOUT, #a, a, _ret);
942
943 #define OUT_MECHANISM_INFO(a) \
944 log_mechanism_info (&_buf, LOUT, #a, a, _ret);
945
946 #define OUT_MECHANISM_TYPE_ARRAY(a, n) \
947 log_mechanism_type_array (&_buf, LOUT, #a, a, n, _ret);
948
949 #define OUT_POINTER(a) \
950 log_pointer (&_buf, LOUT, #a, a, _ret);
951
952 #define OUT_SESSION(a) \
953 log_ulong_pointer (&_buf, LOUT, #a, a, "S", _ret);
954
955 #define OUT_SESSION_INFO(a) \
956 log_session_info (&_buf, LOUT, #a, a, _ret);
957
958 #define OUT_SLOT_ID_ARRAY(a, n) \
959 log_ulong_array (&_buf, LOUT, #a, a, n, "SL", _ret);
960
961 #define OUT_SLOT_ID(a) \
962 log_ulong_pointer (&_buf, LOUT, #a, a, "SL", _ret);
963
964 #define OUT_SLOT_INFO(a) \
965 log_slot_info (&_buf, LOUT, #a, a, _ret);
966
967 #define OUT_TOKEN_INFO(a) \
968 log_token_info (&_buf, LOUT, #a, a, _ret);
969
970 #define OUT_ULONG(a) \
971 log_ulong_pointer (&_buf, LOUT, #a, a, NULL, _ret);
972
973 #define OUT_ULONG_ARRAY(a, n) \
974 log_ulong_array (&_buf, LOUT, #a, a, n, NULL, _ret);
975
976
977
978 /* ---------------------------------------------------------------- */
979
980 static CK_RV
log_C_Initialize(CK_X_FUNCTION_LIST * self,CK_VOID_PTR pInitArgs)981 log_C_Initialize (CK_X_FUNCTION_LIST *self,
982 CK_VOID_PTR pInitArgs)
983 {
984 BEGIN_CALL (Initialize)
985 IN_INIT_ARGS (pInitArgs)
986 PROCESS_CALL ((self, pInitArgs))
987 DONE_CALL
988 }
989
990 static CK_RV
log_C_Finalize(CK_X_FUNCTION_LIST * self,CK_VOID_PTR pReserved)991 log_C_Finalize (CK_X_FUNCTION_LIST *self,
992 CK_VOID_PTR pReserved)
993 {
994 BEGIN_CALL (Finalize)
995 IN_POINTER (pReserved)
996 PROCESS_CALL ((self, pReserved))
997 DONE_CALL
998 }
999
1000 static CK_RV
log_C_GetInfo(CK_X_FUNCTION_LIST * self,CK_INFO_PTR pInfo)1001 log_C_GetInfo (CK_X_FUNCTION_LIST *self,
1002 CK_INFO_PTR pInfo)
1003 {
1004 BEGIN_CALL (GetInfo)
1005 PROCESS_CALL ((self, pInfo))
1006 OUT_INFO (pInfo)
1007 DONE_CALL
1008 }
1009
1010 static CK_RV
log_C_GetSlotList(CK_X_FUNCTION_LIST * self,CK_BBOOL tokenPresent,CK_SLOT_ID_PTR pSlotList,CK_ULONG_PTR pulCount)1011 log_C_GetSlotList (CK_X_FUNCTION_LIST *self,
1012 CK_BBOOL tokenPresent,
1013 CK_SLOT_ID_PTR pSlotList,
1014 CK_ULONG_PTR pulCount)
1015 {
1016 BEGIN_CALL (GetSlotList)
1017 IN_BOOL (tokenPresent)
1018 IN_ULONG_PTR (pulCount)
1019 PROCESS_CALL ((self, tokenPresent, pSlotList, pulCount))
1020 OUT_SLOT_ID_ARRAY (pSlotList, pulCount)
1021 DONE_CALL
1022 }
1023
1024 static CK_RV
log_C_GetSlotInfo(CK_X_FUNCTION_LIST * self,CK_SLOT_ID slotID,CK_SLOT_INFO_PTR pInfo)1025 log_C_GetSlotInfo (CK_X_FUNCTION_LIST *self,
1026 CK_SLOT_ID slotID,
1027 CK_SLOT_INFO_PTR pInfo)
1028 {
1029 BEGIN_CALL (GetSlotInfo)
1030 IN_SLOT_ID (slotID)
1031 PROCESS_CALL ((self, slotID, pInfo))
1032 OUT_SLOT_INFO (pInfo)
1033 DONE_CALL
1034 }
1035
1036 static CK_RV
log_C_GetTokenInfo(CK_X_FUNCTION_LIST * self,CK_SLOT_ID slotID,CK_TOKEN_INFO_PTR pInfo)1037 log_C_GetTokenInfo (CK_X_FUNCTION_LIST *self,
1038 CK_SLOT_ID slotID,
1039 CK_TOKEN_INFO_PTR pInfo)
1040 {
1041 BEGIN_CALL (GetTokenInfo)
1042 IN_SLOT_ID (slotID)
1043 PROCESS_CALL ((self, slotID, pInfo))
1044 OUT_TOKEN_INFO (pInfo)
1045 DONE_CALL
1046 }
1047
1048 static CK_RV
log_C_GetMechanismList(CK_X_FUNCTION_LIST * self,CK_SLOT_ID slotID,CK_MECHANISM_TYPE_PTR pMechanismList,CK_ULONG_PTR pulCount)1049 log_C_GetMechanismList (CK_X_FUNCTION_LIST *self,
1050 CK_SLOT_ID slotID,
1051 CK_MECHANISM_TYPE_PTR pMechanismList,
1052 CK_ULONG_PTR pulCount)
1053 {
1054 BEGIN_CALL (GetMechanismList)
1055 IN_SLOT_ID (slotID)
1056 IN_ULONG_PTR (pulCount)
1057 PROCESS_CALL ((self, slotID, pMechanismList, pulCount))
1058 OUT_MECHANISM_TYPE_ARRAY (pMechanismList, pulCount)
1059 DONE_CALL
1060 }
1061
1062 static CK_RV
log_C_GetMechanismInfo(CK_X_FUNCTION_LIST * self,CK_SLOT_ID slotID,CK_MECHANISM_TYPE type,CK_MECHANISM_INFO_PTR pInfo)1063 log_C_GetMechanismInfo (CK_X_FUNCTION_LIST *self,
1064 CK_SLOT_ID slotID,
1065 CK_MECHANISM_TYPE type,
1066 CK_MECHANISM_INFO_PTR pInfo)
1067 {
1068 BEGIN_CALL (GetMechanismInfo)
1069 IN_SLOT_ID (slotID)
1070 IN_MECHANISM_TYPE (type)
1071 PROCESS_CALL ((self, slotID, type, pInfo))
1072 OUT_MECHANISM_INFO (pInfo)
1073 DONE_CALL
1074 }
1075
1076 static CK_RV
log_C_InitToken(CK_X_FUNCTION_LIST * self,CK_SLOT_ID slotID,CK_UTF8CHAR_PTR pPin,CK_ULONG ulPinLen,CK_UTF8CHAR_PTR pLabel)1077 log_C_InitToken (CK_X_FUNCTION_LIST *self,
1078 CK_SLOT_ID slotID,
1079 CK_UTF8CHAR_PTR pPin,
1080 CK_ULONG ulPinLen,
1081 CK_UTF8CHAR_PTR pLabel)
1082 {
1083 BEGIN_CALL (InitToken)
1084 IN_SLOT_ID (slotID)
1085 IN_BYTE_ARRAY (pPin, ulPinLen)
1086 IN_STRING (pLabel)
1087 PROCESS_CALL ((self, slotID, pPin, ulPinLen, pLabel))
1088 DONE_CALL
1089 }
1090
1091 static CK_RV
log_C_WaitForSlotEvent(CK_X_FUNCTION_LIST * self,CK_FLAGS flags,CK_SLOT_ID_PTR pSlot,CK_VOID_PTR pReserved)1092 log_C_WaitForSlotEvent (CK_X_FUNCTION_LIST *self,
1093 CK_FLAGS flags,
1094 CK_SLOT_ID_PTR pSlot,
1095 CK_VOID_PTR pReserved)
1096 {
1097 char temp[32];
1098 int had = 0;
1099
1100 BEGIN_CALL (WaitForSlotEvent)
1101 p11_buffer_add (&_buf, " IN: flags = ", -1);
1102 snprintf (temp, sizeof (temp), "%lu", flags);
1103 p11_buffer_add (&_buf, temp, -1);
1104 LOG_FLAG (&_buf, flags, had, CKF_DONT_BLOCK);
1105 p11_buffer_add (&_buf, "\n", 1);
1106 PROCESS_CALL ((self, flags, pSlot, pReserved))
1107 OUT_SLOT_ID (pSlot)
1108 OUT_POINTER (pReserved)
1109 DONE_CALL
1110 }
1111
1112 static CK_RV
log_C_OpenSession(CK_X_FUNCTION_LIST * self,CK_SLOT_ID slotID,CK_FLAGS flags,CK_VOID_PTR pApplication,CK_NOTIFY Notify,CK_SESSION_HANDLE_PTR phSession)1113 log_C_OpenSession (CK_X_FUNCTION_LIST *self,
1114 CK_SLOT_ID slotID,
1115 CK_FLAGS flags,
1116 CK_VOID_PTR pApplication,
1117 CK_NOTIFY Notify,
1118 CK_SESSION_HANDLE_PTR phSession)
1119 {
1120 char temp[32];
1121 int had = 0;
1122
1123 BEGIN_CALL (OpenSession)
1124 IN_SLOT_ID (slotID)
1125 p11_buffer_add (&_buf, " IN: flags = ", -1);
1126 snprintf (temp, sizeof (temp), "%lu", flags);
1127 p11_buffer_add (&_buf, temp, -1);
1128 LOG_FLAG (&_buf, flags, had, CKF_SERIAL_SESSION);
1129 LOG_FLAG (&_buf, flags, had, CKF_RW_SESSION);
1130 p11_buffer_add (&_buf, "\n", 1);
1131 IN_POINTER (pApplication);
1132 IN_POINTER (Notify);
1133 PROCESS_CALL ((self, slotID, flags, pApplication, Notify, phSession));
1134 OUT_SESSION (phSession)
1135 DONE_CALL
1136 }
1137
1138 static CK_RV
log_C_CloseSession(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession)1139 log_C_CloseSession (CK_X_FUNCTION_LIST *self,
1140 CK_SESSION_HANDLE hSession)
1141 {
1142 BEGIN_CALL (CloseSession)
1143 IN_SESSION (hSession)
1144 PROCESS_CALL ((self, hSession))
1145 DONE_CALL
1146 }
1147
1148 static CK_RV
log_C_CloseAllSessions(CK_X_FUNCTION_LIST * self,CK_SLOT_ID slotID)1149 log_C_CloseAllSessions (CK_X_FUNCTION_LIST *self,
1150 CK_SLOT_ID slotID)
1151 {
1152 BEGIN_CALL (CloseAllSessions)
1153 IN_SLOT_ID (slotID)
1154 PROCESS_CALL ((self, slotID))
1155 DONE_CALL
1156 }
1157
1158 static CK_RV
log_C_GetSessionInfo(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_SESSION_INFO_PTR pInfo)1159 log_C_GetSessionInfo (CK_X_FUNCTION_LIST *self,
1160 CK_SESSION_HANDLE hSession,
1161 CK_SESSION_INFO_PTR pInfo)
1162 {
1163 BEGIN_CALL (GetSessionInfo)
1164 IN_SESSION (hSession)
1165 PROCESS_CALL ((self, hSession, pInfo))
1166 OUT_SESSION_INFO (pInfo)
1167 DONE_CALL
1168 }
1169
1170 static CK_RV
log_C_InitPIN(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_UTF8CHAR_PTR pPin,CK_ULONG ulPinLen)1171 log_C_InitPIN (CK_X_FUNCTION_LIST *self,
1172 CK_SESSION_HANDLE hSession,
1173 CK_UTF8CHAR_PTR pPin,
1174 CK_ULONG ulPinLen)
1175 {
1176 BEGIN_CALL (InitPIN)
1177 IN_SESSION (hSession)
1178 IN_BYTE_ARRAY (pPin, ulPinLen)
1179 PROCESS_CALL ((self, hSession, pPin, ulPinLen))
1180 DONE_CALL
1181 }
1182
1183 static CK_RV
log_C_SetPIN(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_UTF8CHAR_PTR pOldPin,CK_ULONG ulOldLen,CK_UTF8CHAR_PTR pNewPin,CK_ULONG ulNewLen)1184 log_C_SetPIN (CK_X_FUNCTION_LIST *self,
1185 CK_SESSION_HANDLE hSession,
1186 CK_UTF8CHAR_PTR pOldPin,
1187 CK_ULONG ulOldLen,
1188 CK_UTF8CHAR_PTR pNewPin,
1189 CK_ULONG ulNewLen)
1190 {
1191 BEGIN_CALL (SetPIN)
1192 IN_SESSION (hSession)
1193 IN_BYTE_ARRAY (pOldPin, ulOldLen)
1194 IN_BYTE_ARRAY (pNewPin, ulNewLen);
1195 PROCESS_CALL ((self, hSession, pOldPin, ulOldLen, pNewPin, ulNewLen))
1196 DONE_CALL
1197 }
1198
1199 static CK_RV
log_C_GetOperationState(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pOperationState,CK_ULONG_PTR pulOperationStateLen)1200 log_C_GetOperationState (CK_X_FUNCTION_LIST *self,
1201 CK_SESSION_HANDLE hSession,
1202 CK_BYTE_PTR pOperationState,
1203 CK_ULONG_PTR pulOperationStateLen)
1204 {
1205 BEGIN_CALL (GetOperationState)
1206 IN_SESSION (hSession)
1207 IN_ULONG_PTR (pulOperationStateLen)
1208 PROCESS_CALL ((self, hSession, pOperationState, pulOperationStateLen))
1209 OUT_BYTE_ARRAY (pOperationState, pulOperationStateLen)
1210 DONE_CALL
1211 }
1212
1213 static CK_RV
log_C_SetOperationState(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pOperationState,CK_ULONG ulOperationStateLen,CK_OBJECT_HANDLE hEncryptionKey,CK_OBJECT_HANDLE hAuthenticationKey)1214 log_C_SetOperationState (CK_X_FUNCTION_LIST *self,
1215 CK_SESSION_HANDLE hSession,
1216 CK_BYTE_PTR pOperationState,
1217 CK_ULONG ulOperationStateLen,
1218 CK_OBJECT_HANDLE hEncryptionKey,
1219 CK_OBJECT_HANDLE hAuthenticationKey)
1220 {
1221 BEGIN_CALL (SetOperationState)
1222 IN_SESSION (hSession)
1223 IN_BYTE_ARRAY (pOperationState, ulOperationStateLen)
1224 IN_HANDLE (hEncryptionKey)
1225 IN_HANDLE (hAuthenticationKey)
1226 PROCESS_CALL ((self, hSession, pOperationState, ulOperationStateLen, hEncryptionKey, hAuthenticationKey))
1227 DONE_CALL
1228 }
1229
1230 static CK_RV
log_C_Login(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_USER_TYPE userType,CK_UTF8CHAR_PTR pPin,CK_ULONG ulPinLen)1231 log_C_Login (CK_X_FUNCTION_LIST *self,
1232 CK_SESSION_HANDLE hSession,
1233 CK_USER_TYPE userType,
1234 CK_UTF8CHAR_PTR pPin,
1235 CK_ULONG ulPinLen)
1236 {
1237 BEGIN_CALL (Login)
1238 IN_SESSION (hSession)
1239 IN_USER_TYPE (userType)
1240 IN_BYTE_ARRAY (pPin, ulPinLen);
1241 PROCESS_CALL ((self, hSession, userType, pPin, ulPinLen))
1242 DONE_CALL
1243 }
1244
1245 static CK_RV
log_C_Logout(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession)1246 log_C_Logout (CK_X_FUNCTION_LIST *self,
1247 CK_SESSION_HANDLE hSession)
1248 {
1249 BEGIN_CALL (Logout)
1250 IN_SESSION (hSession)
1251 PROCESS_CALL ((self, hSession))
1252 DONE_CALL
1253 }
1254
1255 static CK_RV
log_C_CreateObject(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phObject)1256 log_C_CreateObject (CK_X_FUNCTION_LIST *self,
1257 CK_SESSION_HANDLE hSession,
1258 CK_ATTRIBUTE_PTR pTemplate,
1259 CK_ULONG ulCount,
1260 CK_OBJECT_HANDLE_PTR phObject)
1261 {
1262 BEGIN_CALL (CreateObject)
1263 IN_SESSION (hSession)
1264 IN_ATTRIBUTE_ARRAY (pTemplate, ulCount)
1265 PROCESS_CALL ((self, hSession, pTemplate, ulCount, phObject))
1266 OUT_HANDLE (phObject)
1267 DONE_CALL
1268 }
1269
1270 static CK_RV
log_C_CopyObject(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phNewObject)1271 log_C_CopyObject (CK_X_FUNCTION_LIST *self,
1272 CK_SESSION_HANDLE hSession,
1273 CK_OBJECT_HANDLE hObject,
1274 CK_ATTRIBUTE_PTR pTemplate,
1275 CK_ULONG ulCount,
1276 CK_OBJECT_HANDLE_PTR phNewObject)
1277 {
1278 BEGIN_CALL (CopyObject)
1279 IN_SESSION (hSession)
1280 IN_HANDLE (hObject)
1281 IN_ATTRIBUTE_ARRAY (pTemplate, ulCount)
1282 PROCESS_CALL ((self, hSession, hObject, pTemplate, ulCount, phNewObject))
1283 OUT_HANDLE (phNewObject)
1284 DONE_CALL
1285 }
1286
1287
1288 static CK_RV
log_C_DestroyObject(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject)1289 log_C_DestroyObject (CK_X_FUNCTION_LIST *self,
1290 CK_SESSION_HANDLE hSession,
1291 CK_OBJECT_HANDLE hObject)
1292 {
1293 BEGIN_CALL (DestroyObject);
1294 IN_SESSION (hSession)
1295 IN_HANDLE (hObject)
1296 PROCESS_CALL ((self, hSession, hObject))
1297 DONE_CALL
1298 }
1299
1300 static CK_RV
log_C_GetObjectSize(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ULONG_PTR size)1301 log_C_GetObjectSize (CK_X_FUNCTION_LIST *self,
1302 CK_SESSION_HANDLE hSession,
1303 CK_OBJECT_HANDLE hObject,
1304 CK_ULONG_PTR size)
1305 {
1306 BEGIN_CALL (GetObjectSize);
1307 IN_SESSION (hSession)
1308 IN_HANDLE (hObject)
1309 PROCESS_CALL ((self, hSession, hObject, size))
1310 OUT_ULONG (size)
1311 DONE_CALL
1312 }
1313
1314 static CK_RV
log_C_GetAttributeValue(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)1315 log_C_GetAttributeValue (CK_X_FUNCTION_LIST *self,
1316 CK_SESSION_HANDLE hSession,
1317 CK_OBJECT_HANDLE hObject,
1318 CK_ATTRIBUTE_PTR pTemplate,
1319 CK_ULONG ulCount)
1320 {
1321 BEGIN_CALL (GetAttributeValue)
1322 IN_SESSION (hSession)
1323 IN_HANDLE (hObject)
1324 IN_ATTRIBUTE_ARRAY (pTemplate, ulCount)
1325 PROCESS_CALL ((self, hSession, hObject, pTemplate, ulCount))
1326 OUT_ATTRIBUTE_ARRAY (pTemplate, ulCount)
1327 DONE_CALL
1328 }
1329
1330 static CK_RV
log_C_SetAttributeValue(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)1331 log_C_SetAttributeValue (CK_X_FUNCTION_LIST *self,
1332 CK_SESSION_HANDLE hSession,
1333 CK_OBJECT_HANDLE hObject,
1334 CK_ATTRIBUTE_PTR pTemplate,
1335 CK_ULONG ulCount)
1336 {
1337 BEGIN_CALL (SetAttributeValue)
1338 IN_SESSION (hSession)
1339 IN_HANDLE (hObject)
1340 IN_ATTRIBUTE_ARRAY (pTemplate, ulCount)
1341 PROCESS_CALL ((self, hSession, hObject, pTemplate, ulCount))
1342 DONE_CALL
1343 }
1344
1345 static CK_RV
log_C_FindObjectsInit(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)1346 log_C_FindObjectsInit (CK_X_FUNCTION_LIST *self,
1347 CK_SESSION_HANDLE hSession,
1348 CK_ATTRIBUTE_PTR pTemplate,
1349 CK_ULONG ulCount)
1350 {
1351 BEGIN_CALL (FindObjectsInit)
1352 IN_SESSION (hSession)
1353 IN_ATTRIBUTE_ARRAY (pTemplate, ulCount)
1354 PROCESS_CALL ((self, hSession, pTemplate, ulCount))
1355 DONE_CALL
1356 }
1357
1358 static CK_RV
log_C_FindObjects(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE_PTR object,CK_ULONG max_object_count,CK_ULONG_PTR object_count)1359 log_C_FindObjects (CK_X_FUNCTION_LIST *self,
1360 CK_SESSION_HANDLE hSession,
1361 CK_OBJECT_HANDLE_PTR object,
1362 CK_ULONG max_object_count,
1363 CK_ULONG_PTR object_count)
1364 {
1365 BEGIN_CALL (FindObjects)
1366 IN_SESSION (hSession)
1367 IN_ULONG (max_object_count)
1368 PROCESS_CALL ((self, hSession, object, max_object_count, object_count))
1369 OUT_HANDLE_ARRAY (object, object_count)
1370 DONE_CALL
1371 }
1372
1373 static CK_RV
log_C_FindObjectsFinal(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession)1374 log_C_FindObjectsFinal (CK_X_FUNCTION_LIST *self,
1375 CK_SESSION_HANDLE hSession)
1376 {
1377 BEGIN_CALL (FindObjectsFinal)
1378 IN_SESSION (hSession)
1379 PROCESS_CALL ((self, hSession))
1380 DONE_CALL
1381 }
1382
1383 static CK_RV
log_C_EncryptInit(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1384 log_C_EncryptInit (CK_X_FUNCTION_LIST *self,
1385 CK_SESSION_HANDLE hSession,
1386 CK_MECHANISM_PTR pMechanism,
1387 CK_OBJECT_HANDLE hKey)
1388 {
1389 BEGIN_CALL (EncryptInit)
1390 IN_SESSION (hSession)
1391 IN_MECHANISM (pMechanism)
1392 IN_HANDLE (hKey)
1393 PROCESS_CALL ((self, hSession, pMechanism, hKey))
1394 DONE_CALL
1395 }
1396
1397 static CK_RV
log_C_Encrypt(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pEncryptedData,CK_ULONG_PTR pulEncryptedDataLen)1398 log_C_Encrypt (CK_X_FUNCTION_LIST *self,
1399 CK_SESSION_HANDLE hSession,
1400 CK_BYTE_PTR pData,
1401 CK_ULONG ulDataLen,
1402 CK_BYTE_PTR pEncryptedData,
1403 CK_ULONG_PTR pulEncryptedDataLen)
1404 {
1405 BEGIN_CALL (Encrypt)
1406 IN_SESSION (hSession)
1407 IN_BYTE_ARRAY (pData, ulDataLen)
1408 PROCESS_CALL ((self, hSession, pData, ulDataLen, pEncryptedData, pulEncryptedDataLen))
1409 OUT_BYTE_ARRAY (pEncryptedData, pulEncryptedDataLen)
1410 DONE_CALL
1411 }
1412
1413 static CK_RV
log_C_EncryptUpdate(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)1414 log_C_EncryptUpdate (CK_X_FUNCTION_LIST *self,
1415 CK_SESSION_HANDLE hSession,
1416 CK_BYTE_PTR pPart,
1417 CK_ULONG ulPartLen,
1418 CK_BYTE_PTR pEncryptedPart,
1419 CK_ULONG_PTR pulEncryptedPartLen)
1420 {
1421 BEGIN_CALL (EncryptUpdate)
1422 IN_SESSION (hSession)
1423 IN_BYTE_ARRAY (pPart, ulPartLen)
1424 PROCESS_CALL ((self, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen))
1425 OUT_BYTE_ARRAY (pEncryptedPart, pulEncryptedPartLen)
1426 DONE_CALL
1427 }
1428
1429 static CK_RV
log_C_EncryptFinal(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pLastEncryptedPart,CK_ULONG_PTR pulLastEncryptedPartLen)1430 log_C_EncryptFinal (CK_X_FUNCTION_LIST *self,
1431 CK_SESSION_HANDLE hSession,
1432 CK_BYTE_PTR pLastEncryptedPart,
1433 CK_ULONG_PTR pulLastEncryptedPartLen)
1434 {
1435 BEGIN_CALL (EncryptFinal)
1436 IN_SESSION (hSession)
1437 PROCESS_CALL ((self, hSession, pLastEncryptedPart, pulLastEncryptedPartLen))
1438 OUT_BYTE_ARRAY (pLastEncryptedPart, pulLastEncryptedPartLen)
1439 DONE_CALL
1440 }
1441
1442 static CK_RV
log_C_DecryptInit(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1443 log_C_DecryptInit (CK_X_FUNCTION_LIST *self,
1444 CK_SESSION_HANDLE hSession,
1445 CK_MECHANISM_PTR pMechanism,
1446 CK_OBJECT_HANDLE hKey)
1447 {
1448 BEGIN_CALL (DecryptInit)
1449 IN_SESSION (hSession)
1450 IN_MECHANISM (pMechanism)
1451 IN_HANDLE (hKey)
1452 PROCESS_CALL ((self, hSession, pMechanism, hKey))
1453 DONE_CALL
1454 }
1455
1456 static CK_RV
log_C_Decrypt(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedData,CK_ULONG ulEncryptedDataLen,CK_BYTE_PTR pData,CK_ULONG_PTR pulDataLen)1457 log_C_Decrypt (CK_X_FUNCTION_LIST *self,
1458 CK_SESSION_HANDLE hSession,
1459 CK_BYTE_PTR pEncryptedData,
1460 CK_ULONG ulEncryptedDataLen,
1461 CK_BYTE_PTR pData,
1462 CK_ULONG_PTR pulDataLen)
1463 {
1464 BEGIN_CALL (Decrypt)
1465 IN_SESSION (hSession)
1466 IN_BYTE_ARRAY (pEncryptedData, ulEncryptedDataLen)
1467 PROCESS_CALL ((self, hSession, pEncryptedData, ulEncryptedDataLen, pData, pulDataLen))
1468 OUT_BYTE_ARRAY (pData, pulDataLen)
1469 DONE_CALL
1470 }
1471
1472 static CK_RV
log_C_DecryptUpdate(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)1473 log_C_DecryptUpdate (CK_X_FUNCTION_LIST *self,
1474 CK_SESSION_HANDLE hSession,
1475 CK_BYTE_PTR pEncryptedPart,
1476 CK_ULONG ulEncryptedPartLen,
1477 CK_BYTE_PTR pPart,
1478 CK_ULONG_PTR pulPartLen)
1479 {
1480 BEGIN_CALL (DecryptUpdate)
1481 IN_SESSION (hSession)
1482 IN_BYTE_ARRAY (pEncryptedPart, ulEncryptedPartLen)
1483 PROCESS_CALL ((self, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen))
1484 OUT_BYTE_ARRAY (pPart, pulPartLen)
1485 DONE_CALL
1486 }
1487
1488 static CK_RV
log_C_DecryptFinal(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pLastPart,CK_ULONG_PTR pulLastPartLen)1489 log_C_DecryptFinal (CK_X_FUNCTION_LIST *self,
1490 CK_SESSION_HANDLE hSession,
1491 CK_BYTE_PTR pLastPart,
1492 CK_ULONG_PTR pulLastPartLen)
1493 {
1494 BEGIN_CALL (DecryptFinal)
1495 IN_SESSION (hSession)
1496 PROCESS_CALL ((self, hSession, pLastPart, pulLastPartLen))
1497 OUT_BYTE_ARRAY (pLastPart, pulLastPartLen)
1498 DONE_CALL
1499 }
1500
1501 static CK_RV
log_C_DigestInit(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism)1502 log_C_DigestInit (CK_X_FUNCTION_LIST *self,
1503 CK_SESSION_HANDLE hSession,
1504 CK_MECHANISM_PTR pMechanism)
1505 {
1506 BEGIN_CALL (DigestInit)
1507 IN_SESSION (hSession)
1508 IN_MECHANISM (pMechanism)
1509 PROCESS_CALL ((self, hSession, pMechanism))
1510 DONE_CALL
1511 }
1512
1513 static CK_RV
log_C_Digest(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pDigest,CK_ULONG_PTR pulDigestLen)1514 log_C_Digest (CK_X_FUNCTION_LIST *self,
1515 CK_SESSION_HANDLE hSession,
1516 CK_BYTE_PTR pData,
1517 CK_ULONG ulDataLen,
1518 CK_BYTE_PTR pDigest,
1519 CK_ULONG_PTR pulDigestLen)
1520 {
1521 BEGIN_CALL (Digest)
1522 IN_SESSION (hSession)
1523 IN_BYTE_ARRAY (pData, ulDataLen)
1524 PROCESS_CALL ((self, hSession, pData, ulDataLen, pDigest, pulDigestLen))
1525 OUT_BYTE_ARRAY (pDigest, pulDigestLen)
1526 DONE_CALL
1527 }
1528
1529 static CK_RV
log_C_DigestUpdate(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen)1530 log_C_DigestUpdate (CK_X_FUNCTION_LIST *self,
1531 CK_SESSION_HANDLE hSession,
1532 CK_BYTE_PTR pPart,
1533 CK_ULONG ulPartLen)
1534 {
1535 BEGIN_CALL (DigestUpdate)
1536 IN_SESSION (hSession)
1537 IN_BYTE_ARRAY (pPart, ulPartLen)
1538 PROCESS_CALL ((self, hSession, pPart, ulPartLen))
1539 DONE_CALL
1540 }
1541
1542 static CK_RV
log_C_DigestKey(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hKey)1543 log_C_DigestKey (CK_X_FUNCTION_LIST *self,
1544 CK_SESSION_HANDLE hSession,
1545 CK_OBJECT_HANDLE hKey)
1546 {
1547 BEGIN_CALL (DigestKey)
1548 IN_SESSION (hSession)
1549 IN_HANDLE (hKey)
1550 PROCESS_CALL ((self, hSession, hKey))
1551 DONE_CALL
1552 }
1553
1554 static CK_RV
log_C_DigestFinal(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pDigest,CK_ULONG_PTR pulDigestLen)1555 log_C_DigestFinal (CK_X_FUNCTION_LIST *self,
1556 CK_SESSION_HANDLE hSession,
1557 CK_BYTE_PTR pDigest,
1558 CK_ULONG_PTR pulDigestLen)
1559 {
1560 BEGIN_CALL (DigestFinal)
1561 IN_SESSION (hSession)
1562 PROCESS_CALL ((self, hSession, pDigest, pulDigestLen))
1563 OUT_BYTE_ARRAY (pDigest, pulDigestLen)
1564 DONE_CALL
1565 }
1566
1567 static CK_RV
log_C_SignInit(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1568 log_C_SignInit (CK_X_FUNCTION_LIST *self,
1569 CK_SESSION_HANDLE hSession,
1570 CK_MECHANISM_PTR pMechanism,
1571 CK_OBJECT_HANDLE hKey)
1572 {
1573 BEGIN_CALL (SignInit)
1574 IN_SESSION (hSession)
1575 IN_MECHANISM (pMechanism)
1576 IN_HANDLE (hKey)
1577 PROCESS_CALL ((self, hSession, pMechanism, hKey))
1578 DONE_CALL
1579 }
1580
1581 static CK_RV
log_C_Sign(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)1582 log_C_Sign (CK_X_FUNCTION_LIST *self,
1583 CK_SESSION_HANDLE hSession,
1584 CK_BYTE_PTR pData,
1585 CK_ULONG ulDataLen,
1586 CK_BYTE_PTR pSignature,
1587 CK_ULONG_PTR pulSignatureLen)
1588 {
1589 BEGIN_CALL (Sign)
1590 IN_SESSION (hSession)
1591 IN_BYTE_ARRAY (pData, ulDataLen)
1592 PROCESS_CALL ((self, hSession, pData, ulDataLen, pSignature, pulSignatureLen))
1593 OUT_BYTE_ARRAY (pSignature, pulSignatureLen)
1594 DONE_CALL
1595 }
1596
1597 static CK_RV
log_C_SignUpdate(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen)1598 log_C_SignUpdate (CK_X_FUNCTION_LIST *self,
1599 CK_SESSION_HANDLE hSession,
1600 CK_BYTE_PTR pPart,
1601 CK_ULONG ulPartLen)
1602 {
1603 BEGIN_CALL (SignUpdate)
1604 IN_SESSION (hSession)
1605 IN_BYTE_ARRAY (pPart, ulPartLen)
1606 PROCESS_CALL ((self, hSession, pPart, ulPartLen))
1607 DONE_CALL
1608 }
1609
1610 static CK_RV
log_C_SignFinal(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)1611 log_C_SignFinal (CK_X_FUNCTION_LIST *self,
1612 CK_SESSION_HANDLE hSession,
1613 CK_BYTE_PTR pSignature,
1614 CK_ULONG_PTR pulSignatureLen)
1615 {
1616 BEGIN_CALL (SignFinal)
1617 IN_SESSION (hSession)
1618 PROCESS_CALL ((self, hSession, pSignature, pulSignatureLen))
1619 OUT_BYTE_ARRAY (pSignature, pulSignatureLen)
1620 DONE_CALL
1621 }
1622
1623 static CK_RV
log_C_SignRecoverInit(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1624 log_C_SignRecoverInit (CK_X_FUNCTION_LIST *self,
1625 CK_SESSION_HANDLE hSession,
1626 CK_MECHANISM_PTR pMechanism,
1627 CK_OBJECT_HANDLE hKey)
1628 {
1629 BEGIN_CALL (SignRecoverInit)
1630 IN_SESSION (hSession)
1631 IN_MECHANISM (pMechanism)
1632 IN_HANDLE (hKey)
1633 PROCESS_CALL ((self, hSession, pMechanism, hKey))
1634 DONE_CALL
1635 }
1636
1637 static CK_RV
log_C_SignRecover(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)1638 log_C_SignRecover (CK_X_FUNCTION_LIST *self,
1639 CK_SESSION_HANDLE hSession,
1640 CK_BYTE_PTR pData,
1641 CK_ULONG ulDataLen,
1642 CK_BYTE_PTR pSignature,
1643 CK_ULONG_PTR pulSignatureLen)
1644 {
1645 BEGIN_CALL (SignRecover)
1646 IN_SESSION (hSession)
1647 IN_BYTE_ARRAY (pData, ulDataLen)
1648 PROCESS_CALL ((self, hSession, pData, ulDataLen, pSignature, pulSignatureLen))
1649 OUT_BYTE_ARRAY (pSignature, pulSignatureLen)
1650 DONE_CALL
1651 }
1652
1653 static CK_RV
log_C_VerifyInit(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1654 log_C_VerifyInit (CK_X_FUNCTION_LIST *self,
1655 CK_SESSION_HANDLE hSession,
1656 CK_MECHANISM_PTR pMechanism,
1657 CK_OBJECT_HANDLE hKey)
1658 {
1659 BEGIN_CALL (VerifyInit);
1660 IN_SESSION (hSession)
1661 IN_MECHANISM (pMechanism)
1662 IN_HANDLE (hKey)
1663 PROCESS_CALL ((self, hSession, pMechanism, hKey))
1664 DONE_CALL
1665 }
1666
1667 static CK_RV
log_C_Verify(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen)1668 log_C_Verify (CK_X_FUNCTION_LIST *self,
1669 CK_SESSION_HANDLE hSession,
1670 CK_BYTE_PTR pData,
1671 CK_ULONG ulDataLen,
1672 CK_BYTE_PTR pSignature,
1673 CK_ULONG ulSignatureLen)
1674 {
1675 BEGIN_CALL (Verify)
1676 IN_SESSION (hSession)
1677 IN_BYTE_ARRAY (pData, ulDataLen)
1678 IN_BYTE_ARRAY (pSignature, ulSignatureLen)
1679 PROCESS_CALL ((self, hSession, pData, ulDataLen, pSignature, ulSignatureLen))
1680 DONE_CALL
1681 }
1682
1683 static CK_RV
log_C_VerifyUpdate(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen)1684 log_C_VerifyUpdate (CK_X_FUNCTION_LIST *self,
1685 CK_SESSION_HANDLE hSession,
1686 CK_BYTE_PTR pPart,
1687 CK_ULONG ulPartLen)
1688 {
1689 BEGIN_CALL (VerifyUpdate)
1690 IN_SESSION (hSession)
1691 IN_BYTE_ARRAY (pPart, ulPartLen)
1692 PROCESS_CALL ((self, hSession, pPart, ulPartLen))
1693 DONE_CALL
1694 }
1695
1696 static CK_RV
log_C_VerifyFinal(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen)1697 log_C_VerifyFinal (CK_X_FUNCTION_LIST *self,
1698 CK_SESSION_HANDLE hSession,
1699 CK_BYTE_PTR pSignature,
1700 CK_ULONG ulSignatureLen)
1701 {
1702 BEGIN_CALL (VerifyFinal)
1703 IN_SESSION (hSession)
1704 IN_BYTE_ARRAY (pSignature, ulSignatureLen);
1705 PROCESS_CALL ((self, hSession, pSignature, ulSignatureLen))
1706 DONE_CALL
1707 }
1708
1709 static CK_RV
log_C_VerifyRecoverInit(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1710 log_C_VerifyRecoverInit (CK_X_FUNCTION_LIST *self,
1711 CK_SESSION_HANDLE hSession,
1712 CK_MECHANISM_PTR pMechanism,
1713 CK_OBJECT_HANDLE hKey)
1714 {
1715 BEGIN_CALL (VerifyRecoverInit)
1716 IN_SESSION (hSession)
1717 IN_MECHANISM (pMechanism)
1718 IN_HANDLE (hKey)
1719 PROCESS_CALL ((self, hSession, pMechanism, hKey))
1720 DONE_CALL
1721 }
1722
1723 static CK_RV
log_C_VerifyRecover(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen,CK_BYTE_PTR pData,CK_ULONG_PTR pulDataLen)1724 log_C_VerifyRecover (CK_X_FUNCTION_LIST *self,
1725 CK_SESSION_HANDLE hSession,
1726 CK_BYTE_PTR pSignature,
1727 CK_ULONG ulSignatureLen,
1728 CK_BYTE_PTR pData,
1729 CK_ULONG_PTR pulDataLen)
1730 {
1731 BEGIN_CALL (VerifyRecover)
1732 IN_SESSION (hSession)
1733 IN_BYTE_ARRAY (pSignature, ulSignatureLen)
1734 PROCESS_CALL ((self, hSession, pSignature, ulSignatureLen, pData, pulDataLen))
1735 OUT_BYTE_ARRAY (pData, pulDataLen)
1736 DONE_CALL
1737 }
1738
1739 static CK_RV
log_C_DigestEncryptUpdate(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)1740 log_C_DigestEncryptUpdate (CK_X_FUNCTION_LIST *self,
1741 CK_SESSION_HANDLE hSession,
1742 CK_BYTE_PTR pPart,
1743 CK_ULONG ulPartLen,
1744 CK_BYTE_PTR pEncryptedPart,
1745 CK_ULONG_PTR pulEncryptedPartLen)
1746 {
1747 BEGIN_CALL (DigestEncryptUpdate);
1748 IN_SESSION (hSession)
1749 IN_BYTE_ARRAY (pPart, ulPartLen)
1750 PROCESS_CALL ((self, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen))
1751 OUT_BYTE_ARRAY (pEncryptedPart, pulEncryptedPartLen)
1752 DONE_CALL
1753 }
1754
1755 static CK_RV
log_C_DecryptDigestUpdate(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)1756 log_C_DecryptDigestUpdate (CK_X_FUNCTION_LIST *self,
1757 CK_SESSION_HANDLE hSession,
1758 CK_BYTE_PTR pEncryptedPart,
1759 CK_ULONG ulEncryptedPartLen,
1760 CK_BYTE_PTR pPart,
1761 CK_ULONG_PTR pulPartLen)
1762 {
1763 BEGIN_CALL (DecryptDigestUpdate)
1764 IN_SESSION (hSession)
1765 IN_BYTE_ARRAY (pEncryptedPart, ulEncryptedPartLen)
1766 PROCESS_CALL ((self, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen))
1767 OUT_BYTE_ARRAY (pPart, pulPartLen)
1768 DONE_CALL
1769 }
1770
1771 static CK_RV
log_C_SignEncryptUpdate(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)1772 log_C_SignEncryptUpdate (CK_X_FUNCTION_LIST *self,
1773 CK_SESSION_HANDLE hSession,
1774 CK_BYTE_PTR pPart,
1775 CK_ULONG ulPartLen,
1776 CK_BYTE_PTR pEncryptedPart,
1777 CK_ULONG_PTR pulEncryptedPartLen)
1778 {
1779 BEGIN_CALL (SignEncryptUpdate)
1780 IN_SESSION (hSession)
1781 IN_BYTE_ARRAY (pPart, ulPartLen)
1782 PROCESS_CALL ((self, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen))
1783 OUT_BYTE_ARRAY (pEncryptedPart, pulEncryptedPartLen)
1784 DONE_CALL
1785 }
1786
1787 static CK_RV
log_C_DecryptVerifyUpdate(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)1788 log_C_DecryptVerifyUpdate (CK_X_FUNCTION_LIST *self,
1789 CK_SESSION_HANDLE hSession,
1790 CK_BYTE_PTR pEncryptedPart,
1791 CK_ULONG ulEncryptedPartLen,
1792 CK_BYTE_PTR pPart,
1793 CK_ULONG_PTR pulPartLen)
1794 {
1795 BEGIN_CALL (DecryptVerifyUpdate)
1796 IN_SESSION (hSession)
1797 IN_BYTE_ARRAY (pEncryptedPart, ulEncryptedPartLen)
1798 PROCESS_CALL ((self, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen))
1799 OUT_BYTE_ARRAY (pPart, pulPartLen)
1800 DONE_CALL
1801 }
1802
1803 static CK_RV
log_C_GenerateKey(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phKey)1804 log_C_GenerateKey (CK_X_FUNCTION_LIST *self,
1805 CK_SESSION_HANDLE hSession,
1806 CK_MECHANISM_PTR pMechanism,
1807 CK_ATTRIBUTE_PTR pTemplate,
1808 CK_ULONG ulCount,
1809 CK_OBJECT_HANDLE_PTR phKey)
1810 {
1811 BEGIN_CALL (GenerateKey)
1812 IN_SESSION (hSession)
1813 IN_MECHANISM (pMechanism)
1814 IN_ATTRIBUTE_ARRAY (pTemplate, ulCount)
1815 PROCESS_CALL ((self, hSession, pMechanism, pTemplate, ulCount, phKey))
1816 OUT_HANDLE (phKey)
1817 DONE_CALL
1818 }
1819
1820 static CK_RV
log_C_GenerateKeyPair(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_ATTRIBUTE_PTR pPublicKeyTemplate,CK_ULONG ulPublicKeyAttributeCount,CK_ATTRIBUTE_PTR pPrivateKeyTemplate,CK_ULONG ulPrivateKeyAttributeCount,CK_OBJECT_HANDLE_PTR phPublicKey,CK_OBJECT_HANDLE_PTR phPrivateKey)1821 log_C_GenerateKeyPair (CK_X_FUNCTION_LIST *self,
1822 CK_SESSION_HANDLE hSession,
1823 CK_MECHANISM_PTR pMechanism,
1824 CK_ATTRIBUTE_PTR pPublicKeyTemplate,
1825 CK_ULONG ulPublicKeyAttributeCount,
1826 CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
1827 CK_ULONG ulPrivateKeyAttributeCount,
1828 CK_OBJECT_HANDLE_PTR phPublicKey,
1829 CK_OBJECT_HANDLE_PTR phPrivateKey)
1830 {
1831 BEGIN_CALL (GenerateKeyPair)
1832 IN_SESSION (hSession)
1833 IN_MECHANISM (pMechanism)
1834 IN_ATTRIBUTE_ARRAY (pPublicKeyTemplate, ulPublicKeyAttributeCount)
1835 IN_ATTRIBUTE_ARRAY (pPrivateKeyTemplate, ulPrivateKeyAttributeCount)
1836 PROCESS_CALL ((self, hSession, pMechanism, pPublicKeyTemplate, ulPublicKeyAttributeCount,
1837 pPrivateKeyTemplate, ulPrivateKeyAttributeCount, phPublicKey, phPrivateKey))
1838 OUT_HANDLE (phPublicKey)
1839 OUT_HANDLE (phPrivateKey)
1840 DONE_CALL
1841 }
1842
1843 static CK_RV
log_C_WrapKey(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hWrappingKey,CK_OBJECT_HANDLE hKey,CK_BYTE_PTR pWrappedKey,CK_ULONG_PTR pulWrappedKeyLen)1844 log_C_WrapKey (CK_X_FUNCTION_LIST *self,
1845 CK_SESSION_HANDLE hSession,
1846 CK_MECHANISM_PTR pMechanism,
1847 CK_OBJECT_HANDLE hWrappingKey,
1848 CK_OBJECT_HANDLE hKey,
1849 CK_BYTE_PTR pWrappedKey,
1850 CK_ULONG_PTR pulWrappedKeyLen)
1851 {
1852 BEGIN_CALL (WrapKey)
1853 IN_SESSION (hSession)
1854 IN_MECHANISM (pMechanism)
1855 IN_HANDLE (hWrappingKey)
1856 IN_HANDLE (hKey)
1857 PROCESS_CALL ((self, hSession, pMechanism, hWrappingKey, hKey, pWrappedKey, pulWrappedKeyLen))
1858 OUT_BYTE_ARRAY (pWrappedKey, pulWrappedKeyLen)
1859 DONE_CALL
1860 }
1861
1862 static CK_RV
log_C_UnwrapKey(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hUnwrappingKey,CK_BYTE_PTR pWrappedKey,CK_ULONG ulWrappedKeyLen,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulAttributeCount,CK_OBJECT_HANDLE_PTR phKey)1863 log_C_UnwrapKey (CK_X_FUNCTION_LIST *self,
1864 CK_SESSION_HANDLE hSession,
1865 CK_MECHANISM_PTR pMechanism,
1866 CK_OBJECT_HANDLE hUnwrappingKey,
1867 CK_BYTE_PTR pWrappedKey,
1868 CK_ULONG ulWrappedKeyLen,
1869 CK_ATTRIBUTE_PTR pTemplate,
1870 CK_ULONG ulAttributeCount,
1871 CK_OBJECT_HANDLE_PTR phKey)
1872 {
1873 BEGIN_CALL (UnwrapKey)
1874 IN_SESSION (hSession)
1875 IN_MECHANISM (pMechanism)
1876 IN_HANDLE (hUnwrappingKey)
1877 IN_BYTE_ARRAY (pWrappedKey, ulWrappedKeyLen)
1878 IN_ATTRIBUTE_ARRAY (pTemplate, ulAttributeCount)
1879 PROCESS_CALL ((self, hSession, pMechanism, hUnwrappingKey, pWrappedKey,
1880 ulWrappedKeyLen, pTemplate, ulAttributeCount, phKey))
1881 OUT_HANDLE (phKey)
1882 DONE_CALL
1883 }
1884
1885 static CK_RV
log_C_DeriveKey(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hBaseKey,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulAttributeCount,CK_OBJECT_HANDLE_PTR phObject)1886 log_C_DeriveKey (CK_X_FUNCTION_LIST *self,
1887 CK_SESSION_HANDLE hSession,
1888 CK_MECHANISM_PTR pMechanism,
1889 CK_OBJECT_HANDLE hBaseKey,
1890 CK_ATTRIBUTE_PTR pTemplate,
1891 CK_ULONG ulAttributeCount,
1892 CK_OBJECT_HANDLE_PTR phObject)
1893 {
1894 BEGIN_CALL (DeriveKey)
1895 IN_SESSION (hSession)
1896 IN_MECHANISM (pMechanism)
1897 IN_HANDLE (hBaseKey)
1898 IN_ATTRIBUTE_ARRAY (pTemplate, ulAttributeCount)
1899 PROCESS_CALL ((self, hSession, pMechanism, hBaseKey, pTemplate, ulAttributeCount, phObject))
1900 OUT_HANDLE (phObject)
1901 DONE_CALL
1902 }
1903
1904 static CK_RV
log_C_SeedRandom(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSeed,CK_ULONG ulSeedLen)1905 log_C_SeedRandom (CK_X_FUNCTION_LIST *self,
1906 CK_SESSION_HANDLE hSession,
1907 CK_BYTE_PTR pSeed,
1908 CK_ULONG ulSeedLen)
1909 {
1910 BEGIN_CALL (SeedRandom)
1911 IN_SESSION (hSession)
1912 IN_BYTE_ARRAY (pSeed, ulSeedLen);
1913 PROCESS_CALL ((self, hSession, pSeed, ulSeedLen))
1914 DONE_CALL
1915 }
1916
1917 static CK_RV
log_C_GenerateRandom(CK_X_FUNCTION_LIST * self,CK_SESSION_HANDLE hSession,CK_BYTE_PTR pRandomData,CK_ULONG ulRandomLen)1918 log_C_GenerateRandom (CK_X_FUNCTION_LIST *self,
1919 CK_SESSION_HANDLE hSession,
1920 CK_BYTE_PTR pRandomData,
1921 CK_ULONG ulRandomLen)
1922 {
1923 BEGIN_CALL (GenerateRandom)
1924 IN_SESSION (hSession)
1925 IN_ULONG (ulRandomLen)
1926 PROCESS_CALL ((self, hSession, pRandomData, ulRandomLen))
1927 OUT_BYTE_ARRAY (pRandomData, &ulRandomLen)
1928 DONE_CALL
1929 }
1930
1931 static CK_X_FUNCTION_LIST log_functions = {
1932 { -1, -1 },
1933 log_C_Initialize,
1934 log_C_Finalize,
1935 log_C_GetInfo,
1936 log_C_GetSlotList,
1937 log_C_GetSlotInfo,
1938 log_C_GetTokenInfo,
1939 log_C_GetMechanismList,
1940 log_C_GetMechanismInfo,
1941 log_C_InitToken,
1942 log_C_InitPIN,
1943 log_C_SetPIN,
1944 log_C_OpenSession,
1945 log_C_CloseSession,
1946 log_C_CloseAllSessions,
1947 log_C_GetSessionInfo,
1948 log_C_GetOperationState,
1949 log_C_SetOperationState,
1950 log_C_Login,
1951 log_C_Logout,
1952 log_C_CreateObject,
1953 log_C_CopyObject,
1954 log_C_DestroyObject,
1955 log_C_GetObjectSize,
1956 log_C_GetAttributeValue,
1957 log_C_SetAttributeValue,
1958 log_C_FindObjectsInit,
1959 log_C_FindObjects,
1960 log_C_FindObjectsFinal,
1961 log_C_EncryptInit,
1962 log_C_Encrypt,
1963 log_C_EncryptUpdate,
1964 log_C_EncryptFinal,
1965 log_C_DecryptInit,
1966 log_C_Decrypt,
1967 log_C_DecryptUpdate,
1968 log_C_DecryptFinal,
1969 log_C_DigestInit,
1970 log_C_Digest,
1971 log_C_DigestUpdate,
1972 log_C_DigestKey,
1973 log_C_DigestFinal,
1974 log_C_SignInit,
1975 log_C_Sign,
1976 log_C_SignUpdate,
1977 log_C_SignFinal,
1978 log_C_SignRecoverInit,
1979 log_C_SignRecover,
1980 log_C_VerifyInit,
1981 log_C_Verify,
1982 log_C_VerifyUpdate,
1983 log_C_VerifyFinal,
1984 log_C_VerifyRecoverInit,
1985 log_C_VerifyRecover,
1986 log_C_DigestEncryptUpdate,
1987 log_C_DecryptDigestUpdate,
1988 log_C_SignEncryptUpdate,
1989 log_C_DecryptVerifyUpdate,
1990 log_C_GenerateKey,
1991 log_C_GenerateKeyPair,
1992 log_C_WrapKey,
1993 log_C_UnwrapKey,
1994 log_C_DeriveKey,
1995 log_C_SeedRandom,
1996 log_C_GenerateRandom,
1997 log_C_WaitForSlotEvent,
1998 };
1999
2000 void
p11_log_release(void * data)2001 p11_log_release (void *data)
2002 {
2003 LogData *log = (LogData *)data;
2004
2005 return_if_fail (data != NULL);
2006 p11_virtual_uninit (&log->virt);
2007 free (log);
2008 }
2009
2010 p11_virtual *
p11_log_subclass(p11_virtual * lower,p11_destroyer destroyer)2011 p11_log_subclass (p11_virtual *lower,
2012 p11_destroyer destroyer)
2013 {
2014 LogData *log;
2015
2016 log = calloc (1, sizeof (LogData));
2017 return_val_if_fail (log != NULL, NULL);
2018
2019 p11_virtual_init (&log->virt, &log_functions, lower, destroyer);
2020 log->lower = &lower->funcs;
2021 return &log->virt;
2022 }
2023