Debian Codegraph @

pkcs11/rpc-layer/gkm-rpc-module.c

raw
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2 /* gkr-pkcs11-rpc-module.c - a PKCS#11 module which communicates with another process
3
4 Copyright (C) 2008, Stefan Walter
5
6 The Gnome Keyring Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Library General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 License, or (at your option) any later version.
10
11 The Gnome Keyring Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Library General Public License for more details.
15
16 You should have received a copy of the GNU Library General Public
17 License along with the Gnome Library; see the file COPYING.LIB. If not,
18 <http://www.gnu.org/licenses/>.
19
20 Author: Stef Walter <[email protected]>
21 */
22
23 #include "config.h"
24
25 #include "gkm-rpc-layer.h"
26 #include "gkm-rpc-private.h"
27
28 #include "pkcs11/pkcs11.h"
29
30 #include "egg/egg-unix-credentials.h"
31
32 #include <glib.h>
33
34 #include <sys/types.h>
35 #include <sys/param.h>
36 #include <sys/socket.h>
37 #include <sys/un.h>
38
39 #include <stdlib.h>
40 #include <limits.h>
41 #include <ctype.h>
42 #include <stdint.h>
43 #include <pthread.h>
44 #include <unistd.h>
45 #include <fcntl.h>
46 #include <errno.h>
47 #include <stdarg.h>
48 #include <stdio.h>
49 #include <string.h>
50
51 /* -------------------------------------------------------------------
52 * GLOBALS / DEFINES
53 */
54
55 /* Various mutexes */
56 static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
57
58 /* Whether we've been initialized, and on what process id it happened */
59 static int pkcs11_initialized = 0;
60 static pid_t pkcs11_initialized_pid = 0;
61
62 /* The socket to connect to */
63 static char *pkcs11_socket_path = NULL;
64
65 /* The error used by us when parsing of rpc message fails */
66 #define PARSE_ERROR CKR_DEVICE_ERROR
67
68 /* -----------------------------------------------------------------------------
69 * LOGGING and DEBUGGING
70 */
71
72 #if DEBUG_OUTPUT
73 #define debug(x) gkm_rpc_debug x
74 #else
75 #define debug(x)
76 #endif
77 #define warning(x) gkm_rpc_warn x
78
79 #define return_val_if_fail(x, v) \
80 if (!(x)) { gkm_rpc_warn ("'%s' not true at %s", #x, __func__); return v; }
81
82 void
83 gkm_rpc_log (const char *line)
84 {
85 fprintf (stderr, "%s\n", line);
86 }
87
88 /* -----------------------------------------------------------------------------
89 * MODULE ARGUMENTS
90 */
91
92 static void
93 parse_argument (char *arg)
94 {
95 char *value;
96
97 value = arg + strcspn (arg, ":=");
98 if (!*value)
99 value = NULL;
100 else
101 *(value++) = 0;
102
103 /* Setup the socket path from the arguments */
104 if (strcmp (arg, "socket") == 0) {
105 free (pkcs11_socket_path);
106 pkcs11_socket_path = strdup (value);
107 } else {
108 warning (("unrecognized argument: %s", arg));
109 }
110 }
111
112 static void
113 parse_arguments (const char *string)
114 {
115 char quote = '\0';
116 char *src, *dup, *at, *arg;
117
118 if (!string)
119 return;
120
121 src = dup = strdup (string);
122 if (!dup) {
123 warning (("couldn't allocate memory for argument string"));
124 return;
125 }
126
127 arg = at = src;
128 for (src = dup; *src; src++) {
129
130 /* Matching quote */
131 if (quote == *src) {
132 quote = '\0';
133
134 /* Inside of quotes */
135 } else if (quote != '\0') {
136 if (*src == '\\') {
137 *at++ = *src++;
138 if (!*src) {
139 warning (("couldn't parse argument string: %s", string));
140 goto done;
141 }
142 if (*src != quote)
143 *at++ = '\\';
144 }
145 *at++ = *src;
146
147 /* Space, not inside of quotes */
148 } else if (isspace(*src)) {
149 *at = 0;
150 parse_argument (arg);
151 arg = at;
152
153 /* Other character outside of quotes */
154 } else {
155 switch (*src) {
156 case '\'':
157 case '"':
158 quote = *src;
159 break;
160 case '\\':
161 *at++ = *src++;
162 if (!*src) {
163 warning (("couldn't parse argument string: %s", string));
164 goto done;
165 }
166 /* fall through */
167 default:
168 *at++ = *src;
169 break;
170 }
171 }
172 }
173
174
175 if (at != arg)
176 parse_argument (arg);
177
178 done:
179 free (dup);
180 }
181
182 /* -----------------------------------------------------------------------------
183 * CALL SESSION
184 */
185
186 enum CallStatus {
187 CALL_INVALID,
188 CALL_READY,
189 CALL_PREP,
190 CALL_TRANSIT,
191 CALL_PARSE
192 };
193
194 typedef struct _CallState {
195 int socket; /* The connection we're sending on */
196 GkmRpcMessage *req; /* The current request */
197 GkmRpcMessage *resp; /* The current response */
198 int call_status;
199 struct _CallState *next; /* For pooling of completed sockets */
200 } CallState;
201
202 /* Maximum number of idle calls */
203 #define MAX_CALL_STATE_POOL 8
204
205 /* All call unused call states are in this list */
206 static CallState *call_state_pool = NULL;
207 static unsigned int n_call_state_pool = 0;
208
209 /* Mutex to protect above call state list */
210 static pthread_mutex_t call_state_mutex = PTHREAD_MUTEX_INITIALIZER;
211
212 /* Allocator for call session buffers */
213 static void*
214 call_allocator (void* p, size_t sz)
215 {
216 void* res = realloc (p, (size_t)sz);
217 if (!res && sz)
218 warning (("memory allocation of %lu bytes failed", sz));
219 return res;
220 }
221
222 static CK_RV
223 call_connect (CallState *cs)
224 {
225 struct sockaddr_un addr;
226 int sock;
227
228 assert (cs);
229 assert (cs->socket == -1);
230 assert (cs->call_status == CALL_INVALID);
231
232 if (!pkcs11_socket_path)
233 return CKR_DEVICE_REMOVED;
234
235 debug (("connecting to: %s", pkcs11_socket_path));
236
237 addr.sun_family = AF_UNIX;
238 g_strlcpy (addr.sun_path, pkcs11_socket_path, sizeof (addr.sun_path));
239
240 sock = socket (AF_UNIX, SOCK_STREAM, 0);
241 if (sock < 0) {
242 warning (("couldn't open socket: %s", strerror (errno)));
243 return CKR_DEVICE_ERROR;
244 }
245
246 /* close on exec */
247 if (fcntl (sock, F_SETFD, 1) == -1) {
248 close (sock);
249 warning (("couldn't secure socket: %s", strerror (errno)));
250 return CKR_DEVICE_ERROR;
251 }
252
253 if (connect (sock, (struct sockaddr*) &addr, sizeof (addr)) < 0) {
254 close (sock);
255 if (errno == ENOENT) {
256 debug (("couldn't connect to: %s: %s", pkcs11_socket_path, strerror (errno)));
257 return CKR_DEVICE_REMOVED;
258 } else {
259 warning (("couldn't connect to: %s: %s", pkcs11_socket_path, strerror (errno)));
260 return CKR_DEVICE_ERROR;
261 }
262 }
263
264 if (egg_unix_credentials_write (sock) < 0) {
265 close (sock);
266 warning (("couldn't send socket credentials: %s", strerror (errno)));
267 return CKR_DEVICE_ERROR;
268 }
269
270 cs->socket = sock;
271 cs->call_status = CALL_READY;
272 debug (("connected socket"));
273
274 return CKR_OK;
275 }
276
277 static void
278 call_disconnect (CallState *cs)
279 {
280 assert (cs);
281
282 if (cs->socket != -1) {
283 debug (("disconnected socket"));
284 close (cs->socket);
285 cs->socket = -1;
286 }
287 }
288
289 static void
290 call_destroy (void *value)
291 {
292 CallState *cs = value;
293
294 if (value) {
295 call_disconnect (cs);
296 assert (cs->socket == -1);
297
298 gkm_rpc_message_free (cs->req);
299 gkm_rpc_message_free (cs->resp);
300
301 free (cs);
302
303 debug (("destroyed state"));
304 }
305 }
306
307 static CK_RV
308 call_lookup (CallState **ret)
309 {
310 CallState *cs = NULL;
311 CK_RV rv;
312
313 assert (ret);
314
315 pthread_mutex_lock (&call_state_mutex);
316
317 /* Pop one from the pool if possible */
318 if (call_state_pool != NULL) {
319 cs = call_state_pool;
320 call_state_pool = cs->next;
321 cs->next = NULL;
322 assert (n_call_state_pool > 0);
323 --n_call_state_pool;
324 }
325
326 pthread_mutex_unlock (&call_state_mutex);
327
328 if (cs == NULL) {
329 cs = calloc(1, sizeof (CallState));
330 if (cs == NULL)
331 return CKR_HOST_MEMORY;
332 cs->socket = -1;
333 cs->call_status = CALL_INVALID;
334
335 /* Try to connect the call */
336 rv = call_connect (cs);
337 if (rv != CKR_OK) {
338 free (cs);
339 return rv;
340 }
341 }
342
343 assert (cs->call_status == CALL_READY);
344 assert (cs->socket != -1);
345 assert (cs->next == NULL);
346 *ret = cs;
347 return CKR_OK;
348 }
349
350 /* Perform the initial setup for a new call. */
351 static CK_RV
352 call_prepare (CallState *cs, int call_id)
353 {
354 assert (cs);
355 assert (cs->call_status == CALL_READY);
356
357 /* Allocate a new request if we've lost the old one */
358 if (!cs->req) {
359 cs->req = gkm_rpc_message_new (call_allocator);
360 if (!cs->req) {
361 warning (("cannot allocate request buffer: out of memory"));
362 return CKR_HOST_MEMORY;
363 }
364 }
365
366 /* Put in the Call ID and signature */
367 gkm_rpc_message_reset (cs->req);
368 if (!gkm_rpc_message_prep (cs->req, call_id, GKM_RPC_REQUEST))
369 return CKR_HOST_MEMORY;
370
371 debug (("prepared call: %d", call_id));
372
373 /* Ready to fill in arguments */
374 cs->call_status = CALL_PREP;
375 return CKR_OK;
376 }
377
378 /* Write all data to session socket. */
379 static CK_RV
380 call_write (CallState *cs, unsigned char* data, size_t len)
381 {
382 int fd, r;
383
384 assert (cs);
385 assert (data);
386 assert (len > 0);
387
388 while (len > 0) {
389
390 fd = cs->socket;
391 if (fd == -1) {
392 warning (("couldn't send data: socket has been closed"));
393 return CKR_DEVICE_ERROR;
394 }
395
396 r = write (fd, data, len);
397
398 if (r == -1) {
399 if (errno == EPIPE) {
400 warning (("couldn't send data: daemon closed connection"));
401 call_disconnect (cs);
402 return CKR_DEVICE_ERROR;
403 } else if (errno != EAGAIN && errno != EINTR) {
404 warning (("couldn't send data: %s", strerror (errno)));
405 return CKR_DEVICE_ERROR;
406 }
407 } else {
408 debug (("wrote %d bytes", r));
409 data += r;
410 len -= r;
411 }
412 }
413
414 return CKR_OK;
415 }
416
417 /* Read a certain amount of data from session socket. */
418 static CK_RV
419 call_read (CallState *cs, unsigned char* data, size_t len)
420 {
421 int fd, r;
422
423 assert (cs);
424 assert (data);
425 assert (len > 0);
426
427 while (len > 0) {
428
429 fd = cs->socket;
430 if (fd == -1) {
431 warning (("couldn't receive data: session socket has been closed"));
432 return CKR_DEVICE_ERROR;
433 }
434
435 r = read (fd, data, len);
436
437 if (r == 0) {
438 warning (("couldn't receive data: daemon closed connection"));
439 call_disconnect (cs);
440 return CKR_DEVICE_ERROR;
441 } else if (r == -1) {
442 if (errno != EAGAIN && errno != EINTR) {
443 warning (("couldn't receive data: %s", strerror (errno)));
444 return CKR_DEVICE_ERROR;
445 }
446 } else {
447 debug (("read %d bytes", r));
448 data += r;
449 len -= r;
450 }
451 }
452
453 return CKR_OK;
454 }
455
456 /*
457 * Used by call_session_do_call() to actually send the message to the daemon.
458 * Note how we unlock and relock the session during the call.
459 */
460 static CK_RV
461 call_send_recv (CallState *cs)
462 {
463 GkmRpcMessage *req, *resp;
464 unsigned char buf[4];
465 uint32_t len;
466 CK_RV ret;
467
468 assert (cs);
469 assert (cs->req);
470 assert (cs->call_status == CALL_PREP);
471
472 cs->call_status = CALL_TRANSIT;
473
474 /* Setup the response buffer properly */
475 if (!cs->resp) {
476 /* TODO: Do secrets or passwords ever flow through here? */
477 cs->resp = gkm_rpc_message_new (call_allocator);
478 if (!cs->resp) {
479 warning (("couldn't allocate response buffer: out of memory"));
480 return CKR_HOST_MEMORY;
481 }
482 }
483 gkm_rpc_message_reset (cs->resp);
484
485 /*
486 * Now as an additional check to make sure nothing nasty will
487 * happen while we are unlocked, we remove the request and
488 * response from the session during the action.
489 */
490 req = cs->req;
491 resp = cs->resp;
492 cs->req = cs->resp = NULL;
493
494 /* Send the number of bytes, and then the data */
495 egg_buffer_encode_uint32 (buf, req->buffer.len);
496 ret = call_write (cs, buf, 4);
497 if (ret != CKR_OK)
498 goto cleanup;
499 ret = call_write (cs, req->buffer.buf, req->buffer.len);
500 if (ret != CKR_OK)
501 goto cleanup;
502
503 /* Now read out the number of bytes, and then the data */
504 ret = call_read (cs, buf, 4);
505 if (ret != CKR_OK)
506 goto cleanup;
507 len = egg_buffer_decode_uint32 (buf);
508 if (!egg_buffer_reserve (&resp->buffer, len + resp->buffer.len)) {
509 warning (("couldn't allocate %u byte response area: out of memory", len));
510 ret = CKR_HOST_MEMORY;
511 goto cleanup;
512 }
513 ret = call_read (cs, resp->buffer.buf, len);
514 if (ret != CKR_OK)
515 goto cleanup;
516
517 egg_buffer_add_empty (&resp->buffer, len);
518 if (!gkm_rpc_message_parse (resp, GKM_RPC_RESPONSE))
519 goto cleanup;
520
521 debug (("received response from daemon"));
522
523 cleanup:
524 /* Make sure nobody else used this thread while unlocked */
525 assert (cs->call_status == CALL_TRANSIT);
526 assert (cs->resp == NULL);
527 cs->resp = resp;
528 assert (cs->req == NULL);
529 cs->req = req;
530
531 return ret;
532 }
533
534 /*
535 * At this point the request is ready. So we validate it, and we send it to
536 * the daemon for a response.
537 */
538 static CK_RV
539 call_run (CallState *cs)
540 {
541 CK_RV ret = CKR_OK;
542 CK_ULONG ckerr;
543
544 assert (cs);
545 assert (cs->req);
546 assert (cs->call_status == CALL_PREP);
547 assert (cs->socket != -1);
548
549 /* Did building the call fail? */
550 if (gkm_rpc_message_buffer_error (cs->req)) {
551 warning (("couldn't allocate request area: out of memory"));
552 return CKR_HOST_MEMORY;
553 }
554
555 /* Make sure that the signature is valid */
556 assert (gkm_rpc_message_is_verified (cs->req));
557
558 /* Do the dialog with daemon */
559 ret = call_send_recv (cs);
560
561 cs->call_status = CALL_PARSE;
562
563 if (ret != CKR_OK)
564 return ret;
565
566 /* If it's an error code then return it */
567 if (cs->resp->call_id == GKM_RPC_CALL_ERROR) {
568
569 if (!gkm_rpc_message_read_ulong (cs->resp, &ckerr)) {
570 warning (("invalid error response from gnome-keyring-daemon: too short"));
571 return CKR_DEVICE_ERROR;
572 }
573
574 if (ckerr <= CKR_OK) {
575 warning (("invalid error response from gnome-keyring-daemon: bad error code"));
576 return CKR_DEVICE_ERROR;
577 }
578
579 /* An error code from the daemon */
580 return (CK_RV)ckerr;
581 }
582
583 /* Make sure daemon answered the right call */
584 if (cs->req->call_id != cs->resp->call_id) {
585 warning (("invalid response from gnome-keyring-daemon: call mismatch"));
586 return CKR_DEVICE_ERROR;
587 }
588
589 assert (!gkm_rpc_message_buffer_error (cs->resp));
590 debug (("parsing response values"));
591
592 return CKR_OK;
593 }
594
595 static CK_RV
596 call_done (CallState *cs, CK_RV ret)
597 {
598 assert (cs);
599 assert (cs->call_status > CALL_INVALID);
600
601 if (cs->call_status == CALL_PARSE && cs->req && cs->resp) {
602
603 /* Check for parsing errors that were not caught elsewhere */
604 if (ret == CKR_OK) {
605
606 if (gkm_rpc_message_buffer_error (cs->resp)) {
607 warning (("invalid response from gnome-keyring-daemon: bad argument data"));
608 ret = CKR_GENERAL_ERROR;
609 } else {
610 /* Double check that the signature matched our decoding */
611 assert (gkm_rpc_message_is_verified (cs->resp));
612 }
613 }
614 }
615
616 /* Certain error codes cause us to discard the conenction */
617 if (ret != CKR_DEVICE_ERROR && ret != CKR_DEVICE_REMOVED && cs->socket != -1) {
618
619 /* Try and stash it away for later use */
620 pthread_mutex_lock (&call_state_mutex);
621
622 if (n_call_state_pool < MAX_CALL_STATE_POOL) {
623 cs->call_status = CALL_READY;
624 assert (cs->next == NULL);
625 cs->next = call_state_pool;
626 call_state_pool = cs;
627 ++n_call_state_pool;
628 cs = NULL;
629 }
630
631 pthread_mutex_unlock (&call_state_mutex);
632 }
633
634 if (cs != NULL)
635 call_destroy (cs);
636
637 return ret;
638 }
639
640 /* -----------------------------------------------------------------------------
641 * MODULE SPECIFIC PROTOCOL CODE
642 */
643
644 static CK_RV
645 proto_read_attribute_array (GkmRpcMessage *msg, CK_ATTRIBUTE_PTR arr, CK_ULONG len)
646 {
647 uint32_t i, num, value, type;
648 CK_ATTRIBUTE_PTR attr;
649 const unsigned char *attrval;
650 size_t attrlen;
651 unsigned char validity;
652 CK_RV ret;
653
654 assert (len);
655 assert (msg);
656
657 /* Make sure this is in the right order */
658 assert (!msg->signature || gkm_rpc_message_verify_part (msg, "aA"));
659
660 /* Get the number of items. We need this value to be correct */
661 if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &num))
662 return PARSE_ERROR;
663
664 if (len != num) {
665
666 /*
667 * This should never happen in normal operation. It denotes a goof up
668 * on the other side of our RPC. We should be indicating the exact number
669 * of attributes to the other side. And it should respond with the same
670 * number.
671 */
672
673 warning (("received an attribute array with wrong number of attributes"));
674 return PARSE_ERROR;
675 }
676
677 ret = CKR_OK;
678
679 /* We need to go ahead and read everything in all cases */
680 for (i = 0; i < num; ++i) {
681
682 /* The attribute type */
683 egg_buffer_get_uint32 (&msg->buffer, msg->parsed,
684 &msg->parsed, &type);
685
686 /* Attribute validity */
687 egg_buffer_get_byte (&msg->buffer, msg->parsed,
688 &msg->parsed, &validity);
689
690 /* And the data itself */
691 if (validity) {
692 if (egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &value) &&
693 egg_buffer_get_byte_array (&msg->buffer, msg->parsed, &msg->parsed, &attrval, &attrlen)) {
694 if (attrval && value != attrlen) {
695 warning (("attribute length does not match attribute data"));
696 return PARSE_ERROR;
697 }
698 attrlen = value;
699 }
700 }
701
702 /* Don't act on this data unless no errors */
703 if (egg_buffer_has_error (&msg->buffer))
704 break;
705
706 /* Try and stuff it in the output data */
707 if (arr) {
708 attr = &(arr[i]);
709 if (attr->type != type) {
710 warning (("returned attributes in invalid order"));
711 return PARSE_ERROR;
712 }
713
714 if (validity) {
715 /* Just requesting the attribute size */
716 if (!attr->pValue) {
717 attr->ulValueLen = attrlen;
718
719 /* Wants attribute data, but too small */
720 } else if (attr->ulValueLen < attrlen) {
721 attr->ulValueLen = attrlen;
722 ret = CKR_BUFFER_TOO_SMALL;
723
724 /* Wants attribute data, value is null */
725 } else if (attrval == NULL) {
726 attr->ulValueLen = 0;
727
728 /* Wants attribute data, enough space */
729 } else {
730 attr->ulValueLen = attrlen;
731 memcpy (attr->pValue, attrval, attrlen);
732 }
733
734 /* Not a valid attribute */
735 } else {
736 attr->ulValueLen = ((CK_ULONG)-1);
737 }
738 }
739 }
740
741 if (egg_buffer_has_error (&msg->buffer))
742 return PARSE_ERROR;
743
744 /* Read in the code that goes along with these attributes */
745 if (!gkm_rpc_message_read_ulong (msg, &ret))
746 return PARSE_ERROR;
747
748 return ret;
749 }
750
751 static CK_RV
752 proto_read_byte_array (GkmRpcMessage *msg, CK_BYTE_PTR arr,
753 CK_ULONG_PTR len, CK_ULONG max)
754 {
755 const unsigned char *val;
756 unsigned char valid;
757 uint32_t length;
758 size_t vlen;
759
760 assert (len);
761 assert (msg);
762
763 /* Make sure this is in the right order */
764 assert (!msg->signature || gkm_rpc_message_verify_part (msg, "ay"));
765
766 /* A single byte which determines whether valid or not */
767 if (!egg_buffer_get_byte (&msg->buffer, msg->parsed, &msg->parsed, &valid))
768 return PARSE_ERROR;
769
770 /* If not valid, then just the length is encoded, this can signify CKR_BUFFER_TOO_SMALL */
771 if (!valid) {
772 if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &length))
773 return PARSE_ERROR;
774
775 *len = length;
776
777 if (arr)
778 return CKR_BUFFER_TOO_SMALL;
779 else
780 return CKR_OK;
781 }
782
783 /* Get the actual bytes */
784 if (!egg_buffer_get_byte_array (&msg->buffer, msg->parsed, &msg->parsed, &val, &vlen))
785 return PARSE_ERROR;
786
787 *len = vlen;
788
789 /* Just asking us for size */
790 if (!arr)
791 return CKR_OK;
792
793 if (max < vlen)
794 return CKR_BUFFER_TOO_SMALL;
795
796 /* Enough space, yay */
797 memcpy (arr, val, vlen);
798 return CKR_OK;
799 }
800
801 static CK_RV
802 proto_read_ulong_array (GkmRpcMessage *msg, CK_ULONG_PTR arr,
803 CK_ULONG_PTR len, CK_ULONG max)
804 {
805 uint32_t i, num;
806 uint64_t val;
807 unsigned char valid;
808
809 assert (len);
810 assert (msg);
811
812 /* Make sure this is in the right order */
813 assert (!msg->signature || gkm_rpc_message_verify_part (msg, "au"));
814
815 /* A single byte which determines whether valid or not */
816 if (!egg_buffer_get_byte (&msg->buffer, msg->parsed, &msg->parsed, &valid))
817 return PARSE_ERROR;
818
819 /* Get the number of items. */
820 if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &num))
821 return PARSE_ERROR;
822
823 *len = num;
824
825 /* If not valid, then just the length is encoded, this can signify CKR_BUFFER_TOO_SMALL */
826 if (!valid) {
827 if (arr)
828 return CKR_BUFFER_TOO_SMALL;
829 else
830 return CKR_OK;
831 }
832
833 if (max < num)
834 return CKR_BUFFER_TOO_SMALL;
835
836 /* We need to go ahead and read everything in all cases */
837 for (i = 0; i < num; ++i) {
838 egg_buffer_get_uint64 (&msg->buffer, msg->parsed, &msg->parsed, &val);
839 if (arr)
840 arr[i] = (CK_ULONG)val;
841 }
842
843 return egg_buffer_has_error (&msg->buffer) ? PARSE_ERROR : CKR_OK;
844 }
845
846 static CK_RV
847 proto_write_mechanism (GkmRpcMessage *msg, CK_MECHANISM_PTR mech)
848 {
849 assert (msg);
850 assert (mech);
851
852 /* Make sure this is in the right order */
853 assert (!msg->signature || gkm_rpc_message_verify_part (msg, "M"));
854
855 /* The mechanism type */
856 egg_buffer_add_uint32 (&msg->buffer, mech->mechanism);
857
858 /*
859 * PKCS#11 mechanism parameters are not easy to serialize. They're
860 * completely different for so many mechanisms, they contain
861 * pointers to arbitrary memory, and many callers don't initialize
862 * them completely or properly.
863 *
864 * We only support certain mechanisms.
865 *
866 * Also callers do yucky things like leaving parts of the structure
867 * pointing to garbage if they don't think it's going to be used.
868 */
869
870 if (gkm_rpc_mechanism_has_no_parameters (mech->mechanism))
871 egg_buffer_add_byte_array (&msg->buffer, NULL, 0);
872 else if (gkm_rpc_mechanism_has_sane_parameters (mech->mechanism))
873 egg_buffer_add_byte_array (&msg->buffer, mech->pParameter,
874 mech->ulParameterLen);
875 else
876 return CKR_MECHANISM_INVALID;
877
878 return egg_buffer_has_error (&msg->buffer) ? CKR_HOST_MEMORY : CKR_OK;
879 }
880
881 static CK_RV
882 proto_read_info (GkmRpcMessage *msg, CK_INFO_PTR info)
883 {
884 assert (msg);
885 assert (info);
886
887 if (!gkm_rpc_message_read_version (msg, &info->cryptokiVersion) ||
888 !gkm_rpc_message_read_space_string (msg, info->manufacturerID, 32) ||
889 !gkm_rpc_message_read_ulong (msg, &info->flags) ||
890 !gkm_rpc_message_read_space_string (msg, info->libraryDescription, 32) ||
891 !gkm_rpc_message_read_version (msg, &info->libraryVersion))
892 return PARSE_ERROR;
893
894 return CKR_OK;
895 }
896
897 static CK_RV
898 proto_read_slot_info (GkmRpcMessage *msg, CK_SLOT_INFO_PTR info)
899 {
900 assert (msg);
901 assert (info);
902
903 if (!gkm_rpc_message_read_space_string (msg, info->slotDescription, 64) ||
904 !gkm_rpc_message_read_space_string (msg, info->manufacturerID, 32) ||
905 !gkm_rpc_message_read_ulong (msg, &info->flags) ||
906 !gkm_rpc_message_read_version (msg, &info->hardwareVersion) ||
907 !gkm_rpc_message_read_version (msg, &info->firmwareVersion))
908 return PARSE_ERROR;
909
910 return CKR_OK;
911 }
912
913 static CK_RV
914 proto_read_token_info (GkmRpcMessage *msg, CK_TOKEN_INFO_PTR info)
915 {
916 assert (msg);
917 assert (info);
918
919 if (!gkm_rpc_message_read_space_string (msg, info->label, 32) ||
920 !gkm_rpc_message_read_space_string (msg, info->manufacturerID, 32) ||
921 !gkm_rpc_message_read_space_string (msg, info->model, 16) ||
922 !gkm_rpc_message_read_space_string (msg, info->serialNumber, 16) ||
923 !gkm_rpc_message_read_ulong (msg, &info->flags) ||
924 !gkm_rpc_message_read_ulong (msg, &info->ulMaxSessionCount) ||
925 !gkm_rpc_message_read_ulong (msg, &info->ulSessionCount) ||
926 !gkm_rpc_message_read_ulong (msg, &info->ulMaxRwSessionCount) ||
927 !gkm_rpc_message_read_ulong (msg, &info->ulRwSessionCount) ||
928 !gkm_rpc_message_read_ulong (msg, &info->ulMaxPinLen) ||
929 !gkm_rpc_message_read_ulong (msg, &info->ulMinPinLen) ||
930 !gkm_rpc_message_read_ulong (msg, &info->ulTotalPublicMemory) ||
931 !gkm_rpc_message_read_ulong (msg, &info->ulFreePublicMemory) ||
932 !gkm_rpc_message_read_ulong (msg, &info->ulTotalPrivateMemory) ||
933 !gkm_rpc_message_read_ulong (msg, &info->ulFreePrivateMemory) ||
934 !gkm_rpc_message_read_version (msg, &info->hardwareVersion) ||
935 !gkm_rpc_message_read_version (msg, &info->firmwareVersion) ||
936 !gkm_rpc_message_read_space_string (msg, info->utcTime, 16))
937 return PARSE_ERROR;
938
939 return CKR_OK;
940 }
941
942 static CK_RV
943 proto_read_mechanism_info (GkmRpcMessage *msg, CK_MECHANISM_INFO_PTR info)
944 {
945 assert (msg);
946 assert (info);
947
948 if (!gkm_rpc_message_read_ulong (msg, &info->ulMinKeySize) ||
949 !gkm_rpc_message_read_ulong (msg, &info->ulMaxKeySize) ||
950 !gkm_rpc_message_read_ulong (msg, &info->flags))
951 return PARSE_ERROR;
952
953 return CKR_OK;
954 }
955
956 static CK_RV
957 proto_read_sesssion_info (GkmRpcMessage *msg, CK_SESSION_INFO_PTR info)
958 {
959 assert (msg);
960 assert (info);
961
962 if (!gkm_rpc_message_read_ulong (msg, &info->slotID) ||
963 !gkm_rpc_message_read_ulong (msg, &info->state) ||
964 !gkm_rpc_message_read_ulong (msg, &info->flags) ||
965 !gkm_rpc_message_read_ulong (msg, &info->ulDeviceError))
966 return PARSE_ERROR;
967
968 return CKR_OK;
969 }
970
971 /* -------------------------------------------------------------------
972 * CALL MACROS
973 */
974
975 #define BEGIN_CALL_OR(call_id, if_no_daemon) \
976 debug ((#call_id ": enter")); \
977 return_val_if_fail (pkcs11_initialized, CKR_CRYPTOKI_NOT_INITIALIZED); \
978 { \
979 CallState *_cs; \
980 CK_RV _ret = CKR_OK; \
981 _ret = call_lookup (&_cs); \
982 if (_ret == CKR_DEVICE_REMOVED) return (if_no_daemon); \
983 if (_ret != CKR_OK) return _ret; \
984 _ret = call_prepare (_cs, GKM_RPC_CALL_##call_id); \
985 if (_ret != CKR_OK) goto _cleanup;
986
987 #define PROCESS_CALL \
988 _ret = call_run (_cs); \
989 if (_ret != CKR_OK) goto _cleanup;
990
991 #define RETURN(ret) \
992 _ret = ret; \
993 goto _cleanup;
994
995 #define END_CALL \
996 _cleanup: \
997 _ret = call_done (_cs, _ret); \
998 debug (("ret: %d", _ret)); \
999 return _ret; \
1000 }
1001
1002 #define IN_BYTE(val) \
1003 if (!gkm_rpc_message_write_byte (_cs->req, val)) \
1004 { _ret = CKR_HOST_MEMORY; goto _cleanup; }
1005
1006 #define IN_ULONG(val) \
1007 if (!gkm_rpc_message_write_ulong (_cs->req, val)) \
1008 { _ret = CKR_HOST_MEMORY; goto _cleanup; }
1009
1010 #define IN_STRING(val) \
1011 if (!gkm_rpc_message_write_zero_string (_cs->req, val)) \
1012 { _ret = CKR_HOST_MEMORY; goto _cleanup; }
1013
1014 #define IN_BYTE_BUFFER(arr, len) \
1015 if (len == NULL) \
1016 { _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
1017 if (!gkm_rpc_message_write_byte_buffer (_cs->req, arr ? *len : 0)) \
1018 { _ret = CKR_HOST_MEMORY; goto _cleanup; }
1019
1020 #define IN_BYTE_ARRAY(arr, len) \
1021 if (len != 0 && arr == NULL) \
1022 { _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
1023 if (!gkm_rpc_message_write_byte_array (_cs->req, arr, len)) \
1024 { _ret = CKR_HOST_MEMORY; goto _cleanup; }
1025
1026 #define IN_ULONG_BUFFER(arr, len) \
1027 if (len == NULL) \
1028 { _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
1029 if (!gkm_rpc_message_write_ulong_buffer (_cs->req, arr ? *len : 0)) \
1030 { _ret = CKR_HOST_MEMORY; goto _cleanup; }
1031
1032 #define IN_ULONG_ARRAY(arr, len) \
1033 if (len != 0 && arr == NULL) \
1034 { _ret = CKR_ARGUMENTS_BAD; goto _cleanup; }\
1035 if (!gkm_rpc_message_write_ulong_array (_cs->req, arr, len)) \
1036 { _ret = CKR_HOST_MEMORY; goto _cleanup; }
1037
1038 #define IN_ATTRIBUTE_BUFFER(arr, num) \
1039 if (num != 0 && arr == NULL) \
1040 { _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
1041 if (!gkm_rpc_message_write_attribute_buffer (_cs->req, (arr), (num))) \
1042 { _ret = CKR_HOST_MEMORY; goto _cleanup; }
1043
1044 #define IN_ATTRIBUTE_ARRAY(arr, num) \
1045 if (num != 0 && arr == NULL) \
1046 { _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
1047 if (!gkm_rpc_message_write_attribute_array (_cs->req, (arr), (num))) \
1048 { _ret = CKR_HOST_MEMORY; goto _cleanup; }
1049
1050 #define IN_MECHANISM_TYPE(val) \
1051 if(!gkm_rpc_mechanism_is_supported (val)) \
1052 { _ret = CKR_MECHANISM_INVALID; goto _cleanup; } \
1053 if (!gkm_rpc_message_write_ulong (_cs->req, val)) \
1054 { _ret = CKR_HOST_MEMORY; goto _cleanup; }
1055
1056 #define IN_MECHANISM(val) \
1057 if (val == NULL) \
1058 { _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
1059 _ret = proto_write_mechanism (_cs->req, val); \
1060 if (_ret != CKR_OK) goto _cleanup;
1061
1062
1063
1064 #define OUT_ULONG(val) \
1065 if (val == NULL) \
1066 _ret = CKR_ARGUMENTS_BAD; \
1067 if (_ret == CKR_OK && !gkm_rpc_message_read_ulong (_cs->resp, val)) \
1068 _ret = PARSE_ERROR;
1069
1070 #define OUT_BYTE_ARRAY(arr, len) \
1071 if (len == NULL) \
1072 _ret = CKR_ARGUMENTS_BAD; \
1073 if (_ret == CKR_OK) \
1074 _ret = proto_read_byte_array (_cs->resp, (arr), (len), *(len));
1075
1076 #define OUT_ULONG_ARRAY(a, len) \
1077 if (len == NULL) \
1078 _ret = CKR_ARGUMENTS_BAD; \
1079 if (_ret == CKR_OK) \
1080 _ret = proto_read_ulong_array (_cs->resp, (a), (len), *(len));
1081
1082 #define OUT_ATTRIBUTE_ARRAY(arr, num) \
1083 if (_ret == CKR_OK) \
1084 _ret = proto_read_attribute_array (_cs->resp, (arr), (num));
1085
1086 #define OUT_INFO(info) \
1087 if (info == NULL) \
1088 _ret = CKR_ARGUMENTS_BAD; \
1089 if (_ret == CKR_OK) \
1090 _ret = proto_read_info (_cs->resp, info);
1091
1092 #define OUT_SLOT_INFO(info) \
1093 if (info == NULL) \
1094 _ret = CKR_ARGUMENTS_BAD; \
1095 if (_ret == CKR_OK) \
1096 _ret = proto_read_slot_info (_cs->resp, info);
1097
1098 #define OUT_TOKEN_INFO(info) \
1099 if (info == NULL) \
1100 _ret = CKR_ARGUMENTS_BAD; \
1101 if (_ret == CKR_OK) \
1102 _ret = proto_read_token_info (_cs->resp, info);
1103
1104 #define OUT_SESSION_INFO(info) \
1105 if (info == NULL) \
1106 _ret = CKR_ARGUMENTS_BAD; \
1107 if (_ret == CKR_OK) \
1108 _ret = proto_read_sesssion_info (_cs->resp, info);
1109
1110 #define OUT_MECHANISM_TYPE_ARRAY(arr, len) \
1111 if (len == NULL) \
1112 _ret = CKR_ARGUMENTS_BAD; \
1113 if (_ret == CKR_OK) \
1114 _ret = proto_read_ulong_array (_cs->resp, (arr), (len), *(len)); \
1115 if (_ret == CKR_OK && arr) \
1116 gkm_rpc_mechanism_list_purge (arr, len);
1117
1118 #define OUT_MECHANISM_INFO(info) \
1119 if (info == NULL) \
1120 _ret = CKR_ARGUMENTS_BAD; \
1121 if (_ret == CKR_OK) \
1122 _ret = proto_read_mechanism_info (_cs->resp, info);
1123
1124
1125 /* -------------------------------------------------------------------
1126 * INITIALIZATION and 'GLOBAL' CALLS
1127 */
1128
1129 static CK_RV
1130 rpc_C_Initialize (CK_VOID_PTR init_args)
1131 {
1132 CK_C_INITIALIZE_ARGS_PTR args = NULL;
1133 CK_RV ret = CKR_OK;
1134 const char *path;
1135 CallState *cs;
1136 pid_t pid;
1137
1138 debug (("C_Initialize: enter"));
1139
1140 #ifdef _DEBUG
1141 GKM_RPC_CHECK_CALLS();
1142 #endif
1143
1144 pthread_mutex_lock (&init_mutex);
1145
1146 if (init_args != NULL) {
1147 int supplied_ok;
1148
1149 /* pReserved must be NULL */
1150 args = init_args;
1151
1152 /* ALL supplied function pointers need to have the value either NULL or non-NULL. */
1153 supplied_ok = (args->CreateMutex == NULL && args->DestroyMutex == NULL &&
1154 args->LockMutex == NULL && args->UnlockMutex == NULL) ||
1155 (args->CreateMutex != NULL && args->DestroyMutex != NULL &&
1156 args->LockMutex != NULL && args->UnlockMutex != NULL);
1157 if (!supplied_ok) {
1158 warning (("invalid set of mutex calls supplied"));
1159 ret = CKR_ARGUMENTS_BAD;
1160 goto done;
1161 }
1162
1163 /*
1164 * When the CKF_OS_LOCKING_OK flag isn't set return an error.
1165 * We must be able to use our pthread functionality.
1166 */
1167 if (!(args->flags & CKF_OS_LOCKING_OK)) {
1168 warning (("can't do without os locking"));
1169 ret = CKR_CANT_LOCK;
1170 goto done;
1171 }
1172
1173 /*
1174 * We support setting the socket path and other arguments from from the
1175 * pReserved pointer, similar to how NSS PKCS#11 components are initialized.
1176 */
1177 if (args->pReserved)
1178 parse_arguments ((const char*)args->pReserved);
1179 }
1180
1181 pid = getpid ();
1182 if (pkcs11_initialized) {
1183
1184 /* This process has called C_Initialize already */
1185 if (pid == pkcs11_initialized_pid) {
1186 warning (("C_Initialize called twice for same process"));
1187 ret = CKR_CRYPTOKI_ALREADY_INITIALIZED;
1188 goto done;
1189 }
1190 }
1191
1192 /* Lookup the socket path, append '/pkcs11' */
1193 if (pkcs11_socket_path == NULL) {
1194 path = getenv ("GNOME_KEYRING_CONTROL");
1195 if (path && path[0]) {
1196 pkcs11_socket_path = malloc (strlen (path) + strlen ("/pkcs11") + 1);
1197 if (pkcs11_socket_path == NULL) {
1198 warning (("can't malloc memory"));
1199 ret = CKR_HOST_MEMORY;
1200 goto done;
1201 }
1202 sprintf (pkcs11_socket_path, "%s/pkcs11", path);
1203 } else {
1204 path = getenv ("XDG_RUNTIME_DIR");
1205 if (path) {
1206 pkcs11_socket_path = malloc (strlen (path) + strlen ("/keyring/pkcs11") + 1);
1207 if (pkcs11_socket_path == NULL) {
1208 warning (("can't malloc memory"));
1209 ret = CKR_HOST_MEMORY;
1210 goto done;
1211 }
1212 sprintf (pkcs11_socket_path, "%s/keyring/pkcs11", path);
1213 }
1214 }
1215 }
1216
1217 /* Call through and initialize the daemon if available */
1218 if (pkcs11_socket_path != NULL) {
1219 ret = call_lookup (&cs);
1220 if (ret == CKR_OK) {
1221 ret = call_prepare (cs, GKM_RPC_CALL_C_Initialize);
1222 if (ret == CKR_OK)
1223 if (!gkm_rpc_message_write_byte_array (cs->req, GKM_RPC_HANDSHAKE, GKM_RPC_HANDSHAKE_LEN))
1224 ret = CKR_HOST_MEMORY;
1225 if (ret == CKR_OK)
1226 ret = call_run (cs);
1227 call_done (cs, ret);
1228
1229 /* No daemon available */
1230 } else if (ret == CKR_DEVICE_REMOVED) {
1231 ret = CKR_OK;
1232 }
1233 }
1234
1235 done:
1236 /* Mark us as officially initialized */
1237 if (ret == CKR_OK) {
1238 pkcs11_initialized = 1;
1239 pkcs11_initialized_pid = pid;
1240 } else if (ret != CKR_CRYPTOKI_ALREADY_INITIALIZED) {
1241 pkcs11_initialized = 0;
1242 pkcs11_initialized_pid = 0;
1243 free (pkcs11_socket_path);
1244 pkcs11_socket_path = NULL;
1245 }
1246
1247 pthread_mutex_unlock (&init_mutex);
1248
1249 debug (("C_Initialize: %d", ret));
1250 return ret;
1251 }
1252
1253 static CK_RV
1254 rpc_C_Finalize (CK_VOID_PTR reserved)
1255 {
1256 CallState *cs;
1257 CK_RV ret = CKR_OK;
1258
1259 debug (("C_Finalize: enter"));
1260 return_val_if_fail (pkcs11_initialized, CKR_CRYPTOKI_NOT_INITIALIZED);
1261 return_val_if_fail (!reserved, CKR_ARGUMENTS_BAD);
1262
1263 pthread_mutex_lock (&init_mutex);
1264
1265 if (pkcs11_socket_path != NULL) {
1266 ret = call_lookup (&cs);
1267 if (ret == CKR_OK) {
1268 ret = call_prepare (cs, GKM_RPC_CALL_C_Finalize);
1269 if (ret == CKR_OK)
1270 ret = call_run (cs);
1271 call_done (cs, ret);
1272
1273 /* No daemon available */
1274 } else if (ret == CKR_DEVICE_REMOVED) {
1275 ret = CKR_OK;
1276 }
1277
1278
1279 if (ret != CKR_OK)
1280 warning (("finalizing the daemon returned an error: %d", ret));
1281 }
1282
1283 /* Cleanup the call state pool */
1284 while (call_state_pool) {
1285 cs = call_state_pool;
1286 call_state_pool = cs->next;
1287 call_destroy (cs);
1288 }
1289
1290 /* This should stop all other calls in */
1291 pkcs11_initialized = 0;
1292 pkcs11_initialized_pid = 0;
1293 free (pkcs11_socket_path);
1294 pkcs11_socket_path = NULL;
1295
1296 pthread_mutex_unlock (&init_mutex);
1297
1298 debug (("C_Finalize: %d", CKR_OK));
1299 return CKR_OK;
1300 }
1301
1302 static CK_RV
1303 fill_stand_in_info (CK_INFO_PTR info)
1304 {
1305 static CK_INFO stand_in_info = {
1306 { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },
1307 "GNOME Keyring ",
1308 0,
1309 "GNOME Keyring (without daemon) ",
1310 { 1, 1 },
1311 };
1312 memcpy (info, &stand_in_info, sizeof (CK_INFO));
1313 return CKR_OK;
1314
1315 }
1316
1317 static CK_RV
1318 rpc_C_GetInfo (CK_INFO_PTR info)
1319 {
1320 return_val_if_fail (info, CKR_ARGUMENTS_BAD);
1321
1322 BEGIN_CALL_OR (C_GetInfo, fill_stand_in_info (info));
1323 PROCESS_CALL;
1324 OUT_INFO (info);
1325 END_CALL;
1326 }
1327
1328 static CK_RV
1329 rpc_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
1330 {
1331 /* This would be a strange call to receive */
1332 return C_GetFunctionList (list);
1333 }
1334
1335 static CK_RV
1336 rpc_C_GetSlotList (CK_BBOOL token_present, CK_SLOT_ID_PTR slot_list, CK_ULONG_PTR count)
1337 {
1338 return_val_if_fail (count, CKR_ARGUMENTS_BAD);
1339
1340 BEGIN_CALL_OR (C_GetSlotList, (*count = 0, CKR_OK));
1341 IN_BYTE (token_present);
1342 IN_ULONG_BUFFER (slot_list, count);
1343 PROCESS_CALL;
1344 OUT_ULONG_ARRAY (slot_list, count);
1345 END_CALL;
1346 }
1347
1348 static CK_RV
1349 rpc_C_GetSlotInfo (CK_SLOT_ID id, CK_SLOT_INFO_PTR info)
1350 {
1351 return_val_if_fail (info, CKR_ARGUMENTS_BAD);
1352
1353 BEGIN_CALL_OR (C_GetSlotInfo, CKR_SLOT_ID_INVALID);
1354 IN_ULONG (id);
1355 PROCESS_CALL;
1356 OUT_SLOT_INFO (info);
1357 END_CALL;
1358 }
1359
1360 static CK_RV
1361 rpc_C_GetTokenInfo (CK_SLOT_ID id, CK_TOKEN_INFO_PTR info)
1362 {
1363 return_val_if_fail (info, CKR_ARGUMENTS_BAD);
1364
1365 BEGIN_CALL_OR (C_GetTokenInfo, CKR_SLOT_ID_INVALID);
1366 IN_ULONG (id);
1367 PROCESS_CALL;
1368 OUT_TOKEN_INFO (info);
1369 END_CALL;
1370 }
1371
1372 static CK_RV
1373 rpc_C_GetMechanismList (CK_SLOT_ID id, CK_MECHANISM_TYPE_PTR mechanism_list,
1374 CK_ULONG_PTR count)
1375 {
1376 return_val_if_fail (count, CKR_ARGUMENTS_BAD);
1377
1378 BEGIN_CALL_OR (C_GetMechanismList, CKR_SLOT_ID_INVALID);
1379 IN_ULONG (id);
1380 IN_ULONG_BUFFER (mechanism_list, count);
1381 PROCESS_CALL;
1382 OUT_MECHANISM_TYPE_ARRAY (mechanism_list, count);
1383 END_CALL;
1384
1385 }
1386
1387 static CK_RV
1388 rpc_C_GetMechanismInfo (CK_SLOT_ID id, CK_MECHANISM_TYPE type,
1389 CK_MECHANISM_INFO_PTR info)
1390 {
1391 return_val_if_fail (info, CKR_ARGUMENTS_BAD);
1392
1393 BEGIN_CALL_OR (C_GetMechanismInfo, CKR_SLOT_ID_INVALID);
1394 IN_ULONG (id);
1395 IN_MECHANISM_TYPE (type);
1396 PROCESS_CALL;
1397 OUT_MECHANISM_INFO (info);
1398 END_CALL;
1399 }
1400
1401 static CK_RV
1402 rpc_C_InitToken (CK_SLOT_ID id, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len,
1403 CK_UTF8CHAR_PTR label)
1404 {
1405 BEGIN_CALL_OR (C_InitToken, CKR_SLOT_ID_INVALID);
1406 IN_ULONG (id);
1407 IN_BYTE_ARRAY (pin, pin_len);
1408 IN_STRING (label);
1409 PROCESS_CALL;
1410 END_CALL;
1411 }
1412
1413 static CK_RV
1414 rpc_C_WaitForSlotEvent (CK_FLAGS flags, CK_SLOT_ID_PTR slot, CK_VOID_PTR reserved)
1415 {
1416 return_val_if_fail (slot, CKR_ARGUMENTS_BAD);
1417
1418 BEGIN_CALL_OR (C_WaitForSlotEvent, CKR_DEVICE_REMOVED);
1419 IN_ULONG (flags);
1420 PROCESS_CALL;
1421 OUT_ULONG (slot);
1422 END_CALL;
1423 }
1424
1425 static CK_RV
1426 rpc_C_OpenSession (CK_SLOT_ID id, CK_FLAGS flags, CK_VOID_PTR user_data,
1427 CK_NOTIFY callback, CK_SESSION_HANDLE_PTR session)
1428 {
1429 return_val_if_fail (session, CKR_ARGUMENTS_BAD);
1430
1431 BEGIN_CALL_OR (C_OpenSession, CKR_SLOT_ID_INVALID);
1432 IN_ULONG (id);
1433 IN_ULONG (flags);
1434 PROCESS_CALL;
1435 OUT_ULONG (session);
1436 END_CALL;
1437 }
1438
1439 static CK_RV
1440 rpc_C_CloseSession (CK_SESSION_HANDLE session)
1441 {
1442 BEGIN_CALL_OR (C_CloseSession, CKR_SESSION_HANDLE_INVALID);
1443 IN_ULONG (session);
1444 PROCESS_CALL;
1445 END_CALL;
1446 }
1447
1448 static CK_RV
1449 rpc_C_CloseAllSessions (CK_SLOT_ID id)
1450 {
1451 BEGIN_CALL_OR (C_CloseAllSessions, CKR_SLOT_ID_INVALID);
1452 IN_ULONG (id);
1453 PROCESS_CALL;
1454 END_CALL;
1455 }
1456
1457 static CK_RV
1458 rpc_C_GetFunctionStatus (CK_SESSION_HANDLE session)
1459 {
1460 BEGIN_CALL_OR (C_GetFunctionStatus, CKR_SESSION_HANDLE_INVALID);
1461 IN_ULONG (session);
1462 PROCESS_CALL;
1463 END_CALL;
1464 }
1465
1466 static CK_RV
1467 rpc_C_CancelFunction (CK_SESSION_HANDLE session)
1468 {
1469 BEGIN_CALL_OR (C_CancelFunction, CKR_SESSION_HANDLE_INVALID);
1470 IN_ULONG (session);
1471 PROCESS_CALL;
1472 END_CALL;
1473 }
1474
1475 static CK_RV
1476 rpc_C_GetSessionInfo(CK_SESSION_HANDLE session, CK_SESSION_INFO_PTR info)
1477 {
1478 return_val_if_fail (info, CKR_ARGUMENTS_BAD);
1479
1480 BEGIN_CALL_OR (C_GetSessionInfo, CKR_SESSION_HANDLE_INVALID);
1481 IN_ULONG (session);
1482 PROCESS_CALL;
1483 OUT_SESSION_INFO (info);
1484 END_CALL;
1485 }
1486
1487 static CK_RV
1488 rpc_C_InitPIN (CK_SESSION_HANDLE session, CK_UTF8CHAR_PTR pin,
1489 CK_ULONG pin_len)
1490 {
1491 BEGIN_CALL_OR (C_InitPIN, CKR_SESSION_HANDLE_INVALID);
1492 IN_ULONG (session);
1493 IN_BYTE_ARRAY (pin, pin_len);
1494 PROCESS_CALL;
1495 END_CALL;
1496 }
1497
1498 static CK_RV
1499 rpc_C_SetPIN (CK_SESSION_HANDLE session, CK_UTF8CHAR_PTR old_pin,
1500 CK_ULONG old_pin_len, CK_UTF8CHAR_PTR new_pin, CK_ULONG new_pin_len)
1501 {
1502 BEGIN_CALL_OR (C_SetPIN, CKR_SESSION_HANDLE_INVALID);
1503 IN_ULONG (session);
1504 IN_BYTE_ARRAY (old_pin, old_pin_len);
1505 IN_BYTE_ARRAY (new_pin, old_pin_len);
1506 PROCESS_CALL;
1507 END_CALL;
1508 }
1509
1510 static CK_RV
1511 rpc_C_GetOperationState (CK_SESSION_HANDLE session, CK_BYTE_PTR operation_state,
1512 CK_ULONG_PTR operation_state_len)
1513 {
1514 return_val_if_fail (operation_state_len, CKR_ARGUMENTS_BAD);
1515
1516 BEGIN_CALL_OR (C_GetOperationState, CKR_SESSION_HANDLE_INVALID);
1517 IN_ULONG (session);
1518 IN_BYTE_BUFFER (operation_state, operation_state_len);
1519 PROCESS_CALL;
1520 OUT_BYTE_ARRAY (operation_state, operation_state_len);
1521 END_CALL;
1522 }
1523
1524 static CK_RV
1525 rpc_C_SetOperationState (CK_SESSION_HANDLE session, CK_BYTE_PTR operation_state,
1526 CK_ULONG operation_state_len, CK_OBJECT_HANDLE encryption_key,
1527 CK_OBJECT_HANDLE authentication_key)
1528 {
1529 BEGIN_CALL_OR (C_SetOperationState, CKR_SESSION_HANDLE_INVALID);
1530 IN_ULONG (session);
1531 IN_BYTE_ARRAY (operation_state, operation_state_len);
1532 IN_ULONG (encryption_key);
1533 IN_ULONG (authentication_key);
1534 PROCESS_CALL;
1535 END_CALL;
1536 }
1537
1538 static CK_RV
1539 rpc_C_Login (CK_SESSION_HANDLE session, CK_USER_TYPE user_type,
1540 CK_UTF8CHAR_PTR pin, CK_ULONG pin_len)
1541 {
1542 BEGIN_CALL_OR (C_Login, CKR_SESSION_HANDLE_INVALID);
1543 IN_ULONG (session);
1544 IN_ULONG (user_type);
1545 IN_BYTE_ARRAY (pin, pin_len);
1546 PROCESS_CALL;
1547 END_CALL;
1548 }
1549
1550 static CK_RV
1551 rpc_C_Logout (CK_SESSION_HANDLE session)
1552 {
1553 BEGIN_CALL_OR (C_Logout, CKR_SESSION_HANDLE_INVALID);
1554 IN_ULONG (session);
1555 PROCESS_CALL;
1556 END_CALL;
1557 }
1558
1559 static CK_RV
1560 rpc_C_CreateObject (CK_SESSION_HANDLE session, CK_ATTRIBUTE_PTR template,
1561 CK_ULONG count, CK_OBJECT_HANDLE_PTR new_object)
1562 {
1563 return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
1564
1565 BEGIN_CALL_OR (C_CreateObject, CKR_SESSION_HANDLE_INVALID);
1566 IN_ULONG (session);
1567 IN_ATTRIBUTE_ARRAY (template, count);
1568 PROCESS_CALL;
1569 OUT_ULONG (new_object);
1570 END_CALL;
1571 }
1572
1573 static CK_RV
1574 rpc_C_CopyObject (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object,
1575 CK_ATTRIBUTE_PTR template, CK_ULONG count,
1576 CK_OBJECT_HANDLE_PTR new_object)
1577 {
1578 return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
1579
1580 BEGIN_CALL_OR (C_CopyObject, CKR_SESSION_HANDLE_INVALID);
1581 IN_ULONG (session);
1582 IN_ULONG (object);
1583 IN_ATTRIBUTE_ARRAY (template, count);
1584 PROCESS_CALL;
1585 OUT_ULONG (new_object);
1586 END_CALL;
1587 }
1588
1589
1590 static CK_RV
1591 rpc_C_DestroyObject (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object)
1592 {
1593 BEGIN_CALL_OR (C_DestroyObject, CKR_SESSION_HANDLE_INVALID);
1594 IN_ULONG (session);
1595 IN_ULONG (object);
1596 PROCESS_CALL;
1597 END_CALL;
1598 }
1599
1600 static CK_RV
1601 rpc_C_GetObjectSize (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object,
1602 CK_ULONG_PTR size)
1603 {
1604 return_val_if_fail (size, CKR_ARGUMENTS_BAD);
1605
1606 BEGIN_CALL_OR (C_GetObjectSize, CKR_SESSION_HANDLE_INVALID);
1607 IN_ULONG (session);
1608 IN_ULONG (object);
1609 PROCESS_CALL;
1610 OUT_ULONG (size);
1611 END_CALL;
1612 }
1613
1614 static CK_RV
1615 rpc_C_GetAttributeValue (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object,
1616 CK_ATTRIBUTE_PTR template, CK_ULONG count)
1617 {
1618 BEGIN_CALL_OR (C_GetAttributeValue, CKR_SESSION_HANDLE_INVALID);
1619 IN_ULONG (session);
1620 IN_ULONG (object);
1621 IN_ATTRIBUTE_BUFFER (template, count);
1622 PROCESS_CALL;
1623 OUT_ATTRIBUTE_ARRAY (template, count);
1624 END_CALL;
1625 }
1626
1627 static CK_RV
1628 rpc_C_SetAttributeValue (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object,
1629 CK_ATTRIBUTE_PTR template, CK_ULONG count)
1630 {
1631 BEGIN_CALL_OR (C_SetAttributeValue, CKR_SESSION_HANDLE_INVALID);
1632 IN_ULONG (session);
1633 IN_ULONG (object);
1634 IN_ATTRIBUTE_ARRAY (template, count);
1635 PROCESS_CALL;
1636 END_CALL;
1637 }
1638
1639 static CK_RV
1640 rpc_C_FindObjectsInit (CK_SESSION_HANDLE session, CK_ATTRIBUTE_PTR template,
1641 CK_ULONG count)
1642 {
1643 BEGIN_CALL_OR (C_FindObjectsInit, CKR_SESSION_HANDLE_INVALID);
1644 IN_ULONG (session);
1645 IN_ATTRIBUTE_ARRAY (template, count);
1646 PROCESS_CALL;
1647 END_CALL;
1648 }
1649
1650 static CK_RV
1651 rpc_C_FindObjects (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE_PTR objects,
1652 CK_ULONG max_count, CK_ULONG_PTR count)
1653 {
1654 /* HACK: To fix a stupid gcc warning */
1655 CK_ULONG_PTR address_of_max_count = &max_count;
1656
1657 return_val_if_fail (count, CKR_ARGUMENTS_BAD);
1658
1659 BEGIN_CALL_OR (C_FindObjects, CKR_SESSION_HANDLE_INVALID);
1660 IN_ULONG (session);
1661 IN_ULONG_BUFFER (objects, address_of_max_count);
1662 PROCESS_CALL;
1663 *count = max_count;
1664 OUT_ULONG_ARRAY (objects, count);
1665 END_CALL;
1666 }
1667
1668 static CK_RV
1669 rpc_C_FindObjectsFinal (CK_SESSION_HANDLE session)
1670 {
1671 BEGIN_CALL_OR (C_FindObjectsFinal, CKR_SESSION_HANDLE_INVALID);
1672 IN_ULONG (session);
1673 PROCESS_CALL;
1674 END_CALL;
1675 }
1676
1677 static CK_RV
1678 rpc_C_EncryptInit (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
1679 CK_OBJECT_HANDLE key)
1680 {
1681 BEGIN_CALL_OR (C_EncryptInit, CKR_SESSION_HANDLE_INVALID);
1682 IN_ULONG (session);
1683 IN_MECHANISM (mechanism);
1684 IN_ULONG (key);
1685 PROCESS_CALL;
1686 END_CALL;
1687 }
1688
1689 static CK_RV
1690 rpc_C_Encrypt (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len,
1691 CK_BYTE_PTR encrypted_data, CK_ULONG_PTR encrypted_data_len)
1692 {
1693 return_val_if_fail (encrypted_data_len, CKR_ARGUMENTS_BAD);
1694
1695 BEGIN_CALL_OR (C_Encrypt, CKR_SESSION_HANDLE_INVALID);
1696 IN_ULONG (session);
1697 IN_BYTE_ARRAY (data, data_len);
1698 IN_BYTE_BUFFER (encrypted_data, encrypted_data_len);
1699 PROCESS_CALL;
1700 OUT_BYTE_ARRAY (encrypted_data, encrypted_data_len);
1701 END_CALL;
1702 }
1703
1704 static CK_RV
1705 rpc_C_EncryptUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part,
1706 CK_ULONG part_len, CK_BYTE_PTR encrypted_part,
1707 CK_ULONG_PTR encrypted_part_len)
1708 {
1709 return_val_if_fail (encrypted_part_len, CKR_ARGUMENTS_BAD);
1710
1711 BEGIN_CALL_OR (C_EncryptUpdate, CKR_SESSION_HANDLE_INVALID);
1712 IN_ULONG (session);
1713 IN_BYTE_ARRAY (part, part_len);
1714 IN_BYTE_BUFFER (encrypted_part, encrypted_part_len);
1715 PROCESS_CALL;
1716 OUT_BYTE_ARRAY (encrypted_part, encrypted_part_len);
1717 END_CALL;
1718 }
1719
1720 static CK_RV
1721 rpc_C_EncryptFinal (CK_SESSION_HANDLE session, CK_BYTE_PTR last_part,
1722 CK_ULONG_PTR last_part_len)
1723 {
1724 return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
1725
1726 BEGIN_CALL_OR (C_EncryptFinal, CKR_SESSION_HANDLE_INVALID);
1727 IN_ULONG (session);
1728 IN_BYTE_BUFFER (last_part, last_part_len);
1729 PROCESS_CALL;
1730 OUT_BYTE_ARRAY (last_part, last_part_len);
1731 END_CALL;
1732 }
1733
1734 static CK_RV
1735 rpc_C_DecryptInit (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
1736 CK_OBJECT_HANDLE key)
1737 {
1738 BEGIN_CALL_OR (C_DecryptInit, CKR_SESSION_HANDLE_INVALID);
1739 IN_ULONG (session);
1740 IN_MECHANISM (mechanism);
1741 IN_ULONG (key);
1742 PROCESS_CALL;
1743 END_CALL;
1744 }
1745
1746 static CK_RV
1747 rpc_C_Decrypt (CK_SESSION_HANDLE session, CK_BYTE_PTR enc_data,
1748 CK_ULONG enc_data_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len)
1749 {
1750 return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
1751
1752 BEGIN_CALL_OR (C_Decrypt, CKR_SESSION_HANDLE_INVALID);
1753 IN_ULONG (session);
1754 IN_BYTE_ARRAY (enc_data, enc_data_len);
1755 IN_BYTE_BUFFER (data, data_len);
1756 PROCESS_CALL;
1757 OUT_BYTE_ARRAY (data, data_len);
1758 END_CALL;
1759 }
1760
1761 static CK_RV
1762 rpc_C_DecryptUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR enc_part,
1763 CK_ULONG enc_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len)
1764 {
1765 return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
1766
1767 BEGIN_CALL_OR (C_DecryptUpdate, CKR_SESSION_HANDLE_INVALID);
1768 IN_ULONG (session);
1769 IN_BYTE_ARRAY (enc_part, enc_part_len);
1770 IN_BYTE_BUFFER (part, part_len);
1771 PROCESS_CALL;
1772 OUT_BYTE_ARRAY (part, part_len);
1773 END_CALL;
1774 }
1775
1776 static CK_RV
1777 rpc_C_DecryptFinal (CK_SESSION_HANDLE session, CK_BYTE_PTR last_part,
1778 CK_ULONG_PTR last_part_len)
1779 {
1780 return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
1781
1782 BEGIN_CALL_OR (C_DecryptFinal, CKR_SESSION_HANDLE_INVALID);
1783 IN_ULONG (session);
1784 IN_BYTE_BUFFER (last_part, last_part_len);
1785 PROCESS_CALL;
1786 OUT_BYTE_ARRAY (last_part, last_part_len);
1787 END_CALL;
1788 }
1789
1790 static CK_RV
1791 rpc_C_DigestInit (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism)
1792 {
1793 BEGIN_CALL_OR (C_DigestInit, CKR_SESSION_HANDLE_INVALID);
1794 IN_ULONG (session);
1795 IN_MECHANISM (mechanism);
1796 PROCESS_CALL;
1797 END_CALL;
1798 }
1799
1800 static CK_RV
1801 rpc_C_Digest (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len,
1802 CK_BYTE_PTR digest, CK_ULONG_PTR digest_len)
1803 {
1804 return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
1805
1806 BEGIN_CALL_OR (C_Digest, CKR_SESSION_HANDLE_INVALID);
1807 IN_ULONG (session);
1808 IN_BYTE_ARRAY (data, data_len);
1809 IN_BYTE_BUFFER (digest, digest_len);
1810 PROCESS_CALL;
1811 OUT_BYTE_ARRAY (digest, digest_len);
1812 END_CALL;
1813 }
1814
1815 static CK_RV
1816 rpc_C_DigestUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len)
1817 {
1818 BEGIN_CALL_OR (C_DigestUpdate, CKR_SESSION_HANDLE_INVALID);
1819 IN_ULONG (session);
1820 IN_BYTE_ARRAY (part, part_len);
1821 PROCESS_CALL;
1822 END_CALL;
1823 }
1824
1825 static CK_RV
1826 rpc_C_DigestKey (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE key)
1827 {
1828 BEGIN_CALL_OR (C_DigestKey, CKR_SESSION_HANDLE_INVALID);
1829 IN_ULONG (session);
1830 IN_ULONG (key);
1831 PROCESS_CALL;
1832 END_CALL;
1833 }
1834
1835 static CK_RV
1836 rpc_C_DigestFinal (CK_SESSION_HANDLE session, CK_BYTE_PTR digest,
1837 CK_ULONG_PTR digest_len)
1838 {
1839 return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
1840
1841 BEGIN_CALL_OR (C_DigestFinal, CKR_SESSION_HANDLE_INVALID);
1842 IN_ULONG (session);
1843 IN_BYTE_BUFFER (digest, digest_len);
1844 PROCESS_CALL;
1845 OUT_BYTE_ARRAY (digest, digest_len);
1846 END_CALL;
1847 }
1848
1849 static CK_RV
1850 rpc_C_SignInit (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
1851 CK_OBJECT_HANDLE key)
1852 {
1853 BEGIN_CALL_OR (C_SignInit, CKR_SESSION_HANDLE_INVALID);
1854 IN_ULONG (session);
1855 IN_MECHANISM (mechanism);
1856 IN_ULONG (key);
1857 PROCESS_CALL;
1858 END_CALL;
1859 }
1860
1861 static CK_RV
1862 rpc_C_Sign (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len,
1863 CK_BYTE_PTR signature, CK_ULONG_PTR signature_len)
1864 {
1865 return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
1866
1867 BEGIN_CALL_OR (C_Sign, CKR_SESSION_HANDLE_INVALID);
1868 IN_ULONG (session);
1869 IN_BYTE_ARRAY (data, data_len);
1870 IN_BYTE_BUFFER (signature, signature_len);
1871 PROCESS_CALL;
1872 OUT_BYTE_ARRAY (signature, signature_len);
1873 END_CALL;
1874 }
1875
1876 static CK_RV
1877 rpc_C_SignUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len)
1878 {
1879 return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
1880
1881 BEGIN_CALL_OR (C_SignUpdate, CKR_SESSION_HANDLE_INVALID);
1882 IN_ULONG (session);
1883 IN_BYTE_ARRAY (part, part_len);
1884 PROCESS_CALL;
1885 END_CALL;
1886 }
1887
1888 static CK_RV
1889 rpc_C_SignFinal (CK_SESSION_HANDLE session, CK_BYTE_PTR signature,
1890 CK_ULONG_PTR signature_len)
1891 {
1892 return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
1893
1894 BEGIN_CALL_OR (C_SignFinal, CKR_SESSION_HANDLE_INVALID);
1895 IN_ULONG (session);
1896 IN_BYTE_BUFFER (signature, signature_len);
1897 PROCESS_CALL;
1898 OUT_BYTE_ARRAY (signature, signature_len);
1899 END_CALL;
1900 }
1901
1902 static CK_RV
1903 rpc_C_SignRecoverInit (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
1904 CK_OBJECT_HANDLE key)
1905 {
1906 BEGIN_CALL_OR (C_SignRecoverInit, CKR_SESSION_HANDLE_INVALID);
1907 IN_ULONG (session);
1908 IN_MECHANISM (mechanism);
1909 IN_ULONG (key);
1910 PROCESS_CALL;
1911 END_CALL;
1912 }
1913
1914 static CK_RV
1915 rpc_C_SignRecover (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len,
1916 CK_BYTE_PTR signature, CK_ULONG_PTR signature_len)
1917 {
1918 return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
1919
1920 BEGIN_CALL_OR (C_SignRecover, CKR_SESSION_HANDLE_INVALID);
1921 IN_ULONG (session);
1922 IN_BYTE_ARRAY (data, data_len);
1923 IN_BYTE_BUFFER (signature, signature_len);
1924 PROCESS_CALL;
1925 OUT_BYTE_ARRAY (signature, signature_len);
1926 END_CALL;
1927 }
1928
1929 static CK_RV
1930 rpc_C_VerifyInit (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
1931 CK_OBJECT_HANDLE key)
1932 {
1933 BEGIN_CALL_OR (C_VerifyInit, CKR_SESSION_HANDLE_INVALID);
1934 IN_ULONG (session);
1935 IN_MECHANISM (mechanism);
1936 IN_ULONG (key);
1937 PROCESS_CALL;
1938 END_CALL;
1939 }
1940
1941 static CK_RV
1942 rpc_C_Verify (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len,
1943 CK_BYTE_PTR signature, CK_ULONG signature_len)
1944 {
1945 BEGIN_CALL_OR (C_Verify, CKR_SESSION_HANDLE_INVALID);
1946 IN_ULONG (session);
1947 IN_BYTE_ARRAY (data, data_len);
1948 IN_BYTE_ARRAY (signature, signature_len);
1949 PROCESS_CALL;
1950 END_CALL;
1951 }
1952
1953 static CK_RV
1954 rpc_C_VerifyUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len)
1955 {
1956 BEGIN_CALL_OR (C_VerifyUpdate, CKR_SESSION_HANDLE_INVALID);
1957 IN_ULONG (session);
1958 IN_BYTE_ARRAY (part, part_len);
1959 PROCESS_CALL;
1960 END_CALL;
1961 }
1962
1963 static CK_RV
1964 rpc_C_VerifyFinal (CK_SESSION_HANDLE session, CK_BYTE_PTR signature,
1965 CK_ULONG signature_len)
1966 {
1967 BEGIN_CALL_OR (C_VerifyFinal, CKR_SESSION_HANDLE_INVALID);
1968 IN_ULONG (session);
1969 IN_BYTE_ARRAY (signature, signature_len);
1970 PROCESS_CALL;
1971 END_CALL;
1972 }
1973
1974 static CK_RV
1975 rpc_C_VerifyRecoverInit (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
1976 CK_OBJECT_HANDLE key)
1977 {
1978 BEGIN_CALL_OR (C_VerifyRecoverInit, CKR_SESSION_HANDLE_INVALID);
1979 IN_ULONG (session);
1980 IN_MECHANISM (mechanism);
1981 IN_ULONG (key);
1982 PROCESS_CALL;
1983 END_CALL;
1984 }
1985
1986 static CK_RV
1987 rpc_C_VerifyRecover (CK_SESSION_HANDLE session, CK_BYTE_PTR signature,
1988 CK_ULONG signature_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len)
1989 {
1990 return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
1991
1992 BEGIN_CALL_OR (C_VerifyRecover, CKR_SESSION_HANDLE_INVALID);
1993 IN_ULONG (session);
1994 IN_BYTE_ARRAY (signature, signature_len);
1995 IN_BYTE_BUFFER (data, data_len);
1996 PROCESS_CALL;
1997 OUT_BYTE_ARRAY (data, data_len);
1998 END_CALL;
1999 }
2000
2001 static CK_RV
2002 rpc_C_DigestEncryptUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part,
2003 CK_ULONG part_len, CK_BYTE_PTR enc_part,
2004 CK_ULONG_PTR enc_part_len)
2005 {
2006 return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
2007
2008 BEGIN_CALL_OR (C_DigestEncryptUpdate, CKR_SESSION_HANDLE_INVALID);
2009 IN_ULONG (session);
2010 IN_BYTE_ARRAY (part, part_len);
2011 IN_BYTE_BUFFER (enc_part, enc_part_len);
2012 PROCESS_CALL;
2013 OUT_BYTE_ARRAY (enc_part, enc_part_len);
2014 END_CALL;
2015 }
2016
2017 static CK_RV
2018 rpc_C_DecryptDigestUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR enc_part,
2019 CK_ULONG enc_part_len, CK_BYTE_PTR part,
2020 CK_ULONG_PTR part_len)
2021 {
2022 return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
2023
2024 BEGIN_CALL_OR (C_DecryptDigestUpdate, CKR_SESSION_HANDLE_INVALID);
2025 IN_ULONG (session);
2026 IN_BYTE_ARRAY (enc_part, enc_part_len);
2027 IN_BYTE_BUFFER (part, part_len);
2028 PROCESS_CALL;
2029 OUT_BYTE_ARRAY (part, part_len);
2030 END_CALL;
2031 }
2032
2033 static CK_RV
2034 rpc_C_SignEncryptUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part,
2035 CK_ULONG part_len, CK_BYTE_PTR enc_part,
2036 CK_ULONG_PTR enc_part_len)
2037 {
2038 return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
2039
2040 BEGIN_CALL_OR (C_SignEncryptUpdate, CKR_SESSION_HANDLE_INVALID);
2041 IN_ULONG (session);
2042 IN_BYTE_ARRAY (part, part_len);
2043 IN_BYTE_BUFFER (enc_part, enc_part_len);
2044 PROCESS_CALL;
2045 OUT_BYTE_ARRAY (enc_part, enc_part_len);
2046 END_CALL;
2047 }
2048
2049 static CK_RV
2050 rpc_C_DecryptVerifyUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR enc_part,
2051 CK_ULONG enc_part_len, CK_BYTE_PTR part,
2052 CK_ULONG_PTR part_len)
2053 {
2054 return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
2055
2056 BEGIN_CALL_OR (C_DecryptVerifyUpdate, CKR_SESSION_HANDLE_INVALID);
2057 IN_ULONG (session);
2058 IN_BYTE_ARRAY (enc_part, enc_part_len);
2059 IN_BYTE_BUFFER (part, part_len);
2060 PROCESS_CALL;
2061 OUT_BYTE_ARRAY (part, part_len);
2062 END_CALL;
2063 }
2064
2065 static CK_RV
2066 rpc_C_GenerateKey (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
2067 CK_ATTRIBUTE_PTR template, CK_ULONG count,
2068 CK_OBJECT_HANDLE_PTR key)
2069 {
2070 BEGIN_CALL_OR (C_GenerateKey, CKR_SESSION_HANDLE_INVALID);
2071 IN_ULONG (session);
2072 IN_MECHANISM (mechanism);
2073 IN_ATTRIBUTE_ARRAY (template, count);
2074 PROCESS_CALL;
2075 OUT_ULONG (key);
2076 END_CALL;
2077 }
2078
2079 static CK_RV
2080 rpc_C_GenerateKeyPair (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
2081 CK_ATTRIBUTE_PTR pub_template, CK_ULONG pub_count,
2082 CK_ATTRIBUTE_PTR priv_template, CK_ULONG priv_count,
2083 CK_OBJECT_HANDLE_PTR pub_key, CK_OBJECT_HANDLE_PTR priv_key)
2084 {
2085 BEGIN_CALL_OR (C_GenerateKeyPair, CKR_SESSION_HANDLE_INVALID);
2086 IN_ULONG (session);
2087 IN_MECHANISM (mechanism);
2088 IN_ATTRIBUTE_ARRAY (pub_template, pub_count);
2089 IN_ATTRIBUTE_ARRAY (priv_template, priv_count);
2090 PROCESS_CALL;
2091 OUT_ULONG (pub_key);
2092 OUT_ULONG (priv_key);
2093 END_CALL;
2094 }
2095
2096 static CK_RV
2097 rpc_C_WrapKey (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
2098 CK_OBJECT_HANDLE wrapping_key, CK_OBJECT_HANDLE key,
2099 CK_BYTE_PTR wrapped_key, CK_ULONG_PTR wrapped_key_len)
2100 {
2101 return_val_if_fail (wrapped_key_len, CKR_ARGUMENTS_BAD);
2102
2103 BEGIN_CALL_OR (C_WrapKey, CKR_SESSION_HANDLE_INVALID);
2104 IN_ULONG (session);
2105 IN_MECHANISM (mechanism);
2106 IN_ULONG (wrapping_key);
2107 IN_ULONG (key);
2108 IN_BYTE_BUFFER (wrapped_key, wrapped_key_len);
2109 PROCESS_CALL;
2110 OUT_BYTE_ARRAY (wrapped_key, wrapped_key_len);
2111 END_CALL;
2112 }
2113
2114 static CK_RV
2115 rpc_C_UnwrapKey (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
2116 CK_OBJECT_HANDLE unwrapping_key, CK_BYTE_PTR wrapped_key,
2117 CK_ULONG wrapped_key_len, CK_ATTRIBUTE_PTR template,
2118 CK_ULONG count, CK_OBJECT_HANDLE_PTR key)
2119 {
2120 BEGIN_CALL_OR (C_UnwrapKey, CKR_SESSION_HANDLE_INVALID);
2121 IN_ULONG (session);
2122 IN_MECHANISM (mechanism);
2123 IN_ULONG (unwrapping_key);
2124 IN_BYTE_ARRAY (wrapped_key, wrapped_key_len);
2125 IN_ATTRIBUTE_ARRAY (template, count);
2126 PROCESS_CALL;
2127 OUT_ULONG (key);
2128 END_CALL;
2129 }
2130
2131 static CK_RV
2132 rpc_C_DeriveKey (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism,
2133 CK_OBJECT_HANDLE base_key, CK_ATTRIBUTE_PTR template,
2134 CK_ULONG count, CK_OBJECT_HANDLE_PTR key)
2135 {
2136 BEGIN_CALL_OR (C_DeriveKey, CKR_SESSION_HANDLE_INVALID);
2137 IN_ULONG (session);
2138 IN_MECHANISM (mechanism);
2139 IN_ULONG (base_key);
2140 IN_ATTRIBUTE_ARRAY (template, count);
2141 PROCESS_CALL;
2142 OUT_ULONG (key);
2143 END_CALL;
2144 }
2145
2146 static CK_RV
2147 rpc_C_SeedRandom (CK_SESSION_HANDLE session, CK_BYTE_PTR seed, CK_ULONG seed_len)
2148 {
2149 BEGIN_CALL_OR (C_SeedRandom, CKR_SESSION_HANDLE_INVALID);
2150 IN_ULONG (session);
2151 IN_BYTE_ARRAY (seed, seed_len);
2152 PROCESS_CALL;
2153 END_CALL;
2154 }
2155
2156 static CK_RV
2157 rpc_C_GenerateRandom (CK_SESSION_HANDLE session, CK_BYTE_PTR random_data,
2158 CK_ULONG random_len)
2159 {
2160 CK_ULONG_PTR address = &random_len;
2161 BEGIN_CALL_OR (C_GenerateRandom, CKR_SESSION_HANDLE_INVALID);
2162 IN_ULONG (session);
2163 IN_BYTE_BUFFER (random_data, address);
2164 PROCESS_CALL;
2165 OUT_BYTE_ARRAY (random_data, address);
2166 END_CALL;
2167 }
2168
2169 /* --------------------------------------------------------------------
2170 * MODULE ENTRY POINT
2171 */
2172
2173 /*
2174 * PKCS#11 is broken here. It states that Unix compilers automatically byte
2175 * pack structures. This is wrong. GCC on Linux aligns to 4 by default.
2176 *
2177 * This results in incompatibilities. Where this structure's first version
2178 * members take up too much or too little space depending on how this module
2179 * is compiled.
2180 */
2181
2182 static CK_FUNCTION_LIST functionList = {
2183 { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR }, /* version */
2184 rpc_C_Initialize,
2185 rpc_C_Finalize,
2186 rpc_C_GetInfo,
2187 rpc_C_GetFunctionList,
2188 rpc_C_GetSlotList,
2189 rpc_C_GetSlotInfo,
2190 rpc_C_GetTokenInfo,
2191 rpc_C_GetMechanismList,
2192 rpc_C_GetMechanismInfo,
2193 rpc_C_InitToken,
2194 rpc_C_InitPIN,
2195 rpc_C_SetPIN,
2196 rpc_C_OpenSession,
2197 rpc_C_CloseSession,
2198 rpc_C_CloseAllSessions,
2199 rpc_C_GetSessionInfo,
2200 rpc_C_GetOperationState,
2201 rpc_C_SetOperationState,
2202 rpc_C_Login,
2203 rpc_C_Logout,
2204 rpc_C_CreateObject,
2205 rpc_C_CopyObject,
2206 rpc_C_DestroyObject,
2207 rpc_C_GetObjectSize,
2208 rpc_C_GetAttributeValue,
2209 rpc_C_SetAttributeValue,
2210 rpc_C_FindObjectsInit,
2211 rpc_C_FindObjects,
2212 rpc_C_FindObjectsFinal,
2213 rpc_C_EncryptInit,
2214 rpc_C_Encrypt,
2215 rpc_C_EncryptUpdate,
2216 rpc_C_EncryptFinal,
2217 rpc_C_DecryptInit,
2218 rpc_C_Decrypt,
2219 rpc_C_DecryptUpdate,
2220 rpc_C_DecryptFinal,
2221 rpc_C_DigestInit,
2222 rpc_C_Digest,
2223 rpc_C_DigestUpdate,
2224 rpc_C_DigestKey,
2225 rpc_C_DigestFinal,
2226 rpc_C_SignInit,
2227 rpc_C_Sign,
2228 rpc_C_SignUpdate,
2229 rpc_C_SignFinal,
2230 rpc_C_SignRecoverInit,
2231 rpc_C_SignRecover,
2232 rpc_C_VerifyInit,
2233 rpc_C_Verify,
2234 rpc_C_VerifyUpdate,
2235 rpc_C_VerifyFinal,
2236 rpc_C_VerifyRecoverInit,
2237 rpc_C_VerifyRecover,
2238 rpc_C_DigestEncryptUpdate,
2239 rpc_C_DecryptDigestUpdate,
2240 rpc_C_SignEncryptUpdate,
2241 rpc_C_DecryptVerifyUpdate,
2242 rpc_C_GenerateKey,
2243 rpc_C_GenerateKeyPair,
2244 rpc_C_WrapKey,
2245 rpc_C_UnwrapKey,
2246 rpc_C_DeriveKey,
2247 rpc_C_SeedRandom,
2248 rpc_C_GenerateRandom,
2249 rpc_C_GetFunctionStatus,
2250 rpc_C_CancelFunction,
2251 rpc_C_WaitForSlotEvent
2252 };
2253
2254 CK_RV
2255 C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
2256 {
2257 return_val_if_fail (list, CKR_ARGUMENTS_BAD);
2258
2259 *list = &functionList;
2260 return CKR_OK;
2261 }