Attachment 66161 Details for Bug 54105 – rpc: Implement PKCS#11 messages/client/server code

[patch] rpc: Implement PKCS#11 messages/client/server code

0002-rpc-Implement-PKCS-11-messages-client-server-code.patch (text/plain), 359.34 KB, created by Stef Walter on 2012-08-27 06:26:06 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Stef Walter

Created: 2012-08-27 06:26:06 UTC

Size: 359.34 KB

patch

obsolete

>From 5ab15db9ff43027935857d8b7751050a5fa1e01b Mon Sep 17 00:00:00 2001
>From: Stef Walter <stefw@gnome.org>
>Date: Thu, 23 Aug 2012 19:17:46 +0200
>Subject: [PATCH 2/2] rpc: Implement PKCS#11 messages/client/server code
>
> * This enables passing around byte arrays which represent PKCS#11 RPC
>   calls.
> * Caller is responsible for connecting/disconnecting and so on.
> * Client side caller gets a PKCS#11 CK_FUNCTION_LIST_PTR from
>   p11_rpc_client_register() to call into, which generates callbacks
>   with byte arrays to be transported.
> * Server side calls p11_rpc_server_handle() with a CK_FUNCTION_LIST_PTR
>   on which relevant methods get called.
> * Doesn't yet implement the actual daemon or clients etc...
>
>https://bugs.freedesktop.org/show_bug.cgi?id=54105
>---
> doc/Makefile.am       |    3 +
> p11-kit/Makefile.am   |    4 +
> p11-kit/debug.c       |    1 +
> p11-kit/debug.h       |    1 +
> p11-kit/private.h     |    2 +
> p11-kit/rpc-client.c  | 2251 ++++++++++++++++++++++++++++++++++++++++++++++
> p11-kit/rpc-message.c |  496 +++++++++++
> p11-kit/rpc-message.h |  299 +++++++
> p11-kit/rpc-private.h |   30 +
> p11-kit/rpc-server.c  | 1995 +++++++++++++++++++++++++++++++++++++++++
> p11-kit/rpc.h         |   33 +
> p11-kit/util.c        |    8 +
> tests/Makefile.am     |   15 +-
> tests/mock-module.c   | 2377 ++++++++++++++++++++++++++++++++++++++++++++++++-
> tests/mock-module.h   |  365 +++++++-
> tests/test-buffer.c   |   12 +-
> tests/test-init.c     |    2 +-
> tests/test-rpc.c      | 2275 ++++++++++++++++++++++++++++++++++++++++++++++
> 18 files changed, 10107 insertions(+), 62 deletions(-)
> create mode 100644 p11-kit/rpc-client.c
> create mode 100644 p11-kit/rpc-message.c
> create mode 100644 p11-kit/rpc-message.h
> create mode 100644 p11-kit/rpc-private.h
> create mode 100644 p11-kit/rpc-server.c
> create mode 100644 tests/test-rpc.c
>
>diff --git a/doc/Makefile.am b/doc/Makefile.am
>index 4a2d6bb..dad8d70 100644
>--- a/doc/Makefile.am
>+++ b/doc/Makefile.am
>@@ -51,6 +51,9 @@ IGNORE_HFILES= \
> 	pkcs11.h \
> 	private.h \
> 	ptr-array.h \
>+	rpc-client.h \
>+	rpc-message.h \
>+	rpc-server.h \
> 	util.h
> 
> # Images to copy into HTML directory.
>diff --git a/p11-kit/Makefile.am b/p11-kit/Makefile.am
>index 005fd61..940d239 100644
>--- a/p11-kit/Makefile.am
>+++ b/p11-kit/Makefile.am
>@@ -24,6 +24,8 @@ MODULE_SRCS = \
> 	proxy.c \
> 	private.h \
> 	ptr-array.c ptr-array.h \
>+	rpc-message.c rpc-message.h \
>+	rpc-client.c rpc-server.c rpc.h \
> 	messages.c \
> 	uri.c \
> 	util.c util.h \
>@@ -84,7 +86,9 @@ endif
> 
> libp11_kit_compat_la_SOURCES = \
> 	debug.c debug.h \
>+	hashmap.c hashmap.h \
> 	messages.c \
>+	ptr-array.c ptr-array.h \
> 	util.c util.h \
> 	$(top_srcdir)/common/compat.c \
> 	$(top_srcdir)/common/compat.h
>diff --git a/p11-kit/debug.c b/p11-kit/debug.c
>index a665d0f..f47cd58 100644
>--- a/p11-kit/debug.c
>+++ b/p11-kit/debug.c
>@@ -55,6 +55,7 @@ static struct DebugKey debug_keys[] = {
> 	{ "conf", DEBUG_CONF },
> 	{ "uri", DEBUG_URI },
> 	{ "proxy", DEBUG_PROXY },
>+	{ "rpc", DEBUG_RPC },
> 	{ 0, }
> };
> 
>diff --git a/p11-kit/debug.h b/p11-kit/debug.h
>index c6e26f5..6f1d07d 100644
>--- a/p11-kit/debug.h
>+++ b/p11-kit/debug.h
>@@ -43,6 +43,7 @@ typedef enum {
> 	DEBUG_CONF = 1 << 2,
> 	DEBUG_URI = 1 << 3,
> 	DEBUG_PROXY = 1 << 4,
>+	DEBUG_RPC = 1 << 5,
> } DebugFlags;
> 
> extern int        _p11_debug_current_flags;
>diff --git a/p11-kit/private.h b/p11-kit/private.h
>index f2cd181..c3ca327 100644
>--- a/p11-kit/private.h
>+++ b/p11-kit/private.h
>@@ -94,6 +94,8 @@ void        _p11_kit_clear_message                              (void);
> 
> void        _p11_kit_default_message                            (CK_RV rv);
> 
>+void        _p11_kit_be_loud                                    (void);
>+
> const char * _p11_get_progname_unlocked                         (void);
> 
> void        _p11_set_progname_unlocked                          (const char *progname);
>diff --git a/p11-kit/rpc-client.c b/p11-kit/rpc-client.c
>new file mode 100644
>index 0000000..d848e01
>--- /dev/null
>+++ b/p11-kit/rpc-client.c
>@@ -0,0 +1,2251 @@
>+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
>+/* client.c - a PKCS#11 module which communicates with another process
>+
>+   Copyright (C) 2012 Red Hat Inc.
>+
>+   The Gnome Keyring Library is free software; you can redistribute it and/or
>+   modify it under the terms of the GNU Library General Public License as
>+   published by the Free Software Foundation; either version 2 of the
>+   License, or (at your option) any later version.
>+
>+   The Gnome Keyring Library is distributed in the hope that it will be useful,
>+   but WITHOUT ANY WARRANTY; without even the implied warranty of
>+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+   Library General Public License for more details.
>+
>+   You should have received a copy of the GNU Library General Public
>+   License along with the Gnome Library; see the file COPYING.LIB.  If not,
>+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
>+   Boston, MA 02111-1307, USA.
>+
>+   Author: Stef Walter <stefw@gnome.org>
>+*/
>+
>+#include "config.h"
>+
>+#define DEBUG_FLAG DEBUG_RPC
>+#include "debug.h"
>+#include "pkcs11.h"
>+#include "private.h"
>+#include "rpc.h"
>+#include "rpc-message.h"
>+
>+#include <assert.h>
>+#include <pthread.h>
>+#include <string.h>
>+#include <unistd.h>
>+
>+/* The error used by us when parsing of rpc message fails */
>+#define PARSE_ERROR   CKR_DEVICE_ERROR
>+
>+typedef struct {
>+	int check;
>+	CK_FUNCTION_LIST_PTR function_list;
>+	pthread_mutex_t mutex;
>+	P11RpcClientVtable *vtable;
>+	pid_t initialized_pid;
>+	int initialize_done;
>+} RpcClient;
>+
>+#define RPC_CLIENT_INIT(id, function_list) \
>+	{ id, (CK_FUNCTION_LIST_PTR)function_list, PTHREAD_MUTEX_INITIALIZER, NULL, 0 }
>+
>+/* Allocator for call session buffers */
>+static void *
>+log_allocator (void *pointer,
>+               size_t size)
>+{
>+	void *result = realloc (pointer, (size_t)size);
>+	if (!result && size)
>+		_p11_message ("memory allocation of %lu bytes failed", size);
>+	return result;
>+}
>+
>+static CK_RV
>+call_prepare (RpcClient *module,
>+              RpcMessage *msg,
>+              int call_id)
>+{
>+	P11Buffer *buffer;
>+
>+	assert (module != NULL);
>+	assert (msg != NULL);
>+
>+	if (module->initialized_pid == 0)
>+		return CKR_CRYPTOKI_NOT_INITIALIZED;
>+	if (!module->initialize_done)
>+		return CKR_DEVICE_REMOVED;
>+
>+	buffer = p11_buffer_new_full (64, log_allocator, free);
>+	return_val_if_fail (buffer != NULL, CKR_GENERAL_ERROR);
>+
>+	/* We use the same buffer for reading and writing */
>+	_p11_rpc_message_init (msg, buffer, _p11_buffer_to_output (buffer));
>+
>+	/* Put in the Call ID and signature */
>+	if (!_p11_rpc_message_prep (msg, call_id, RPC_REQUEST))
>+		return CKR_HOST_MEMORY;
>+
>+	_p11_debug ("prepared call: %d", call_id);
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+call_run (RpcClient *module,
>+          RpcMessage *msg)
>+{
>+	CK_RV ret = CKR_OK;
>+	CK_ULONG ckerr;
>+
>+	int call_id;
>+
>+	assert (module != NULL);
>+	assert (msg != NULL);
>+
>+	/* Did building the call fail? */
>+	if (_p11_buffer_failed (msg->output))
>+		return_val_if_reached (CKR_HOST_MEMORY);
>+
>+	/* Make sure that the signature is valid */
>+	assert (_p11_rpc_message_is_verified (msg));
>+	call_id = msg->call_id;
>+
>+	/* Do the transport send and receive */
>+	assert (module->vtable->transport != NULL);
>+	ret = (module->vtable->transport) (module->vtable,
>+	                                   &msg->output->buf,
>+	                                   msg->input);
>+
>+	if (ret != CKR_OK)
>+		return ret;
>+
>+	if (!_p11_rpc_message_parse (msg, RPC_RESPONSE))
>+		return CKR_DEVICE_ERROR;
>+
>+	/* If it's an error code then return it */
>+	if (msg->call_id == RPC_CALL_ERROR) {
>+		if (!_p11_rpc_message_read_ulong (msg, &ckerr)) {
>+			_p11_message ("invalid rpc error response: too short");
>+			return CKR_DEVICE_ERROR;
>+		}
>+
>+		if (ckerr <= CKR_OK) {
>+			_p11_message ("invalid rpc error response: bad error code");
>+			return CKR_DEVICE_ERROR;
>+		}
>+
>+		/* An error code from the daemon */
>+		return (CK_RV)ckerr;
>+	}
>+
>+	/* Make sure daemon answered the right call */
>+	if (call_id != msg->call_id) {
>+		_p11_message ("invalid rpc response: call mismatch");
>+		return CKR_DEVICE_ERROR;
>+	}
>+
>+	assert (!_p11_buffer_failed (msg->input));
>+
>+	_p11_debug ("parsing response values");
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+call_done (RpcClient *module,
>+           RpcMessage *msg,
>+           CK_RV ret)
>+{
>+	assert (module != NULL);
>+	assert (msg != NULL);
>+
>+	/* Check for parsing errors that were not caught elsewhere */
>+	if (ret == CKR_OK) {
>+		if (_p11_buffer_failed (msg->input)) {
>+			_p11_message ("invalid rpc response: bad argument data");
>+			ret = CKR_GENERAL_ERROR;
>+		} else {
>+			/* Double check that the signature matched our decoding */
>+			assert (_p11_rpc_message_is_verified (msg));
>+		}
>+	}
>+
>+	/* We used the same buffer for input/output, so this frees both */
>+	assert (msg->input == &msg->output->buf);
>+	p11_buffer_free (msg->input);
>+
>+	_p11_rpc_message_clear (msg);
>+
>+	return ret;
>+}
>+
>+/* -----------------------------------------------------------------------------
>+ * MODULE SPECIFIC PROTOCOL CODE
>+ */
>+
>+static CK_RV
>+proto_read_attribute_array (RpcMessage *msg,
>+                            CK_ATTRIBUTE_PTR arr,
>+                            CK_ULONG len)
>+{
>+	uint32_t i, num, value, type;
>+	CK_ATTRIBUTE_PTR attr;
>+	const unsigned char *attrval;
>+	size_t attrlen;
>+	unsigned char validity;
>+	CK_RV ret;
>+
>+	assert (len != 0);
>+	assert (msg != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "aA"));
>+
>+	/* Get the number of items. We need this value to be correct */
>+	if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &num))
>+		return PARSE_ERROR;
>+
>+	/*
>+	 * This should never happen in normal operation. It denotes a goof up
>+	 * on the other side of our RPC. We should be indicating the exact number
>+	 * of attributes to the other side. And it should respond with the same
>+	 * number.
>+	 */
>+	if (len != num) {
>+		_p11_message ("received an attribute array with wrong number of attributes");
>+		return PARSE_ERROR;
>+	}
>+
>+	ret = CKR_OK;
>+
>+	/* We need to go ahead and read everything in all cases */
>+	for (i = 0; i < num; ++i) {
>+
>+		/* The attribute type */
>+		_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &type);
>+
>+		/* Attribute validity */
>+		_p11_buffer_get_byte (msg->input, msg->parsed, &msg->parsed, &validity);
>+
>+		/* And the data itself */
>+		if (validity) {
>+			if (_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &value) &&
>+			    _p11_buffer_get_byte_array (msg->input, msg->parsed, &msg->parsed, &attrval, &attrlen)) {
>+				if (attrval && value != attrlen) {
>+					_p11_message ("attribute length does not match attribute data");
>+					return PARSE_ERROR;
>+				}
>+				attrlen = value;
>+			}
>+		}
>+
>+		/* Don't act on this data unless no errors */
>+		if (_p11_buffer_failed (msg->input))
>+			break;
>+
>+		/* Try and stuff it in the output data */
>+		if (arr) {
>+			attr = &(arr[i]);
>+			if (attr->type != type) {
>+				_p11_message ("returned attributes in invalid order");
>+				return PARSE_ERROR;
>+			}
>+
>+			if (validity) {
>+				/* Just requesting the attribute size */
>+				if (!attr->pValue) {
>+					attr->ulValueLen = attrlen;
>+
>+				/* Wants attribute data, but too small */
>+				} else if (attr->ulValueLen < attrlen) {
>+					attr->ulValueLen = attrlen;
>+					ret = CKR_BUFFER_TOO_SMALL;
>+
>+				/* Wants attribute data, value is null */
>+				} else if (attrval == NULL) {
>+					attr->ulValueLen = 0;
>+
>+				/* Wants attribute data, enough space */
>+				} else {
>+					attr->ulValueLen = attrlen;
>+					memcpy (attr->pValue, attrval, attrlen);
>+				}
>+
>+			/* Not a valid attribute */
>+			} else {
>+				attr->ulValueLen = ((CK_ULONG)-1);
>+			}
>+		}
>+	}
>+
>+	if (_p11_buffer_failed (msg->input))
>+		return PARSE_ERROR;
>+
>+	/* Read in the code that goes along with these attributes */
>+	if (!_p11_rpc_message_read_ulong (msg, &ret))
>+		return PARSE_ERROR;
>+
>+	return ret;
>+}
>+
>+static CK_RV
>+proto_read_byte_array (RpcMessage *msg,
>+                       CK_BYTE_PTR arr,
>+                       CK_ULONG_PTR len,
>+                       CK_ULONG max)
>+{
>+	const unsigned char *val;
>+	unsigned char valid;
>+	uint32_t length;
>+	size_t vlen;
>+
>+	assert (len != NULL);
>+	assert (msg != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "ay"));
>+
>+	/* A single byte which determines whether valid or not */
>+	if (!_p11_buffer_get_byte (msg->input, msg->parsed, &msg->parsed, &valid))
>+		return PARSE_ERROR;
>+
>+	/* If not valid, then just the length is encoded, this can signify CKR_BUFFER_TOO_SMALL */
>+	if (!valid) {
>+		if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &length))
>+			return PARSE_ERROR;
>+
>+		*len = length;
>+
>+		if (arr)
>+			return CKR_BUFFER_TOO_SMALL;
>+		else
>+			return CKR_OK;
>+	}
>+
>+	/* Get the actual bytes */
>+	if (!_p11_buffer_get_byte_array (msg->input, msg->parsed, &msg->parsed, &val, &vlen))
>+		return PARSE_ERROR;
>+
>+	*len = vlen;
>+
>+	/* Just asking us for size */
>+	if (!arr)
>+		return CKR_OK;
>+
>+	if (max < vlen)
>+		return CKR_BUFFER_TOO_SMALL;
>+
>+	/* Enough space, yay */
>+	memcpy (arr, val, vlen);
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_ulong_array (RpcMessage *msg, CK_ULONG_PTR arr,
>+                        CK_ULONG_PTR len, CK_ULONG max)
>+{
>+	uint32_t i, num;
>+	uint64_t val;
>+	unsigned char valid;
>+
>+	assert (len != NULL);
>+	assert (msg != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "au"));
>+
>+	/* A single byte which determines whether valid or not */
>+	if (!_p11_buffer_get_byte (msg->input, msg->parsed, &msg->parsed, &valid))
>+		return PARSE_ERROR;
>+
>+	/* Get the number of items. */
>+	if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &num))
>+		return PARSE_ERROR;
>+
>+	*len = num;
>+
>+	/* If not valid, then just the length is encoded, this can signify CKR_BUFFER_TOO_SMALL */
>+	if (!valid) {
>+		if (arr)
>+			return CKR_BUFFER_TOO_SMALL;
>+		else
>+			return CKR_OK;
>+	}
>+
>+	if (max < num)
>+		return CKR_BUFFER_TOO_SMALL;
>+
>+	/* We need to go ahead and read everything in all cases */
>+	for (i = 0; i < num; ++i) {
>+		_p11_buffer_get_uint64 (msg->input, msg->parsed, &msg->parsed, &val);
>+		if (arr)
>+			arr[i] = (CK_ULONG)val;
>+	}
>+
>+	return _p11_buffer_failed (msg->input) ? PARSE_ERROR : CKR_OK;
>+}
>+
>+/* Used to override the supported mechanisms in tests */
>+CK_MECHANISM_TYPE *_p11_rpc_mechanisms_override_supported = NULL;
>+
>+static int
>+mechanism_has_sane_parameters (CK_MECHANISM_TYPE type)
>+{
>+	int i;
>+
>+	/* This can be set from tests, to override default set of supported */
>+	if (_p11_rpc_mechanisms_override_supported) {
>+		for (i = 0; _p11_rpc_mechanisms_override_supported[i] != 0; i++) {
>+			if (_p11_rpc_mechanisms_override_supported[i] == type)
>+				return 1;
>+		}
>+
>+		return 0;
>+	}
>+
>+	/* This list is incomplete */
>+	switch (type) {
>+	case CKM_RSA_PKCS_OAEP:
>+	case CKM_RSA_PKCS_PSS:
>+		return 1;
>+	default:
>+		return 0;
>+	}
>+}
>+
>+static int
>+mechanism_has_no_parameters (CK_MECHANISM_TYPE mech)
>+{
>+	/* This list is incomplete */
>+
>+	switch (mech) {
>+	case CKM_RSA_PKCS_KEY_PAIR_GEN:
>+	case CKM_RSA_X9_31_KEY_PAIR_GEN:
>+	case CKM_RSA_PKCS:
>+	case CKM_RSA_9796:
>+	case CKM_RSA_X_509:
>+	case CKM_RSA_X9_31:
>+	case CKM_MD2_RSA_PKCS:
>+	case CKM_MD5_RSA_PKCS:
>+	case CKM_SHA1_RSA_PKCS:
>+	case CKM_SHA256_RSA_PKCS:
>+	case CKM_SHA384_RSA_PKCS:
>+	case CKM_SHA512_RSA_PKCS:
>+	case CKM_RIPEMD128_RSA_PKCS:
>+	case CKM_RIPEMD160_RSA_PKCS:
>+	case CKM_SHA1_RSA_X9_31:
>+	case CKM_DSA_KEY_PAIR_GEN:
>+	case CKM_DSA_PARAMETER_GEN:
>+	case CKM_DSA:
>+	case CKM_DSA_SHA1:
>+	case CKM_FORTEZZA_TIMESTAMP:
>+	case CKM_EC_KEY_PAIR_GEN:
>+	case CKM_ECDSA:
>+	case CKM_ECDSA_SHA1:
>+	case CKM_DH_PKCS_KEY_PAIR_GEN:
>+	case CKM_DH_PKCS_PARAMETER_GEN:
>+	case CKM_X9_42_DH_KEY_PAIR_GEN:
>+	case CKM_X9_42_DH_PARAMETER_GEN:
>+	case CKM_KEA_KEY_PAIR_GEN:
>+	case CKM_GENERIC_SECRET_KEY_GEN:
>+	case CKM_RC2_KEY_GEN:
>+	case CKM_RC4_KEY_GEN:
>+	case CKM_RC4:
>+	case CKM_RC5_KEY_GEN:
>+	case CKM_AES_KEY_GEN:
>+	case CKM_AES_ECB:
>+	case CKM_AES_MAC:
>+	case CKM_DES_KEY_GEN:
>+	case CKM_DES2_KEY_GEN:
>+	case CKM_DES3_KEY_GEN:
>+	case CKM_CDMF_KEY_GEN:
>+	case CKM_CAST_KEY_GEN:
>+	case CKM_CAST3_KEY_GEN:
>+	case CKM_CAST128_KEY_GEN:
>+	case CKM_IDEA_KEY_GEN:
>+	case CKM_SSL3_PRE_MASTER_KEY_GEN:
>+	case CKM_TLS_PRE_MASTER_KEY_GEN:
>+	case CKM_SKIPJACK_KEY_GEN:
>+	case CKM_BATON_KEY_GEN:
>+	case CKM_JUNIPER_KEY_GEN:
>+	case CKM_RC2_ECB:
>+	case CKM_DES_ECB:
>+	case CKM_DES3_ECB:
>+	case CKM_CDMF_ECB:
>+	case CKM_CAST_ECB:
>+	case CKM_CAST3_ECB:
>+	case CKM_CAST128_ECB:
>+	case CKM_RC5_ECB:
>+	case CKM_IDEA_ECB:
>+	case CKM_RC2_MAC:
>+	case CKM_DES_MAC:
>+	case CKM_DES3_MAC:
>+	case CKM_CDMF_MAC:
>+	case CKM_CAST_MAC:
>+	case CKM_CAST3_MAC:
>+	case CKM_RC5_MAC:
>+	case CKM_IDEA_MAC:
>+	case CKM_SSL3_MD5_MAC:
>+	case CKM_SSL3_SHA1_MAC:
>+	case CKM_SKIPJACK_WRAP:
>+	case CKM_BATON_WRAP:
>+	case CKM_JUNIPER_WRAP:
>+	case CKM_MD2:
>+	case CKM_MD2_HMAC:
>+	case CKM_MD5:
>+	case CKM_MD5_HMAC:
>+	case CKM_SHA_1:
>+	case CKM_SHA_1_HMAC:
>+	case CKM_SHA256:
>+	case CKM_SHA256_HMAC:
>+	case CKM_SHA384:
>+	case CKM_SHA384_HMAC:
>+	case CKM_SHA512:
>+	case CKM_SHA512_HMAC:
>+	case CKM_FASTHASH:
>+	case CKM_RIPEMD128:
>+	case CKM_RIPEMD128_HMAC:
>+	case CKM_RIPEMD160:
>+	case CKM_RIPEMD160_HMAC:
>+	case CKM_KEY_WRAP_LYNKS:
>+		return 1;
>+	default:
>+		return 0;
>+	};
>+}
>+
>+static int
>+mechanism_is_supported (CK_MECHANISM_TYPE mech)
>+{
>+	if (mechanism_has_no_parameters (mech) ||
>+	    mechanism_has_sane_parameters (mech))
>+		return 1;
>+	return 0;
>+}
>+static void
>+mechanism_list_purge (CK_MECHANISM_TYPE_PTR mechs,
>+                      CK_ULONG *n_mechs)
>+{
>+	int i;
>+
>+	assert (mechs != NULL);
>+	assert (n_mechs != NULL);
>+
>+	for (i = 0; i < (int)(*n_mechs); ++i) {
>+		if (!mechanism_is_supported (mechs[i])) {
>+
>+			/* Remove the mechanism from the list */
>+			memmove (&mechs[i], &mechs[i + 1],
>+			         (*n_mechs - i) * sizeof (CK_MECHANISM_TYPE));
>+
>+			--(*n_mechs);
>+			--i;
>+		}
>+	}
>+}
>+
>+static CK_RV
>+proto_write_mechanism (RpcMessage *msg,
>+                       CK_MECHANISM_PTR mech)
>+{
>+	assert (msg != NULL);
>+	assert (mech != NULL);
>+	assert (msg->output != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "M"));
>+
>+	/* The mechanism type */
>+	_p11_buffer_add_uint32 (msg->output, mech->mechanism);
>+
>+	/*
>+	 * PKCS#11 mechanism parameters are not easy to serialize. They're
>+	 * completely different for so many mechanisms, they contain
>+	 * pointers to arbitrary memory, and many callers don't initialize
>+	 * them completely or properly.
>+	 *
>+	 * We only support certain mechanisms.
>+	 *
>+	 * Also callers do yucky things like leaving parts of the structure
>+	 * pointing to garbage if they don't think it's going to be used.
>+	 */
>+
>+	if (mechanism_has_no_parameters (mech->mechanism))
>+		_p11_buffer_add_byte_array (msg->output, NULL, 0);
>+	else if (mechanism_has_sane_parameters (mech->mechanism))
>+		_p11_buffer_add_byte_array (msg->output, mech->pParameter,
>+		                            mech->ulParameterLen);
>+	else
>+		return CKR_MECHANISM_INVALID;
>+
>+	return _p11_buffer_failed (msg->output) ? CKR_HOST_MEMORY : CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_info (RpcMessage *msg,
>+                 CK_INFO_PTR info)
>+{
>+	assert (msg != NULL);
>+	assert (info != NULL);
>+
>+	if (!_p11_rpc_message_read_version (msg, &info->cryptokiVersion) ||
>+	    !_p11_rpc_message_read_space_string (msg, info->manufacturerID, 32) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->flags) ||
>+	    !_p11_rpc_message_read_space_string (msg, info->libraryDescription, 32) ||
>+	    !_p11_rpc_message_read_version (msg, &info->libraryVersion))
>+		return PARSE_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_slot_info (RpcMessage *msg,
>+                      CK_SLOT_INFO_PTR info)
>+{
>+	assert (msg != NULL);
>+	assert (info != NULL);
>+
>+	if (!_p11_rpc_message_read_space_string (msg, info->slotDescription, 64) ||
>+	    !_p11_rpc_message_read_space_string (msg, info->manufacturerID, 32) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->flags) ||
>+	    !_p11_rpc_message_read_version (msg, &info->hardwareVersion) ||
>+	    !_p11_rpc_message_read_version (msg, &info->firmwareVersion))
>+		return PARSE_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_token_info (RpcMessage *msg,
>+                       CK_TOKEN_INFO_PTR info)
>+{
>+	assert (msg != NULL);
>+	assert (info != NULL);
>+
>+	if (!_p11_rpc_message_read_space_string (msg, info->label, 32) ||
>+	    !_p11_rpc_message_read_space_string (msg, info->manufacturerID, 32) ||
>+	    !_p11_rpc_message_read_space_string (msg, info->model, 16) ||
>+	    !_p11_rpc_message_read_space_string (msg, info->serialNumber, 16) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->flags) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulMaxSessionCount) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulSessionCount) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulMaxRwSessionCount) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulRwSessionCount) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulMaxPinLen) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulMinPinLen) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulTotalPublicMemory) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulFreePublicMemory) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulTotalPrivateMemory) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulFreePrivateMemory) ||
>+	    !_p11_rpc_message_read_version (msg, &info->hardwareVersion) ||
>+	    !_p11_rpc_message_read_version (msg, &info->firmwareVersion) ||
>+	    !_p11_rpc_message_read_space_string (msg, info->utcTime, 16))
>+		return PARSE_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_mechanism_info (RpcMessage *msg,
>+                           CK_MECHANISM_INFO_PTR info)
>+{
>+	assert (msg != NULL);
>+	assert (info != NULL);
>+
>+	if (!_p11_rpc_message_read_ulong (msg, &info->ulMinKeySize) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulMaxKeySize) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->flags))
>+		return PARSE_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_sesssion_info (RpcMessage *msg,
>+                          CK_SESSION_INFO_PTR info)
>+{
>+	assert (msg != NULL);
>+	assert (info != NULL);
>+
>+	if (!_p11_rpc_message_read_ulong (msg, &info->slotID) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->state) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->flags) ||
>+	    !_p11_rpc_message_read_ulong (msg, &info->ulDeviceError))
>+		return PARSE_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+/* -------------------------------------------------------------------
>+ * CALL MACROS
>+ */
>+
>+#define BEGIN_CALL_OR(call_id, module, if_no_daemon) \
>+	_p11_debug (#call_id ": enter"); \
>+	{ \
>+		RpcClient *_mod = module; RpcMessage _msg; \
>+		CK_RV _ret = call_prepare (_mod, &_msg, RPC_CALL_##call_id); \
>+		if (_ret == CKR_DEVICE_REMOVED) return (if_no_daemon); \
>+		if (_ret != CKR_OK) return _ret;
>+
>+#define PROCESS_CALL \
>+		_ret = call_run (_mod, &_msg); \
>+		if (_ret != CKR_OK) goto _cleanup;
>+
>+#define RETURN(ret) \
>+		_ret = ret; \
>+		goto _cleanup;
>+
>+#define END_CALL \
>+	_cleanup: \
>+		_ret = call_done (_mod, &_msg, _ret); \
>+		_p11_debug ("ret: %lu", _ret); \
>+		return _ret; \
>+	}
>+
>+#define IN_BYTE(val) \
>+	if (!_p11_rpc_message_write_byte (&_msg, val)) \
>+		{ _ret = CKR_HOST_MEMORY; goto _cleanup; }
>+
>+#define IN_ULONG(val) \
>+	if (!_p11_rpc_message_write_ulong (&_msg, val)) \
>+		{ _ret = CKR_HOST_MEMORY; goto _cleanup; }
>+
>+#define IN_STRING(val) \
>+	if (!_p11_rpc_message_write_zero_string (&_msg, val)) \
>+		{ _ret = CKR_HOST_MEMORY; goto _cleanup; }
>+
>+#define IN_BYTE_BUFFER(arr, len) \
>+	if (len == NULL) \
>+		{ _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
>+	if (!_p11_rpc_message_write_byte_buffer (&_msg, arr ? *len : 0)) \
>+		{ _ret = CKR_HOST_MEMORY; goto _cleanup; }
>+
>+#define IN_BYTE_ARRAY(arr, len) \
>+	if (len != 0 && arr == NULL) \
>+		{ _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
>+	if (!_p11_rpc_message_write_byte_array (&_msg, arr, len)) \
>+		{ _ret = CKR_HOST_MEMORY; goto _cleanup; }
>+
>+#define IN_ULONG_BUFFER(arr, len) \
>+	if (len == NULL) \
>+		{ _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
>+	if (!_p11_rpc_message_write_ulong_buffer (&_msg, arr ? *len : 0)) \
>+		{ _ret = CKR_HOST_MEMORY; goto _cleanup; }
>+
>+#define IN_ULONG_ARRAY(arr, len) \
>+	if (len != 0 && arr == NULL) \
>+		{ _ret = CKR_ARGUMENTS_BAD; goto _cleanup; }\
>+	if (!_p11_rpc_message_write_ulong_array (&_msg, arr, len)) \
>+		{ _ret = CKR_HOST_MEMORY; goto _cleanup; }
>+
>+#define IN_ATTRIBUTE_BUFFER(arr, num) \
>+	if (num != 0 && arr == NULL) \
>+		{ _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
>+	if (!_p11_rpc_message_write_attribute_buffer (&_msg, (arr), (num))) \
>+		{ _ret = CKR_HOST_MEMORY; goto _cleanup; }
>+
>+#define IN_ATTRIBUTE_ARRAY(arr, num) \
>+	if (num != 0 && arr == NULL) \
>+		{ _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
>+	if (!_p11_rpc_message_write_attribute_array (&_msg, (arr), (num))) \
>+		{ _ret = CKR_HOST_MEMORY; goto _cleanup; }
>+
>+#define IN_MECHANISM_TYPE(val) \
>+	if(!mechanism_is_supported (val)) \
>+		{ _ret = CKR_MECHANISM_INVALID; goto _cleanup; } \
>+	if (!_p11_rpc_message_write_ulong (&_msg, val)) \
>+		{ _ret = CKR_HOST_MEMORY; goto _cleanup; }
>+
>+#define IN_MECHANISM(val) \
>+	if (val == NULL) \
>+		{ _ret = CKR_ARGUMENTS_BAD; goto _cleanup; } \
>+	_ret = proto_write_mechanism (&_msg, val); \
>+	if (_ret != CKR_OK) goto _cleanup;
>+
>+
>+
>+#define OUT_ULONG(val) \
>+	if (val == NULL) \
>+		_ret = CKR_ARGUMENTS_BAD; \
>+	if (_ret == CKR_OK && !_p11_rpc_message_read_ulong (&_msg, val)) \
>+		_ret = PARSE_ERROR;
>+
>+#define OUT_BYTE_ARRAY(arr, len)  \
>+	if (len == NULL) \
>+		_ret = CKR_ARGUMENTS_BAD; \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_read_byte_array (&_msg, (arr), (len), *(len));
>+
>+#define OUT_ULONG_ARRAY(a, len) \
>+	if (len == NULL) \
>+		_ret = CKR_ARGUMENTS_BAD; \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_read_ulong_array (&_msg, (a), (len), *(len));
>+
>+#define OUT_ATTRIBUTE_ARRAY(arr, num) \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_read_attribute_array (&_msg, (arr), (num));
>+
>+#define OUT_INFO(info) \
>+	if (info == NULL) \
>+		_ret = CKR_ARGUMENTS_BAD; \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_read_info (&_msg, info);
>+
>+#define OUT_SLOT_INFO(info) \
>+	if (info == NULL) \
>+		_ret = CKR_ARGUMENTS_BAD; \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_read_slot_info (&_msg, info);
>+
>+#define OUT_TOKEN_INFO(info) \
>+	if (info == NULL) \
>+		_ret = CKR_ARGUMENTS_BAD; \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_read_token_info (&_msg, info);
>+
>+#define OUT_SESSION_INFO(info) \
>+	if (info == NULL) \
>+		_ret = CKR_ARGUMENTS_BAD; \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_read_sesssion_info (&_msg, info);
>+
>+#define OUT_MECHANISM_TYPE_ARRAY(arr, len) \
>+	if (len == NULL) \
>+		_ret = CKR_ARGUMENTS_BAD; \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_read_ulong_array (&_msg, (arr), (len), *(len)); \
>+	if (_ret == CKR_OK && arr) \
>+		mechanism_list_purge (arr, len);
>+
>+#define OUT_MECHANISM_INFO(info) \
>+	if (info == NULL) \
>+		_ret = CKR_ARGUMENTS_BAD; \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_read_mechanism_info (&_msg, info);
>+
>+
>+/* -------------------------------------------------------------------
>+ * INITIALIZATION and 'GLOBAL' CALLS
>+ */
>+
>+static CK_RV
>+rpc_C_Initialize (RpcClient *module,
>+                  CK_VOID_PTR init_args)
>+{
>+	CK_C_INITIALIZE_ARGS_PTR args = NULL;
>+	void *reserved = NULL;
>+	CK_RV ret = CKR_OK;
>+	RpcMessage msg;
>+	pid_t pid;
>+
>+	assert (module != NULL);
>+	_p11_debug ("C_Initialize: enter");
>+
>+	if (init_args != NULL) {
>+		int supplied_ok;
>+
>+		/* pReserved must be NULL */
>+		args = init_args;
>+
>+		/* ALL supplied function pointers need to have the value either NULL or non-NULL. */
>+		supplied_ok = (args->CreateMutex == NULL && args->DestroyMutex == NULL &&
>+		               args->LockMutex == NULL && args->UnlockMutex == NULL) ||
>+		              (args->CreateMutex != NULL && args->DestroyMutex != NULL &&
>+		               args->LockMutex != NULL && args->UnlockMutex != NULL);
>+		if (!supplied_ok) {
>+			_p11_message ("invalid set of mutex calls supplied");
>+			return CKR_ARGUMENTS_BAD;
>+		}
>+
>+		/*
>+		 * When the CKF_OS_LOCKING_OK flag isn't set return an error.
>+		 * We must be able to use our pthread functionality.
>+		 */
>+		if (!(args->flags & CKF_OS_LOCKING_OK)) {
>+			_p11_message ("can't do without os locking");
>+			return CKR_CANT_LOCK;
>+		}
>+
>+		if (args->pReserved)
>+			reserved = args->pReserved;
>+	}
>+
>+	pthread_mutex_lock (&module->mutex);
>+
>+	pid = getpid ();
>+	if (module->initialized_pid != 0) {
>+		/* This process has called C_Initialize already */
>+		if (pid == module->initialized_pid) {
>+			_p11_message ("C_Initialize called twice for same process");
>+			ret = CKR_CRYPTOKI_ALREADY_INITIALIZED;
>+			goto done;
>+		}
>+	}
>+
>+	/* Call out to initialize client callback */
>+	assert (module->vtable->connect != NULL);
>+	ret = (module->vtable->connect) (module->vtable, reserved);
>+
>+	/* Successfully initialized */
>+	if (ret == CKR_OK) {
>+		module->initialized_pid = pid;
>+		module->initialize_done = 1;
>+
>+	/* Server doesn't exist, initialize but don't call */
>+	} else if (ret == CKR_DEVICE_REMOVED) {
>+		module->initialized_pid = pid;
>+		module->initialize_done = 0;
>+		ret = CKR_OK;
>+		goto done;
>+
>+	} else {
>+		goto done;
>+	}
>+
>+	/* If we don't have read and write fds now, then initialize other side */
>+	ret = call_prepare (module, &msg, RPC_CALL_C_Initialize);
>+	if (ret == CKR_OK)
>+		if (!_p11_rpc_message_write_byte_array (&msg, RPC_HANDSHAKE, RPC_HANDSHAKE_LEN))
>+			ret = CKR_HOST_MEMORY;
>+	if (ret == CKR_OK)
>+		ret = call_run (module, &msg);
>+	call_done (module, &msg, ret);
>+
>+done:
>+	/* If failed then unmark initialized */
>+	if (ret != CKR_OK && ret != CKR_CRYPTOKI_ALREADY_INITIALIZED)
>+		module->initialized_pid = 0;
>+
>+	/* If we told our caller that we're initialized, but not really, then finalize */
>+	if (ret != CKR_OK && module->initialize_done) {
>+		module->initialize_done = 0;
>+		assert (module->vtable->disconnect != NULL);
>+		(module->vtable->disconnect) (module->vtable, reserved);
>+	}
>+
>+	pthread_mutex_unlock (&module->mutex);
>+
>+	_p11_debug ("C_Initialize: %lu", ret);
>+	return ret;
>+}
>+
>+static CK_RV
>+rpc_C_Finalize (RpcClient *module,
>+                CK_VOID_PTR reserved)
>+{
>+	CK_RV ret = CKR_OK;
>+	RpcMessage msg;
>+
>+	_p11_debug ("C_Finalize: enter");
>+	return_val_if_fail (module->initialized_pid != 0, CKR_CRYPTOKI_NOT_INITIALIZED);
>+	return_val_if_fail (!reserved, CKR_ARGUMENTS_BAD);
>+
>+	pthread_mutex_lock (&module->mutex);
>+
>+	if (module->initialize_done) {
>+		ret = call_prepare (module, &msg, RPC_CALL_C_Finalize);
>+		if (ret == CKR_OK)
>+			ret = call_run (module, &msg);
>+		call_done (module, &msg, ret);
>+		if (ret != CKR_OK)
>+			_p11_message ("finalizing the daemon returned an error: %lu", ret);
>+
>+		module->initialize_done = 0;
>+		assert (module->vtable->disconnect != NULL);
>+		(module->vtable->disconnect) (module->vtable, reserved);
>+	}
>+
>+	module->initialized_pid = 0;
>+
>+	pthread_mutex_unlock (&module->mutex);
>+
>+	_p11_debug ("C_Finalize: %lu", CKR_OK);
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+fill_stand_in_info (CK_INFO_PTR info)
>+{
>+	static CK_INFO stand_in_info = {
>+		{ CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },
>+		"p11-kit                         ",
>+		0,
>+		"p11-kit (no connection)         ",
>+		{ 1, 1 },
>+	};
>+	memcpy (info, &stand_in_info, sizeof (CK_INFO));
>+	return CKR_OK;
>+
>+}
>+
>+static CK_RV
>+rpc_C_GetInfo (RpcClient *module,
>+               CK_INFO_PTR info)
>+{
>+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_GetInfo, module, fill_stand_in_info (info));
>+	PROCESS_CALL;
>+		OUT_INFO (info);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetFunctionList (RpcClient *module,
>+                       CK_FUNCTION_LIST_PTR_PTR list)
>+{
>+	return_val_if_fail (list != NULL, CKR_ARGUMENTS_BAD);
>+	*list = module->function_list;
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+rpc_C_GetSlotList (RpcClient *module,
>+                   CK_BBOOL token_present,
>+                   CK_SLOT_ID_PTR slot_list,
>+                   CK_ULONG_PTR count)
>+{
>+	return_val_if_fail (count, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_GetSlotList, module, (*count = 0, CKR_OK));
>+		IN_BYTE (token_present);
>+		IN_ULONG_BUFFER (slot_list, count);
>+	PROCESS_CALL;
>+		OUT_ULONG_ARRAY (slot_list, count);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetSlotInfo (RpcClient *module,
>+                   CK_SLOT_ID slot_id,
>+                   CK_SLOT_INFO_PTR info)
>+{
>+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_GetSlotInfo, module, CKR_SLOT_ID_INVALID);
>+		IN_ULONG (slot_id);
>+	PROCESS_CALL;
>+		OUT_SLOT_INFO (info);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetTokenInfo (RpcClient *module,
>+                    CK_SLOT_ID slot_id,
>+                    CK_TOKEN_INFO_PTR info)
>+{
>+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_GetTokenInfo, module, CKR_SLOT_ID_INVALID);
>+		IN_ULONG (slot_id);
>+	PROCESS_CALL;
>+		OUT_TOKEN_INFO (info);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetMechanismList (RpcClient *module,
>+                        CK_SLOT_ID slot_id,
>+                        CK_MECHANISM_TYPE_PTR mechanism_list,
>+                        CK_ULONG_PTR count)
>+{
>+	return_val_if_fail (count, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_GetMechanismList, module, CKR_SLOT_ID_INVALID);
>+		IN_ULONG (slot_id);
>+		IN_ULONG_BUFFER (mechanism_list, count);
>+	PROCESS_CALL;
>+		OUT_MECHANISM_TYPE_ARRAY (mechanism_list, count);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetMechanismInfo (RpcClient *module,
>+                        CK_SLOT_ID slot_id,
>+                        CK_MECHANISM_TYPE type,
>+                        CK_MECHANISM_INFO_PTR info)
>+{
>+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_GetMechanismInfo, module, CKR_SLOT_ID_INVALID);
>+		IN_ULONG (slot_id);
>+		IN_MECHANISM_TYPE (type);
>+	PROCESS_CALL;
>+		OUT_MECHANISM_INFO (info);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_InitToken (RpcClient *module,
>+                 CK_SLOT_ID slot_id,
>+                 CK_UTF8CHAR_PTR pin, CK_ULONG pin_len,
>+                 CK_UTF8CHAR_PTR label)
>+{
>+	BEGIN_CALL_OR (C_InitToken, module, CKR_SLOT_ID_INVALID);
>+		IN_ULONG (slot_id);
>+		IN_BYTE_ARRAY (pin, pin_len);
>+		IN_STRING (label);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_WaitForSlotEvent (RpcClient *module,
>+                        CK_FLAGS flags,
>+                        CK_SLOT_ID_PTR slot,
>+                        CK_VOID_PTR reserved)
>+{
>+	return_val_if_fail (slot, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_WaitForSlotEvent, module, CKR_DEVICE_REMOVED);
>+		IN_ULONG (flags);
>+	PROCESS_CALL;
>+		OUT_ULONG (slot);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_OpenSession (RpcClient *module,
>+                   CK_SLOT_ID slot_id,
>+                   CK_FLAGS flags,
>+                   CK_VOID_PTR user_data,
>+                   CK_NOTIFY callback,
>+                   CK_SESSION_HANDLE_PTR session)
>+{
>+	return_val_if_fail (session, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_OpenSession, module, CKR_SLOT_ID_INVALID);
>+		IN_ULONG (slot_id);
>+		IN_ULONG (flags);
>+	PROCESS_CALL;
>+		OUT_ULONG (session);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_CloseSession (RpcClient *module,
>+                    CK_SESSION_HANDLE session)
>+{
>+	BEGIN_CALL_OR (C_CloseSession, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_CloseAllSessions (RpcClient *module,
>+                        CK_SLOT_ID slot_id)
>+{
>+	BEGIN_CALL_OR (C_CloseAllSessions, module, CKR_SLOT_ID_INVALID);
>+		IN_ULONG (slot_id);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetFunctionStatus (RpcClient *module,
>+                         CK_SESSION_HANDLE session)
>+{
>+	BEGIN_CALL_OR (C_GetFunctionStatus, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_CancelFunction (RpcClient *module,
>+                      CK_SESSION_HANDLE session)
>+{
>+	BEGIN_CALL_OR (C_CancelFunction, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetSessionInfo (RpcClient *module,
>+                      CK_SESSION_HANDLE session,
>+                      CK_SESSION_INFO_PTR info)
>+{
>+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_GetSessionInfo, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+	PROCESS_CALL;
>+		OUT_SESSION_INFO (info);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_InitPIN (RpcClient *module,
>+               CK_SESSION_HANDLE session,
>+               CK_UTF8CHAR_PTR pin,
>+               CK_ULONG pin_len)
>+{
>+	BEGIN_CALL_OR (C_InitPIN, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (pin, pin_len);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SetPIN (RpcClient *module,
>+              CK_SESSION_HANDLE session,
>+              CK_UTF8CHAR_PTR old_pin,
>+              CK_ULONG old_pin_len,
>+              CK_UTF8CHAR_PTR new_pin,
>+              CK_ULONG new_pin_len)
>+{
>+	BEGIN_CALL_OR (C_SetPIN, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (old_pin, old_pin_len);
>+		IN_BYTE_ARRAY (new_pin, new_pin_len);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetOperationState (RpcClient *module,
>+                         CK_SESSION_HANDLE session,
>+                         CK_BYTE_PTR operation_state,
>+                         CK_ULONG_PTR operation_state_len)
>+{
>+	return_val_if_fail (operation_state_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_GetOperationState, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (operation_state, operation_state_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (operation_state, operation_state_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SetOperationState (RpcClient *module,
>+                         CK_SESSION_HANDLE session,
>+                         CK_BYTE_PTR operation_state,
>+                         CK_ULONG operation_state_len,
>+                         CK_OBJECT_HANDLE encryption_key,
>+                         CK_OBJECT_HANDLE authentication_key)
>+{
>+	BEGIN_CALL_OR (C_SetOperationState, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (operation_state, operation_state_len);
>+		IN_ULONG (encryption_key);
>+		IN_ULONG (authentication_key);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Login (RpcClient *module,
>+             CK_SESSION_HANDLE session,
>+             CK_USER_TYPE user_type,
>+             CK_UTF8CHAR_PTR pin,
>+             CK_ULONG pin_len)
>+{
>+	BEGIN_CALL_OR (C_Login, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_ULONG (user_type);
>+		IN_BYTE_ARRAY (pin, pin_len);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Logout (RpcClient *module,
>+              CK_SESSION_HANDLE session)
>+{
>+	BEGIN_CALL_OR (C_Logout, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_CreateObject (RpcClient *module,
>+                    CK_SESSION_HANDLE session,
>+                    CK_ATTRIBUTE_PTR template,
>+                    CK_ULONG count,
>+                    CK_OBJECT_HANDLE_PTR new_object)
>+{
>+	return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_CreateObject, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL;
>+		OUT_ULONG (new_object);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_CopyObject (RpcClient *module,
>+                  CK_SESSION_HANDLE session,
>+                  CK_OBJECT_HANDLE object,
>+                  CK_ATTRIBUTE_PTR template,
>+                  CK_ULONG count,
>+                  CK_OBJECT_HANDLE_PTR new_object)
>+{
>+	return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_CopyObject, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_ULONG (object);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL;
>+		OUT_ULONG (new_object);
>+	END_CALL;
>+}
>+
>+
>+static CK_RV
>+rpc_C_DestroyObject (RpcClient *module,
>+                     CK_SESSION_HANDLE session,
>+                     CK_OBJECT_HANDLE object)
>+{
>+	BEGIN_CALL_OR (C_DestroyObject, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_ULONG (object);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetObjectSize (RpcClient *module,
>+                     CK_SESSION_HANDLE session,
>+                     CK_OBJECT_HANDLE object,
>+                     CK_ULONG_PTR size)
>+{
>+	return_val_if_fail (size, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_GetObjectSize, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_ULONG (object);
>+	PROCESS_CALL;
>+		OUT_ULONG (size);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetAttributeValue (RpcClient *module,
>+                         CK_SESSION_HANDLE session,
>+                         CK_OBJECT_HANDLE object,
>+                         CK_ATTRIBUTE_PTR template,
>+                         CK_ULONG count)
>+{
>+	BEGIN_CALL_OR (C_GetAttributeValue, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_ULONG (object);
>+		IN_ATTRIBUTE_BUFFER (template, count);
>+	PROCESS_CALL;
>+		OUT_ATTRIBUTE_ARRAY (template, count);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SetAttributeValue (RpcClient *module,
>+                         CK_SESSION_HANDLE session,
>+                         CK_OBJECT_HANDLE object,
>+                         CK_ATTRIBUTE_PTR template,
>+                         CK_ULONG count)
>+{
>+	BEGIN_CALL_OR (C_SetAttributeValue, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_ULONG (object);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_FindObjectsInit (RpcClient *module,
>+                       CK_SESSION_HANDLE session,
>+                       CK_ATTRIBUTE_PTR template,
>+                       CK_ULONG count)
>+{
>+	BEGIN_CALL_OR (C_FindObjectsInit, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_FindObjects (RpcClient *module,
>+                   CK_SESSION_HANDLE session,
>+                   CK_OBJECT_HANDLE_PTR objects,
>+                   CK_ULONG max_count,
>+                   CK_ULONG_PTR count)
>+{
>+	/* HACK: To fix a stupid gcc warning */
>+	CK_ULONG_PTR address_of_max_count = &max_count;
>+
>+	return_val_if_fail (count, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_FindObjects, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_ULONG_BUFFER (objects, address_of_max_count);
>+	PROCESS_CALL;
>+		*count = max_count;
>+		OUT_ULONG_ARRAY (objects, count);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_FindObjectsFinal (RpcClient *module,
>+                        CK_SESSION_HANDLE session)
>+{
>+	BEGIN_CALL_OR (C_FindObjectsFinal, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_EncryptInit (RpcClient *module,
>+                   CK_SESSION_HANDLE session,
>+                   CK_MECHANISM_PTR mechanism,
>+                   CK_OBJECT_HANDLE key)
>+{
>+	BEGIN_CALL_OR (C_EncryptInit, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Encrypt (RpcClient *module,
>+               CK_SESSION_HANDLE session,
>+               CK_BYTE_PTR data,
>+               CK_ULONG data_len,
>+               CK_BYTE_PTR encrypted_data,
>+               CK_ULONG_PTR encrypted_data_len)
>+{
>+	return_val_if_fail (encrypted_data_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_Encrypt, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (data, data_len);
>+		IN_BYTE_BUFFER (encrypted_data, encrypted_data_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (encrypted_data, encrypted_data_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_EncryptUpdate (RpcClient *module,
>+                     CK_SESSION_HANDLE session,
>+                     CK_BYTE_PTR part,
>+                     CK_ULONG part_len,
>+                     CK_BYTE_PTR encrypted_part,
>+                     CK_ULONG_PTR encrypted_part_len)
>+{
>+	return_val_if_fail (encrypted_part_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_EncryptUpdate, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+		IN_BYTE_BUFFER (encrypted_part, encrypted_part_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (encrypted_part, encrypted_part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_EncryptFinal (RpcClient *module,
>+                    CK_SESSION_HANDLE session,
>+                    CK_BYTE_PTR last_part,
>+                    CK_ULONG_PTR last_part_len)
>+{
>+	return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_EncryptFinal, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (last_part, last_part_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (last_part, last_part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DecryptInit (RpcClient *module,
>+                   CK_SESSION_HANDLE session,
>+                   CK_MECHANISM_PTR mechanism,
>+                   CK_OBJECT_HANDLE key)
>+{
>+	BEGIN_CALL_OR (C_DecryptInit, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Decrypt (RpcClient *module,
>+               CK_SESSION_HANDLE session,
>+               CK_BYTE_PTR enc_data,
>+               CK_ULONG enc_data_len,
>+               CK_BYTE_PTR data,
>+               CK_ULONG_PTR data_len)
>+{
>+	return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_Decrypt, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (enc_data, enc_data_len);
>+		IN_BYTE_BUFFER (data, data_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (data, data_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DecryptUpdate (RpcClient *module,
>+                     CK_SESSION_HANDLE session,
>+                     CK_BYTE_PTR enc_part,
>+                     CK_ULONG enc_part_len,
>+                     CK_BYTE_PTR part,
>+                     CK_ULONG_PTR part_len)
>+{
>+	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_DecryptUpdate, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (enc_part, enc_part_len);
>+		IN_BYTE_BUFFER (part, part_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (part, part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DecryptFinal (RpcClient *module,
>+                    CK_SESSION_HANDLE session,
>+                    CK_BYTE_PTR last_part,
>+                    CK_ULONG_PTR last_part_len)
>+{
>+	return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_DecryptFinal, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (last_part, last_part_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (last_part, last_part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DigestInit (RpcClient *module,
>+                  CK_SESSION_HANDLE session,
>+                  CK_MECHANISM_PTR mechanism)
>+{
>+	BEGIN_CALL_OR (C_DigestInit, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Digest (RpcClient *module,
>+              CK_SESSION_HANDLE session,
>+              CK_BYTE_PTR data,
>+              CK_ULONG data_len,
>+              CK_BYTE_PTR digest,
>+              CK_ULONG_PTR digest_len)
>+{
>+	return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_Digest, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (data, data_len);
>+		IN_BYTE_BUFFER (digest, digest_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (digest, digest_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DigestUpdate (RpcClient *module,
>+                    CK_SESSION_HANDLE session,
>+                    CK_BYTE_PTR part,
>+                    CK_ULONG part_len)
>+{
>+	BEGIN_CALL_OR (C_DigestUpdate, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DigestKey (RpcClient *module,
>+                 CK_SESSION_HANDLE session,
>+                 CK_OBJECT_HANDLE key)
>+{
>+	BEGIN_CALL_OR (C_DigestKey, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_ULONG (key);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DigestFinal (RpcClient *module,
>+                   CK_SESSION_HANDLE session,
>+                   CK_BYTE_PTR digest,
>+                   CK_ULONG_PTR digest_len)
>+{
>+	return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_DigestFinal, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (digest, digest_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (digest, digest_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignInit (RpcClient *module,
>+                CK_SESSION_HANDLE session,
>+                CK_MECHANISM_PTR mechanism,
>+                CK_OBJECT_HANDLE key)
>+{
>+	BEGIN_CALL_OR (C_SignInit, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Sign (RpcClient *module,
>+            CK_SESSION_HANDLE session,
>+            CK_BYTE_PTR data,
>+            CK_ULONG data_len,
>+            CK_BYTE_PTR signature,
>+            CK_ULONG_PTR signature_len)
>+{
>+	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_Sign, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (data, data_len);
>+		IN_BYTE_BUFFER (signature, signature_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (signature, signature_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignUpdate (RpcClient *module,
>+                  CK_SESSION_HANDLE session,
>+                  CK_BYTE_PTR part,
>+                  CK_ULONG part_len)
>+{
>+	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_SignUpdate, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignFinal (RpcClient *module,
>+                 CK_SESSION_HANDLE session,
>+                 CK_BYTE_PTR signature,
>+                 CK_ULONG_PTR signature_len)
>+{
>+	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_SignFinal, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (signature, signature_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (signature, signature_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignRecoverInit (RpcClient *module,
>+                       CK_SESSION_HANDLE session,
>+                       CK_MECHANISM_PTR mechanism,
>+                       CK_OBJECT_HANDLE key)
>+{
>+	BEGIN_CALL_OR (C_SignRecoverInit, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignRecover (RpcClient *module,
>+                   CK_SESSION_HANDLE session,
>+                   CK_BYTE_PTR data,
>+                   CK_ULONG data_len,
>+                   CK_BYTE_PTR signature, CK_ULONG_PTR signature_len)
>+{
>+	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_SignRecover, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (data, data_len);
>+		IN_BYTE_BUFFER (signature, signature_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (signature, signature_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_VerifyInit (RpcClient *module,
>+                  CK_SESSION_HANDLE session,
>+                  CK_MECHANISM_PTR mechanism,
>+                  CK_OBJECT_HANDLE key)
>+{
>+	BEGIN_CALL_OR (C_VerifyInit, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Verify (RpcClient *module,
>+              CK_SESSION_HANDLE session,
>+              CK_BYTE_PTR data,
>+              CK_ULONG data_len,
>+              CK_BYTE_PTR signature,
>+              CK_ULONG signature_len)
>+{
>+	BEGIN_CALL_OR (C_Verify, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (data, data_len);
>+		IN_BYTE_ARRAY (signature, signature_len);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_VerifyUpdate (RpcClient *module,
>+                    CK_SESSION_HANDLE session,
>+                    CK_BYTE_PTR part,
>+                    CK_ULONG part_len)
>+{
>+	BEGIN_CALL_OR (C_VerifyUpdate, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_VerifyFinal (RpcClient *module,
>+                   CK_SESSION_HANDLE session,
>+                   CK_BYTE_PTR signature,
>+                   CK_ULONG signature_len)
>+{
>+	BEGIN_CALL_OR (C_VerifyFinal, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (signature, signature_len);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_VerifyRecoverInit (RpcClient *module,
>+                         CK_SESSION_HANDLE session,
>+                         CK_MECHANISM_PTR mechanism,
>+                         CK_OBJECT_HANDLE key)
>+{
>+	BEGIN_CALL_OR (C_VerifyRecoverInit, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_VerifyRecover (RpcClient *module,
>+                     CK_SESSION_HANDLE session,
>+                     CK_BYTE_PTR signature,
>+                     CK_ULONG signature_len,
>+                     CK_BYTE_PTR data,
>+                     CK_ULONG_PTR data_len)
>+{
>+	return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_VerifyRecover, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (signature, signature_len);
>+		IN_BYTE_BUFFER (data, data_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (data, data_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DigestEncryptUpdate (RpcClient *module,
>+                           CK_SESSION_HANDLE session,
>+                           CK_BYTE_PTR part,
>+                           CK_ULONG part_len,
>+                           CK_BYTE_PTR enc_part,
>+                           CK_ULONG_PTR enc_part_len)
>+{
>+	return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_DigestEncryptUpdate, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+		IN_BYTE_BUFFER (enc_part, enc_part_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (enc_part, enc_part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DecryptDigestUpdate (RpcClient *module,
>+                           CK_SESSION_HANDLE session,
>+                           CK_BYTE_PTR enc_part,
>+                           CK_ULONG enc_part_len,
>+                           CK_BYTE_PTR part,
>+                           CK_ULONG_PTR part_len)
>+{
>+	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_DecryptDigestUpdate, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (enc_part, enc_part_len);
>+		IN_BYTE_BUFFER (part, part_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (part, part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignEncryptUpdate (RpcClient *module,
>+                         CK_SESSION_HANDLE session,
>+                         CK_BYTE_PTR part,
>+                         CK_ULONG part_len,
>+                         CK_BYTE_PTR enc_part,
>+                         CK_ULONG_PTR enc_part_len)
>+{
>+	return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_SignEncryptUpdate, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+		IN_BYTE_BUFFER (enc_part, enc_part_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (enc_part, enc_part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DecryptVerifyUpdate (RpcClient *module,
>+                           CK_SESSION_HANDLE session,
>+                           CK_BYTE_PTR enc_part,
>+                           CK_ULONG enc_part_len,
>+                           CK_BYTE_PTR part,
>+                           CK_ULONG_PTR part_len)
>+{
>+	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_DecryptVerifyUpdate, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (enc_part, enc_part_len);
>+		IN_BYTE_BUFFER (part, part_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (part, part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GenerateKey (RpcClient *module,
>+                   CK_SESSION_HANDLE session,
>+                   CK_MECHANISM_PTR mechanism,
>+                   CK_ATTRIBUTE_PTR template,
>+                   CK_ULONG count,
>+                   CK_OBJECT_HANDLE_PTR key)
>+{
>+	BEGIN_CALL_OR (C_GenerateKey, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL;
>+		OUT_ULONG (key);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GenerateKeyPair (RpcClient *module,
>+                       CK_SESSION_HANDLE session,
>+                       CK_MECHANISM_PTR mechanism,
>+                       CK_ATTRIBUTE_PTR pub_template,
>+                       CK_ULONG pub_count,
>+                       CK_ATTRIBUTE_PTR priv_template,
>+                       CK_ULONG priv_count,
>+                       CK_OBJECT_HANDLE_PTR pub_key,
>+                       CK_OBJECT_HANDLE_PTR priv_key)
>+{
>+	BEGIN_CALL_OR (C_GenerateKeyPair, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ATTRIBUTE_ARRAY (pub_template, pub_count);
>+		IN_ATTRIBUTE_ARRAY (priv_template, priv_count);
>+	PROCESS_CALL;
>+		OUT_ULONG (pub_key);
>+		OUT_ULONG (priv_key);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_WrapKey (RpcClient *module,
>+               CK_SESSION_HANDLE session,
>+               CK_MECHANISM_PTR mechanism,
>+               CK_OBJECT_HANDLE wrapping_key,
>+               CK_OBJECT_HANDLE key,
>+               CK_BYTE_PTR wrapped_key,
>+               CK_ULONG_PTR wrapped_key_len)
>+{
>+	return_val_if_fail (wrapped_key_len, CKR_ARGUMENTS_BAD);
>+
>+	BEGIN_CALL_OR (C_WrapKey, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (wrapping_key);
>+		IN_ULONG (key);
>+		IN_BYTE_BUFFER (wrapped_key, wrapped_key_len);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (wrapped_key, wrapped_key_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_UnwrapKey (RpcClient *module,
>+                 CK_SESSION_HANDLE session,
>+                 CK_MECHANISM_PTR mechanism,
>+                 CK_OBJECT_HANDLE unwrapping_key,
>+                 CK_BYTE_PTR wrapped_key,
>+                 CK_ULONG wrapped_key_len,
>+                 CK_ATTRIBUTE_PTR template,
>+                 CK_ULONG count,
>+                 CK_OBJECT_HANDLE_PTR key)
>+{
>+	BEGIN_CALL_OR (C_UnwrapKey, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (unwrapping_key);
>+		IN_BYTE_ARRAY (wrapped_key, wrapped_key_len);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL;
>+		OUT_ULONG (key);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DeriveKey (RpcClient *module,
>+                 CK_SESSION_HANDLE session,
>+                 CK_MECHANISM_PTR mechanism,
>+                 CK_OBJECT_HANDLE base_key,
>+                 CK_ATTRIBUTE_PTR template,
>+                 CK_ULONG count,
>+                 CK_OBJECT_HANDLE_PTR key)
>+{
>+	BEGIN_CALL_OR (C_DeriveKey, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (base_key);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL;
>+		OUT_ULONG (key);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SeedRandom (RpcClient *module,
>+                  CK_SESSION_HANDLE session,
>+                  CK_BYTE_PTR seed,
>+                  CK_ULONG seed_len)
>+{
>+	BEGIN_CALL_OR (C_SeedRandom, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (seed, seed_len);
>+	PROCESS_CALL;
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GenerateRandom (RpcClient *module,
>+                      CK_SESSION_HANDLE session,
>+                      CK_BYTE_PTR random_data,
>+                      CK_ULONG random_len)
>+{
>+	CK_ULONG_PTR address = &random_len;
>+	BEGIN_CALL_OR (C_GenerateRandom, module, CKR_SESSION_HANDLE_INVALID);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (random_data, address);
>+	PROCESS_CALL;
>+		OUT_BYTE_ARRAY (random_data, address);
>+	END_CALL;
>+}
>+
>+/*
>+ * This macro defines an RPC PKCS#11 client module.
>+ *
>+ * Sadly PKCS#11 is not fully OOP does not pass the pointer to the module to
>+ * each module function. Thus we have to define different functions for each
>+ * RPC module which "know" which module they belong to.
>+ *
>+ * This macro defines PKCS#11 functions and function list which pass their
>+ * RpcClient to the actual implementation functions above.
>+ */
>+
>+#define RPC_DEFINE_CLIENT(id) \
>+	static RpcClient rpc_module_##id; \
>+	static CK_RV rpc_C_Initialize_##id (CK_VOID_PTR init_args) \
>+		{ return rpc_C_Initialize (&rpc_module_##id, init_args); } \
>+	static CK_RV rpc_C_Finalize_##id (CK_VOID_PTR reserved) \
>+		{ return rpc_C_Finalize (&rpc_module_##id, reserved); } \
>+	static CK_RV rpc_C_GetInfo_##id (CK_INFO_PTR info) \
>+		{ return rpc_C_GetInfo (&rpc_module_##id, info); } \
>+	static CK_RV rpc_C_GetFunctionList_##id (CK_FUNCTION_LIST_PTR_PTR list) \
>+		{ return rpc_C_GetFunctionList (&rpc_module_##id, list); } \
>+	static CK_RV rpc_C_GetSlotList_##id (CK_BBOOL token_present, CK_SLOT_ID_PTR slot_list, CK_ULONG_PTR count) \
>+		{ return rpc_C_GetSlotList (&rpc_module_##id, token_present, slot_list, count); } \
>+	static CK_RV rpc_C_GetSlotInfo_##id (CK_SLOT_ID slot_id, CK_SLOT_INFO_PTR info) \
>+		{ return rpc_C_GetSlotInfo (&rpc_module_##id, slot_id, info); } \
>+	static CK_RV rpc_C_GetTokenInfo_##id (CK_SLOT_ID slot_id, CK_TOKEN_INFO_PTR info) \
>+		{ return rpc_C_GetTokenInfo (&rpc_module_##id, slot_id, info); } \
>+	static CK_RV rpc_C_GetMechanismList_##id (CK_SLOT_ID slot_id, CK_MECHANISM_TYPE_PTR mechanism_list, CK_ULONG_PTR count) \
>+		{ return rpc_C_GetMechanismList (&rpc_module_##id, slot_id, mechanism_list, count); } \
>+	static CK_RV rpc_C_GetMechanismInfo_##id (CK_SLOT_ID slot_id, CK_MECHANISM_TYPE type, CK_MECHANISM_INFO_PTR info) \
>+		{ return rpc_C_GetMechanismInfo (&rpc_module_##id, slot_id, type, info); } \
>+	static CK_RV rpc_C_InitToken_##id (CK_SLOT_ID slot_id, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len, CK_UTF8CHAR_PTR label) \
>+		{ return rpc_C_InitToken (&rpc_module_##id, slot_id, pin, pin_len, label); } \
>+	static CK_RV rpc_C_WaitForSlotEvent_##id (CK_FLAGS flags, CK_SLOT_ID_PTR slot, CK_VOID_PTR reserved) \
>+		{ return rpc_C_WaitForSlotEvent (&rpc_module_##id, flags, slot, reserved); } \
>+	static CK_RV rpc_C_OpenSession_##id (CK_SLOT_ID slot_id, CK_FLAGS flags, CK_VOID_PTR user_data, CK_NOTIFY callback, CK_SESSION_HANDLE_PTR session) \
>+		{ return rpc_C_OpenSession (&rpc_module_##id, slot_id, flags, user_data, callback, session); } \
>+	static CK_RV rpc_C_CloseSession_##id (CK_SESSION_HANDLE session) \
>+		{ return rpc_C_CloseSession (&rpc_module_##id, session); } \
>+	static CK_RV rpc_C_CloseAllSessions_##id (CK_SLOT_ID slot_id) \
>+		{ return rpc_C_CloseAllSessions (&rpc_module_##id, slot_id); } \
>+	static CK_RV rpc_C_GetFunctionStatus_##id (CK_SESSION_HANDLE session) \
>+		{ return rpc_C_GetFunctionStatus (&rpc_module_##id, session); } \
>+	static CK_RV rpc_C_CancelFunction_##id (CK_SESSION_HANDLE session) \
>+		{ return rpc_C_CancelFunction (&rpc_module_##id, session); } \
>+	static CK_RV rpc_C_GetSessionInfo_##id (CK_SESSION_HANDLE session, CK_SESSION_INFO_PTR info) \
>+		{ return rpc_C_GetSessionInfo (&rpc_module_##id, session, info); } \
>+	static CK_RV rpc_C_InitPIN_##id (CK_SESSION_HANDLE session, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len) \
>+		{ return rpc_C_InitPIN (&rpc_module_##id, session, pin, pin_len); } \
>+	static CK_RV rpc_C_SetPIN_##id (CK_SESSION_HANDLE session, CK_UTF8CHAR_PTR old_pin, CK_ULONG old_pin_len, CK_UTF8CHAR_PTR new_pin, CK_ULONG new_pin_len) \
>+		{ return rpc_C_SetPIN (&rpc_module_##id, session, old_pin, old_pin_len, new_pin, new_pin_len); } \
>+	static CK_RV rpc_C_GetOperationState_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR operation_state, CK_ULONG_PTR operation_state_len) \
>+		{ return rpc_C_GetOperationState (&rpc_module_##id, session, operation_state, operation_state_len); } \
>+	static CK_RV rpc_C_SetOperationState_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR operation_state, CK_ULONG operation_state_len, CK_OBJECT_HANDLE encryption_key, CK_OBJECT_HANDLE authentication_key) \
>+		{ return rpc_C_SetOperationState (&rpc_module_##id, session, operation_state, operation_state_len, encryption_key, authentication_key); } \
>+	static CK_RV rpc_C_Login_##id (CK_SESSION_HANDLE session, CK_USER_TYPE user_type, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len) \
>+		{ return rpc_C_Login (&rpc_module_##id, session, user_type, pin, pin_len); } \
>+	static CK_RV rpc_C_Logout_##id (CK_SESSION_HANDLE session) \
>+		{ return rpc_C_Logout (&rpc_module_##id, session); } \
>+	static CK_RV rpc_C_CreateObject_##id (CK_SESSION_HANDLE session, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR new_object) \
>+		{ return rpc_C_CreateObject (&rpc_module_##id, session, template, count, new_object); } \
>+	static CK_RV rpc_C_CopyObject_##id (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR new_object) \
>+		{ return rpc_C_CopyObject (&rpc_module_##id, session, object, template, count, new_object); } \
>+	static CK_RV rpc_C_DestroyObject_##id (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object) \
>+		{ return rpc_C_DestroyObject (&rpc_module_##id, session, object); } \
>+	static CK_RV rpc_C_GetObjectSize_##id (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object, CK_ULONG_PTR size) \
>+		{ return rpc_C_GetObjectSize (&rpc_module_##id, session, object, size); } \
>+	static CK_RV rpc_C_GetAttributeValue_##id (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object, CK_ATTRIBUTE_PTR template, CK_ULONG count) \
>+		{ return rpc_C_GetAttributeValue (&rpc_module_##id, session, object, template, count); } \
>+	static CK_RV rpc_C_SetAttributeValue_##id (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object, CK_ATTRIBUTE_PTR template, CK_ULONG count) \
>+		{ return rpc_C_SetAttributeValue (&rpc_module_##id, session, object, template, count); } \
>+	static CK_RV rpc_C_FindObjectsInit_##id (CK_SESSION_HANDLE session, CK_ATTRIBUTE_PTR template, CK_ULONG count) \
>+		{ return rpc_C_FindObjectsInit (&rpc_module_##id, session, template, count); } \
>+	static CK_RV rpc_C_FindObjects_##id (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE_PTR objects, CK_ULONG max_count, CK_ULONG_PTR count) \
>+		{ return rpc_C_FindObjects (&rpc_module_##id, session, objects, max_count, count); } \
>+	static CK_RV rpc_C_FindObjectsFinal_##id (CK_SESSION_HANDLE session) \
>+		{ return rpc_C_FindObjectsFinal (&rpc_module_##id, session); } \
>+	static CK_RV rpc_C_EncryptInit_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) \
>+		{ return rpc_C_EncryptInit (&rpc_module_##id, session, mechanism, key); } \
>+	static CK_RV rpc_C_Encrypt_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR encrypted_data, CK_ULONG_PTR encrypted_data_len) \
>+		{ return rpc_C_Encrypt (&rpc_module_##id, session, data, data_len, encrypted_data, encrypted_data_len); } \
>+	static CK_RV rpc_C_EncryptUpdate_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len, CK_BYTE_PTR encrypted_part, CK_ULONG_PTR encrypted_part_len) \
>+		{ return rpc_C_EncryptUpdate (&rpc_module_##id, session, part, part_len, encrypted_part, encrypted_part_len); } \
>+	static CK_RV rpc_C_EncryptFinal_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR last_part, CK_ULONG_PTR last_part_len) \
>+		{ return rpc_C_EncryptFinal (&rpc_module_##id, session, last_part, last_part_len); } \
>+	static CK_RV rpc_C_DecryptInit_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) \
>+		{ return rpc_C_DecryptInit (&rpc_module_##id, session, mechanism, key); } \
>+	static CK_RV rpc_C_Decrypt_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR enc_data, CK_ULONG enc_data_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len) \
>+		{ return rpc_C_Decrypt (&rpc_module_##id, session, enc_data, enc_data_len, data, data_len); } \
>+	static CK_RV rpc_C_DecryptUpdate_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR enc_part, CK_ULONG enc_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len) \
>+		{ return rpc_C_DecryptUpdate (&rpc_module_##id, session, enc_part, enc_part_len, part, part_len); } \
>+	static CK_RV rpc_C_DecryptFinal_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR last_part, CK_ULONG_PTR last_part_len) \
>+		{ return rpc_C_DecryptFinal (&rpc_module_##id, session, last_part, last_part_len); } \
>+	static CK_RV rpc_C_DigestInit_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism) \
>+		{ return rpc_C_DigestInit (&rpc_module_##id, session, mechanism); } \
>+	static CK_RV rpc_C_Digest_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR digest, CK_ULONG_PTR digest_len) \
>+		{ return rpc_C_Digest (&rpc_module_##id, session, data, data_len, digest, digest_len); } \
>+	static CK_RV rpc_C_DigestUpdate_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len) \
>+		{ return rpc_C_DigestUpdate (&rpc_module_##id, session, part, part_len); } \
>+	static CK_RV rpc_C_DigestKey_##id (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE key) \
>+		{ return rpc_C_DigestKey (&rpc_module_##id, session, key); } \
>+	static CK_RV rpc_C_DigestFinal_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR digest, CK_ULONG_PTR digest_len) \
>+		{ return rpc_C_DigestFinal (&rpc_module_##id, session, digest, digest_len); } \
>+	static CK_RV rpc_C_SignInit_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) \
>+		{ return rpc_C_SignInit (&rpc_module_##id, session, mechanism, key); } \
>+	static CK_RV rpc_C_Sign_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR signature, CK_ULONG_PTR signature_len) \
>+		{ return rpc_C_Sign (&rpc_module_##id, session, data, data_len, signature, signature_len); } \
>+	static CK_RV rpc_C_SignUpdate_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len) \
>+		{ return rpc_C_SignUpdate (&rpc_module_##id, session, part, part_len); } \
>+	static CK_RV rpc_C_SignFinal_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR signature, CK_ULONG_PTR signature_len) \
>+		{ return rpc_C_SignFinal (&rpc_module_##id, session, signature, signature_len); } \
>+	static CK_RV rpc_C_SignRecoverInit_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) \
>+		{ return rpc_C_SignRecoverInit (&rpc_module_##id, session, mechanism, key); } \
>+	static CK_RV rpc_C_SignRecover_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR signature, CK_ULONG_PTR signature_len) \
>+		{ return rpc_C_SignRecover (&rpc_module_##id, session, data, data_len, signature, signature_len); } \
>+	static CK_RV rpc_C_VerifyInit_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) \
>+		{ return rpc_C_VerifyInit (&rpc_module_##id, session, mechanism, key); } \
>+	static CK_RV rpc_C_Verify_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR signature, CK_ULONG signature_len) \
>+		{ return rpc_C_Verify (&rpc_module_##id, session, data, data_len, signature, signature_len); } \
>+	static CK_RV rpc_C_VerifyUpdate_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len) \
>+		{ return rpc_C_VerifyUpdate (&rpc_module_##id, session, part, part_len); } \
>+	static CK_RV rpc_C_VerifyFinal_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR signature, CK_ULONG signature_len) \
>+		{ return rpc_C_VerifyFinal (&rpc_module_##id, session, signature, signature_len); } \
>+	static CK_RV rpc_C_VerifyRecoverInit_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) \
>+		{ return rpc_C_VerifyRecoverInit (&rpc_module_##id, session, mechanism, key); } \
>+	static CK_RV rpc_C_VerifyRecover_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR signature, CK_ULONG signature_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len) \
>+		{ return rpc_C_VerifyRecover (&rpc_module_##id, session, signature, signature_len, data, data_len); } \
>+	static CK_RV rpc_C_DigestEncryptUpdate_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len, CK_BYTE_PTR enc_part, CK_ULONG_PTR enc_part_len) \
>+		{ return rpc_C_DigestEncryptUpdate (&rpc_module_##id, session, part, part_len, enc_part, enc_part_len); } \
>+	static CK_RV rpc_C_DecryptDigestUpdate_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR enc_part, CK_ULONG enc_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len) \
>+		{ return rpc_C_DecryptDigestUpdate (&rpc_module_##id, session, enc_part, enc_part_len, part, part_len); } \
>+	static CK_RV rpc_C_SignEncryptUpdate_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len, CK_BYTE_PTR enc_part, CK_ULONG_PTR enc_part_len) \
>+		{ return rpc_C_SignEncryptUpdate (&rpc_module_##id, session, part, part_len, enc_part, enc_part_len); } \
>+	static CK_RV rpc_C_DecryptVerifyUpdate_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR enc_part, CK_ULONG enc_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len) \
>+		{ return rpc_C_DecryptVerifyUpdate (&rpc_module_##id, session, enc_part, enc_part_len, part, part_len); } \
>+	static CK_RV rpc_C_GenerateKey_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR key) \
>+		{ return rpc_C_GenerateKey (&rpc_module_##id, session, mechanism, template, count, key); } \
>+	static CK_RV rpc_C_GenerateKeyPair_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_ATTRIBUTE_PTR pub_template, CK_ULONG pub_count, CK_ATTRIBUTE_PTR priv_template, CK_ULONG priv_count, CK_OBJECT_HANDLE_PTR pub_key, CK_OBJECT_HANDLE_PTR priv_key) \
>+		{ return rpc_C_GenerateKeyPair (&rpc_module_##id, session, mechanism, pub_template, pub_count, priv_template, priv_count, pub_key, priv_key); } \
>+	static CK_RV rpc_C_WrapKey_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE wrapping_key, CK_OBJECT_HANDLE key, CK_BYTE_PTR wrapped_key, CK_ULONG_PTR wrapped_key_len) \
>+		{ return rpc_C_WrapKey (&rpc_module_##id, session, mechanism, wrapping_key, key, wrapped_key, wrapped_key_len); } \
>+	static CK_RV rpc_C_UnwrapKey_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE unwrapping_key, CK_BYTE_PTR wrapped_key, CK_ULONG wrapped_key_len, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR key) \
>+		{ return rpc_C_UnwrapKey (&rpc_module_##id, session, mechanism, unwrapping_key, wrapped_key, wrapped_key_len, template, count, key); } \
>+	static CK_RV rpc_C_DeriveKey_##id (CK_SESSION_HANDLE session, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE base_key, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR key) \
>+		{ return rpc_C_DeriveKey (&rpc_module_##id, session, mechanism, base_key, template, count, key); } \
>+	static CK_RV rpc_C_SeedRandom_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR seed, CK_ULONG seed_len) \
>+		{ return rpc_C_SeedRandom (&rpc_module_##id, session, seed, seed_len); } \
>+	static CK_RV rpc_C_GenerateRandom_##id (CK_SESSION_HANDLE session, CK_BYTE_PTR random_data, CK_ULONG random_len) \
>+		{ return rpc_C_GenerateRandom (&rpc_module_##id, session, random_data, random_len); } \
>+	static const CK_FUNCTION_LIST rpc_function_list##id = { { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR }, \
>+		rpc_C_Initialize_##id, rpc_C_Finalize_##id, rpc_C_GetInfo_##id, rpc_C_GetFunctionList_##id, \
>+		rpc_C_GetSlotList_##id, rpc_C_GetSlotInfo_##id, rpc_C_GetTokenInfo_##id, rpc_C_GetMechanismList_##id, \
>+		rpc_C_GetMechanismInfo_##id, rpc_C_InitToken_##id, rpc_C_InitPIN_##id, rpc_C_SetPIN_##id, \
>+		rpc_C_OpenSession_##id, rpc_C_CloseSession_##id, rpc_C_CloseAllSessions_##id, rpc_C_GetSessionInfo_##id, \
>+		rpc_C_GetOperationState_##id, rpc_C_SetOperationState_##id, rpc_C_Login_##id, rpc_C_Logout_##id, \
>+		rpc_C_CreateObject_##id, rpc_C_CopyObject_##id, rpc_C_DestroyObject_##id, rpc_C_GetObjectSize_##id, \
>+		rpc_C_GetAttributeValue_##id, rpc_C_SetAttributeValue_##id, rpc_C_FindObjectsInit_##id, \
>+		rpc_C_FindObjects_##id, rpc_C_FindObjectsFinal_##id, rpc_C_EncryptInit_##id, rpc_C_Encrypt_##id, \
>+		rpc_C_EncryptUpdate_##id, rpc_C_EncryptFinal_##id, rpc_C_DecryptInit_##id, rpc_C_Decrypt_##id, \
>+		rpc_C_DecryptUpdate_##id, rpc_C_DecryptFinal_##id, rpc_C_DigestInit_##id, rpc_C_Digest_##id, \
>+		rpc_C_DigestUpdate_##id, rpc_C_DigestKey_##id, rpc_C_DigestFinal_##id, rpc_C_SignInit_##id, \
>+		rpc_C_Sign_##id, rpc_C_SignUpdate_##id, rpc_C_SignFinal_##id, rpc_C_SignRecoverInit_##id, \
>+		rpc_C_SignRecover_##id, rpc_C_VerifyInit_##id, rpc_C_Verify_##id, rpc_C_VerifyUpdate_##id, \
>+		rpc_C_VerifyFinal_##id, rpc_C_VerifyRecoverInit_##id, rpc_C_VerifyRecover_##id, rpc_C_DigestEncryptUpdate_##id, \
>+		rpc_C_DecryptDigestUpdate_##id, rpc_C_SignEncryptUpdate_##id, rpc_C_DecryptVerifyUpdate_##id, \
>+		rpc_C_GenerateKey_##id, rpc_C_GenerateKeyPair_##id, rpc_C_WrapKey_##id, rpc_C_UnwrapKey_##id, \
>+		rpc_C_DeriveKey_##id, rpc_C_SeedRandom_##id, rpc_C_GenerateRandom_##id, rpc_C_GetFunctionStatus_##id, \
>+		rpc_C_CancelFunction_##id, rpc_C_WaitForSlotEvent_##id, }; \
>+	static RpcClient rpc_module_##id = RPC_CLIENT_INIT (id, &rpc_function_list##id);
>+
>+/*
>+ * This macro is to save typing in the two definitions below.
>+ * RPC_CLIENT is redefined as needed below. The numbers must be sequential.
>+ */
>+#define RPC_CLIENT_ELEMENTS \
>+	RPC_CLIENT (0) RPC_CLIENT (1) RPC_CLIENT (2) RPC_CLIENT (3) RPC_CLIENT (4) \
>+	RPC_CLIENT (5) RPC_CLIENT (6) RPC_CLIENT (7) RPC_CLIENT (8) RPC_CLIENT (9) \
>+	RPC_CLIENT (10) RPC_CLIENT (11) RPC_CLIENT (12) RPC_CLIENT (13) RPC_CLIENT (14) \
>+	RPC_CLIENT (15) RPC_CLIENT (16) RPC_CLIENT (17) RPC_CLIENT (18) RPC_CLIENT (19) \
>+	RPC_CLIENT (20) RPC_CLIENT (21) RPC_CLIENT (22) RPC_CLIENT (23) RPC_CLIENT (24) \
>+	RPC_CLIENT (25) RPC_CLIENT (26) RPC_CLIENT (27) RPC_CLIENT (28) RPC_CLIENT (29) \
>+	RPC_CLIENT (30) RPC_CLIENT (31) RPC_CLIENT (32) RPC_CLIENT (33) RPC_CLIENT (34) \
>+	RPC_CLIENT (35) RPC_CLIENT (36) RPC_CLIENT (37) RPC_CLIENT (38) RPC_CLIENT (39) \
>+	RPC_CLIENT (40) RPC_CLIENT (41) RPC_CLIENT (42) RPC_CLIENT (43) RPC_CLIENT (44) \
>+	RPC_CLIENT (45) RPC_CLIENT (46) RPC_CLIENT (47) RPC_CLIENT (48) RPC_CLIENT (49) \
>+	RPC_CLIENT (50) RPC_CLIENT (51) RPC_CLIENT (52) RPC_CLIENT (53) RPC_CLIENT (54) \
>+	RPC_CLIENT (55) RPC_CLIENT (56) RPC_CLIENT (57) RPC_CLIENT (58) RPC_CLIENT (59) \
>+	RPC_CLIENT (60) RPC_CLIENT (61) RPC_CLIENT (62) RPC_CLIENT (63)
>+
>+/*
>+ * Use RPC_DEFINE_MODULE to define all the RPC functions and function lists
>+ * for each module.
>+ */
>+#define RPC_CLIENT(id) RPC_DEFINE_CLIENT (id)
>+RPC_CLIENT_ELEMENTS
>+#undef RPC_CLIENT
>+
>+/* Now init the array of modules */
>+static RpcClient *RPC_CLIENTS[] = {
>+	#define RPC_CLIENT(id) &rpc_module_##id,
>+	RPC_CLIENT_ELEMENTS
>+	#undef RPC_CLIENT
>+};
>+
>+#define N_RPC_CLIENTS \
>+	(sizeof (RPC_CLIENTS) / sizeof (RPC_CLIENTS[0]))
>+
>+CK_FUNCTION_LIST_PTR
>+p11_rpc_client_register (P11RpcClientVtable *vtable)
>+{
>+	static pthread_mutex_t register_mutex = PTHREAD_MUTEX_INITIALIZER;
>+	CK_FUNCTION_LIST_PTR function_list = NULL;
>+	int i;
>+
>+	_p11_kit_clear_message ();
>+
>+	return_val_if_fail (vtable != NULL, NULL);
>+	return_val_if_fail (vtable->connect != NULL, NULL);
>+	return_val_if_fail (vtable->transport != NULL, NULL);
>+	return_val_if_fail (vtable->disconnect != NULL, NULL);
>+
>+	RPC_CHECK_CALLS ();
>+
>+	pthread_mutex_lock (&register_mutex);
>+
>+	/* Find an rpc module function list that's free */
>+	for (i = 0; i < N_RPC_CLIENTS; i++) {
>+		assert (RPC_CLIENTS[i]->check == i);
>+		if (RPC_CLIENTS[i]->vtable == NULL) {
>+			RPC_CLIENTS[i]->vtable = vtable;
>+			function_list = RPC_CLIENTS[i]->function_list;
>+			assert (function_list != NULL);
>+			break;
>+		}
>+	}
>+
>+	pthread_mutex_unlock (&register_mutex);
>+
>+	if (function_list == NULL)
>+		_p11_message ("too many rpc client modules: %d", (int)N_RPC_CLIENTS);
>+
>+	return function_list;
>+}
>diff --git a/p11-kit/rpc-message.c b/p11-kit/rpc-message.c
>new file mode 100644
>index 0000000..ae48f3e
>--- /dev/null
>+++ b/p11-kit/rpc-message.c
>@@ -0,0 +1,496 @@
>+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
>+/* p11-rpc-message.c - our marshalled PKCS#11 protocol.
>+
>+   Copyright (C) 2008, Stef Walter
>+
>+   The Gnome Keyring Library is free software; you can redistribute it and/or
>+   modify it under the terms of the GNU Library General Public License as
>+   published by the Free Software Foundation; either version 2 of the
>+   License, or (at your option) any later version.
>+
>+   The Gnome Keyring Library is distributed in the hope that it will be useful,
>+   but WITHOUT ANY WARRANTY; without even the implied warranty of
>+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+   Library General Public License for more details.
>+
>+   You should have received a copy of the GNU Library General Public
>+   License along with the Gnome Library; see the file COPYING.LIB.  If not,
>+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
>+   Boston, MA 02111-1307, USA.
>+
>+   Author: Stef Walter <stef@memberwebs.com>
>+*/
>+
>+#include "config.h"
>+
>+#include "debug.h"
>+#include "private.h"
>+#include "rpc-message.h"
>+
>+#include <assert.h>
>+#include <string.h>
>+
>+void
>+_p11_rpc_message_init (RpcMessage *msg,
>+                       P11Buffer *input,
>+                       P11Output *output)
>+{
>+	assert (input != NULL);
>+	assert (output != NULL);
>+	assert (output->ffree != NULL);
>+	assert (output->frealloc != NULL);
>+
>+	memset (msg, 0, sizeof (*msg));
>+
>+	msg->output = output;
>+	msg->input = input;
>+}
>+
>+void
>+_p11_rpc_message_clear (RpcMessage *msg)
>+{
>+	void *allocated;
>+	void **data;
>+
>+	assert (msg != NULL);
>+
>+	/* Free up the extra allocated memory */
>+	allocated = msg->extra;
>+	while (allocated != NULL) {
>+		data = (void **)allocated;
>+
>+		/* Pointer to the next allocation */
>+		allocated = *data;
>+		assert (msg->output->ffree);
>+		(msg->output->ffree) (data);
>+	}
>+
>+	msg->output = NULL;
>+	msg->input = NULL;
>+	msg->extra = NULL;
>+}
>+
>+void *
>+_p11_rpc_message_alloc_extra (RpcMessage *msg,
>+                              size_t length)
>+{
>+	void **data;
>+
>+	assert (msg != NULL);
>+
>+	if (length > 0x7fffffff)
>+		return NULL;
>+
>+	assert (msg->output->frealloc != NULL);
>+	data = (msg->output->frealloc) (NULL, sizeof (void *) + length);
>+	if (data == NULL)
>+		return NULL;
>+
>+	/* Munch up the memory to help catch bugs */
>+	memset (data, 0xff, sizeof (void *) + length);
>+
>+	/* Store pointer to next allocated block at beginning */
>+	*data = msg->extra;
>+	msg->extra = data;
>+
>+	/* Data starts after first pointer */
>+	return (void *)(data + 1);
>+}
>+
>+int
>+_p11_rpc_message_prep (RpcMessage *msg,
>+                       int call_id,
>+                       RpcMessageType type)
>+{
>+	int len;
>+
>+	assert (type != 0);
>+	assert (call_id >= RPC_CALL_ERROR);
>+	assert (call_id < RPC_CALL_MAX);
>+
>+	_p11_buffer_reset (msg->output);
>+	msg->signature = NULL;
>+
>+	/* The call id and signature */
>+	if (type == RPC_REQUEST)
>+		msg->signature = rpc_calls[call_id].request;
>+	else if (type == RPC_RESPONSE)
>+		msg->signature = rpc_calls[call_id].response;
>+	else
>+		assert_not_reached ();
>+	assert (msg->signature != NULL);
>+	msg->sigverify = msg->signature;
>+
>+	msg->call_id = call_id;
>+	msg->call_type = type;
>+
>+	/* Encode the two of them */
>+	_p11_buffer_add_uint32 (msg->output, call_id);
>+	if (msg->signature) {
>+		len = strlen (msg->signature);
>+		_p11_buffer_add_byte_array (msg->output, (unsigned char*)msg->signature, len);
>+	}
>+
>+	msg->parsed = 0;
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_parse (RpcMessage *msg,
>+                        RpcMessageType type)
>+{
>+	const unsigned char *val;
>+	size_t len;
>+	uint32_t call_id;
>+
>+	assert (msg != NULL);
>+	assert (msg->input != NULL);
>+
>+	msg->parsed = 0;
>+
>+	/* Pull out the call identifier */
>+	if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &(msg->parsed), &call_id)) {
>+		_p11_message ("invalid message: couldn't read call identifier");
>+		return 0;
>+	}
>+
>+	msg->signature = msg->sigverify = NULL;
>+
>+	/* The call id and signature */
>+	if (call_id < 0 || call_id >= RPC_CALL_MAX) {
>+		_p11_message ("invalid message: bad call id: %d", call_id);
>+		return 0;
>+	}
>+	if (type == RPC_REQUEST)
>+		msg->signature = rpc_calls[call_id].request;
>+	else if (type == RPC_RESPONSE)
>+		msg->signature = rpc_calls[call_id].response;
>+	else
>+		assert_not_reached ();
>+	assert (msg->signature != NULL);
>+	msg->call_id = call_id;
>+	msg->call_type = type;
>+	msg->sigverify = msg->signature;
>+
>+	/* Verify the incoming signature */
>+	if (!_p11_buffer_get_byte_array (msg->input, msg->parsed, &(msg->parsed), &val, &len)) {
>+		_p11_message ("invalid message: couldn't read signature");
>+		return 0;
>+	}
>+
>+	if ((strlen (msg->signature) != len) || (memcmp (val, msg->signature, len) != 0)) {
>+		_p11_message ("invalid message: signature doesn't match");
>+		return 0;
>+	}
>+
>+	return 1;
>+}
>+
>+int
>+_p11_rpc_message_verify_part (RpcMessage *msg,
>+                              const char* part)
>+{
>+	int len, ok;
>+
>+	if (!msg->sigverify)
>+		return 1;
>+
>+	len = strlen (part);
>+	ok = (strncmp (msg->sigverify, part, len) == 0);
>+	if (ok)
>+		msg->sigverify += len;
>+	return ok;
>+}
>+
>+int
>+_p11_rpc_message_write_attribute_buffer (RpcMessage *msg,
>+                                         CK_ATTRIBUTE_PTR arr,
>+                                         CK_ULONG num)
>+{
>+	CK_ATTRIBUTE_PTR attr;
>+	CK_ULONG i;
>+
>+	assert (num == 0 || arr != NULL);
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+
>+	/* Make sure this is in the rigth order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "fA"));
>+
>+	/* Write the number of items */
>+	_p11_buffer_add_uint32 (msg->output, num);
>+
>+	for (i = 0; i < num; ++i) {
>+		attr = &(arr[i]);
>+
>+		/* The attribute type */
>+		_p11_buffer_add_uint32 (msg->output, attr->type);
>+
>+		/* And the attribute buffer length */
>+		_p11_buffer_add_uint32 (msg->output, attr->pValue ? attr->ulValueLen : 0);
>+	}
>+
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_write_attribute_array (RpcMessage *msg,
>+                                        CK_ATTRIBUTE_PTR arr,
>+                                        CK_ULONG num)
>+{
>+	CK_ULONG i;
>+	CK_ATTRIBUTE_PTR attr;
>+	unsigned char validity;
>+
>+	assert (num == 0 || arr != NULL);
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+
>+	/* Make sure this is in the rigth order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "aA"));
>+
>+	/* Write the number of items */
>+	_p11_buffer_add_uint32 (msg->output, num);
>+
>+	for (i = 0; i < num; ++i) {
>+		attr = &(arr[i]);
>+
>+		/* The attribute type */
>+		_p11_buffer_add_uint32 (msg->output, attr->type);
>+
>+		/* Write out the attribute validity */
>+		validity = (((CK_LONG)attr->ulValueLen) == -1) ? 0 : 1;
>+		_p11_buffer_add_byte (msg->output, validity);
>+
>+		/* The attribute length and value */
>+		if (validity) {
>+			_p11_buffer_add_uint32 (msg->output, attr->ulValueLen);
>+			_p11_buffer_add_byte_array (msg->output, attr->pValue, attr->ulValueLen);
>+		}
>+	}
>+
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_read_byte (RpcMessage *msg,
>+                            CK_BYTE *val)
>+{
>+	assert (msg != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "y"));
>+	return _p11_buffer_get_byte (msg->input, msg->parsed, &msg->parsed, val);
>+}
>+
>+int
>+_p11_rpc_message_write_byte (RpcMessage *msg,
>+                             CK_BYTE val)
>+{
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "y"));
>+	_p11_buffer_add_byte (msg->output, val);
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_read_ulong (RpcMessage *msg,
>+                             CK_ULONG *val)
>+{
>+	uint64_t v;
>+
>+	assert (msg != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "u"));
>+
>+	if (!_p11_buffer_get_uint64 (msg->input, msg->parsed, &msg->parsed, &v))
>+		return 0;
>+	if (val)
>+		*val = (CK_ULONG)v;
>+	return 1;
>+}
>+
>+int
>+_p11_rpc_message_write_ulong (RpcMessage *msg,
>+                              CK_ULONG val)
>+{
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+
>+	/* Make sure this is in the rigth order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "u"));
>+	_p11_buffer_add_uint64 (msg->output, val);
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_write_byte_buffer (RpcMessage *msg,
>+                                    CK_ULONG count)
>+{
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "fy"));
>+	_p11_buffer_add_uint32 (msg->output, count);
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_write_byte_array (RpcMessage *msg,
>+                                   CK_BYTE_PTR arr,
>+                                   CK_ULONG num)
>+{
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "ay"));
>+
>+	/* No array, no data, just length */
>+	if (!arr) {
>+		_p11_buffer_add_byte (msg->output, 0);
>+		_p11_buffer_add_uint32 (msg->output, num);
>+	} else {
>+		_p11_buffer_add_byte (msg->output, 1);
>+		_p11_buffer_add_byte_array (msg->output, arr, num);
>+	}
>+
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_write_ulong_buffer (RpcMessage *msg,
>+                                     CK_ULONG count)
>+{
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "fu"));
>+	_p11_buffer_add_uint32 (msg->output, count);
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_write_ulong_array (RpcMessage *msg,
>+                                    CK_ULONG_PTR array,
>+                                    CK_ULONG n_array)
>+{
>+	CK_ULONG i;
>+
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+
>+	/* Check that we're supposed to have this at this point */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "au"));
>+
>+	/* We send a byte which determines whether there's actual data present or not */
>+	_p11_buffer_add_byte (msg->output, array ? 1 : 0);
>+	_p11_buffer_add_uint32 (msg->output, n_array);
>+
>+	/* Now send the data if valid */
>+	if (array) {
>+		for (i = 0; i < n_array; ++i)
>+			_p11_buffer_add_uint64 (msg->output, array[i]);
>+	}
>+
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_read_version (RpcMessage *msg,
>+                               CK_VERSION *version)
>+{
>+	assert (msg != NULL);
>+	assert (msg->input != NULL);
>+	assert (version != NULL);
>+
>+	/* Check that we're supposed to have this at this point */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "v"));
>+
>+	return _p11_buffer_get_byte (msg->input, msg->parsed, &msg->parsed, &version->major) &&
>+	       _p11_buffer_get_byte (msg->input, msg->parsed, &msg->parsed, &version->minor);
>+}
>+
>+int
>+_p11_rpc_message_write_version (RpcMessage *msg,
>+                                CK_VERSION *version)
>+{
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+	assert (version != NULL);
>+
>+	/* Check that we're supposed to have this at this point */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "v"));
>+
>+	_p11_buffer_add_byte (msg->output, version->major);
>+	_p11_buffer_add_byte (msg->output, version->minor);
>+
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_read_space_string (RpcMessage *msg,
>+                                    CK_UTF8CHAR *buffer,
>+                                    CK_ULONG length)
>+{
>+	const unsigned char *data;
>+	size_t n_data;
>+
>+	assert (msg != NULL);
>+	assert (msg->input != NULL);
>+	assert (buffer != NULL);
>+	assert (length != 0);
>+
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "s"));
>+
>+	if (!_p11_buffer_get_byte_array (msg->input, msg->parsed, &msg->parsed, &data, &n_data))
>+		return 0;
>+
>+	if (n_data != length) {
>+		_p11_message ("invalid length space padded string received: %d != %d",
>+		              (int)length, (int)n_data);
>+		return 0;
>+	}
>+
>+	memcpy (buffer, data, length);
>+	return 1;
>+}
>+
>+int
>+_p11_rpc_message_write_space_string (RpcMessage *msg,
>+                                     CK_UTF8CHAR *data,
>+                                     CK_ULONG length)
>+{
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+	assert (data != NULL);
>+	assert (length != 0);
>+
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "s"));
>+
>+	_p11_buffer_add_byte_array (msg->output, data, length);
>+	return !_p11_buffer_failed (msg->output);
>+}
>+
>+int
>+_p11_rpc_message_write_zero_string (RpcMessage *msg,
>+                                    CK_UTF8CHAR *string)
>+{
>+	assert (msg != NULL);
>+	assert (msg->output != NULL);
>+	assert (string != NULL);
>+
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "z"));
>+
>+	_p11_buffer_add_byte_array (msg->output, string,
>+	                            string ? strlen ((char *)string) : 0);
>+	return !_p11_buffer_failed (msg->output);
>+}
>diff --git a/p11-kit/rpc-message.h b/p11-kit/rpc-message.h
>new file mode 100644
>index 0000000..7ece150
>--- /dev/null
>+++ b/p11-kit/rpc-message.h
>@@ -0,0 +1,299 @@
>+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
>+/* rpc-private.h - various ids and signatures for our protocol
>+
>+   Copyright (C) 2008, Stef Walter
>+
>+   The Gnome Keyring Library is free software; you can redistribute it and/or
>+   modify it under the terms of the GNU Library General Public License as
>+   published by the Free Software Foundation; either version 2 of the
>+   License, or (at your option) any later version.
>+
>+   The Gnome Keyring Library is distributed in the hope that it will be useful,
>+   but WITHOUT ANY WARRANTY; without even the implied warranty of
>+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+   Library General Public License for more details.
>+
>+   You should have received a copy of the GNU Library General Public
>+   License along with the Gnome Library; see the file COPYING.LIB.  If not,
>+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
>+   Boston, MA 02111-1307, USA.
>+
>+   Author: Stef Walter <stef@memberwebs.com>
>+*/
>+
>+#ifndef _RPC_MESSAGE_H
>+#define _RPC_MESSAGE_H
>+
>+#include <stdlib.h>
>+#include <stdarg.h>
>+
>+#include "buffer.h"
>+#include "pkcs11.h"
>+
>+/* The calls, must be in sync with array below */
>+enum {
>+	RPC_CALL_ERROR = 0,
>+
>+	RPC_CALL_C_Initialize,
>+	RPC_CALL_C_Finalize,
>+	RPC_CALL_C_GetInfo,
>+	RPC_CALL_C_GetSlotList,
>+	RPC_CALL_C_GetSlotInfo,
>+	RPC_CALL_C_GetTokenInfo,
>+	RPC_CALL_C_GetMechanismList,
>+	RPC_CALL_C_GetMechanismInfo,
>+	RPC_CALL_C_InitToken,
>+	RPC_CALL_C_WaitForSlotEvent,
>+
>+	RPC_CALL_C_OpenSession,
>+
>+	RPC_CALL_C_CloseSession,
>+	RPC_CALL_C_CloseAllSessions,
>+	RPC_CALL_C_GetFunctionStatus,
>+	RPC_CALL_C_CancelFunction,
>+
>+	RPC_CALL_C_GetSessionInfo,
>+	RPC_CALL_C_InitPIN,
>+	RPC_CALL_C_SetPIN,
>+	RPC_CALL_C_GetOperationState,
>+	RPC_CALL_C_SetOperationState,
>+	RPC_CALL_C_Login,
>+	RPC_CALL_C_Logout,
>+	RPC_CALL_C_CreateObject,
>+	RPC_CALL_C_CopyObject,
>+	RPC_CALL_C_DestroyObject,
>+	RPC_CALL_C_GetObjectSize,
>+	RPC_CALL_C_GetAttributeValue,
>+	RPC_CALL_C_SetAttributeValue,
>+	RPC_CALL_C_FindObjectsInit,
>+	RPC_CALL_C_FindObjects,
>+	RPC_CALL_C_FindObjectsFinal,
>+	RPC_CALL_C_EncryptInit,
>+	RPC_CALL_C_Encrypt,
>+	RPC_CALL_C_EncryptUpdate,
>+	RPC_CALL_C_EncryptFinal,
>+	RPC_CALL_C_DecryptInit,
>+	RPC_CALL_C_Decrypt,
>+	RPC_CALL_C_DecryptUpdate,
>+	RPC_CALL_C_DecryptFinal,
>+	RPC_CALL_C_DigestInit,
>+	RPC_CALL_C_Digest,
>+	RPC_CALL_C_DigestUpdate,
>+	RPC_CALL_C_DigestKey,
>+	RPC_CALL_C_DigestFinal,
>+	RPC_CALL_C_SignInit,
>+	RPC_CALL_C_Sign,
>+	RPC_CALL_C_SignUpdate,
>+	RPC_CALL_C_SignFinal,
>+	RPC_CALL_C_SignRecoverInit,
>+	RPC_CALL_C_SignRecover,
>+	RPC_CALL_C_VerifyInit,
>+	RPC_CALL_C_Verify,
>+	RPC_CALL_C_VerifyUpdate,
>+	RPC_CALL_C_VerifyFinal,
>+	RPC_CALL_C_VerifyRecoverInit,
>+	RPC_CALL_C_VerifyRecover,
>+	RPC_CALL_C_DigestEncryptUpdate,
>+	RPC_CALL_C_DecryptDigestUpdate,
>+	RPC_CALL_C_SignEncryptUpdate,
>+	RPC_CALL_C_DecryptVerifyUpdate,
>+	RPC_CALL_C_GenerateKey,
>+	RPC_CALL_C_GenerateKeyPair,
>+	RPC_CALL_C_WrapKey,
>+	RPC_CALL_C_UnwrapKey,
>+	RPC_CALL_C_DeriveKey,
>+	RPC_CALL_C_SeedRandom,
>+	RPC_CALL_C_GenerateRandom,
>+
>+	RPC_CALL_MAX
>+};
>+
>+typedef struct _RpcCall {
>+	int call_id;
>+	const char* name;
>+	const char* request;
>+	const char* response;
>+} RpcCall;
>+
>+/*
>+ *  a_ = prefix denotes array of _
>+ *  A  = CK_ATTRIBUTE
>+ *  f_ = prefix denotes buffer for _
>+ *  M  = CK_MECHANISM
>+ *  u  = CK_ULONG
>+ *  s  = space padded string
>+ *  v  = CK_VERSION
>+ *  y  = CK_BYTE
>+ *  z  = null terminated string
>+ */
>+
>+static const RpcCall rpc_calls[] = {
>+	{ RPC_CALL_ERROR,                  "ERROR",                  NULL,      "u"                    },
>+	{ RPC_CALL_C_Initialize,           "C_Initialize",           "ay",      ""                     },
>+	{ RPC_CALL_C_Finalize,             "C_Finalize",             "",        ""                     },
>+	{ RPC_CALL_C_GetInfo,              "C_GetInfo",              "",        "vsusv"                },
>+	{ RPC_CALL_C_GetSlotList,          "C_GetSlotList",          "yfu",     "au"                   },
>+	{ RPC_CALL_C_GetSlotInfo,          "C_GetSlotInfo",          "u",       "ssuvv"                },
>+	{ RPC_CALL_C_GetTokenInfo,         "C_GetTokenInfo",         "u",       "ssssuuuuuuuuuuuvvs"   },
>+	{ RPC_CALL_C_GetMechanismList,     "C_GetMechanismList",     "ufu",     "au"                   },
>+	{ RPC_CALL_C_GetMechanismInfo,     "C_GetMechanismInfo",     "uu",      "uuu"                  },
>+	{ RPC_CALL_C_InitToken,            "C_InitToken",            "uayz",    ""                     },
>+	{ RPC_CALL_C_WaitForSlotEvent,     "C_WaitForSlotEvent",     "u",       "u"                    },
>+	{ RPC_CALL_C_OpenSession,          "C_OpenSession",          "uu",      "u"                    },
>+	{ RPC_CALL_C_CloseSession,         "C_CloseSession",         "u",       ""                     },
>+	{ RPC_CALL_C_CloseAllSessions,     "C_CloseAllSessions",     "u",       ""                     },
>+	{ RPC_CALL_C_GetFunctionStatus,    "C_GetFunctionStatus",    "u",       ""                     },
>+	{ RPC_CALL_C_CancelFunction,       "C_CancelFunction",       "u",       ""                     },
>+	{ RPC_CALL_C_GetSessionInfo,       "C_GetSessionInfo",       "u",       "uuuu"                 },
>+	{ RPC_CALL_C_InitPIN,              "C_InitPIN",              "uay",     ""                     },
>+	{ RPC_CALL_C_SetPIN,               "C_SetPIN",               "uayay",   ""                     },
>+	{ RPC_CALL_C_GetOperationState,    "C_GetOperationState",    "ufy",     "ay"                   },
>+	{ RPC_CALL_C_SetOperationState,    "C_SetOperationState",    "uayuu",   ""                     },
>+	{ RPC_CALL_C_Login,                "C_Login",                "uuay",    ""                     },
>+	{ RPC_CALL_C_Logout,               "C_Logout",               "u",       ""                     },
>+	{ RPC_CALL_C_CreateObject,         "C_CreateObject",         "uaA",     "u"                    },
>+	{ RPC_CALL_C_CopyObject,           "C_CopyObject",           "uuaA",    "u"                    },
>+	{ RPC_CALL_C_DestroyObject,        "C_DestroyObject",        "uu",      ""                     },
>+	{ RPC_CALL_C_GetObjectSize,        "C_GetObjectSize",        "uu",      "u"                    },
>+	{ RPC_CALL_C_GetAttributeValue,    "C_GetAttributeValue",    "uufA",    "aAu"                  },
>+	{ RPC_CALL_C_SetAttributeValue,    "C_SetAttributeValue",    "uuaA",    ""                     },
>+	{ RPC_CALL_C_FindObjectsInit,      "C_FindObjectsInit",      "uaA",     ""                     },
>+	{ RPC_CALL_C_FindObjects,          "C_FindObjects",          "ufu",     "au"                   },
>+	{ RPC_CALL_C_FindObjectsFinal,     "C_FindObjectsFinal",     "u",       ""                     },
>+	{ RPC_CALL_C_EncryptInit,          "C_EncryptInit",          "uMu",     ""                     },
>+	{ RPC_CALL_C_Encrypt,              "C_Encrypt",              "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_EncryptUpdate,        "C_EncryptUpdate",        "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_EncryptFinal,         "C_EncryptFinal",         "ufy",     "ay"                   },
>+	{ RPC_CALL_C_DecryptInit,          "C_DecryptInit",          "uMu",     ""                     },
>+	{ RPC_CALL_C_Decrypt,              "C_Decrypt",              "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_DecryptUpdate,        "C_DecryptUpdate",        "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_DecryptFinal,         "C_DecryptFinal",         "ufy",     "ay"                   },
>+	{ RPC_CALL_C_DigestInit,           "C_DigestInit",           "uM",      ""                     },
>+	{ RPC_CALL_C_Digest,               "C_Digest",               "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_DigestUpdate,         "C_DigestUpdate",         "uay",     ""                     },
>+	{ RPC_CALL_C_DigestKey,            "C_DigestKey",            "uu",      ""                     },
>+	{ RPC_CALL_C_DigestFinal,          "C_DigestFinal",          "ufy",     "ay"                   },
>+	{ RPC_CALL_C_SignInit,             "C_SignInit",             "uMu",     ""                     },
>+	{ RPC_CALL_C_Sign,                 "C_Sign",                 "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_SignUpdate,           "C_SignUpdate",           "uay",     ""                     },
>+	{ RPC_CALL_C_SignFinal,            "C_SignFinal",            "ufy",     "ay"                   },
>+	{ RPC_CALL_C_SignRecoverInit,      "C_SignRecoverInit",      "uMu",     ""                     },
>+	{ RPC_CALL_C_SignRecover,          "C_SignRecover",          "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_VerifyInit,           "C_VerifyInit",           "uMu",     ""                     },
>+	{ RPC_CALL_C_Verify,               "C_Verify",               "uayay",   ""                     },
>+	{ RPC_CALL_C_VerifyUpdate,         "C_VerifyUpdate",         "uay",     ""                     },
>+	{ RPC_CALL_C_VerifyFinal,          "C_VerifyFinal",          "uay",     ""                     },
>+	{ RPC_CALL_C_VerifyRecoverInit,    "C_VerifyRecoverInit",    "uMu",     ""                     },
>+	{ RPC_CALL_C_VerifyRecover,        "C_VerifyRecover",        "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_DigestEncryptUpdate,  "C_DigestEncryptUpdate",  "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_DecryptDigestUpdate,  "C_DecryptDigestUpdate",  "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_SignEncryptUpdate,    "C_SignEncryptUpdate",    "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_DecryptVerifyUpdate,  "C_DecryptVerifyUpdate",  "uayfy",   "ay"                   },
>+	{ RPC_CALL_C_GenerateKey,          "C_GenerateKey",          "uMaA",    "u"                    },
>+	{ RPC_CALL_C_GenerateKeyPair,      "C_GenerateKeyPair",      "uMaAaA",  "uu"                   },
>+	{ RPC_CALL_C_WrapKey,              "C_WrapKey",              "uMuufy",  "ay"                   },
>+	{ RPC_CALL_C_UnwrapKey,            "C_UnwrapKey",            "uMuayaA", "u"                    },
>+	{ RPC_CALL_C_DeriveKey,            "C_DeriveKey",            "uMuaA",   "u"                    },
>+	{ RPC_CALL_C_SeedRandom,           "C_SeedRandom",           "uay",     ""                     },
>+	{ RPC_CALL_C_GenerateRandom,       "C_GenerateRandom",       "ufy",     "ay"                   },
>+};
>+
>+#ifdef _DEBUG
>+#define RPC_CHECK_CALLS() \
>+	{ int i; for (i = 0; i < RPC_CALL_MAX; ++i) assert (rpc_calls[i].call_id == i); }
>+#endif
>+
>+#define RPC_HANDSHAKE \
>+	((unsigned char *)"PRIVATE-GNOME-KEYRING-PKCS11-PROTOCOL-V-1")
>+#define RPC_HANDSHAKE_LEN \
>+	(strlen ((char *)RPC_HANDSHAKE))
>+
>+typedef enum _RpcMessageType {
>+	RPC_REQUEST = 1,
>+	RPC_RESPONSE
>+} RpcMessageType;
>+
>+typedef struct _RpcMessage {
>+	int call_id;
>+	RpcMessageType call_type;
>+	const char *signature;
>+	P11Buffer *input;
>+	P11Output *output;
>+	size_t parsed;
>+	const char *sigverify;
>+	void *extra;
>+} RpcMessage;
>+
>+void                     _p11_rpc_message_init                    (RpcMessage *msg,
>+                                                                   P11Buffer *input,
>+                                                                   P11Output *output);
>+
>+void                     _p11_rpc_message_clear                   (RpcMessage *msg);
>+
>+#define                  _p11_rpc_message_is_verified(msg)        (!(msg)->sigverify || (msg)->sigverify[0] == 0)
>+
>+void *                   _p11_rpc_message_alloc_extra             (RpcMessage *msg,
>+                                                                   size_t length);
>+
>+int                      _p11_rpc_message_prep                    (RpcMessage *msg,
>+                                                                   int call_id,
>+                                                                   RpcMessageType type);
>+
>+int                      _p11_rpc_message_parse                   (RpcMessage *msg,
>+                                                                   RpcMessageType type);
>+
>+int                      _p11_rpc_message_verify_part             (RpcMessage *msg,
>+                                                                   const char* part);
>+
>+int                      _p11_rpc_message_write_byte              (RpcMessage *msg,
>+                                                                   CK_BYTE val);
>+
>+int                      _p11_rpc_message_write_ulong             (RpcMessage *msg,
>+                                                                   CK_ULONG val);
>+
>+int                      _p11_rpc_message_write_zero_string       (RpcMessage *msg,
>+                                                                   CK_UTF8CHAR *string);
>+
>+int                      _p11_rpc_message_write_space_string      (RpcMessage *msg,
>+                                                                   CK_UTF8CHAR *buffer,
>+                                                                   CK_ULONG length);
>+
>+int                      _p11_rpc_message_write_byte_buffer       (RpcMessage *msg,
>+                                                                   CK_ULONG count);
>+
>+int                      _p11_rpc_message_write_byte_array        (RpcMessage *msg,
>+                                                                   CK_BYTE_PTR arr,
>+                                                                   CK_ULONG num);
>+
>+int                      _p11_rpc_message_write_ulong_buffer      (RpcMessage *msg,
>+                                                                   CK_ULONG count);
>+
>+int                      _p11_rpc_message_write_ulong_array       (RpcMessage *msg,
>+                                                                   CK_ULONG_PTR arr,
>+                                                                   CK_ULONG num);
>+
>+int                      _p11_rpc_message_write_attribute_buffer  (RpcMessage *msg,
>+                                                                   CK_ATTRIBUTE_PTR arr,
>+                                                                   CK_ULONG num);
>+
>+int                      _p11_rpc_message_write_attribute_array   (RpcMessage *msg,
>+                                                                   CK_ATTRIBUTE_PTR arr,
>+                                                                   CK_ULONG num);
>+
>+int                      _p11_rpc_message_write_version           (RpcMessage *msg,
>+                                                                   CK_VERSION* version);
>+
>+int                      _p11_rpc_message_read_byte               (RpcMessage *msg,
>+                                                                   CK_BYTE* val);
>+
>+int                      _p11_rpc_message_read_ulong              (RpcMessage *msg,
>+                                                                   CK_ULONG* val);
>+
>+int                      _p11_rpc_message_read_space_string       (RpcMessage *msg,
>+                                                                   CK_UTF8CHAR* buffer,
>+                                                                   CK_ULONG length);
>+
>+int                      _p11_rpc_message_read_version            (RpcMessage *msg,
>+                                                                   CK_VERSION* version);
>+
>+#endif /* _RPC_MESSAGE_H */
>diff --git a/p11-kit/rpc-private.h b/p11-kit/rpc-private.h
>new file mode 100644
>index 0000000..cca8739
>--- /dev/null
>+++ b/p11-kit/rpc-private.h
>@@ -0,0 +1,30 @@
>+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
>+/*
>+   Copyright (C) 2012 Red Hat Inc.
>+
>+   The Gnome Keyring Library is free software; you can redistribute it and/or
>+   modify it under the terms of the GNU Library General Public License as
>+   published by the Free Software Foundation; either version 2 of the
>+   License, or (at your option) any later version.
>+
>+   The Gnome Keyring Library is distributed in the hope that it will be useful,
>+   but WITHOUT ANY WARRANTY; without even the implied warranty of
>+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+   Library General Public License for more details.
>+
>+   You should have received a copy of the GNU Library General Public
>+   License along with the Gnome Library; see the file COPYING.LIB.  If not,
>+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
>+   Boston, MA 02111-1307, USA.
>+
>+   Author: Stef Walter <stefw@gnome.org>
>+*/
>+
>+#ifndef __RPC_PRIVATE_H__
>+#define __RPC_PRIVATE_H__
>+
>+#include "rpc.h"
>+
>+extern CK_MECHANISM_TYPE *_p11_rpc_mechanisms_override_supported;
>+
>+#endif /* __RPC_PRIVATE_H__ */
>diff --git a/p11-kit/rpc-server.c b/p11-kit/rpc-server.c
>new file mode 100644
>index 0000000..3b9b5f3
>--- /dev/null
>+++ b/p11-kit/rpc-server.c
>@@ -0,0 +1,1995 @@
>+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
>+/* rpc-dispatch.h - receiver of our PKCS#11 protocol.
>+
>+   Copyright (C) 2008, Stef Walter
>+   Copyright (C) 2012, Stef Walter
>+
>+   The Gnome Keyring Library is free software; you can redistribute it and/or
>+   modify it under the terms of the GNU Library General Public License as
>+   published by the Free Software Foundation; either version 2 of the
>+   License, or (at your option) any later version.
>+
>+   The Gnome Keyring Library is distributed in the hope that it will be useful,
>+   but WITHOUT ANY WARRANTY; without even the implied warranty of
>+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+   Library General Public License for more details.
>+
>+   You should have received a copy of the GNU Library General Public
>+   License along with the Gnome Library; see the file COPYING.LIB.  If not,
>+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
>+   Boston, MA 02111-1307, USA.
>+
>+   Author: Stef Walter <stef@thewalter.net>
>+*/
>+
>+#include "config.h"
>+
>+#define DEBUG_FLAG DEBUG_RPC
>+#include "debug.h"
>+#include "pkcs11.h"
>+#include "private.h"
>+#include "rpc.h"
>+#include "rpc-message.h"
>+
>+#include <sys/types.h>
>+#include <sys/param.h>
>+#include <sys/socket.h>
>+#include <sys/un.h>
>+#include <assert.h>
>+#include <pthread.h>
>+#include <errno.h>
>+#include <stdlib.h>
>+#include <string.h>
>+#include <unistd.h>
>+
>+/* The error returned on protocol failures */
>+#define PARSE_ERROR CKR_DEVICE_ERROR
>+#define PREP_ERROR  CKR_DEVICE_MEMORY
>+
>+static CK_RV
>+proto_read_byte_buffer (RpcMessage *msg,
>+                        CK_BYTE_PTR *buffer,
>+                        CK_ULONG *n_buffer)
>+{
>+	uint32_t length;
>+
>+	assert (msg != NULL);
>+	assert (buffer != NULL);
>+	assert (n_buffer != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Check that we're supposed to be reading this at this point */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "fy"));
>+
>+	/* The number of ulongs there's room for on the other end */
>+	if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &length))
>+		return PARSE_ERROR;
>+
>+	*n_buffer = length;
>+	*buffer = NULL;
>+
>+	/* If set to zero, then they just want the length */
>+	if (length == 0)
>+		return CKR_OK;
>+
>+	*buffer = _p11_rpc_message_alloc_extra (msg, length * sizeof (CK_BYTE));
>+	if (*buffer == NULL)
>+		return CKR_DEVICE_MEMORY;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_byte_array (RpcMessage *msg,
>+                       CK_BYTE_PTR *array,
>+                       CK_ULONG *n_array)
>+{
>+	const unsigned char *data;
>+	unsigned char valid;
>+	size_t n_data;
>+
>+	assert (msg != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Check that we're supposed to have this at this point */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "ay"));
>+
>+	/* Read out the byte which says whether data is present or not */
>+	if (!_p11_buffer_get_byte (msg->input, msg->parsed, &msg->parsed, &valid))
>+		return PARSE_ERROR;
>+
>+	if (!valid) {
>+		*array = NULL;
>+		*n_array = 0;
>+		return CKR_OK;
>+	}
>+
>+	/* Point our arguments into the buffer */
>+	if (!_p11_buffer_get_byte_array (msg->input, msg->parsed, &msg->parsed,
>+	                                 &data, &n_data))
>+		return PARSE_ERROR;
>+
>+	*array = (CK_BYTE_PTR)data;
>+	*n_array = n_data;
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_write_byte_array (RpcMessage *msg,
>+                        CK_BYTE_PTR array,
>+                        CK_ULONG len,
>+                        CK_RV ret)
>+{
>+	assert (msg != NULL);
>+
>+	/*
>+	 * When returning an byte array, in many cases we need to pass
>+	 * an invalid array along with a length, which signifies CKR_BUFFER_TOO_SMALL.
>+	 */
>+
>+	switch (ret) {
>+	case CKR_BUFFER_TOO_SMALL:
>+		array = NULL;
>+		/* fall through */
>+	case CKR_OK:
>+		break;
>+
>+	/* Pass all other errors straight through */
>+	default:
>+		return ret;
>+	};
>+
>+	if (!_p11_rpc_message_write_byte_array (msg, array, len))
>+		return PREP_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_ulong_buffer (RpcMessage *msg,
>+                         CK_ULONG_PTR *buffer,
>+                         CK_ULONG *n_buffer)
>+{
>+	uint32_t length;
>+
>+	assert (msg != NULL);
>+	assert (buffer != NULL);
>+	assert (n_buffer != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Check that we're supposed to be reading this at this point */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "fu"));
>+
>+	/* The number of ulongs there's room for on the other end */
>+	if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &length))
>+		return PARSE_ERROR;
>+
>+	*n_buffer = length;
>+	*buffer = NULL;
>+
>+	/* If set to zero, then they just want the length */
>+	if (length == 0)
>+		return CKR_OK;
>+
>+	*buffer = _p11_rpc_message_alloc_extra (msg, length * sizeof (CK_ULONG));
>+	if (!*buffer)
>+		return CKR_DEVICE_MEMORY;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_write_ulong_array (RpcMessage *msg,
>+                         CK_ULONG_PTR array,
>+                         CK_ULONG len,
>+                         CK_RV ret)
>+{
>+	assert (msg != NULL);
>+
>+	/*
>+	 * When returning an ulong array, in many cases we need to pass
>+	 * an invalid array along with a length, which signifies CKR_BUFFER_TOO_SMALL.
>+	 */
>+
>+	switch (ret) {
>+	case CKR_BUFFER_TOO_SMALL:
>+		array = NULL;
>+		/* fall through */
>+	case CKR_OK:
>+		break;
>+
>+	/* Pass all other errors straight through */
>+	default:
>+		return ret;
>+	};
>+
>+	if (!_p11_rpc_message_write_ulong_array (msg, array, len))
>+		return PREP_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_attribute_buffer (RpcMessage *msg,
>+                             CK_ATTRIBUTE_PTR *result,
>+                             CK_ULONG *n_result)
>+{
>+	CK_ATTRIBUTE_PTR attrs;
>+	uint32_t n_attrs, i;
>+	uint32_t value;
>+
>+	assert (msg != NULL);
>+	assert (result != NULL);
>+	assert (n_result != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Make sure this is in the rigth order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "fA"));
>+
>+	/* Read the number of attributes */
>+	if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &n_attrs))
>+		return PARSE_ERROR;
>+
>+	/* Allocate memory for the attribute structures */
>+	attrs = _p11_rpc_message_alloc_extra (msg, n_attrs * sizeof (CK_ATTRIBUTE));
>+	if (attrs == NULL)
>+		return CKR_DEVICE_MEMORY;
>+
>+	/* Now go through and fill in each one */
>+	for (i = 0; i < n_attrs; ++i) {
>+
>+		/* The attribute type */
>+		if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &value))
>+			return PARSE_ERROR;
>+
>+		attrs[i].type = value;
>+
>+		/* The number of bytes to allocate */
>+		if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &value))
>+			return PARSE_ERROR;
>+
>+		if (value == 0) {
>+			attrs[i].pValue = NULL;
>+			attrs[i].ulValueLen = 0;
>+		} else {
>+			attrs[i].pValue = _p11_rpc_message_alloc_extra (msg, value);
>+			if (!attrs[i].pValue)
>+				return CKR_DEVICE_MEMORY;
>+			attrs[i].ulValueLen = value;
>+		}
>+	}
>+
>+	*result = attrs;
>+	*n_result = n_attrs;
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_attribute_array (RpcMessage *msg,
>+                            CK_ATTRIBUTE_PTR *result,
>+                            CK_ULONG *n_result)
>+{
>+	CK_ATTRIBUTE_PTR attrs;
>+	const unsigned char *data;
>+	unsigned char valid;
>+	uint32_t n_attrs, i;
>+	uint32_t value;
>+	size_t n_data;
>+
>+	assert (msg != NULL);
>+	assert (result != NULL);
>+	assert (n_result != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Make sure this is in the rigth order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "aA"));
>+
>+	/* Read the number of attributes */
>+	if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &n_attrs))
>+		return PARSE_ERROR;
>+
>+	/* Allocate memory for the attribute structures */
>+	attrs = _p11_rpc_message_alloc_extra (msg, n_attrs * sizeof (CK_ATTRIBUTE));
>+	if (attrs == NULL)
>+		return CKR_DEVICE_MEMORY;
>+
>+	/* Now go through and fill in each one */
>+	for (i = 0; i < n_attrs; ++i) {
>+
>+		/* The attribute type */
>+		if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &value))
>+			return PARSE_ERROR;
>+
>+		attrs[i].type = value;
>+
>+		/* Whether this one is valid or not */
>+		if (!_p11_buffer_get_byte (msg->input, msg->parsed, &msg->parsed, &valid))
>+			return PARSE_ERROR;
>+
>+		if (valid) {
>+			if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &value))
>+				return PARSE_ERROR;
>+			if (!_p11_buffer_get_byte_array (msg->input, msg->parsed, &msg->parsed, &data, &n_data))
>+				return PARSE_ERROR;
>+
>+			if (data != NULL && n_data != value) {
>+				_p11_message ("attribute length and data do not match");
>+				return PARSE_ERROR;
>+			}
>+
>+			attrs[i].pValue = (CK_VOID_PTR)data;
>+			attrs[i].ulValueLen = value;
>+		} else {
>+			attrs[i].pValue = NULL;
>+			attrs[i].ulValueLen = -1;
>+		}
>+	}
>+
>+	*result = attrs;
>+	*n_result = n_attrs;
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_write_attribute_array (RpcMessage *msg,
>+                             CK_ATTRIBUTE_PTR array,
>+                             CK_ULONG len,
>+                             CK_RV ret)
>+{
>+	assert (msg != NULL);
>+
>+	/*
>+	 * When returning an attribute array, certain errors aren't
>+	 * actually real errors, these are passed through to the other
>+	 * side along with the attribute array.
>+	 */
>+
>+	switch (ret) {
>+	case CKR_ATTRIBUTE_SENSITIVE:
>+	case CKR_ATTRIBUTE_TYPE_INVALID:
>+	case CKR_BUFFER_TOO_SMALL:
>+	case CKR_OK:
>+		break;
>+
>+	/* Pass all other errors straight through */
>+	default:
>+		return ret;
>+	};
>+
>+	if (!_p11_rpc_message_write_attribute_array (msg, array, len) ||
>+	    !_p11_rpc_message_write_ulong (msg, ret))
>+		return PREP_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_null_string (RpcMessage *msg,
>+                        CK_UTF8CHAR_PTR *val)
>+{
>+	const unsigned char *data;
>+	size_t n_data;
>+
>+	assert (msg != NULL);
>+	assert (val != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Check that we're supposed to have this at this point */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "z"));
>+
>+	if (!_p11_buffer_get_byte_array (msg->input, msg->parsed, &msg->parsed, &data, &n_data))
>+		return PARSE_ERROR;
>+
>+	/* Allocate a block of memory for it */
>+	*val = _p11_rpc_message_alloc_extra (msg, n_data);
>+	if (*val == NULL)
>+		return CKR_DEVICE_MEMORY;
>+
>+	memcpy (*val, data, n_data);
>+	(*val)[n_data] = 0;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_read_mechanism (RpcMessage *msg,
>+                      CK_MECHANISM_PTR mech)
>+{
>+	const unsigned char *data;
>+	uint32_t value;
>+	size_t n_data;
>+
>+	assert (msg != NULL);
>+	assert (mech != NULL);
>+	assert (msg->input != NULL);
>+
>+	/* Make sure this is in the right order */
>+	assert (!msg->signature || _p11_rpc_message_verify_part (msg, "M"));
>+
>+	/* The mechanism type */
>+	if (!_p11_buffer_get_uint32 (msg->input, msg->parsed, &msg->parsed, &value))
>+		return PARSE_ERROR;
>+
>+	/* The mechanism data */
>+	if (!_p11_buffer_get_byte_array (msg->input, msg->parsed, &msg->parsed, &data, &n_data))
>+		return PARSE_ERROR;
>+
>+	mech->mechanism = value;
>+	mech->pParameter = (CK_VOID_PTR)data;
>+	mech->ulParameterLen = n_data;
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_write_info (RpcMessage *msg,
>+                  CK_INFO_PTR info)
>+{
>+	assert (msg != NULL);
>+	assert (info != NULL);
>+
>+	if (!_p11_rpc_message_write_version (msg, &info->cryptokiVersion) ||
>+	    !_p11_rpc_message_write_space_string (msg, info->manufacturerID, 32) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->flags) ||
>+	    !_p11_rpc_message_write_space_string (msg, info->libraryDescription, 32) ||
>+	    !_p11_rpc_message_write_version (msg, &info->libraryVersion))
>+		return PREP_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_write_slot_info (RpcMessage *msg,
>+                       CK_SLOT_INFO_PTR info)
>+{
>+	assert (msg != NULL);
>+	assert (info != NULL);
>+
>+	if (!_p11_rpc_message_write_space_string (msg, info->slotDescription, 64) ||
>+	    !_p11_rpc_message_write_space_string (msg, info->manufacturerID, 32) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->flags) ||
>+	    !_p11_rpc_message_write_version (msg, &info->hardwareVersion) ||
>+	    !_p11_rpc_message_write_version (msg, &info->firmwareVersion))
>+		return PREP_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_write_token_info (RpcMessage *msg,
>+                        CK_TOKEN_INFO_PTR info)
>+{
>+	assert (msg != NULL);
>+	assert (info != NULL);
>+
>+	if (!_p11_rpc_message_write_space_string (msg, info->label, 32) ||
>+	    !_p11_rpc_message_write_space_string (msg, info->manufacturerID, 32) ||
>+	    !_p11_rpc_message_write_space_string (msg, info->model, 16) ||
>+	    !_p11_rpc_message_write_space_string (msg, info->serialNumber, 16) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->flags) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulMaxSessionCount) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulSessionCount) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulMaxRwSessionCount) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulRwSessionCount) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulMaxPinLen) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulMinPinLen) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulTotalPublicMemory) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulFreePublicMemory) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulTotalPrivateMemory) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulFreePrivateMemory) ||
>+	    !_p11_rpc_message_write_version (msg, &info->hardwareVersion) ||
>+	    !_p11_rpc_message_write_version (msg, &info->firmwareVersion) ||
>+	    !_p11_rpc_message_write_space_string (msg, info->utcTime, 16))
>+		return PREP_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_write_mechanism_info (RpcMessage *msg,
>+                            CK_MECHANISM_INFO_PTR info)
>+{
>+	assert (msg != NULL);
>+	assert (info != NULL);
>+
>+	if (!_p11_rpc_message_write_ulong (msg, info->ulMinKeySize) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulMaxKeySize) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->flags))
>+		return PREP_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+proto_write_session_info (RpcMessage *msg,
>+                          CK_SESSION_INFO_PTR info)
>+{
>+	assert (msg != NULL);
>+	assert (info != NULL);
>+
>+	if (!_p11_rpc_message_write_ulong (msg, info->slotID) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->state) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->flags) ||
>+	    !_p11_rpc_message_write_ulong (msg, info->ulDeviceError))
>+		return PREP_ERROR;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+call_ready (RpcMessage *msg)
>+{
>+	assert (msg->output);
>+
>+	/*
>+	 * Called right before invoking the actual PKCS#11 function
>+	 * Reading out of data is complete, get ready to write return values.
>+	 */
>+
>+	if (_p11_buffer_failed (msg->output)) {
>+		_p11_message ("invalid request from module, probably too short"); \
>+		return PARSE_ERROR;
>+	}
>+
>+	assert (_p11_rpc_message_is_verified (msg));
>+
>+	/* All done parsing input */
>+	msg->input = NULL;
>+
>+	if (!_p11_rpc_message_prep (msg, msg->call_id, RPC_RESPONSE)) {
>+		_p11_message ("couldn't initialize rpc response");
>+		return CKR_DEVICE_MEMORY;
>+	}
>+
>+	return CKR_OK;
>+}
>+
>+/* -------------------------------------------------------------------
>+ * CALL MACROS
>+ */
>+
>+#define BEGIN_CALL(call_id) \
>+	_p11_debug (#call_id ": enter"); \
>+	assert (msg != NULL); \
>+	assert (module != NULL); \
>+	{  \
>+		CK_ ## call_id _func = module-> call_id; \
>+		CK_RV _ret = CKR_OK; \
>+		if (!_func) { _ret = CKR_GENERAL_ERROR; goto _cleanup; }
>+
>+#define PROCESS_CALL(args) \
>+		_ret = call_ready (msg); \
>+		if (_ret != CKR_OK) { goto _cleanup; } \
>+		_ret = _func args
>+
>+#define END_CALL \
>+	_cleanup: \
>+		_p11_debug ("ret: %d", (int)_ret); \
>+		return _ret; \
>+	}
>+
>+#define IN_BYTE(val) \
>+	if (!_p11_rpc_message_read_byte (msg, &val)) \
>+		{ _ret = PARSE_ERROR; goto _cleanup; }
>+
>+#define IN_ULONG(val) \
>+	if (!_p11_rpc_message_read_ulong (msg, &val)) \
>+		{ _ret = PARSE_ERROR; goto _cleanup; }
>+
>+#define IN_STRING(val) \
>+	_ret = proto_read_null_string (msg, &val); \
>+	if (_ret != CKR_OK) goto _cleanup;
>+
>+#define IN_BYTE_BUFFER(buffer, buffer_len) \
>+	_ret = proto_read_byte_buffer (msg, &buffer, &buffer_len); \
>+	if (_ret != CKR_OK) goto _cleanup;
>+
>+#define IN_BYTE_ARRAY(buffer, buffer_len) \
>+	_ret = proto_read_byte_array (msg, &buffer, &buffer_len); \
>+	if (_ret != CKR_OK) goto _cleanup;
>+
>+#define IN_ULONG_BUFFER(buffer, buffer_len) \
>+	_ret = proto_read_ulong_buffer (msg, &buffer, &buffer_len); \
>+	if (_ret != CKR_OK) goto _cleanup;
>+
>+#define IN_ATTRIBUTE_BUFFER(buffer, buffer_len) \
>+	_ret = proto_read_attribute_buffer (msg, &buffer, &buffer_len); \
>+	if (_ret != CKR_OK) goto _cleanup;
>+
>+#define IN_ATTRIBUTE_ARRAY(attrs, n_attrs) \
>+	_ret = proto_read_attribute_array (msg, &attrs, &n_attrs); \
>+	if (_ret != CKR_OK) goto _cleanup;
>+
>+#define IN_MECHANISM(mech) \
>+	_ret = proto_read_mechanism (msg, &mech); \
>+	if (_ret != CKR_OK) goto _cleanup;
>+
>+
>+#define OUT_ULONG(val) \
>+	if (_ret == CKR_OK && !_p11_rpc_message_write_ulong (msg, val)) \
>+		_ret = PREP_ERROR;
>+
>+#define OUT_BYTE_ARRAY(array, len) \
>+	/* Note how we filter return codes */ \
>+	_ret = proto_write_byte_array (msg, array, len, _ret);
>+
>+#define OUT_ULONG_ARRAY(array, len) \
>+	/* Note how we filter return codes */ \
>+	_ret = proto_write_ulong_array (msg, array, len, _ret);
>+
>+#define OUT_ATTRIBUTE_ARRAY(array, len) \
>+	/* Note how we filter return codes */ \
>+	_ret = proto_write_attribute_array (msg, array, len, _ret);
>+
>+#define OUT_INFO(val) \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_write_info (msg, &val);
>+
>+#define OUT_SLOT_INFO(val) \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_write_slot_info (msg, &val);
>+
>+#define OUT_TOKEN_INFO(val) \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_write_token_info (msg, &val);
>+
>+#define OUT_MECHANISM_INFO(val) \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_write_mechanism_info (msg, &val);
>+
>+#define OUT_SESSION_INFO(val) \
>+	if (_ret == CKR_OK) \
>+		_ret = proto_write_session_info (msg, &val);
>+
>+/* ---------------------------------------------------------------------------
>+ * DISPATCH SPECIFIC CALLS
>+ */
>+
>+static CK_RV
>+rpc_C_Initialize (P11RpcServerVtable *vtable,
>+                  CK_FUNCTION_LIST_PTR module,
>+                  RpcMessage *msg)
>+{
>+	CK_C_Initialize func;
>+	CK_C_INITIALIZE_ARGS init_args;
>+	CK_BYTE_PTR handshake;
>+	CK_ULONG n_handshake;
>+	CK_RV ret = CKR_OK;
>+
>+	_p11_debug ("C_Initialize: enter");
>+
>+	assert (msg != NULL);
>+	assert (module != NULL);
>+
>+	ret = proto_read_byte_array (msg, &handshake, &n_handshake);
>+	if (ret == CKR_OK) {
>+
>+		/* Check to make sure the header matches */
>+		if (n_handshake != RPC_HANDSHAKE_LEN ||
>+		    memcmp (handshake, RPC_HANDSHAKE, n_handshake) != 0) {
>+			_p11_message ("invalid handshake received from connecting module");
>+			ret = CKR_GENERAL_ERROR;
>+		}
>+
>+		assert (_p11_rpc_message_is_verified (msg));
>+	}
>+
>+	memset (&init_args, 0, sizeof (init_args));
>+	init_args.flags = CKF_OS_LOCKING_OK;
>+
>+	func = module->C_Initialize;
>+	assert (func != NULL);
>+	ret = (func) (&init_args);
>+
>+	/* Empty response */
>+	if (ret == CKR_OK)
>+		ret = call_ready (msg);
>+
>+	_p11_debug ("ret: %d", (int)ret);
>+	return ret;
>+}
>+
>+static CK_RV
>+rpc_C_Finalize (P11RpcServerVtable *vtable,
>+                CK_FUNCTION_LIST_PTR module,
>+                RpcMessage *msg)
>+{
>+	BEGIN_CALL (C_Finalize);
>+	PROCESS_CALL ((NULL));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetInfo (P11RpcServerVtable *vtable,
>+               CK_FUNCTION_LIST_PTR module,
>+               RpcMessage *msg)
>+{
>+	CK_INFO info;
>+
>+	BEGIN_CALL (C_GetInfo);
>+	PROCESS_CALL ((&info));
>+		OUT_INFO (info);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetSlotList (P11RpcServerVtable *vtable,
>+                   CK_FUNCTION_LIST_PTR module,
>+                   RpcMessage *msg)
>+{
>+	CK_BBOOL token_present;
>+	CK_SLOT_ID_PTR slot_list;
>+	CK_ULONG count;
>+
>+	BEGIN_CALL (C_GetSlotList);
>+		IN_BYTE (token_present);
>+		IN_ULONG_BUFFER (slot_list, count);
>+	PROCESS_CALL ((token_present, slot_list, &count));
>+		OUT_ULONG_ARRAY (slot_list, count);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetSlotInfo (P11RpcServerVtable *vtable,
>+                   CK_FUNCTION_LIST_PTR module,
>+                   RpcMessage *msg)
>+{
>+	CK_SLOT_ID slot_id;
>+	CK_SLOT_INFO info;
>+
>+	BEGIN_CALL (C_GetSlotInfo);
>+		IN_ULONG (slot_id);
>+	PROCESS_CALL ((slot_id, &info));
>+		OUT_SLOT_INFO (info);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetTokenInfo (P11RpcServerVtable *vtable,
>+                    CK_FUNCTION_LIST_PTR module,
>+                    RpcMessage *msg)
>+{
>+	CK_SLOT_ID slot_id;
>+	CK_TOKEN_INFO info;
>+
>+	BEGIN_CALL (C_GetTokenInfo);
>+		IN_ULONG (slot_id);
>+	PROCESS_CALL ((slot_id, &info));
>+		OUT_TOKEN_INFO (info);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetMechanismList (P11RpcServerVtable *vtable,
>+                        CK_FUNCTION_LIST_PTR module,
>+                        RpcMessage *msg)
>+{
>+	CK_SLOT_ID slot_id;
>+	CK_MECHANISM_TYPE_PTR mechanism_list;
>+	CK_ULONG count;
>+
>+	BEGIN_CALL (C_GetMechanismList);
>+		IN_ULONG (slot_id);
>+		IN_ULONG_BUFFER (mechanism_list, count);
>+	PROCESS_CALL ((slot_id, mechanism_list, &count));
>+		OUT_ULONG_ARRAY (mechanism_list, count);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetMechanismInfo (P11RpcServerVtable *vtable,
>+                        CK_FUNCTION_LIST_PTR module,
>+                        RpcMessage *msg)
>+{
>+	CK_SLOT_ID slot_id;
>+	CK_MECHANISM_TYPE type;
>+	CK_MECHANISM_INFO info;
>+
>+	BEGIN_CALL (C_GetMechanismInfo);
>+		IN_ULONG (slot_id);
>+		IN_ULONG (type);
>+	PROCESS_CALL ((slot_id, type, &info));
>+		OUT_MECHANISM_INFO (info);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_InitToken (P11RpcServerVtable *vtable,
>+                 CK_FUNCTION_LIST_PTR module,
>+                 RpcMessage *msg)
>+{
>+	CK_SLOT_ID slot_id;
>+	CK_UTF8CHAR_PTR pin;
>+	CK_ULONG pin_len;
>+	CK_UTF8CHAR_PTR label;
>+
>+	BEGIN_CALL (C_InitToken);
>+		IN_ULONG (slot_id);
>+		IN_BYTE_ARRAY (pin, pin_len);
>+		IN_STRING (label);
>+	PROCESS_CALL ((slot_id, pin, pin_len, label));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_WaitForSlotEvent (P11RpcServerVtable *vtable,
>+                        CK_FUNCTION_LIST_PTR module,
>+                        RpcMessage *msg)
>+{
>+	CK_FLAGS flags;
>+	CK_SLOT_ID slot_id;
>+
>+	BEGIN_CALL (C_WaitForSlotEvent);
>+		IN_ULONG (flags);
>+	PROCESS_CALL ((flags, &slot_id, NULL));
>+		OUT_ULONG (slot_id);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_OpenSession (P11RpcServerVtable *vtable,
>+                   CK_FUNCTION_LIST_PTR module,
>+                   RpcMessage *msg)
>+{
>+	CK_SLOT_ID slot_id;
>+	CK_FLAGS flags;
>+	CK_SESSION_HANDLE session;
>+
>+	BEGIN_CALL (C_OpenSession);
>+		IN_ULONG (slot_id);
>+		IN_ULONG (flags);
>+	PROCESS_CALL ((slot_id, flags, NULL, NULL, &session));
>+		OUT_ULONG (session);
>+	END_CALL;
>+}
>+
>+
>+static CK_RV
>+rpc_C_CloseSession (P11RpcServerVtable *vtable,
>+                    CK_FUNCTION_LIST_PTR module,
>+                    RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+
>+	BEGIN_CALL (C_CloseSession);
>+		IN_ULONG (session);
>+	PROCESS_CALL ((session));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_CloseAllSessions (P11RpcServerVtable *vtable,
>+                        CK_FUNCTION_LIST_PTR module,
>+                        RpcMessage *msg)
>+{
>+	CK_SLOT_ID slot_id;
>+
>+	/* Slot id becomes appartment so lower layers can tell clients apart. */
>+
>+	BEGIN_CALL (C_CloseAllSessions);
>+		IN_ULONG (slot_id);
>+	PROCESS_CALL ((slot_id));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetFunctionStatus (P11RpcServerVtable *vtable,
>+                         CK_FUNCTION_LIST_PTR module,
>+                         RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+
>+	BEGIN_CALL (C_GetFunctionStatus);
>+		IN_ULONG (session);
>+	PROCESS_CALL ((session));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_CancelFunction (P11RpcServerVtable *vtable,
>+                      CK_FUNCTION_LIST_PTR module,
>+                      RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+
>+	BEGIN_CALL (C_CancelFunction);
>+		IN_ULONG (session);
>+	PROCESS_CALL ((session));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetSessionInfo (P11RpcServerVtable *vtable,
>+                      CK_FUNCTION_LIST_PTR module,
>+                      RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_SESSION_INFO info;
>+
>+	BEGIN_CALL (C_GetSessionInfo);
>+		IN_ULONG (session);
>+	PROCESS_CALL ((session, &info));
>+		OUT_SESSION_INFO (info);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_InitPIN (P11RpcServerVtable *vtable,
>+               CK_FUNCTION_LIST_PTR module,
>+               RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_UTF8CHAR_PTR pin;
>+	CK_ULONG pin_len;
>+
>+	BEGIN_CALL (C_InitPIN);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (pin, pin_len);
>+	PROCESS_CALL ((session, pin, pin_len));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SetPIN (P11RpcServerVtable *vtable,
>+              CK_FUNCTION_LIST_PTR module,
>+              RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_UTF8CHAR_PTR old_pin;
>+	CK_ULONG old_len;
>+	CK_UTF8CHAR_PTR new_pin;
>+	CK_ULONG new_len;
>+
>+	BEGIN_CALL (C_SetPIN);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (old_pin, old_len);
>+		IN_BYTE_ARRAY (new_pin, new_len);
>+	PROCESS_CALL ((session, old_pin, old_len, new_pin, new_len));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetOperationState (P11RpcServerVtable *vtable,
>+                         CK_FUNCTION_LIST_PTR module,
>+                         RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR operation_state;
>+	CK_ULONG operation_state_len;
>+
>+	BEGIN_CALL (C_GetOperationState);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (operation_state, operation_state_len);
>+	PROCESS_CALL ((session, operation_state, &operation_state_len));
>+		OUT_BYTE_ARRAY (operation_state, operation_state_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SetOperationState (P11RpcServerVtable *vtable,
>+                         CK_FUNCTION_LIST_PTR module,
>+                         RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR operation_state;
>+	CK_ULONG operation_state_len;
>+	CK_OBJECT_HANDLE encryption_key;
>+	CK_OBJECT_HANDLE authentication_key;
>+
>+	BEGIN_CALL (C_SetOperationState);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (operation_state, operation_state_len);
>+		IN_ULONG (encryption_key);
>+		IN_ULONG (authentication_key);
>+	PROCESS_CALL ((session, operation_state, operation_state_len, encryption_key, authentication_key));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Login (P11RpcServerVtable *vtable,
>+             CK_FUNCTION_LIST_PTR module,
>+             RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_USER_TYPE user_type;
>+	CK_UTF8CHAR_PTR pin;
>+	CK_ULONG pin_len;
>+
>+	BEGIN_CALL (C_Login);
>+		IN_ULONG (session);
>+		IN_ULONG (user_type);
>+		IN_BYTE_ARRAY (pin, pin_len);
>+	PROCESS_CALL ((session, user_type, pin, pin_len));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Logout (P11RpcServerVtable *vtable,
>+              CK_FUNCTION_LIST_PTR module,
>+              RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+
>+	BEGIN_CALL (C_Logout);
>+		IN_ULONG (session);
>+	PROCESS_CALL ((session));
>+	END_CALL;
>+}
>+
>+/* -----------------------------------------------------------------------------
>+ * OBJECT OPERATIONS
>+ */
>+
>+static CK_RV
>+rpc_C_CreateObject (P11RpcServerVtable *vtable,
>+                    CK_FUNCTION_LIST_PTR module,
>+                    RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_ATTRIBUTE_PTR template;
>+	CK_ULONG count;
>+	CK_OBJECT_HANDLE new_object;
>+
>+	BEGIN_CALL (C_CreateObject);
>+		IN_ULONG (session);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL ((session, template, count, &new_object));
>+		OUT_ULONG (new_object);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_CopyObject (P11RpcServerVtable *vtable,
>+                  CK_FUNCTION_LIST_PTR module,
>+                  RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_OBJECT_HANDLE object;
>+	CK_ATTRIBUTE_PTR template;
>+	CK_ULONG count;
>+	CK_OBJECT_HANDLE new_object;
>+
>+	BEGIN_CALL (C_CopyObject);
>+		IN_ULONG (session);
>+		IN_ULONG (object);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL ((session, object, template, count, &new_object));
>+		OUT_ULONG (new_object);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DestroyObject (P11RpcServerVtable *vtable,
>+                     CK_FUNCTION_LIST_PTR module,
>+                     RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_OBJECT_HANDLE object;
>+
>+	BEGIN_CALL (C_DestroyObject);
>+		IN_ULONG (session);
>+		IN_ULONG (object);
>+	PROCESS_CALL ((session, object));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetObjectSize (P11RpcServerVtable *vtable,
>+                     CK_FUNCTION_LIST_PTR module,
>+                     RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_OBJECT_HANDLE object;
>+	CK_ULONG size;
>+
>+	BEGIN_CALL (C_GetObjectSize);
>+		IN_ULONG (session);
>+		IN_ULONG (object);
>+	PROCESS_CALL ((session, object, &size));
>+		OUT_ULONG (size);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GetAttributeValue (P11RpcServerVtable *vtable,
>+                         CK_FUNCTION_LIST_PTR module,
>+                         RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_OBJECT_HANDLE object;
>+	CK_ATTRIBUTE_PTR template;
>+	CK_ULONG count;
>+
>+	BEGIN_CALL (C_GetAttributeValue);
>+		IN_ULONG (session);
>+		IN_ULONG (object);
>+		IN_ATTRIBUTE_BUFFER (template, count);
>+	PROCESS_CALL ((session, object, template, count));
>+		OUT_ATTRIBUTE_ARRAY (template, count);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SetAttributeValue (P11RpcServerVtable *vtable,
>+                         CK_FUNCTION_LIST_PTR module,
>+                         RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_OBJECT_HANDLE object;
>+	CK_ATTRIBUTE_PTR template;
>+	CK_ULONG count;
>+
>+	BEGIN_CALL (C_SetAttributeValue);
>+		IN_ULONG (session);
>+		IN_ULONG (object);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL ((session, object, template, count));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_FindObjectsInit (P11RpcServerVtable *vtable,
>+                       CK_FUNCTION_LIST_PTR module,
>+                       RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_ATTRIBUTE_PTR template;
>+	CK_ULONG count;
>+
>+	BEGIN_CALL (C_FindObjectsInit);
>+		IN_ULONG (session);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL ((session, template, count));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_FindObjects (P11RpcServerVtable *vtable,
>+                   CK_FUNCTION_LIST_PTR module,
>+                   RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_OBJECT_HANDLE_PTR objects;
>+	CK_ULONG max_object_count;
>+	CK_ULONG object_count;
>+
>+	BEGIN_CALL (C_FindObjects);
>+		IN_ULONG (session);
>+		IN_ULONG_BUFFER (objects, max_object_count);
>+	PROCESS_CALL ((session, objects, max_object_count, &object_count));
>+		OUT_ULONG_ARRAY (objects, object_count);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_FindObjectsFinal (P11RpcServerVtable *vtable,
>+                        CK_FUNCTION_LIST_PTR module,
>+                        RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+
>+	BEGIN_CALL (C_FindObjectsFinal);
>+		IN_ULONG (session);
>+	PROCESS_CALL ((session));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_EncryptInit (P11RpcServerVtable *vtable,
>+                   CK_FUNCTION_LIST_PTR module,
>+                   RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_OBJECT_HANDLE key;
>+
>+	BEGIN_CALL (C_EncryptInit);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL ((session, &mechanism, key));
>+	END_CALL;
>+
>+}
>+
>+static CK_RV
>+rpc_C_Encrypt (P11RpcServerVtable *vtable,
>+               CK_FUNCTION_LIST_PTR module,
>+               RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR data;
>+	CK_ULONG data_len;
>+	CK_BYTE_PTR encrypted_data;
>+	CK_ULONG encrypted_data_len;
>+
>+	BEGIN_CALL (C_Encrypt);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (data, data_len);
>+		IN_BYTE_BUFFER (encrypted_data, encrypted_data_len);
>+	PROCESS_CALL ((session, data, data_len, encrypted_data, &encrypted_data_len));
>+		OUT_BYTE_ARRAY (encrypted_data, encrypted_data_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_EncryptUpdate (P11RpcServerVtable *vtable,
>+                     CK_FUNCTION_LIST_PTR module,
>+                     RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR part;
>+	CK_ULONG part_len;
>+	CK_BYTE_PTR encrypted_part;
>+	CK_ULONG encrypted_part_len;
>+
>+	BEGIN_CALL (C_EncryptUpdate);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+		IN_BYTE_BUFFER (encrypted_part, encrypted_part_len);
>+	PROCESS_CALL ((session, part, part_len, encrypted_part, &encrypted_part_len));
>+		OUT_BYTE_ARRAY (encrypted_part, encrypted_part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_EncryptFinal (P11RpcServerVtable *vtable,
>+                    CK_FUNCTION_LIST_PTR module,
>+                    RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR last_encrypted_part;
>+	CK_ULONG last_encrypted_part_len;
>+
>+	BEGIN_CALL (C_EncryptFinal);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (last_encrypted_part, last_encrypted_part_len);
>+	PROCESS_CALL ((session, last_encrypted_part, &last_encrypted_part_len));
>+		OUT_BYTE_ARRAY (last_encrypted_part, last_encrypted_part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DecryptInit (P11RpcServerVtable *vtable,
>+                   CK_FUNCTION_LIST_PTR module,
>+                   RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_OBJECT_HANDLE key;
>+
>+	BEGIN_CALL (C_DecryptInit);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL ((session, &mechanism, key));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Decrypt (P11RpcServerVtable *vtable,
>+               CK_FUNCTION_LIST_PTR module,
>+               RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR encrypted_data;
>+	CK_ULONG encrypted_data_len;
>+	CK_BYTE_PTR data;
>+	CK_ULONG data_len;
>+
>+	BEGIN_CALL (C_Decrypt);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (encrypted_data, encrypted_data_len);
>+		IN_BYTE_BUFFER (data, data_len);
>+	PROCESS_CALL ((session, encrypted_data, encrypted_data_len, data, &data_len));
>+		OUT_BYTE_ARRAY (data, data_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DecryptUpdate (P11RpcServerVtable *vtable,
>+                     CK_FUNCTION_LIST_PTR module,
>+                     RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR encrypted_part;
>+	CK_ULONG encrypted_part_len;
>+	CK_BYTE_PTR part;
>+	CK_ULONG part_len;
>+
>+	BEGIN_CALL (C_DecryptUpdate);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (encrypted_part, encrypted_part_len);
>+		IN_BYTE_BUFFER (part, part_len);
>+	PROCESS_CALL ((session, encrypted_part, encrypted_part_len, part, &part_len));
>+		OUT_BYTE_ARRAY (part, part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DecryptFinal (P11RpcServerVtable *vtable,
>+                    CK_FUNCTION_LIST_PTR module,
>+                    RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR last_part;
>+	CK_ULONG last_part_len;
>+
>+	BEGIN_CALL (C_DecryptFinal);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (last_part, last_part_len);
>+	PROCESS_CALL ((session, last_part, &last_part_len));
>+		OUT_BYTE_ARRAY (last_part, last_part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DigestInit (P11RpcServerVtable *vtable,
>+                  CK_FUNCTION_LIST_PTR module,
>+                  RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+
>+	BEGIN_CALL (C_DigestInit);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+	PROCESS_CALL ((session, &mechanism));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Digest (P11RpcServerVtable *vtable,
>+              CK_FUNCTION_LIST_PTR module,
>+              RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR data;
>+	CK_ULONG data_len;
>+	CK_BYTE_PTR digest;
>+	CK_ULONG digest_len;
>+
>+	BEGIN_CALL (C_Digest);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (data, data_len);
>+		IN_BYTE_BUFFER (digest, digest_len);
>+	PROCESS_CALL ((session, data, data_len, digest, &digest_len));
>+		OUT_BYTE_ARRAY (digest, digest_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DigestUpdate (P11RpcServerVtable *vtable,
>+                    CK_FUNCTION_LIST_PTR module,
>+                    RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR part;
>+	CK_ULONG part_len;
>+
>+	BEGIN_CALL (C_DigestUpdate);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+	PROCESS_CALL ((session, part, part_len));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DigestKey (P11RpcServerVtable *vtable,
>+                 CK_FUNCTION_LIST_PTR module,
>+                 RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_OBJECT_HANDLE key;
>+
>+	BEGIN_CALL (C_DigestKey);
>+		IN_ULONG (session);
>+		IN_ULONG (key);
>+	PROCESS_CALL ((session, key));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DigestFinal (P11RpcServerVtable *vtable,
>+                   CK_FUNCTION_LIST_PTR module,
>+                   RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR digest;
>+	CK_ULONG digest_len;
>+
>+	BEGIN_CALL (C_DigestFinal);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (digest, digest_len);
>+	PROCESS_CALL ((session, digest, &digest_len));
>+		OUT_BYTE_ARRAY (digest, digest_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignInit (P11RpcServerVtable *vtable,
>+                CK_FUNCTION_LIST_PTR module,
>+                RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_OBJECT_HANDLE key;
>+
>+	BEGIN_CALL (C_SignInit);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL ((session, &mechanism, key));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Sign (P11RpcServerVtable *vtable,
>+            CK_FUNCTION_LIST_PTR module,
>+            RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR part;
>+	CK_ULONG part_len;
>+	CK_BYTE_PTR signature;
>+	CK_ULONG signature_len;
>+
>+	BEGIN_CALL (C_Sign);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+		IN_BYTE_BUFFER (signature, signature_len);
>+	PROCESS_CALL ((session, part, part_len, signature, &signature_len));
>+		OUT_BYTE_ARRAY (signature, signature_len);
>+	END_CALL;
>+
>+}
>+
>+static CK_RV
>+rpc_C_SignUpdate (P11RpcServerVtable *vtable,
>+                  CK_FUNCTION_LIST_PTR module,
>+                  RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR part;
>+	CK_ULONG part_len;
>+
>+	BEGIN_CALL (C_SignUpdate);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+	PROCESS_CALL ((session, part, part_len));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignFinal (P11RpcServerVtable *vtable,
>+                 CK_FUNCTION_LIST_PTR module,
>+                 RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR signature;
>+	CK_ULONG signature_len;
>+
>+	BEGIN_CALL (C_SignFinal);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (signature, signature_len);
>+	PROCESS_CALL ((session, signature, &signature_len));
>+		OUT_BYTE_ARRAY (signature, signature_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignRecoverInit (P11RpcServerVtable *vtable,
>+                       CK_FUNCTION_LIST_PTR module,
>+                       RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_OBJECT_HANDLE key;
>+
>+	BEGIN_CALL (C_SignRecoverInit);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL ((session, &mechanism, key));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignRecover (P11RpcServerVtable *vtable,
>+                   CK_FUNCTION_LIST_PTR module,
>+                   RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR data;
>+	CK_ULONG data_len;
>+	CK_BYTE_PTR signature;
>+	CK_ULONG signature_len;
>+
>+	BEGIN_CALL (C_SignRecover);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (data, data_len);
>+		IN_BYTE_BUFFER (signature, signature_len);
>+	PROCESS_CALL ((session, data, data_len, signature, &signature_len));
>+		OUT_BYTE_ARRAY (signature, signature_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_VerifyInit (P11RpcServerVtable *vtable,
>+                  CK_FUNCTION_LIST_PTR module,
>+                  RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_OBJECT_HANDLE key;
>+
>+	BEGIN_CALL (C_VerifyInit);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL ((session, &mechanism, key));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_Verify (P11RpcServerVtable *vtable,
>+              CK_FUNCTION_LIST_PTR module,
>+              RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR data;
>+	CK_ULONG data_len;
>+	CK_BYTE_PTR signature;
>+	CK_ULONG signature_len;
>+
>+	BEGIN_CALL (C_Verify);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (data, data_len);
>+		IN_BYTE_ARRAY (signature, signature_len);
>+	PROCESS_CALL ((session, data, data_len, signature, signature_len));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_VerifyUpdate (P11RpcServerVtable *vtable,
>+                    CK_FUNCTION_LIST_PTR module,
>+                    RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR part;
>+	CK_ULONG part_len;
>+
>+	BEGIN_CALL (C_VerifyUpdate);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+	PROCESS_CALL ((session, part, part_len));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_VerifyFinal (P11RpcServerVtable *vtable,
>+                   CK_FUNCTION_LIST_PTR module,
>+                   RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR signature;
>+	CK_ULONG signature_len;
>+
>+	BEGIN_CALL (C_VerifyFinal);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (signature, signature_len);
>+	PROCESS_CALL ((session, signature, signature_len));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_VerifyRecoverInit (P11RpcServerVtable *vtable,
>+                         CK_FUNCTION_LIST_PTR module,
>+                         RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_OBJECT_HANDLE key;
>+
>+	BEGIN_CALL (C_VerifyRecoverInit);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (key);
>+	PROCESS_CALL ((session, &mechanism, key));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_VerifyRecover (P11RpcServerVtable *vtable,
>+                     CK_FUNCTION_LIST_PTR module,
>+                     RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR signature;
>+	CK_ULONG signature_len;
>+	CK_BYTE_PTR data;
>+	CK_ULONG data_len;
>+
>+	BEGIN_CALL (C_VerifyRecover);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (signature, signature_len);
>+		IN_BYTE_BUFFER (data, data_len);
>+	PROCESS_CALL ((session, signature, signature_len, data, &data_len));
>+		OUT_BYTE_ARRAY (data, data_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DigestEncryptUpdate (P11RpcServerVtable *vtable,
>+                           CK_FUNCTION_LIST_PTR module,
>+                           RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR part;
>+	CK_ULONG part_len;
>+	CK_BYTE_PTR encrypted_part;
>+	CK_ULONG encrypted_part_len;
>+
>+	BEGIN_CALL (C_DigestEncryptUpdate);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+		IN_BYTE_BUFFER (encrypted_part, encrypted_part_len);
>+	PROCESS_CALL ((session, part, part_len, encrypted_part, &encrypted_part_len));
>+		OUT_BYTE_ARRAY (encrypted_part, encrypted_part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DecryptDigestUpdate (P11RpcServerVtable *vtable,
>+                           CK_FUNCTION_LIST_PTR module,
>+                           RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR encrypted_part;
>+	CK_ULONG encrypted_part_len;
>+	CK_BYTE_PTR part;
>+	CK_ULONG part_len;
>+
>+	BEGIN_CALL (C_DecryptDigestUpdate);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (encrypted_part, encrypted_part_len);
>+		IN_BYTE_BUFFER (part, part_len);
>+	PROCESS_CALL ((session, encrypted_part, encrypted_part_len, part, &part_len));
>+		OUT_BYTE_ARRAY (part, part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SignEncryptUpdate (P11RpcServerVtable *vtable,
>+                         CK_FUNCTION_LIST_PTR module,
>+                         RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR part;
>+	CK_ULONG part_len;
>+	CK_BYTE_PTR encrypted_part;
>+	CK_ULONG encrypted_part_len;
>+
>+	BEGIN_CALL (C_SignEncryptUpdate);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (part, part_len);
>+		IN_BYTE_BUFFER (encrypted_part, encrypted_part_len);
>+	PROCESS_CALL ((session, part, part_len, encrypted_part, &encrypted_part_len));
>+		OUT_BYTE_ARRAY (encrypted_part, encrypted_part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DecryptVerifyUpdate (P11RpcServerVtable *vtable,
>+                           CK_FUNCTION_LIST_PTR module,
>+                           RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR encrypted_part;
>+	CK_ULONG encrypted_part_len;
>+	CK_BYTE_PTR part;
>+	CK_ULONG part_len;
>+
>+	BEGIN_CALL (C_DecryptVerifyUpdate);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (encrypted_part, encrypted_part_len);
>+		IN_BYTE_BUFFER (part, part_len);
>+	PROCESS_CALL ((session, encrypted_part, encrypted_part_len, part, &part_len));
>+		OUT_BYTE_ARRAY (part, part_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GenerateKey (P11RpcServerVtable *vtable,
>+                   CK_FUNCTION_LIST_PTR module,
>+                   RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_ATTRIBUTE_PTR template;
>+	CK_ULONG count;
>+	CK_OBJECT_HANDLE key;
>+
>+	BEGIN_CALL (C_GenerateKey);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ATTRIBUTE_ARRAY (template, count);
>+	PROCESS_CALL ((session, &mechanism, template, count, &key));
>+		OUT_ULONG (key);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GenerateKeyPair (P11RpcServerVtable *vtable,
>+                       CK_FUNCTION_LIST_PTR module,
>+                       RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_ATTRIBUTE_PTR public_key_template;
>+	CK_ULONG public_key_attribute_count;
>+	CK_ATTRIBUTE_PTR private_key_template;
>+	CK_ULONG private_key_attribute_count;
>+	CK_OBJECT_HANDLE public_key;
>+	CK_OBJECT_HANDLE private_key;
>+
>+	BEGIN_CALL (C_GenerateKeyPair);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ATTRIBUTE_ARRAY (public_key_template, public_key_attribute_count);
>+		IN_ATTRIBUTE_ARRAY (private_key_template, private_key_attribute_count);
>+	PROCESS_CALL ((session, &mechanism, public_key_template, public_key_attribute_count, private_key_template, private_key_attribute_count, &public_key, &private_key));
>+		OUT_ULONG (public_key);
>+		OUT_ULONG (private_key);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_WrapKey (P11RpcServerVtable *vtable,
>+               CK_FUNCTION_LIST_PTR module,
>+               RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_OBJECT_HANDLE wrapping_key;
>+	CK_OBJECT_HANDLE key;
>+	CK_BYTE_PTR wrapped_key;
>+	CK_ULONG wrapped_key_len;
>+
>+	BEGIN_CALL (C_WrapKey);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (wrapping_key);
>+		IN_ULONG (key);
>+		IN_BYTE_BUFFER (wrapped_key, wrapped_key_len);
>+	PROCESS_CALL ((session, &mechanism, wrapping_key, key, wrapped_key, &wrapped_key_len));
>+		OUT_BYTE_ARRAY (wrapped_key, wrapped_key_len);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_UnwrapKey (P11RpcServerVtable *vtable,
>+                 CK_FUNCTION_LIST_PTR module,
>+                 RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_OBJECT_HANDLE unwrapping_key;
>+	CK_BYTE_PTR wrapped_key;
>+	CK_ULONG wrapped_key_len;
>+	CK_ATTRIBUTE_PTR template;
>+	CK_ULONG attribute_count;
>+	CK_OBJECT_HANDLE key;
>+
>+	BEGIN_CALL (C_UnwrapKey);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (unwrapping_key);
>+		IN_BYTE_ARRAY (wrapped_key, wrapped_key_len);
>+		IN_ATTRIBUTE_ARRAY (template, attribute_count);
>+	PROCESS_CALL ((session, &mechanism, unwrapping_key, wrapped_key, wrapped_key_len, template, attribute_count, &key));
>+		OUT_ULONG (key);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_DeriveKey (P11RpcServerVtable *vtable,
>+                 CK_FUNCTION_LIST_PTR module,
>+                 RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_MECHANISM mechanism;
>+	CK_OBJECT_HANDLE base_key;
>+	CK_ATTRIBUTE_PTR template;
>+	CK_ULONG attribute_count;
>+	CK_OBJECT_HANDLE key;
>+
>+	BEGIN_CALL (C_DeriveKey);
>+		IN_ULONG (session);
>+		IN_MECHANISM (mechanism);
>+		IN_ULONG (base_key);
>+		IN_ATTRIBUTE_ARRAY (template, attribute_count);
>+	PROCESS_CALL ((session, &mechanism, base_key, template, attribute_count, &key));
>+		OUT_ULONG (key);
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_SeedRandom (P11RpcServerVtable *vtable,
>+                  CK_FUNCTION_LIST_PTR module,
>+                  RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR seed;
>+	CK_ULONG seed_len;
>+
>+	BEGIN_CALL (C_SeedRandom);
>+		IN_ULONG (session);
>+		IN_BYTE_ARRAY (seed, seed_len);
>+	PROCESS_CALL ((session, seed, seed_len));
>+	END_CALL;
>+}
>+
>+static CK_RV
>+rpc_C_GenerateRandom (P11RpcServerVtable *vtable,
>+                      CK_FUNCTION_LIST_PTR module,
>+                      RpcMessage *msg)
>+{
>+	CK_SESSION_HANDLE session;
>+	CK_BYTE_PTR random_data;
>+	CK_ULONG random_len;
>+
>+	BEGIN_CALL (C_GenerateRandom);
>+		IN_ULONG (session);
>+		IN_BYTE_BUFFER (random_data, random_len);
>+	PROCESS_CALL ((session, random_data, random_len));
>+		OUT_BYTE_ARRAY (random_data, random_len);
>+	END_CALL;
>+}
>+
>+int
>+p11_rpc_server_handle (P11RpcServerVtable *vtable,
>+                       CK_FUNCTION_LIST_PTR module,
>+                       P11Buffer *request,
>+                       P11Buffer *response)
>+{
>+	RpcMessage msg;
>+	P11Output *output;
>+	CK_RV ret;
>+	int req_id;
>+
>+	return_val_if_fail (module != NULL, -1);
>+	return_val_if_fail (request != NULL, -1);
>+	return_val_if_fail (response != NULL, -1);
>+
>+	_p11_kit_clear_message ();
>+
>+	output = _p11_buffer_to_output (response);
>+	if (output == NULL)
>+		return -1;
>+
>+	_p11_rpc_message_init (&msg, request, output);
>+
>+	if (!_p11_rpc_message_parse (&msg, RPC_REQUEST)) {
>+		_p11_rpc_message_clear (&msg);
>+		_p11_message ("couldn't parse pkcs11 rpc message");
>+		return -1;
>+	}
>+
>+	/* This should have been checked by the parsing code */
>+	assert (msg.call_id > RPC_CALL_ERROR);
>+	assert (msg.call_id < RPC_CALL_MAX);
>+	req_id = msg.call_id;
>+
>+	switch(req_id) {
>+	#define CASE_CALL(name) \
>+	case RPC_CALL_##name: \
>+		ret = rpc_##name (vtable, module, &msg); \
>+		break;
>+	CASE_CALL (C_Initialize)
>+	CASE_CALL (C_Finalize)
>+	CASE_CALL (C_GetInfo)
>+	CASE_CALL (C_GetSlotList)
>+	CASE_CALL (C_GetSlotInfo)
>+	CASE_CALL (C_GetTokenInfo)
>+	CASE_CALL (C_GetMechanismList)
>+	CASE_CALL (C_GetMechanismInfo)
>+	CASE_CALL (C_InitToken)
>+	CASE_CALL (C_WaitForSlotEvent)
>+	CASE_CALL (C_OpenSession)
>+	CASE_CALL (C_CloseSession)
>+	CASE_CALL (C_CloseAllSessions)
>+	CASE_CALL (C_GetFunctionStatus)
>+	CASE_CALL (C_CancelFunction)
>+	CASE_CALL (C_GetSessionInfo)
>+	CASE_CALL (C_InitPIN)
>+	CASE_CALL (C_SetPIN)
>+	CASE_CALL (C_GetOperationState)
>+	CASE_CALL (C_SetOperationState)
>+	CASE_CALL (C_Login)
>+	CASE_CALL (C_Logout)
>+	CASE_CALL (C_CreateObject)
>+	CASE_CALL (C_CopyObject)
>+	CASE_CALL (C_DestroyObject)
>+	CASE_CALL (C_GetObjectSize)
>+	CASE_CALL (C_GetAttributeValue)
>+	CASE_CALL (C_SetAttributeValue)
>+	CASE_CALL (C_FindObjectsInit)
>+	CASE_CALL (C_FindObjects)
>+	CASE_CALL (C_FindObjectsFinal)
>+	CASE_CALL (C_EncryptInit)
>+	CASE_CALL (C_Encrypt)
>+	CASE_CALL (C_EncryptUpdate)
>+	CASE_CALL (C_EncryptFinal)
>+	CASE_CALL (C_DecryptInit)
>+	CASE_CALL (C_Decrypt)
>+	CASE_CALL (C_DecryptUpdate)
>+	CASE_CALL (C_DecryptFinal)
>+	CASE_CALL (C_DigestInit)
>+	CASE_CALL (C_Digest)
>+	CASE_CALL (C_DigestUpdate)
>+	CASE_CALL (C_DigestKey)
>+	CASE_CALL (C_DigestFinal)
>+	CASE_CALL (C_SignInit)
>+	CASE_CALL (C_Sign)
>+	CASE_CALL (C_SignUpdate)
>+	CASE_CALL (C_SignFinal)
>+	CASE_CALL (C_SignRecoverInit)
>+	CASE_CALL (C_SignRecover)
>+	CASE_CALL (C_VerifyInit)
>+	CASE_CALL (C_Verify)
>+	CASE_CALL (C_VerifyUpdate)
>+	CASE_CALL (C_VerifyFinal)
>+	CASE_CALL (C_VerifyRecoverInit)
>+	CASE_CALL (C_VerifyRecover)
>+	CASE_CALL (C_DigestEncryptUpdate)
>+	CASE_CALL (C_DecryptDigestUpdate)
>+	CASE_CALL (C_SignEncryptUpdate)
>+	CASE_CALL (C_DecryptVerifyUpdate)
>+	CASE_CALL (C_GenerateKey)
>+	CASE_CALL (C_GenerateKeyPair)
>+	CASE_CALL (C_WrapKey)
>+	CASE_CALL (C_UnwrapKey)
>+	CASE_CALL (C_DeriveKey)
>+	CASE_CALL (C_SeedRandom)
>+	CASE_CALL (C_GenerateRandom)
>+	#undef CASE_CALL
>+	default:
>+		/* This should have been caught by the parse code */
>+		assert (0 && "Unchecked call");
>+		break;
>+	};
>+
>+	if (_p11_buffer_failed (msg.output)) {
>+		_p11_message ("out of memory error putting together message");
>+		_p11_rpc_message_clear (&msg);
>+		return -1;
>+	}
>+
>+	/* A filled in response */
>+	if (ret == CKR_OK) {
>+
>+		/*
>+		 * Since we're dealing with many many functions above generating
>+		 * these messages we want to make sure each of them actually
>+		 * does what it's supposed to.
>+		 */
>+		assert (_p11_rpc_message_is_verified (&msg));
>+		assert (msg.call_type == RPC_RESPONSE);
>+		assert (msg.call_id == req_id);
>+		assert (rpc_calls[msg.call_id].response);
>+		assert (strcmp (rpc_calls[msg.call_id].response, msg.signature) == 0);
>+
>+	/* Fill in an error respnose */
>+	} else {
>+		if (!_p11_rpc_message_prep (&msg, RPC_CALL_ERROR, RPC_RESPONSE) ||
>+		    !_p11_rpc_message_write_ulong (&msg, (uint32_t)ret) ||
>+		    _p11_buffer_failed (msg.output)) {
>+			_p11_message ("out of memory responding with error");
>+			_p11_rpc_message_clear (&msg);
>+			return -1;
>+		}
>+	}
>+
>+	_p11_rpc_message_clear (&msg);
>+	return 0;
>+}
>diff --git a/p11-kit/rpc.h b/p11-kit/rpc.h
>index 16da894..5712de1 100644
>--- a/p11-kit/rpc.h
>+++ b/p11-kit/rpc.h
>@@ -45,4 +45,37 @@ int             p11_buffer_reset            (P11Buffer *buf,
> 
> void            p11_buffer_free             (P11Buffer *buf);
> 
>+typedef struct _P11RpcClientVtable P11RpcClientVtable;
>+
>+struct _P11RpcClientVtable {
>+	void *data;
>+
>+	CK_RV       (* connect)       (P11RpcClientVtable *vtable,
>+	                               void *init_reserved);
>+
>+	CK_RV       (* transport)     (P11RpcClientVtable *vtable,
>+	                               P11Buffer *request,
>+	                               P11Buffer *response);
>+
>+	void        (* disconnect)    (P11RpcClientVtable *vtable,
>+	                               void *fini_reserved);
>+
>+	void *reserved[16];
>+};
>+
>+CK_FUNCTION_LIST_PTR   p11_rpc_client_register     (P11RpcClientVtable *vtable);
>+
>+typedef struct _P11RpcServerVtable P11RpcServerVtable;
>+
>+struct _P11RpcServerVtable {
>+	void *data;
>+
>+	void *reserved[20];
>+};
>+
>+int                    p11_rpc_server_handle       (P11RpcServerVtable *vtable,
>+                                                    CK_FUNCTION_LIST_PTR module,
>+                                                    P11Buffer *request,
>+                                                    P11Buffer *response);
>+
> #endif /* __P11_KIT_RPC_H__ */
>diff --git a/p11-kit/util.c b/p11-kit/util.c
>index ccc954c..779cc95 100644
>--- a/p11-kit/util.c
>+++ b/p11-kit/util.c
>@@ -199,6 +199,14 @@ p11_kit_be_quiet (void)
> 	_p11_unlock ();
> }
> 
>+void
>+_p11_kit_be_loud (void)
>+{
>+	_p11_lock ();
>+	print_messages = 1;
>+	_p11_unlock ();
>+}
>+
> /**
>  * p11_kit_message:
>  *
>diff --git a/tests/Makefile.am b/tests/Makefile.am
>index 9361cdb..c778b77 100644
>--- a/tests/Makefile.am
>+++ b/tests/Makefile.am
>@@ -21,24 +21,28 @@ CHECK_PROGS = \
> 	pin-test \
> 	test-init \
> 	test-modules \
>-	test-buffer
>+	test-buffer \
>+	test-rpc
> 
> noinst_PROGRAMS = \
> 	print-messages \
> 	$(CHECK_PROGS)
> 
> cutestfiles = cutest/CuTest.c cutest/CuTest.h
>+mockfiles = mock-module.c mock-module.h
> 
> conf_test_SOURCES = conf-test.c $(cutestfiles)
> hash_test_SOURCES = hash-test.c $(cutestfiles)
> pin_test_SOURCES = pin-test.c $(cutestfiles)
> ptr_array_test_SOURCES = ptr-array-test.c $(cutestfiles)
> progname_test_SOURCES = progname-test.c $(cutestfiles)
>-test_init_SOURCES = test-init.c $(cutestfiles) \
>-	mock-module.c mock-module.h
>+test_init_SOURCES = test-init.c $(cutestfiles) $(mockfiles)
> test_init_CFLAGS = $(AM_CFLAGS)
> test_modules_SOURCES = test-modules.c $(cutestfiles)
> test_buffer_SOURCES = test-buffer.c $(cutestfiles)
>+test_buffer_CFLAGS = $(AM_CFLAGS)
>+test_rpc_SOURCES = test-rpc.c $(cutestfiles) $(mockfiles)
>+test_rpc_CFLAGS = $(AM_CFLAGS)
> 
> uri_test_SOURCES = uri-test.c $(cutestfiles)
> 
>@@ -54,6 +58,9 @@ mock_one_la_SOURCES = \
> 	mock-module.c mock-module.h \
> 	mock-module-ep.c
> 
>+mock_one_la_CFLAGS = \
>+	$(AM_CFLAGS)
>+
> mock_one_la_LIBADD = \
> 	$(top_builddir)/p11-kit/libp11-kit-compat.la
> 
>@@ -62,10 +69,12 @@ mock_one_la_LDFLAGS = \
> 	-no-undefined -export-symbols-regex 'C_GetFunctionList'
> 
> mock_two_la_SOURCES = $(mock_one_la_SOURCES)
>+mock_two_la_CFLAGS = $(mock_one_la_CFLAGS)
> mock_two_la_LDFLAGS = $(mock_one_la_LDFLAGS)
> mock_two_la_LIBADD = $(mock_one_la_LIBADD)
> 
> mock_three_la_SOURCES = $(mock_one_la_SOURCES)
>+mock_three_la_CFLAGS = $(mock_one_la_CFLAGS)
> mock_three_la_LDFLAGS = $(mock_one_la_LDFLAGS)
> mock_three_la_LIBADD = $(mock_one_la_LIBADD)
> 
>diff --git a/tests/mock-module.c b/tests/mock-module.c
>index 99cde50..60663a5 100644
>--- a/tests/mock-module.c
>+++ b/tests/mock-module.c
>@@ -38,15 +38,21 @@
> #include "pkcs11.h"
> #include "mock-module.h"
> 
>+#include "p11-kit/debug.h"
>+#include "p11-kit/hashmap.h"
>+#include "p11-kit/ptr-array.h"
> #include "p11-kit/util.h"
> 
>+#include <assert.h>
>+#include <ctype.h>
> #include <stdarg.h>
> #include <stdio.h>
>+#include <stdlib.h>
> #include <string.h>
> #include <unistd.h>
> 
> /* -------------------------------------------------------------------
>- * GLOBALS / DEFINES
>+ * GLOBALS and SUPPORT STUFF
>  */
> 
> /* Various mutexes */
>@@ -56,32 +62,262 @@ static mutex_t init_mutex;
> static int pkcs11_initialized = 0;
> static pid_t pkcs11_initialized_pid = 0;
> 
>-/* -----------------------------------------------------------------------------
>- * LOGGING and DEBUGGING
>- */
>+static CK_UTF8CHAR *the_pin = NULL;
>+static CK_ULONG n_the_pin = 0;
>+
>+static int logged_in = 0;
>+static CK_USER_TYPE the_user_type = 0;
>+
>+typedef struct _Session {
>+	CK_SESSION_HANDLE handle;
>+	hashmap *objects;
>+	CK_SESSION_INFO info;
>+
>+	/* For find operations */
>+	CK_BBOOL finding;
>+	ptr_array_t *matches;
>+
>+	CK_BBOOL want_context_login;
>+
>+	/* For encrypt, decrypt operations */
>+	CK_OBJECT_HANDLE crypto_key;
>+	CK_ATTRIBUTE_TYPE crypto_method;
>+	CK_MECHANISM_TYPE crypto_mechanism;
>+
>+	/* For sign, verify, digest, CKM_MOCK_COUNT */
>+	CK_MECHANISM_TYPE hash_mechanism;
>+	CK_ATTRIBUTE_TYPE hash_method;
>+	CK_OBJECT_HANDLE hash_key;
>+	CK_ULONG hash_count;
>+
>+	/* For 'signing' with CKM_MOCK_PREFIX */
>+	CK_BYTE sign_prefix[128];
>+	CK_ULONG n_sign_prefix;
>+
>+	/* The random seed */
>+	CK_BYTE random_seed[128];
>+	CK_ULONG random_seed_len;
>+} Session;
>+
>+static unsigned int unique_identifier = 100;
>+static hashmap *the_sessions = NULL;
>+static hashmap *the_objects = NULL;
>+
>+#define SIGNED_PREFIX "signed-prefix:"
>+
>+#define handle_to_pointer(handle) \
>+	((void *)(size_t)(handle))
>+
>+#define pointer_to_handle(pointer) \
>+	((CK_ULONG)(size_t)(pointer))
>+
>+static void
>+free_session (void *data)
>+{
>+	Session *sess = (Session *)data;
>+	if (sess)
>+		_p11_hash_free (sess->objects);
>+	free (sess);
>+}
> 
>-#define DEBUG_OUTPUT 0
>+static void *
>+memdup (void *data,
>+        size_t length)
>+{
>+	void *copy = malloc (length);
>+	return_val_if_fail (copy != NULL, NULL);
>+	memcpy (copy, data, length);
>+	return copy;
>+}
> 
>-#if DEBUG_OUTPUT
>-#define debug(x) mock_log x
>-#else
>-#define debug(x)
>-#endif
>+static int
>+is_attribute_terminator (CK_ATTRIBUTE_PTR attr)
>+{
>+	return (attr->type == 0 &&
>+	        attr->pValue == NULL &&
>+	        attr->ulValueLen == 0);
>+}
> 
>-#define warning(x) mock_log x
>+static CK_ULONG
>+count_attributes (CK_ATTRIBUTE_PTR attrs)
>+{
>+	CK_ULONG count;
> 
>-#define return_val_if_fail(x, v) \
>-	if (!(x)) { mock_log ("'%s' not true at %s", #x, __func__); return v; }
>+	for (count = 0; attrs && !is_attribute_terminator (attrs + count); count++);
>+
>+	return count;
>+}
> 
> static void
>-mock_log (const char *format, ...)
>+free_attributes (void *data)
>+{
>+	CK_ATTRIBUTE_PTR attrs = data;
>+	int i;
>+
>+	for (i = 0; !is_attribute_terminator (attrs + i); i++)
>+		free (attrs[i].pValue);
>+	free (attrs);
>+}
>+
>+static CK_ATTRIBUTE_PTR
>+dup_attributes (CK_ATTRIBUTE_PTR attrs)
>+{
>+	CK_ATTRIBUTE_PTR copy;
>+	CK_ULONG count;
>+	CK_ULONG i;
>+
>+	/* How many attributes we already have */
>+	count = count_attributes (attrs);
>+
>+	copy = memdup (attrs, (count + 1) * sizeof (CK_ATTRIBUTE));
>+	return_val_if_fail (copy != NULL, NULL);
>+	for (i = 0; i < count; i++) {
>+		if (copy[i].pValue)
>+			copy[i].pValue = memdup (copy[i].pValue, copy[i].ulValueLen);
>+	}
>+
>+	return copy;
>+}
>+
>+static CK_ATTRIBUTE_PTR
>+build_attributes (CK_ATTRIBUTE_PTR attrs,
>+                  CK_ATTRIBUTE_PTR add,
>+                  CK_ULONG n_add)
>+{
>+	CK_ATTRIBUTE_PTR attr;
>+	CK_ULONG count;
>+	CK_ULONG at;
>+	CK_ULONG i, j;
>+
>+	/* How many attributes we already have */
>+	count = count_attributes (attrs);
>+
>+	/* Reallocate for how many we need */
>+	attrs = realloc (attrs, (count + n_add + 1) * sizeof (CK_ATTRIBUTE));
>+	return_val_if_fail (attrs != NULL, NULL);
>+
>+	at = count;
>+	for (i = 0; i < n_add; i++) {
>+		attr = NULL;
>+
>+		/* Do we have this attribute? */
>+		for (j = 0; attr == NULL && j < count; j++) {
>+			if (attrs[j].type == add[i].type) {
>+				attr = attrs + j;
>+				free (attrs[j].pValue);
>+				break;
>+			}
>+		}
>+
>+		if (attr == NULL) {
>+			attr = attrs + at;
>+			at++;
>+		}
>+
>+		memcpy (attr, add + i, sizeof (CK_ATTRIBUTE));
>+		if (attr->pValue)
>+			attr->pValue = memdup (attr->pValue, attr->ulValueLen);
>+	}
>+
>+	memset (attrs + at, 0, sizeof (CK_ATTRIBUTE));
>+	assert (is_attribute_terminator (attrs + at));
>+	return attrs;
>+}
>+
>+static CK_ATTRIBUTE_PTR
>+find_attribute (CK_ATTRIBUTE_PTR attrs,
>+                CK_ATTRIBUTE_TYPE type)
> {
>-	va_list va;
>-	va_start (va, format);
>-	fprintf (stderr, "mock-module: ");
>-	vfprintf (stderr, format, va);
>-	fprintf (stderr, "\n");
>-	va_end (va);
>+	CK_ULONG i;
>+
>+	for (i = 0; !is_attribute_terminator (attrs + i); i++) {
>+		if (attrs[i].type == type)
>+			return attrs + i;
>+	}
>+
>+	return NULL;
>+}
>+
>+static int
>+find_boolean_attribute (CK_ATTRIBUTE_PTR attrs,
>+                        CK_ATTRIBUTE_TYPE type,
>+                        CK_BBOOL *value)
>+{
>+	CK_ULONG i;
>+
>+	for (i = 0; !is_attribute_terminator (attrs + i); i++) {
>+		if (attrs[i].type == type &&
>+		    attrs[i].pValue != NULL &&
>+		    attrs[i].ulValueLen == sizeof (CK_BBOOL)) {
>+			*value = *((CK_BBOOL *)attrs[i].pValue);
>+			return 1;
>+		}
>+	}
>+
>+	return 0;
>+}
>+
>+static CK_RV
>+lookup_object (Session *sess,
>+               CK_OBJECT_HANDLE object,
>+               CK_ATTRIBUTE_PTR *attrs,
>+               hashmap **table)
>+{
>+	CK_BBOOL priv;
>+
>+	*attrs = _p11_hash_get (the_objects, handle_to_pointer (object));
>+	if (*attrs) {
>+		if (table)
>+			*table = the_objects;
>+	} else {
>+		*attrs = _p11_hash_get (sess->objects, handle_to_pointer (object));
>+		if (*attrs) {
>+			if (table)
>+				*table = sess->objects;
>+		}
>+	}
>+
>+	if (!*attrs)
>+		return CKR_OBJECT_HANDLE_INVALID;
>+	else if (!logged_in && find_boolean_attribute (*attrs, CKA_PRIVATE, &priv) && priv)
>+		return CKR_USER_NOT_LOGGED_IN;
>+
>+	return CKR_OK;
>+}
>+
>+void
>+mock_module_enumerate_objects (CK_SESSION_HANDLE handle,
>+                               MockEnumerator func,
>+                               void *user_data)
>+{
>+	hashiter iter;
>+	void *key;
>+	void *value;
>+	Session *sess;
>+
>+	assert (the_objects != NULL);
>+	assert (func != NULL);
>+
>+	/* Token objects */
>+	_p11_hash_iterate (the_objects, &iter);
>+	while (_p11_hash_next (&iter, &key, &value)) {
>+		if (!(func) (pointer_to_handle (key), value,
>+				count_attributes (value), user_data))
>+			return;
>+	}
>+
>+	/* session objects */
>+	if (handle) {
>+		sess = _p11_hash_get (the_sessions, handle_to_pointer (handle));
>+		if (sess) {
>+			_p11_hash_iterate (sess->objects, &iter);
>+			while (_p11_hash_next (&iter, &key, &value)) {
>+				if (!(func) (pointer_to_handle (key), value,
>+						count_attributes (value), user_data))
>+					return;
>+			}
>+		}
>+	}
> }
> 
> /* -------------------------------------------------------------------
>@@ -95,8 +331,6 @@ mock_C_Initialize (CK_VOID_PTR init_args)
> 	CK_RV ret = CKR_OK;
> 	pid_t pid;
> 
>-	debug (("C_Initialize: enter"));
>-
> 	_p11_mutex_lock (&init_mutex);
> 
> 		if (init_args != NULL) {
>@@ -111,7 +345,7 @@ mock_C_Initialize (CK_VOID_PTR init_args)
> 			              (args->CreateMutex != NULL && args->DestroyMutex != NULL &&
> 			               args->LockMutex != NULL && args->UnlockMutex != NULL);
> 			if (!supplied_ok) {
>-				warning (("invalid set of mutex calls supplied"));
>+				_p11_debug_precond ("p11-kit: invalid set of mutex calls supplied");
> 				ret = CKR_ARGUMENTS_BAD;
> 				goto done;
> 			}
>@@ -121,7 +355,7 @@ mock_C_Initialize (CK_VOID_PTR init_args)
> 			 * We must be able to use our pthread functionality.
> 			 */
> 			if (!(args->flags & CKF_OS_LOCKING_OK)) {
>-				warning (("can't do without os locking"));
>+				_p11_debug_precond ("p11-kit: can't do without os locking");
> 				ret = CKR_CANT_LOCK;
> 				goto done;
> 			}
>@@ -132,12 +366,121 @@ mock_C_Initialize (CK_VOID_PTR init_args)
> 
> 			/* This process has called C_Initialize already */
> 			if (pid == pkcs11_initialized_pid) {
>-				warning (("C_Initialize called twice for same process"));
>+				_p11_debug_precond ("p11-kit: C_Initialize called twice for same process");
> 				ret = CKR_CRYPTOKI_ALREADY_INITIALIZED;
> 				goto done;
> 			}
> 		}
> 
>+		/* We store CK_ULONG as pointers here, so verify that they fit */
>+		assert (sizeof (CK_ULONG) <= sizeof (void *));
>+
>+		the_pin = (CK_UTF8CHAR_PTR)strdup ("booo");
>+		n_the_pin = 4;
>+
>+		the_sessions = _p11_hash_create (_p11_hash_direct_hash,
>+		                                 _p11_hash_direct_equal,
>+		                                 NULL, free_session);
>+		the_objects = _p11_hash_create (_p11_hash_direct_hash,
>+		                                _p11_hash_direct_equal,
>+		                                NULL, free_attributes);
>+
>+		/* Our token object */
>+		{
>+			CK_OBJECT_CLASS klass = CKO_DATA;
>+			char *label = "TEST LABEL";
>+			CK_ATTRIBUTE attrs[] = {
>+				{ CKA_CLASS, &klass, sizeof (klass) },
>+				{ CKA_LABEL, label, strlen (label) },
>+				{ 0, NULL, 0 },
>+			};
>+			_p11_hash_set (the_objects, handle_to_pointer (2), dup_attributes (attrs));
>+		}
>+
>+		/* Private capitalize key */
>+		{
>+			CK_OBJECT_CLASS klass = CKO_PRIVATE_KEY;
>+			char *label = "Private Capitalize Key";
>+			char *value = "value";
>+			CK_MECHANISM_TYPE type = CKM_MOCK_CAPITALIZE;
>+			CK_BBOOL btrue = CK_TRUE;
>+			CK_ATTRIBUTE attrs[] = {
>+				{ CKA_CLASS, &klass, sizeof (klass) },
>+				{ CKA_LABEL, label, strlen (label) },
>+				{ CKA_ALLOWED_MECHANISMS, &type, sizeof (type) },
>+				{ CKA_DECRYPT, &btrue, sizeof (btrue) },
>+				{ CKA_PRIVATE, &btrue, sizeof (btrue) },
>+				{ CKA_WRAP, &btrue, sizeof (btrue) },
>+				{ CKA_UNWRAP, &btrue, sizeof (btrue) },
>+				{ CKA_DERIVE, &btrue, sizeof (btrue) },
>+				{ CKA_VALUE, value, strlen (value) },
>+				{ 0, NULL, 0 },
>+			};
>+			_p11_hash_set (the_objects, handle_to_pointer (MOCK_PRIVATE_KEY_CAPITALIZE), dup_attributes (attrs));
>+
>+		}
>+
>+		{
>+			CK_OBJECT_CLASS klass = CKO_PUBLIC_KEY;
>+			char *label = "Public Capitalize Key";
>+			char *value = "value";
>+			CK_MECHANISM_TYPE type = CKM_MOCK_CAPITALIZE;
>+			CK_BBOOL btrue = CK_TRUE;
>+			CK_BBOOL bfalse = CK_FALSE;
>+			CK_ATTRIBUTE attrs[] = {
>+				{ CKA_CLASS, &klass, sizeof (klass) },
>+				{ CKA_LABEL, label, strlen (label) },
>+				{ CKA_ALLOWED_MECHANISMS, &type, sizeof (type) },
>+				{ CKA_ENCRYPT, &btrue, sizeof (btrue) },
>+				{ CKA_PRIVATE, &bfalse, sizeof (bfalse) },
>+				{ CKA_VALUE, value, strlen (value) },
>+				{ 0, NULL, 0 },
>+			};
>+			_p11_hash_set (the_objects, handle_to_pointer (MOCK_PUBLIC_KEY_CAPITALIZE), dup_attributes (attrs));
>+
>+		}
>+
>+		{
>+			CK_OBJECT_CLASS klass = CKO_PRIVATE_KEY;
>+			char *label = "Private prefix key";
>+			char *value = "value";
>+			CK_MECHANISM_TYPE type = CKM_MOCK_PREFIX;
>+			CK_BBOOL btrue = CK_TRUE;
>+			CK_ATTRIBUTE attrs[] = {
>+				{ CKA_CLASS, &klass, sizeof (klass) },
>+				{ CKA_LABEL, label, strlen (label) },
>+				{ CKA_ALLOWED_MECHANISMS, &type, sizeof (type) },
>+				{ CKA_SIGN, &btrue, sizeof (btrue) },
>+				{ CKA_PRIVATE, &btrue, sizeof (btrue) },
>+				{ CKA_ALWAYS_AUTHENTICATE, &btrue, sizeof (btrue) },
>+				{ CKA_VALUE, value, strlen (value) },
>+				{ 0, NULL, 0 },
>+			};
>+			_p11_hash_set (the_objects, handle_to_pointer (MOCK_PRIVATE_KEY_PREFIX), dup_attributes (attrs));
>+
>+		}
>+
>+		{
>+			CK_OBJECT_CLASS klass = CKO_PUBLIC_KEY;
>+			char *label = "Public prefix key";
>+			char *value = "value";
>+			CK_MECHANISM_TYPE type = CKM_MOCK_PREFIX;
>+			CK_BBOOL btrue = CK_TRUE;
>+			CK_BBOOL bfalse = CK_FALSE;
>+			CK_ATTRIBUTE attrs[] = {
>+				{ CKA_CLASS, &klass, sizeof (klass) },
>+				{ CKA_LABEL, label, strlen (label) },
>+				{ CKA_ALLOWED_MECHANISMS, &type, sizeof (type) },
>+				{ CKA_VERIFY, &btrue, sizeof (btrue) },
>+				{ CKA_PRIVATE, &bfalse, sizeof (bfalse) },
>+				{ CKA_ALWAYS_AUTHENTICATE, &btrue, sizeof (btrue) },
>+				{ CKA_VALUE, value, strlen (value) },
>+				{ 0, NULL, 0 },
>+			};
>+			_p11_hash_set (the_objects, handle_to_pointer (MOCK_PUBLIC_KEY_PREFIX), dup_attributes (attrs));
>+
>+		}
>+
> done:
> 		/* Mark us as officially initialized */
> 		if (ret == CKR_OK) {
>@@ -150,14 +493,18 @@ done:
> 
> 	_p11_mutex_unlock (&init_mutex);
> 
>-	debug (("C_Initialize: %d", ret));
> 	return ret;
> }
> 
> CK_RV
>+mock_C_Initialize__fails (CK_VOID_PTR init_args)
>+{
>+	return CKR_FUNCTION_FAILED;
>+}
>+
>+CK_RV
> mock_C_Finalize (CK_VOID_PTR reserved)
> {
>-	debug (("C_Finalize: enter"));
> 	return_val_if_fail (pkcs11_initialized != 0, CKR_CRYPTOKI_NOT_INITIALIZED);
> 	return_val_if_fail (reserved == NULL, CKR_ARGUMENTS_BAD);
> 
>@@ -167,17 +514,26 @@ mock_C_Finalize (CK_VOID_PTR reserved)
> 		pkcs11_initialized = 0;
> 		pkcs11_initialized_pid = 0;
> 
>+		_p11_hash_free (the_objects);
>+		the_objects = NULL;
>+
>+		_p11_hash_free (the_sessions);
>+		the_sessions = NULL;
>+		logged_in = 0;
>+		the_user_type = 0;
>+
>+		free (the_pin);
>+
> 	_p11_mutex_unlock (&init_mutex);
> 
>-	debug (("C_Finalize: %d", CKR_OK));
> 	return CKR_OK;
> }
> 
> static const CK_INFO MOCK_INFO = {
> 	{ CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },
>-	"MOCK MANUFACTURER              ",
>+	"MOCK MANUFACTURER               ",
> 	0,
>-	"MOCK LIBRARY                   ",
>+	"MOCK LIBRARY                    ",
> 	{ 45, 145 }
> };
> 
>@@ -199,6 +555,35 @@ mock_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
> }
> 
> CK_RV
>+mock_C_GetSlotList (CK_BBOOL token_present,
>+                    CK_SLOT_ID_PTR slot_list,
>+                    CK_ULONG_PTR count)
>+{
>+	CK_ULONG num;
>+
>+	return_val_if_fail (count, CKR_ARGUMENTS_BAD);
>+
>+	num = token_present ? 1 : 2;
>+
>+	/* Application only wants to know the number of slots. */
>+	if (slot_list == NULL) {
>+		*count = num;
>+		return CKR_OK;
>+	}
>+
>+	if (*count < num)
>+		return_val_if_reached (CKR_BUFFER_TOO_SMALL);
>+
>+	*count = num;
>+	slot_list[0] = MOCK_SLOT_ONE_ID;
>+	if (!token_present)
>+		slot_list[1] = MOCK_SLOT_TWO_ID;
>+
>+	return CKR_OK;
>+
>+}
>+
>+CK_RV
> mock_C_GetSlotList__no_tokens (CK_BBOOL token_present,
>                                CK_SLOT_ID_PTR slot_list,
>                                CK_ULONG_PTR count)
>@@ -210,8 +595,45 @@ mock_C_GetSlotList__no_tokens (CK_BBOOL token_present,
> 	return CKR_OK;
> }
> 
>+/* Update mock-module.h URIs when updating this */
>+
>+static const CK_SLOT_INFO MOCK_INFO_ONE = {
>+	"TEST SLOT                                                       ",
>+	"TEST MANUFACTURER               ",
>+	CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE,
>+	{ 55, 155 },
>+	{ 65, 165 },
>+};
>+
>+/* Update mock-module.h URIs when updating this */
>+
>+static const CK_SLOT_INFO MOCK_INFO_TWO = {
>+	"TEST SLOT                                                       ",
>+	"TEST MANUFACTURER               ",
>+	CKF_REMOVABLE_DEVICE,
>+	{ 55, 155 },
>+	{ 65, 165 },
>+};
>+
>+CK_RV
>+mock_C_GetSlotInfo (CK_SLOT_ID slot_id,
>+                    CK_SLOT_INFO_PTR info)
>+{
>+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
>+
>+	if (slot_id == MOCK_SLOT_ONE_ID) {
>+		memcpy (info, &MOCK_INFO_ONE, sizeof (*info));
>+		return CKR_OK;
>+	} else if (slot_id == MOCK_SLOT_TWO_ID) {
>+		memcpy (info, &MOCK_INFO_TWO, sizeof (*info));
>+		return CKR_OK;
>+	} else {
>+		return CKR_SLOT_ID_INVALID;
>+	}
>+}
>+
> CK_RV
>-mock_C_GetSlotInfo__invalid_slotid (CK_SLOT_ID id,
>+mock_C_GetSlotInfo__invalid_slotid (CK_SLOT_ID slot_id,
>                                     CK_SLOT_INFO_PTR info)
> {
> 	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
>@@ -219,8 +641,47 @@ mock_C_GetSlotInfo__invalid_slotid (CK_SLOT_ID id,
> 	return CKR_SLOT_ID_INVALID;
> }
> 
>+/* Update gck-mock.h URIs when updating this */
>+
>+static const CK_TOKEN_INFO MOCK_TOKEN_ONE = {
>+	"TEST LABEL                      ",
>+	"TEST MANUFACTURER               ",
>+	"TEST MODEL      ",
>+	"TEST SERIAL     ",
>+	CKF_LOGIN_REQUIRED | CKF_USER_PIN_INITIALIZED | CKF_CLOCK_ON_TOKEN | CKF_TOKEN_INITIALIZED,
>+	1,
>+	2,
>+	3,
>+	4,
>+	5,
>+	6,
>+	7,
>+	8,
>+	9,
>+	10,
>+	{ 75, 175 },
>+	{ 85, 185 },
>+	{ '1', '9', '9', '9', '0', '5', '2', '5', '0', '9', '1', '9', '5', '9', '0', '0' }
>+};
>+
> CK_RV
>-mock_C_GetTokenInfo__invalid_slotid (CK_SLOT_ID id,
>+mock_C_GetTokenInfo (CK_SLOT_ID slot_id,
>+                     CK_TOKEN_INFO_PTR info)
>+{
>+	return_val_if_fail (info != NULL, CKR_ARGUMENTS_BAD);
>+
>+	if (slot_id == MOCK_SLOT_ONE_ID) {
>+		memcpy (info, &MOCK_TOKEN_ONE, sizeof (*info));
>+		return CKR_OK;
>+	} else if (slot_id == MOCK_SLOT_TWO_ID) {
>+		return CKR_TOKEN_NOT_PRESENT;
>+	} else {
>+		return CKR_SLOT_ID_INVALID;
>+	}
>+}
>+
>+CK_RV
>+mock_C_GetTokenInfo__invalid_slotid (CK_SLOT_ID slot_id,
>                                      CK_TOKEN_INFO_PTR info)
> {
> 	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
>@@ -228,8 +689,41 @@ mock_C_GetTokenInfo__invalid_slotid (CK_SLOT_ID id,
> 	return CKR_SLOT_ID_INVALID;
> }
> 
>+/*
>+ * TWO mechanisms:
>+ *  CKM_MOCK_CAPITALIZE
>+ *  CKM_MOCK_PREFIX
>+ */
>+
>+CK_RV
>+mock_C_GetMechanismList (CK_SLOT_ID slot_id,
>+                         CK_MECHANISM_TYPE_PTR mechanism_list,
>+                         CK_ULONG_PTR count)
>+{
>+	return_val_if_fail (count != NULL, CKR_ARGUMENTS_BAD);
>+
>+	if (slot_id == MOCK_SLOT_TWO_ID)
>+		return CKR_TOKEN_NOT_PRESENT;
>+	else if (slot_id != MOCK_SLOT_ONE_ID)
>+		return CKR_SLOT_ID_INVALID;
>+
>+	/* Application only wants to know the number of slots. */
>+	if (mechanism_list == NULL) {
>+		*count = 2;
>+		return CKR_OK;
>+	}
>+
>+	if (*count < 2)
>+		return_val_if_reached (CKR_BUFFER_TOO_SMALL);
>+
>+	mechanism_list[0] = CKM_MOCK_CAPITALIZE;
>+	mechanism_list[1] = CKM_MOCK_PREFIX;
>+	*count = 2;
>+	return CKR_OK;
>+}
>+
> CK_RV
>-mock_C_GetMechanismList__invalid_slotid (CK_SLOT_ID id,
>+mock_C_GetMechanismList__invalid_slotid (CK_SLOT_ID slot_id,
>                                          CK_MECHANISM_TYPE_PTR mechanism_list,
>                                          CK_ULONG_PTR count)
> {
>@@ -238,8 +732,39 @@ mock_C_GetMechanismList__invalid_slotid (CK_SLOT_ID id,
> 	return CKR_SLOT_ID_INVALID;
> }
> 
>+static const CK_MECHANISM_INFO MOCK_MECH_CAPITALIZE = {
>+	512, 4096, CKF_ENCRYPT | CKF_DECRYPT
>+};
>+
>+static const CK_MECHANISM_INFO MOCK_MECH_PREFIX = {
>+	2048, 2048, CKF_SIGN | CKF_VERIFY
>+};
>+
>+CK_RV
>+mock_C_GetMechanismInfo (CK_SLOT_ID slot_id,
>+                         CK_MECHANISM_TYPE type,
>+                         CK_MECHANISM_INFO_PTR info)
>+{
>+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
>+
>+	if (slot_id == MOCK_SLOT_TWO_ID)
>+		return CKR_TOKEN_NOT_PRESENT;
>+	else if (slot_id != MOCK_SLOT_ONE_ID)
>+		return CKR_SLOT_ID_INVALID;
>+
>+	if (type == CKM_MOCK_CAPITALIZE) {
>+		memcpy (info, &MOCK_MECH_CAPITALIZE, sizeof (*info));
>+		return CKR_OK;
>+	} else if (type == CKM_MOCK_PREFIX) {
>+		memcpy (info, &MOCK_MECH_PREFIX, sizeof (*info));
>+		return CKR_OK;
>+	} else {
>+		return CKR_MECHANISM_INVALID;
>+	}
>+}
>+
> CK_RV
>-mock_C_GetMechanismInfo__invalid_slotid (CK_SLOT_ID id,
>+mock_C_GetMechanismInfo__invalid_slotid (CK_SLOT_ID slot_id,
>                                          CK_MECHANISM_TYPE type,
>                                          CK_MECHANISM_INFO_PTR info)
> {
>@@ -249,7 +774,34 @@ mock_C_GetMechanismInfo__invalid_slotid (CK_SLOT_ID id,
> }
> 
> CK_RV
>-mock_C_InitToken__invalid_slotid (CK_SLOT_ID id,
>+mock_C_InitToken__specific_args (CK_SLOT_ID slot_id,
>+                                 CK_UTF8CHAR_PTR pin,
>+                                 CK_ULONG pin_len,
>+                                 CK_UTF8CHAR_PTR label)
>+{
>+	return_val_if_fail (pin != NULL, CKR_ARGUMENTS_BAD);
>+	return_val_if_fail (label != NULL, CKR_ARGUMENTS_BAD);
>+
>+	if (slot_id == MOCK_SLOT_TWO_ID)
>+		return CKR_TOKEN_NOT_PRESENT;
>+	else if (slot_id != MOCK_SLOT_ONE_ID)
>+		return CKR_SLOT_ID_INVALID;
>+
>+	if (strlen ("TEST PIN") != pin_len ||
>+	    strncmp ((char *)pin, "TEST PIN", pin_len) != 0)
>+		return CKR_PIN_INVALID;
>+	if (strcmp ((char *)label, "TEST LABEL") != 0)
>+		return CKR_ARGUMENTS_BAD;
>+
>+	free (the_pin);
>+	the_pin = memdup (pin, pin_len);
>+	return_val_if_fail (the_pin != NULL, CKR_HOST_MEMORY);
>+	n_the_pin = pin_len;
>+	return CKR_OK;
>+}
>+
>+CK_RV
>+mock_C_InitToken__invalid_slotid (CK_SLOT_ID slot_id,
>                                   CK_UTF8CHAR_PTR pin,
>                                   CK_ULONG pin_len,
>                                   CK_UTF8CHAR_PTR label)
>@@ -258,6 +810,20 @@ mock_C_InitToken__invalid_slotid (CK_SLOT_ID id,
> }
> 
> CK_RV
>+mock_C_WaitForSlotEvent (CK_FLAGS flags,
>+                         CK_SLOT_ID_PTR slot,
>+                         CK_VOID_PTR reserved)
>+{
>+	return_val_if_fail (slot, CKR_ARGUMENTS_BAD);
>+
>+	if (flags & CKF_DONT_BLOCK)
>+		return CKR_NO_EVENT;
>+
>+	*slot = MOCK_SLOT_TWO_ID;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_WaitForSlotEvent__no_event (CK_FLAGS flags,
>                                    CK_SLOT_ID_PTR slot,
>                                    CK_VOID_PTR reserved)
>@@ -268,7 +834,42 @@ mock_C_WaitForSlotEvent__no_event (CK_FLAGS flags,
> }
> 
> CK_RV
>-mock_C_OpenSession__invalid_slotid (CK_SLOT_ID id,
>+mock_C_OpenSession (CK_SLOT_ID slot_id,
>+                    CK_FLAGS flags,
>+                    CK_VOID_PTR user_data,
>+                    CK_NOTIFY callback,
>+                    CK_SESSION_HANDLE_PTR session)
>+{
>+	Session *sess;
>+
>+	return_val_if_fail (session, CKR_ARGUMENTS_BAD);
>+
>+	if (slot_id == MOCK_SLOT_TWO_ID)
>+		return CKR_TOKEN_NOT_PRESENT;
>+	else if (slot_id != MOCK_SLOT_ONE_ID)
>+		return CKR_SLOT_ID_INVALID;
>+	if ((flags & CKF_SERIAL_SESSION) != CKF_SERIAL_SESSION)
>+		return CKR_SESSION_PARALLEL_NOT_SUPPORTED;
>+
>+	sess = calloc (1, sizeof (Session));
>+	sess->handle = ++unique_identifier;
>+	sess->info.flags = flags;
>+	sess->info.slotID = slot_id;
>+	sess->info.state = 0;
>+	sess->info.ulDeviceError = 1414;
>+	sess->objects = _p11_hash_create (_p11_hash_direct_hash, _p11_hash_direct_equal,
>+	                                  NULL, free_attributes);
>+	*session = sess->handle;
>+
>+	memcpy (sess->random_seed, "random", 6);
>+	sess->random_seed_len = 6;
>+
>+	_p11_hash_set (the_sessions, handle_to_pointer (sess->handle), sess);
>+	return CKR_OK;
>+}
>+
>+CK_RV
>+mock_C_OpenSession__invalid_slotid (CK_SLOT_ID slot_id,
>                                     CK_FLAGS flags,
>                                     CK_VOID_PTR user_data,
>                                     CK_NOTIFY callback,
>@@ -280,30 +881,99 @@ mock_C_OpenSession__invalid_slotid (CK_SLOT_ID id,
> }
> 
> CK_RV
>+mock_C_CloseSession (CK_SESSION_HANDLE session)
>+{
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	_p11_hash_remove (the_sessions, handle_to_pointer (session));
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_CloseSession__invalid_handle (CK_SESSION_HANDLE session)
> {
> 	return CKR_SESSION_HANDLE_INVALID;
> }
> 
> CK_RV
>-mock_C_CloseAllSessions__invalid_slotid (CK_SLOT_ID id)
>+mock_C_CloseAllSessions (CK_SLOT_ID slot_id)
>+{
>+	if (slot_id == MOCK_SLOT_TWO_ID)
>+		return CKR_TOKEN_NOT_PRESENT;
>+	else if (slot_id != MOCK_SLOT_ONE_ID)
>+		return CKR_SLOT_ID_INVALID;
>+
>+	_p11_hash_clear (the_sessions);
>+	return CKR_OK;
>+}
>+
>+CK_RV
>+mock_C_CloseAllSessions__invalid_slotid (CK_SLOT_ID slot_id)
> {
> 	return CKR_SLOT_ID_INVALID;
> }
> 
> CK_RV
>+mock_C_GetFunctionStatus (CK_SESSION_HANDLE session)
>+{
>+	if (!_p11_hash_get (the_sessions, handle_to_pointer (session)))
>+		return CKR_SESSION_HANDLE_INVALID;
>+	return CKR_FUNCTION_NOT_PARALLEL;
>+}
>+
>+CK_RV
> mock_C_GetFunctionStatus__not_parallel (CK_SESSION_HANDLE session)
> {
> 	return CKR_FUNCTION_NOT_PARALLEL;
> }
> 
> CK_RV
>+mock_C_CancelFunction (CK_SESSION_HANDLE session)
>+{
>+	if (!_p11_hash_get (the_sessions, handle_to_pointer (session)))
>+		return CKR_SESSION_HANDLE_INVALID;
>+	return CKR_FUNCTION_NOT_PARALLEL;
>+}
>+
>+CK_RV
> mock_C_CancelFunction__not_parallel (CK_SESSION_HANDLE session)
> {
> 	return CKR_FUNCTION_NOT_PARALLEL;
> }
> 
> CK_RV
>+mock_C_GetSessionInfo (CK_SESSION_HANDLE session,
>+                       CK_SESSION_INFO_PTR info)
>+{
>+	Session *sess;
>+
>+	return_val_if_fail (info != NULL, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!session)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (logged_in) {
>+		if (sess->info.flags & CKF_RW_SESSION)
>+			sess->info.state = CKS_RW_USER_FUNCTIONS;
>+		else
>+			sess->info.state = CKS_RO_USER_FUNCTIONS;
>+	} else {
>+		if (sess->info.flags & CKF_RW_SESSION)
>+			sess->info.state = CKS_RW_PUBLIC_SESSION;
>+		else
>+			sess->info.state = CKS_RO_PUBLIC_SESSION;
>+	}
>+
>+	memcpy (info, &sess->info, sizeof (*info));
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_GetSessionInfo__invalid_handle (CK_SESSION_HANDLE session,
>                                        CK_SESSION_INFO_PTR info)
> {
>@@ -313,6 +983,28 @@ mock_C_GetSessionInfo__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_InitPIN__specific_args (CK_SESSION_HANDLE session,
>+                               CK_UTF8CHAR_PTR pin,
>+                               CK_ULONG pin_len)
>+{
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (sess == NULL)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (strlen ("TEST PIN") != pin_len ||
>+	    strncmp ((char *)pin, "TEST PIN", pin_len) != 0)
>+		return CKR_PIN_INVALID;
>+
>+	free (the_pin);
>+	the_pin = memdup (pin, pin_len);
>+	return_val_if_fail (the_pin != NULL, CKR_HOST_MEMORY);
>+	n_the_pin = pin_len;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_InitPIN__invalid_handle (CK_SESSION_HANDLE session,
>                                 CK_UTF8CHAR_PTR pin,
>                                 CK_ULONG pin_len)
>@@ -321,6 +1013,35 @@ mock_C_InitPIN__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_SetPIN__specific_args (CK_SESSION_HANDLE session,
>+                              CK_UTF8CHAR_PTR old_pin,
>+                              CK_ULONG old_pin_len,
>+                              CK_UTF8CHAR_PTR new_pin,
>+                              CK_ULONG new_pin_len)
>+{
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (sess == NULL)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (old_pin_len != n_the_pin)
>+		return CKR_PIN_INCORRECT;
>+	if (memcmp (old_pin, the_pin, n_the_pin) != 0)
>+		return CKR_PIN_INCORRECT;
>+
>+	if (strlen ("TEST PIN") != new_pin_len ||
>+	    strncmp ((char *)new_pin, "TEST PIN", new_pin_len) != 0)
>+		return CKR_PIN_INVALID;
>+
>+	free (the_pin);
>+	the_pin = memdup (new_pin, new_pin_len);
>+	return_val_if_fail (the_pin != NULL, CKR_HOST_MEMORY);
>+	n_the_pin = new_pin_len;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_SetPIN__invalid_handle (CK_SESSION_HANDLE session,
>                                CK_UTF8CHAR_PTR old_pin,
>                                CK_ULONG old_pin_len,
>@@ -331,13 +1052,61 @@ mock_C_SetPIN__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>-mock_C_GetOperationState__invalid_handle (CK_SESSION_HANDLE session,
>-                                         CK_BYTE_PTR operation_state,
>-                                         CK_ULONG_PTR operation_state_len)
>+mock_C_GetOperationState (CK_SESSION_HANDLE session,
>+                          CK_BYTE_PTR operation_state,
>+                          CK_ULONG_PTR operation_state_len)
> {
>+	Session *sess;
>+
> 	return_val_if_fail (operation_state_len, CKR_ARGUMENTS_BAD);
> 
>-	return CKR_SESSION_HANDLE_INVALID;
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (sess == NULL)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (!operation_state) {
>+		*operation_state_len = sizeof (sess);
>+		return CKR_OK;
>+	}
>+
>+	if (*operation_state_len < sizeof (sess))
>+		return CKR_BUFFER_TOO_SMALL;
>+
>+	memcpy (operation_state, &sess, sizeof (sess));
>+	*operation_state_len = sizeof (sess);
>+	return CKR_OK;
>+}
>+
>+CK_RV
>+mock_C_GetOperationState__invalid_handle (CK_SESSION_HANDLE session,
>+                                          CK_BYTE_PTR operation_state,
>+                                          CK_ULONG_PTR operation_state_len)
>+{
>+	return CKR_FUNCTION_NOT_SUPPORTED;
>+}
>+
>+CK_RV
>+mock_C_SetOperationState (CK_SESSION_HANDLE session,
>+                          CK_BYTE_PTR operation_state,
>+                          CK_ULONG operation_state_len,
>+                          CK_OBJECT_HANDLE encryption_key,
>+                          CK_OBJECT_HANDLE authentication_key)
>+{
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (sess == NULL)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (!operation_state || operation_state_len != sizeof (sess))
>+		return CKR_ARGUMENTS_BAD;
>+
>+	/* Yes, just arbitrary numbers, to make sure they got through */
>+	if (encryption_key != 355 || authentication_key != 455)
>+		return CKR_KEY_HANDLE_INVALID;
>+	if (memcmp (operation_state, &sess, sizeof (sess)) != 0)
>+		return CKR_SAVED_STATE_INVALID;
>+	return CKR_OK;
> }
> 
> CK_RV
>@@ -351,20 +1120,108 @@ mock_C_SetOperationState__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_Login (CK_SESSION_HANDLE session,
>+              CK_USER_TYPE user_type,
>+              CK_UTF8CHAR_PTR pin,
>+              CK_ULONG pin_len)
>+{
>+	Session *sess;
>+
>+	return_val_if_fail (user_type == CKU_SO ||
>+	                    user_type == CKU_USER ||
>+	                    user_type == CKU_CONTEXT_SPECIFIC,
>+	                    CKR_USER_TYPE_INVALID);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (sess == NULL)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (logged_in && user_type != CKU_CONTEXT_SPECIFIC)
>+		return CKR_USER_ALREADY_LOGGED_IN;
>+
>+	if (!pin)
>+		return CKR_PIN_INCORRECT;
>+
>+	if (pin_len != n_the_pin)
>+		return CKR_PIN_INCORRECT;
>+	if (strncmp ((char *)pin, (char *)the_pin, pin_len) != 0)
>+		return CKR_PIN_INCORRECT;
>+
>+	if (user_type == CKU_CONTEXT_SPECIFIC) {
>+		return_val_if_fail (sess->want_context_login == TRUE, CKR_OPERATION_NOT_INITIALIZED);
>+		sess->want_context_login = CK_FALSE;
>+	} else {
>+		logged_in = TRUE;
>+		the_user_type = user_type;
>+	}
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_Login__invalid_handle (CK_SESSION_HANDLE session,
>                               CK_USER_TYPE user_type,
>                               CK_UTF8CHAR_PTR pin,
>                               CK_ULONG pin_len)
> {
> 	return CKR_SESSION_HANDLE_INVALID;
>+}
>+
>+CK_RV
>+mock_C_Logout (CK_SESSION_HANDLE session)
>+{
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (!logged_in)
>+		return CKR_USER_NOT_LOGGED_IN;
> 
>+	logged_in = FALSE;
>+	the_user_type = 0;
>+	return CKR_OK;
> }
> 
> CK_RV
> mock_C_Logout__invalid_handle (CK_SESSION_HANDLE session)
> {
> 	return CKR_SESSION_HANDLE_INVALID;
>+}
>+
>+CK_RV
>+mock_C_CreateObject (CK_SESSION_HANDLE session,
>+                     CK_ATTRIBUTE_PTR template,
>+                     CK_ULONG count,
>+                     CK_OBJECT_HANDLE_PTR object)
>+{
>+	CK_ATTRIBUTE_PTR attrs;
>+	Session *sess;
>+	CK_BBOOL token, priv;
>+
>+	return_val_if_fail (object, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	attrs = build_attributes (NULL, template, count);
>+
>+	if (find_boolean_attribute (attrs, CKA_PRIVATE, &priv) && priv) {
>+		if (!logged_in) {
>+			free_attributes (attrs);
>+			return CKR_USER_NOT_LOGGED_IN;
>+		}
>+	}
> 
>+	*object = ++unique_identifier;
>+	if (find_boolean_attribute (attrs, CKA_TOKEN, &token) && token)
>+		_p11_hash_set (the_objects, handle_to_pointer (*object), attrs);
>+	else
>+		_p11_hash_set (sess->objects, handle_to_pointer (*object), attrs);
>+
>+	return CKR_OK;
> }
> 
> CK_RV
>@@ -379,6 +1236,46 @@ mock_C_CreateObject__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_CopyObject (CK_SESSION_HANDLE session,
>+                   CK_OBJECT_HANDLE object,
>+                   CK_ATTRIBUTE_PTR template,
>+                   CK_ULONG count,
>+                   CK_OBJECT_HANDLE_PTR new_object)
>+{
>+	CK_ATTRIBUTE_PTR attrs;
>+	Session *sess;
>+	CK_BBOOL token, priv;
>+	CK_RV rv;
>+
>+	return_val_if_fail (object, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	rv = lookup_object (sess, object, &attrs, NULL);
>+	if (rv != CKR_OK)
>+		return rv;
>+
>+	if (find_boolean_attribute (attrs, CKA_PRIVATE, &priv) && priv) {
>+		if (!logged_in) {
>+			free_attributes (attrs);
>+			return CKR_USER_NOT_LOGGED_IN;
>+		}
>+	}
>+
>+	attrs = build_attributes (dup_attributes (attrs), template, count);
>+
>+	*new_object = ++unique_identifier;
>+	if (find_boolean_attribute (attrs, CKA_TOKEN, &token) && token)
>+		_p11_hash_set (the_objects, handle_to_pointer (*new_object), attrs);
>+	else
>+		_p11_hash_set (sess->objects, handle_to_pointer (*new_object), attrs);
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_CopyObject__invalid_handle (CK_SESSION_HANDLE session,
>                                    CK_OBJECT_HANDLE object,
>                                    CK_ATTRIBUTE_PTR template,
>@@ -392,6 +1289,27 @@ mock_C_CopyObject__invalid_handle (CK_SESSION_HANDLE session,
> 
> 
> CK_RV
>+mock_C_DestroyObject (CK_SESSION_HANDLE session,
>+                      CK_OBJECT_HANDLE object)
>+{
>+	CK_ATTRIBUTE_PTR attrs;
>+	Session *sess;
>+	hashmap *table;
>+	CK_RV rv;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	rv = lookup_object (sess, object, &attrs, &table);
>+	if (rv != CKR_OK)
>+		return rv;
>+
>+	_p11_hash_remove (table, handle_to_pointer (object));
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_DestroyObject__invalid_handle (CK_SESSION_HANDLE session,
>                                       CK_OBJECT_HANDLE object)
> {
>@@ -399,6 +1317,35 @@ mock_C_DestroyObject__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_GetObjectSize (CK_SESSION_HANDLE session,
>+                      CK_OBJECT_HANDLE object,
>+                      CK_ULONG_PTR size)
>+{
>+	CK_ATTRIBUTE_PTR attrs;
>+	Session *sess;
>+	CK_RV rv;
>+	CK_ULONG i;
>+
>+	return_val_if_fail (size != NULL, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	rv = lookup_object (sess, object, &attrs, NULL);
>+	if (rv != CKR_OK)
>+		return rv;
>+
>+	*size = 0;
>+	for (i = 0; !is_attribute_terminator (attrs + i); i++) {
>+		if (attrs[i].ulValueLen != (CK_ULONG)-1)
>+			*size += attrs[i].ulValueLen;
>+	}
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_GetObjectSize__invalid_handle (CK_SESSION_HANDLE session,
>                                       CK_OBJECT_HANDLE object,
>                                       CK_ULONG_PTR size)
>@@ -409,6 +1356,55 @@ mock_C_GetObjectSize__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_GetAttributeValue (CK_SESSION_HANDLE session,
>+                          CK_OBJECT_HANDLE object,
>+                          CK_ATTRIBUTE_PTR template,
>+                          CK_ULONG count)
>+{
>+	CK_ATTRIBUTE_PTR result;
>+	CK_RV ret = CKR_OK;
>+	CK_ATTRIBUTE_PTR attrs;
>+	CK_ATTRIBUTE_PTR attr;
>+	Session *sess;
>+	CK_ULONG i;
>+	CK_RV rv;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (sess == NULL)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	rv = lookup_object (sess, object, &attrs, NULL);
>+	if (rv != CKR_OK)
>+		return rv;
>+
>+	for (i = 0; i < count; ++i) {
>+		result = template + i;
>+		attr = find_attribute (attrs, result->type);
>+		if (!attr) {
>+			result->ulValueLen = (CK_ULONG)-1;
>+			ret = CKR_ATTRIBUTE_TYPE_INVALID;
>+			continue;
>+		}
>+
>+		if (!result->pValue) {
>+			result->ulValueLen = attr->ulValueLen;
>+			continue;
>+		}
>+
>+		if (result->ulValueLen >= attr->ulValueLen) {
>+			memcpy (result->pValue, attr->pValue, attr->ulValueLen);
>+			result->ulValueLen = attr->ulValueLen;
>+			continue;
>+		}
>+
>+		result->ulValueLen = (CK_ULONG)-1;
>+		ret = CKR_BUFFER_TOO_SMALL;
>+	}
>+
>+	return ret;
>+}
>+
>+CK_RV
> mock_C_GetAttributeValue__invalid_handle (CK_SESSION_HANDLE session,
>                                           CK_OBJECT_HANDLE object,
>                                           CK_ATTRIBUTE_PTR template,
>@@ -418,6 +1414,31 @@ mock_C_GetAttributeValue__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_SetAttributeValue (CK_SESSION_HANDLE session,
>+                          CK_OBJECT_HANDLE object,
>+                          CK_ATTRIBUTE_PTR template,
>+                          CK_ULONG count)
>+{
>+	Session *sess;
>+	CK_ATTRIBUTE_PTR attrs;
>+	hashmap *table;
>+	CK_RV rv;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	rv = lookup_object (sess, object, &attrs, &table);
>+	if (rv != CKR_OK)
>+		return rv;
>+
>+	_p11_hash_steal (table, handle_to_pointer (object), NULL, (void **)&attrs);
>+	attrs = build_attributes (attrs, template, count);
>+	_p11_hash_set (table, handle_to_pointer (object), attrs);
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_SetAttributeValue__invalid_handle (CK_SESSION_HANDLE session,
>                                           CK_OBJECT_HANDLE object,
>                                           CK_ATTRIBUTE_PTR template,
>@@ -426,6 +1447,66 @@ mock_C_SetAttributeValue__invalid_handle (CK_SESSION_HANDLE session,
> 	return CKR_SESSION_HANDLE_INVALID;
> }
> 
>+typedef struct _FindObjects {
>+	CK_ATTRIBUTE_PTR template;
>+	CK_ULONG count;
>+	Session *sess;
>+} FindObjects;
>+
>+static int
>+enumerate_and_find_objects (CK_OBJECT_HANDLE object,
>+                            CK_ATTRIBUTE_PTR attrs,
>+                            CK_ULONG n_attrs,
>+                            void *user_data)
>+{
>+	FindObjects *ctx = user_data;
>+	CK_ATTRIBUTE_PTR match;
>+	CK_ATTRIBUTE_PTR attr;
>+	CK_ULONG i;
>+
>+	for (i = 0; i < ctx->count; ++i) {
>+		match = ctx->template + i;
>+		attr = find_attribute (attrs, match->type);
>+		if (!attr)
>+			return 1; /* Continue */
>+
>+		if (attr->ulValueLen != match->ulValueLen ||
>+		    memcmp (attr->pValue, match->pValue, attr->ulValueLen) != 0)
>+			return 1; /* Continue */
>+	}
>+
>+	_p11_ptr_array_add (ctx->sess->matches, handle_to_pointer (object));
>+	return 1; /* Continue */
>+}
>+
>+CK_RV
>+mock_C_FindObjectsInit (CK_SESSION_HANDLE session,
>+                        CK_ATTRIBUTE_PTR template,
>+                        CK_ULONG count)
>+{
>+	Session *sess;
>+	FindObjects ctx;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	/* Starting an operation, cancels any previous one */
>+	sess->crypto_mechanism = 0;
>+	sess->hash_mechanism = 0;
>+
>+	sess->finding = CK_TRUE;
>+	_p11_ptr_array_free (sess->matches);
>+	sess->matches = _p11_ptr_array_create (NULL);
>+
>+	ctx.template = template;
>+	ctx.count = count;
>+	ctx.sess = sess;
>+
>+	mock_module_enumerate_objects (session, enumerate_and_find_objects, &ctx);
>+	return CKR_OK;
>+}
>+
> CK_RV
> mock_C_FindObjectsInit__invalid_handle (CK_SESSION_HANDLE session,
>                                         CK_ATTRIBUTE_PTR template,
>@@ -435,6 +1516,40 @@ mock_C_FindObjectsInit__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_FindObjects (CK_SESSION_HANDLE session,
>+                    CK_OBJECT_HANDLE_PTR objects,
>+                    CK_ULONG max_object_count,
>+                    CK_ULONG_PTR object_count)
>+{
>+	Session *sess;
>+	unsigned int count;
>+
>+	return_val_if_fail (objects, CKR_ARGUMENTS_BAD);
>+	return_val_if_fail (object_count, CKR_ARGUMENTS_BAD);
>+	return_val_if_fail (max_object_count != 0, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (sess == NULL)
>+		return CKR_SESSION_HANDLE_INVALID;
>+	if (!sess->finding)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+
>+	*object_count = 0;
>+	while (max_object_count > 0) {
>+		count = _p11_ptr_array_count (sess->matches);
>+		if (count == 0)
>+			break;
>+		*objects = pointer_to_handle (_p11_ptr_array_at (sess->matches, count - 1));
>+		++objects;
>+		--max_object_count;
>+		++(*object_count);
>+		_p11_ptr_array_remove (sess->matches, count - 1);
>+	}
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_FindObjects__invalid_handle (CK_SESSION_HANDLE session,
>                                     CK_OBJECT_HANDLE_PTR objects,
>                                     CK_ULONG max_count,
>@@ -446,12 +1561,58 @@ mock_C_FindObjects__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_FindObjectsFinal (CK_SESSION_HANDLE session)
>+{
>+
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (sess == NULL)
>+		return CKR_SESSION_HANDLE_INVALID;
>+	if (!sess->finding)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+
>+	sess->finding = CK_FALSE;
>+	_p11_ptr_array_free (sess->matches);
>+	sess->matches = NULL;
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_FindObjectsFinal__invalid_handle (CK_SESSION_HANDLE session)
> {
> 	return CKR_SESSION_HANDLE_INVALID;
> }
> 
> CK_RV
>+mock_C_EncryptInit (CK_SESSION_HANDLE session,
>+                    CK_MECHANISM_PTR mechanism,
>+                    CK_OBJECT_HANDLE key)
>+{
>+	Session *sess;
>+
>+	return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	/* Starting an operation, cancels any previous one */
>+	sess->finding = CK_FALSE;
>+
>+	if (mechanism->mechanism != CKM_MOCK_CAPITALIZE)
>+		return CKR_MECHANISM_INVALID;
>+	if (key != MOCK_PUBLIC_KEY_CAPITALIZE)
>+		return CKR_KEY_HANDLE_INVALID;
>+
>+	sess->crypto_method = CKA_ENCRYPT;
>+	sess->crypto_mechanism = CKM_MOCK_CAPITALIZE;
>+	sess->crypto_key = key;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_EncryptInit__invalid_handle (CK_SESSION_HANDLE session,
>                                     CK_MECHANISM_PTR mechanism,
>                                     CK_OBJECT_HANDLE key)
>@@ -460,8 +1621,24 @@ mock_C_EncryptInit__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_Encrypt (CK_SESSION_HANDLE session,
>+                CK_BYTE_PTR data,
>+                CK_ULONG data_len,
>+                CK_BYTE_PTR encrypted_data,
>+                CK_ULONG_PTR encrypted_data_len)
>+{
>+	CK_ULONG last = 0;
>+	CK_RV rv;
>+	rv = mock_C_EncryptUpdate (session, data, data_len, encrypted_data, encrypted_data_len);
>+	if (rv == CKR_OK)
>+		rv = mock_C_EncryptFinal (session, encrypted_data, &last);
>+	return rv;
>+}
>+
>+CK_RV
> mock_C_Encrypt__invalid_handle (CK_SESSION_HANDLE session,
>-                                CK_BYTE_PTR data, CK_ULONG data_len,
>+                                CK_BYTE_PTR data,
>+                                CK_ULONG data_len,
>                                 CK_BYTE_PTR encrypted_data,
>                                 CK_ULONG_PTR encrypted_data_len)
> {
>@@ -471,6 +1648,46 @@ mock_C_Encrypt__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_EncryptUpdate (CK_SESSION_HANDLE session,
>+                      CK_BYTE_PTR part,
>+                      CK_ULONG part_len,
>+                      CK_BYTE_PTR encrypted_part,
>+                      CK_ULONG_PTR encrypted_part_len)
>+{
>+	Session *sess;
>+	CK_ULONG i;
>+
>+	return_val_if_fail (part != NULL, CKR_DATA_INVALID);
>+	return_val_if_fail (encrypted_part_len != NULL, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (!sess->crypto_mechanism)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->crypto_method != CKA_ENCRYPT)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	assert (sess->crypto_mechanism == CKM_MOCK_CAPITALIZE);
>+	assert (sess->crypto_key == MOCK_PUBLIC_KEY_CAPITALIZE);
>+
>+	if (!encrypted_part) {
>+		*encrypted_part_len = part_len;
>+		return CKR_OK;
>+	}
>+
>+	if (*encrypted_part_len < part_len) {
>+		*encrypted_part_len = part_len;
>+		return CKR_BUFFER_TOO_SMALL;
>+	}
>+
>+	for (i = 0; i < part_len; ++i)
>+		encrypted_part[i] = toupper (part[i]);
>+	*encrypted_part_len = part_len;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_EncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
>                                       CK_BYTE_PTR part,
>                                       CK_ULONG part_len,
>@@ -483,6 +1700,32 @@ mock_C_EncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_EncryptFinal (CK_SESSION_HANDLE session,
>+                     CK_BYTE_PTR last_encrypted_part,
>+                     CK_ULONG_PTR last_encrypted_part_len)
>+{
>+	Session *sess;
>+
>+	return_val_if_fail (last_encrypted_part_len != NULL, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (!sess->crypto_mechanism)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->crypto_method != CKA_ENCRYPT)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+
>+	*last_encrypted_part_len = 0;
>+
>+	sess->crypto_method = 0;
>+	sess->crypto_mechanism = 0;
>+	sess->crypto_key = 0;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_EncryptFinal__invalid_handle (CK_SESSION_HANDLE session,
>                                      CK_BYTE_PTR last_part,
>                                      CK_ULONG_PTR last_part_len)
>@@ -493,6 +1736,33 @@ mock_C_EncryptFinal__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_DecryptInit (CK_SESSION_HANDLE session,
>+                    CK_MECHANISM_PTR mechanism,
>+                    CK_OBJECT_HANDLE key)
>+{
>+	Session *sess;
>+
>+	return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	/* Starting an operation, cancels any previous one */
>+	sess->finding = 0;
>+
>+	if (mechanism->mechanism != CKM_MOCK_CAPITALIZE)
>+		return CKR_MECHANISM_INVALID;
>+	if (key != MOCK_PRIVATE_KEY_CAPITALIZE)
>+		return CKR_KEY_HANDLE_INVALID;
>+
>+	sess->crypto_method = CKA_DECRYPT;
>+	sess->crypto_mechanism = CKM_MOCK_CAPITALIZE;
>+	sess->crypto_key = key;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_DecryptInit__invalid_handle (CK_SESSION_HANDLE session,
>                                     CK_MECHANISM_PTR mechanism,
>                                     CK_OBJECT_HANDLE key)
>@@ -501,6 +1771,21 @@ mock_C_DecryptInit__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_Decrypt (CK_SESSION_HANDLE session,
>+                CK_BYTE_PTR encrypted_data,
>+                CK_ULONG encrypted_data_len,
>+                CK_BYTE_PTR data,
>+                CK_ULONG_PTR data_len)
>+{
>+	CK_ULONG last = 0;
>+	CK_RV rv;
>+	rv = mock_C_DecryptUpdate (session, encrypted_data, encrypted_data_len, data, data_len);
>+	if (rv == CKR_OK)
>+		rv = mock_C_DecryptFinal (session, data, &last);
>+	return rv;
>+}
>+
>+CK_RV
> mock_C_Decrypt__invalid_handle (CK_SESSION_HANDLE session,
>                                 CK_BYTE_PTR enc_data,
>                                 CK_ULONG enc_data_len,
>@@ -513,6 +1798,46 @@ mock_C_Decrypt__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_DecryptUpdate (CK_SESSION_HANDLE session,
>+                      CK_BYTE_PTR encrypted_part,
>+                      CK_ULONG encrypted_part_len,
>+                      CK_BYTE_PTR part,
>+                      CK_ULONG_PTR part_len)
>+{
>+	Session *sess;
>+	CK_ULONG i;
>+
>+	return_val_if_fail (encrypted_part, CKR_ENCRYPTED_DATA_INVALID);
>+	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (!sess->crypto_mechanism)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->crypto_method != CKA_DECRYPT)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	assert (sess->crypto_mechanism == CKM_MOCK_CAPITALIZE);
>+	assert (sess->crypto_key == MOCK_PRIVATE_KEY_CAPITALIZE);
>+
>+	if (!part) {
>+		*part_len = encrypted_part_len;
>+		return CKR_OK;
>+	}
>+
>+	if (*part_len < encrypted_part_len) {
>+		*part_len = encrypted_part_len;
>+		return CKR_BUFFER_TOO_SMALL;
>+	}
>+
>+	for (i = 0; i < encrypted_part_len; ++i)
>+		part[i] = tolower (encrypted_part[i]);
>+	*part_len = encrypted_part_len;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_DecryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
>                                       CK_BYTE_PTR enc_part,
>                                       CK_ULONG enc_part_len,
>@@ -525,6 +1850,33 @@ mock_C_DecryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_DecryptFinal (CK_SESSION_HANDLE session,
>+                     CK_BYTE_PTR last_part,
>+                     CK_ULONG_PTR last_part_len)
>+{
>+	Session *sess;
>+
>+	return_val_if_fail (last_part_len != NULL, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (!sess->crypto_mechanism)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->crypto_method != CKA_DECRYPT)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+
>+	*last_part_len = 0;
>+
>+	sess->crypto_method = 0;
>+	sess->crypto_mechanism = 0;
>+	sess->crypto_key = 0;
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_DecryptFinal__invalid_handle (CK_SESSION_HANDLE session,
>                                      CK_BYTE_PTR last_part,
>                                      CK_ULONG_PTR last_part_len)
>@@ -535,6 +1887,31 @@ mock_C_DecryptFinal__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_DigestInit (CK_SESSION_HANDLE session,
>+                   CK_MECHANISM_PTR mechanism)
>+{
>+	Session *sess;
>+
>+	return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	/* Starting an operation, cancels any previous one */
>+	sess->finding = CK_FALSE;
>+
>+	if (mechanism->mechanism != CKM_MOCK_COUNT)
>+		return CKR_MECHANISM_INVALID;
>+
>+	sess->hash_mechanism = CKM_MOCK_COUNT;
>+	sess->hash_method = (CK_ULONG)-1;
>+	sess->hash_count = 0;
>+	sess->hash_key = 0;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_DigestInit__invalid_handle (CK_SESSION_HANDLE session,
>                                    CK_MECHANISM_PTR mechanism)
> {
>@@ -542,6 +1919,23 @@ mock_C_DigestInit__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_Digest (CK_SESSION_HANDLE session,
>+               CK_BYTE_PTR data,
>+               CK_ULONG data_len,
>+               CK_BYTE_PTR digest,
>+               CK_ULONG_PTR digest_len)
>+{
>+	CK_RV rv;
>+
>+	return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
>+
>+	rv = mock_C_DigestUpdate (session, data, data_len);
>+	if (rv == CKR_OK)
>+		rv = mock_C_DigestFinal (session, digest, digest_len);
>+	return rv;
>+}
>+
>+CK_RV
> mock_C_Digest__invalid_handle (CK_SESSION_HANDLE session,
>                                CK_BYTE_PTR data,
>                                CK_ULONG data_len,
>@@ -550,7 +1944,28 @@ mock_C_Digest__invalid_handle (CK_SESSION_HANDLE session,
> {
> 	return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
> 
>-	return CKR_SESSION_HANDLE_INVALID;
>+	return CKR_SESSION_HANDLE_INVALID;
>+}
>+
>+CK_RV
>+mock_C_DigestUpdate (CK_SESSION_HANDLE session,
>+                     CK_BYTE_PTR part,
>+                     CK_ULONG part_len)
>+{
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (!sess->hash_mechanism)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->hash_method != (CK_ULONG)-1)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	assert (sess->hash_mechanism == CKM_MOCK_COUNT);
>+
>+	sess->hash_count += part_len;
>+	return CKR_OK;
> }
> 
> CK_RV
>@@ -562,6 +1977,26 @@ mock_C_DigestUpdate__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_DigestKey (CK_SESSION_HANDLE session,
>+                  CK_OBJECT_HANDLE key)
>+{
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (!sess->hash_mechanism)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->hash_method != (CK_ULONG)-1)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	assert (sess->hash_mechanism == CKM_MOCK_COUNT);
>+
>+	sess->hash_count += key;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_DigestKey__invalid_handle (CK_SESSION_HANDLE session,
>                                   CK_OBJECT_HANDLE key)
> {
>@@ -569,6 +2004,48 @@ mock_C_DigestKey__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_DigestFinal (CK_SESSION_HANDLE session,
>+                    CK_BYTE_PTR digest,
>+                    CK_ULONG_PTR digest_len)
>+{
>+	char buffer[32];
>+	Session *sess;
>+	int len;
>+
>+	return_val_if_fail (digest_len != NULL, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (!sess->hash_mechanism)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->hash_method != (CK_ULONG)-1)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	assert (sess->hash_mechanism == CKM_MOCK_COUNT);
>+
>+	len = snprintf (buffer, sizeof (buffer), "%lu", sess->hash_count);
>+
>+	if (!digest) {
>+		*digest_len = len;
>+		return CKR_OK;
>+	} else if (*digest_len < len) {
>+		*digest_len = len;
>+		return CKR_BUFFER_TOO_SMALL;
>+	}
>+
>+	memcpy (digest, &buffer, len);
>+	*digest_len = len;
>+
>+	sess->hash_count = 0;
>+	sess->hash_mechanism = 0;
>+	sess->hash_key = 0;
>+	sess->hash_method = 0;
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_DigestFinal__invalid_handle (CK_SESSION_HANDLE session,
>                                     CK_BYTE_PTR digest,
>                                     CK_ULONG_PTR digest_len)
>@@ -578,6 +2055,85 @@ mock_C_DigestFinal__invalid_handle (CK_SESSION_HANDLE session,
> 	return CKR_SESSION_HANDLE_INVALID;
> }
> 
>+static CK_RV
>+prefix_mechanism_init (CK_SESSION_HANDLE session,
>+                       CK_ATTRIBUTE_TYPE method,
>+                       CK_MECHANISM_PTR mechanism,
>+                       CK_OBJECT_HANDLE key)
>+{
>+	Session *sess;
>+	CK_ATTRIBUTE_PTR attrs;
>+	CK_ATTRIBUTE_PTR value;
>+	CK_BYTE_PTR param;
>+	CK_ULONG n_param;
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (mechanism->mechanism != CKM_MOCK_PREFIX)
>+		return CKR_MECHANISM_INVALID;
>+	if (method == CKA_SIGN || method == CKA_SIGN_RECOVER) {
>+		if (key != MOCK_PRIVATE_KEY_PREFIX)
>+			return CKR_KEY_HANDLE_INVALID;
>+	} else if (method == CKA_VERIFY || CKA_VERIFY_RECOVER) {
>+		if (key != MOCK_PUBLIC_KEY_PREFIX)
>+			return CKR_KEY_HANDLE_INVALID;
>+	} else {
>+		assert_not_reached ();
>+	}
>+
>+	rv = lookup_object (sess, key, &attrs, NULL);
>+	if (rv != CKR_OK)
>+		return rv;
>+
>+	value = find_attribute (attrs, CKA_VALUE);
>+	if (value == NULL)
>+		return CKR_KEY_TYPE_INCONSISTENT;
>+
>+	if (mechanism->pParameter) {
>+		param = mechanism->pParameter;
>+		n_param = mechanism->ulParameterLen;
>+	} else {
>+		param = (CK_BYTE_PTR)SIGNED_PREFIX;
>+		n_param = strlen (SIGNED_PREFIX) + 1;
>+	}
>+
>+	length = value->ulValueLen + n_param;
>+	if (length > sizeof (sess->sign_prefix))
>+		return CKR_KEY_SIZE_RANGE;
>+
>+	/* Starting an operation, cancels any finding */
>+	sess->finding = CK_FALSE;
>+
>+	sess->hash_mechanism = CKM_MOCK_PREFIX;
>+	sess->hash_method = method;
>+	sess->hash_key = key;
>+	sess->hash_count = 0;
>+
>+	memcpy (sess->sign_prefix, param, n_param);
>+	memcpy (sess->sign_prefix + n_param, value->pValue, value->ulValueLen);
>+	sess->n_sign_prefix = length;
>+
>+	/* The private key has CKA_ALWAYS_AUTHENTICATE above */
>+	if (method == CKA_SIGN || method == CKA_SIGN_RECOVER)
>+		sess->want_context_login = CK_TRUE;
>+
>+	return CKR_OK;
>+
>+}
>+
>+CK_RV
>+mock_C_SignInit (CK_SESSION_HANDLE session,
>+                 CK_MECHANISM_PTR mechanism,
>+                 CK_OBJECT_HANDLE key)
>+{
>+	return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
>+	return prefix_mechanism_init (session, CKA_SIGN, mechanism, key);
>+}
>+
> CK_RV
> mock_C_SignInit__invalid_handle (CK_SESSION_HANDLE session,
>                                  CK_MECHANISM_PTR mechanism,
>@@ -587,6 +2143,22 @@ mock_C_SignInit__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_Sign (CK_SESSION_HANDLE session,
>+             CK_BYTE_PTR data,
>+             CK_ULONG data_len,
>+             CK_BYTE_PTR signature,
>+             CK_ULONG_PTR signature_len)
>+{
>+	CK_RV rv;
>+
>+	rv = mock_C_SignUpdate (session, data, data_len);
>+	if (rv == CKR_OK)
>+		rv = mock_C_SignFinal (session, signature, signature_len);
>+
>+	return rv;
>+}
>+
>+CK_RV
> mock_C_Sign__invalid_handle (CK_SESSION_HANDLE session,
>                              CK_BYTE_PTR data,
>                              CK_ULONG data_len,
>@@ -599,6 +2171,26 @@ mock_C_Sign__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_SignUpdate (CK_SESSION_HANDLE session,
>+                   CK_BYTE_PTR part,
>+                   CK_ULONG part_len)
>+{
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+	if (sess->hash_mechanism != CKM_MOCK_PREFIX ||
>+	    sess->hash_method != CKA_SIGN)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->want_context_login)
>+		return CKR_USER_NOT_LOGGED_IN;
>+
>+	sess->hash_count += part_len;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_SignUpdate__invalid_handle (CK_SESSION_HANDLE session,
>                                    CK_BYTE_PTR part,
>                                    CK_ULONG part_len)
>@@ -609,6 +2201,52 @@ mock_C_SignUpdate__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_SignFinal (CK_SESSION_HANDLE session,
>+                  CK_BYTE_PTR signature,
>+                  CK_ULONG_PTR signature_len)
>+{
>+	char buffer[32];
>+	Session *sess;
>+	CK_ULONG length;
>+	int len;
>+
>+	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+	if (sess->hash_mechanism != CKM_MOCK_PREFIX ||
>+	    sess->hash_method != CKA_SIGN)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->want_context_login)
>+		return CKR_USER_NOT_LOGGED_IN;
>+
>+	len = snprintf (buffer, sizeof (buffer), "%lu", sess->hash_count);
>+	length = sess->n_sign_prefix + len;
>+
>+	if (!signature) {
>+		*signature_len = length;
>+		return CKR_OK;
>+	}
>+
>+	if (*signature_len < length) {
>+		*signature_len = length;
>+		return CKR_BUFFER_TOO_SMALL;
>+	}
>+
>+	memcpy (signature, sess->sign_prefix, sess->n_sign_prefix);
>+	memcpy (signature + sess->n_sign_prefix, buffer, len);
>+	*signature_len = length;
>+
>+	sess->hash_mechanism = 0;
>+	sess->hash_method = 0;
>+	sess->hash_count = 0;
>+	sess->hash_key = 0;
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_SignFinal__invalid_handle (CK_SESSION_HANDLE session,
>                                   CK_BYTE_PTR signature,
>                                   CK_ULONG_PTR signature_len)
>@@ -619,6 +2257,15 @@ mock_C_SignFinal__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_SignRecoverInit (CK_SESSION_HANDLE session,
>+                        CK_MECHANISM_PTR mechanism,
>+                        CK_OBJECT_HANDLE key)
>+{
>+	return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
>+	return prefix_mechanism_init (session, CKA_SIGN_RECOVER, mechanism, key);
>+}
>+
>+CK_RV
> mock_C_SignRecoverInit__invalid_handle (CK_SESSION_HANDLE session,
>                                         CK_MECHANISM_PTR mechanism,
>                                         CK_OBJECT_HANDLE key)
>@@ -627,6 +2274,52 @@ mock_C_SignRecoverInit__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_SignRecover (CK_SESSION_HANDLE session,
>+                    CK_BYTE_PTR data,
>+                    CK_ULONG data_len,
>+                    CK_BYTE_PTR signature,
>+                    CK_ULONG_PTR signature_len)
>+{
>+	Session *sess;
>+	CK_ULONG length;
>+
>+	return_val_if_fail (data, CKR_DATA_INVALID);
>+	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+	if (sess->hash_method != CKA_SIGN_RECOVER ||
>+	    sess->hash_mechanism != CKM_MOCK_PREFIX)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->want_context_login)
>+		return CKR_USER_NOT_LOGGED_IN;
>+
>+	length = sess->n_sign_prefix + data_len;
>+
>+	if (!signature) {
>+		*signature_len = length;
>+		return CKR_OK;
>+	}
>+
>+	if (*signature_len < length) {
>+		*signature_len = length;
>+		return CKR_BUFFER_TOO_SMALL;
>+	}
>+
>+	memcpy (signature, sess->sign_prefix, sess->n_sign_prefix);
>+	memcpy (signature + sess->n_sign_prefix, data, data_len);
>+	*signature_len = length;
>+
>+	sess->hash_method = 0;
>+	sess->hash_mechanism = 0;
>+	sess->hash_key = 0;
>+	sess->hash_count = 0;
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_SignRecover__invalid_handle (CK_SESSION_HANDLE session,
>                                     CK_BYTE_PTR data,
>                                     CK_ULONG data_len,
>@@ -639,6 +2332,15 @@ mock_C_SignRecover__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_VerifyInit (CK_SESSION_HANDLE session,
>+                   CK_MECHANISM_PTR mechanism,
>+                   CK_OBJECT_HANDLE key)
>+{
>+	return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
>+	return prefix_mechanism_init (session, CKA_VERIFY, mechanism, key);
>+}
>+
>+CK_RV
> mock_C_VerifyInit__invalid_handle (CK_SESSION_HANDLE session,
>                                    CK_MECHANISM_PTR mechanism,
>                                    CK_OBJECT_HANDLE key)
>@@ -647,6 +2349,22 @@ mock_C_VerifyInit__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_Verify (CK_SESSION_HANDLE session,
>+               CK_BYTE_PTR data,
>+               CK_ULONG data_len,
>+               CK_BYTE_PTR signature,
>+               CK_ULONG signature_len)
>+{
>+	CK_RV rv;
>+
>+	rv = mock_C_VerifyUpdate (session, data, data_len);
>+	if (rv == CKR_OK)
>+		rv = mock_C_VerifyFinal (session, signature, signature_len);
>+
>+	return rv;
>+}
>+
>+CK_RV
> mock_C_Verify__invalid_handle (CK_SESSION_HANDLE session,
>                                CK_BYTE_PTR data,
>                                CK_ULONG data_len,
>@@ -657,6 +2375,26 @@ mock_C_Verify__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_VerifyUpdate (CK_SESSION_HANDLE session,
>+                     CK_BYTE_PTR part,
>+                     CK_ULONG part_len)
>+{
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+	if (sess->hash_mechanism != CKM_MOCK_PREFIX ||
>+	    sess->hash_method != CKA_VERIFY)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->want_context_login)
>+		return CKR_USER_NOT_LOGGED_IN;
>+
>+	sess->hash_count += part_len;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_VerifyUpdate__invalid_handle (CK_SESSION_HANDLE session,
>                                      CK_BYTE_PTR part,
>                                      CK_ULONG part_len)
>@@ -665,6 +2403,45 @@ mock_C_VerifyUpdate__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_VerifyFinal (CK_SESSION_HANDLE session,
>+                    CK_BYTE_PTR signature,
>+                    CK_ULONG signature_len)
>+{
>+	char buffer[32];
>+	Session *sess;
>+	CK_ULONG length;
>+	int len;
>+
>+	return_val_if_fail (signature, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+	if (sess->hash_mechanism != CKM_MOCK_PREFIX ||
>+	    sess->hash_method != CKA_VERIFY)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->want_context_login)
>+		return CKR_USER_NOT_LOGGED_IN;
>+
>+	len = snprintf (buffer, sizeof (buffer), "%lu", sess->hash_count);
>+	length = sess->n_sign_prefix + len;
>+
>+	if (!signature || signature_len != length)
>+		return CKR_SIGNATURE_LEN_RANGE;
>+
>+	if (memcmp (signature, sess->sign_prefix, sess->n_sign_prefix) != 0 ||
>+	    memcmp (signature + sess->n_sign_prefix, buffer, len) != 0)
>+		return CKR_SIGNATURE_INVALID;
>+
>+	sess->hash_mechanism = 0;
>+	sess->hash_method = 0;
>+	sess->hash_count = 0;
>+	sess->hash_key = 0;
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_VerifyFinal__invalid_handle (CK_SESSION_HANDLE session,
>                                     CK_BYTE_PTR signature,
>                                     CK_ULONG signature_len)
>@@ -673,6 +2450,15 @@ mock_C_VerifyFinal__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_VerifyRecoverInit (CK_SESSION_HANDLE session,
>+                          CK_MECHANISM_PTR mechanism,
>+                          CK_OBJECT_HANDLE key)
>+{
>+	return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
>+	return prefix_mechanism_init (session, CKA_VERIFY_RECOVER, mechanism, key);
>+}
>+
>+CK_RV
> mock_C_VerifyRecoverInit__invalid_handle (CK_SESSION_HANDLE session,
>                                           CK_MECHANISM_PTR mechanism,
>                                           CK_OBJECT_HANDLE key)
>@@ -681,6 +2467,48 @@ mock_C_VerifyRecoverInit__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_VerifyRecover (CK_SESSION_HANDLE session,
>+                      CK_BYTE_PTR signature,
>+                      CK_ULONG signature_len,
>+                      CK_BYTE_PTR data,
>+                      CK_ULONG_PTR data_len)
>+{
>+	Session *sess;
>+	CK_ULONG length;
>+
>+	return_val_if_fail (signature, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+	if (sess->hash_mechanism != CKM_MOCK_PREFIX ||
>+	    sess->hash_method != CKA_VERIFY_RECOVER)
>+		return CKR_OPERATION_NOT_INITIALIZED;
>+	if (sess->want_context_login)
>+		return CKR_USER_NOT_LOGGED_IN;
>+
>+	if (signature_len < sess->n_sign_prefix)
>+		return CKR_SIGNATURE_LEN_RANGE;
>+	if (memcmp (signature, sess->sign_prefix, sess->n_sign_prefix) != 0)
>+		return CKR_SIGNATURE_INVALID;
>+
>+	length = signature_len - sess->n_sign_prefix;
>+	if (!data) {
>+		*data_len = length;
>+		return CKR_OK;
>+	}
>+
>+	if (*data_len < length) {
>+		*data_len = length;
>+		return CKR_BUFFER_TOO_SMALL;
>+	}
>+
>+	*data_len = length;
>+	memcpy (data, signature + sess->n_sign_prefix, length);
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_VerifyRecover__invalid_handle (CK_SESSION_HANDLE session,
>                                       CK_BYTE_PTR signature,
>                                       CK_ULONG signature_len,
>@@ -693,10 +2521,27 @@ mock_C_VerifyRecover__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_DigestEncryptUpdate (CK_SESSION_HANDLE session,
>+                            CK_BYTE_PTR part,
>+                            CK_ULONG part_len,
>+                            CK_BYTE_PTR encrypted_part,
>+                            CK_ULONG_PTR encrypted_part_len)
>+{
>+	CK_RV rv;
>+
>+	rv = mock_C_EncryptUpdate (session, part, part_len, encrypted_part, encrypted_part_len);
>+	if (rv == CKR_OK)
>+		rv = mock_C_DigestUpdate (session, part, part_len);
>+
>+	return rv;
>+}
>+
>+CK_RV
> mock_C_DigestEncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
>                                             CK_BYTE_PTR part,
>-                           CK_ULONG part_len, CK_BYTE_PTR enc_part,
>-                           CK_ULONG_PTR enc_part_len)
>+                                            CK_ULONG part_len,
>+                                            CK_BYTE_PTR enc_part,
>+                                            CK_ULONG_PTR enc_part_len)
> {
> 	return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
> 
>@@ -704,6 +2549,22 @@ mock_C_DigestEncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_DecryptDigestUpdate (CK_SESSION_HANDLE session,
>+                            CK_BYTE_PTR encrypted_part,
>+                            CK_ULONG encrypted_part_len,
>+                            CK_BYTE_PTR part,
>+                            CK_ULONG_PTR part_len)
>+{
>+	CK_RV rv;
>+
>+	rv = mock_C_DecryptUpdate (session, encrypted_part, encrypted_part_len, part, part_len);
>+	if (rv == CKR_OK)
>+		rv = mock_C_DigestUpdate (session, part, *part_len);
>+
>+	return rv;
>+}
>+
>+CK_RV
> mock_C_DecryptDigestUpdate__invalid_handle (CK_SESSION_HANDLE session,
>                                             CK_BYTE_PTR enc_part,
>                                             CK_ULONG enc_part_len,
>@@ -716,6 +2577,22 @@ mock_C_DecryptDigestUpdate__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_SignEncryptUpdate (CK_SESSION_HANDLE session,
>+                          CK_BYTE_PTR part,
>+                          CK_ULONG part_len,
>+                          CK_BYTE_PTR encrypted_part,
>+                          CK_ULONG_PTR encrypted_part_len)
>+{
>+	CK_RV rv;
>+
>+	rv = mock_C_EncryptUpdate (session, part, part_len, encrypted_part, encrypted_part_len);
>+	if (rv == CKR_OK)
>+		rv = mock_C_SignUpdate (session, part, part_len);
>+
>+	return rv;
>+}
>+
>+CK_RV
> mock_C_SignEncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
>                                           CK_BYTE_PTR part,
>                                           CK_ULONG part_len,
>@@ -728,6 +2605,22 @@ mock_C_SignEncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_DecryptVerifyUpdate (CK_SESSION_HANDLE session,
>+                            CK_BYTE_PTR encrypted_part,
>+                            CK_ULONG encrypted_part_len,
>+                            CK_BYTE_PTR part,
>+                            CK_ULONG_PTR part_len)
>+{
>+	CK_RV rv;
>+
>+	rv = mock_C_DecryptUpdate (session, encrypted_part, encrypted_part_len, part, part_len);
>+	if (rv == CKR_OK)
>+		rv = mock_C_VerifyUpdate (session, part, *part_len);
>+
>+	return rv;
>+}
>+
>+CK_RV
> mock_C_DecryptVerifyUpdate__invalid_handle (CK_SESSION_HANDLE session,
>                                             CK_BYTE_PTR enc_part,
>                                             CK_ULONG enc_part_len,
>@@ -740,6 +2633,50 @@ mock_C_DecryptVerifyUpdate__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_GenerateKey (CK_SESSION_HANDLE session,
>+                    CK_MECHANISM_PTR mechanism,
>+                    CK_ATTRIBUTE_PTR template,
>+                    CK_ULONG count,
>+                    CK_OBJECT_HANDLE_PTR key)
>+{
>+	CK_ATTRIBUTE_PTR attrs;
>+	CK_ATTRIBUTE value;
>+	Session *sess;
>+	CK_BBOOL token;
>+
>+	return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
>+	return_val_if_fail (template, CKR_TEMPLATE_INCOMPLETE);
>+	return_val_if_fail (count, CKR_TEMPLATE_INCOMPLETE);
>+	return_val_if_fail (key, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (mechanism->mechanism != CKM_MOCK_GENERATE)
>+		return CKR_MECHANISM_INVALID;
>+
>+	if (!mechanism->pParameter || mechanism->ulParameterLen != 9 ||
>+	    memcmp (mechanism->pParameter, "generate", 9) != 0)
>+		return CKR_MECHANISM_PARAM_INVALID;
>+
>+	value.type = CKA_VALUE;
>+	value.pValue = "generated";
>+	value.ulValueLen = strlen (value.pValue);
>+
>+	attrs = build_attributes (NULL, template, count);
>+	attrs = build_attributes (attrs, &value, 1);
>+
>+	*key = ++unique_identifier;
>+	if (find_boolean_attribute (attrs, CKA_TOKEN, &token) && token)
>+		_p11_hash_set (the_objects, handle_to_pointer (*key), attrs);
>+	else
>+		_p11_hash_set (sess->objects, handle_to_pointer (*key), attrs);
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_GenerateKey__invalid_handle (CK_SESSION_HANDLE session,
>                                     CK_MECHANISM_PTR mechanism,
>                                     CK_ATTRIBUTE_PTR template,
>@@ -750,6 +2687,65 @@ mock_C_GenerateKey__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_GenerateKeyPair (CK_SESSION_HANDLE session,
>+                        CK_MECHANISM_PTR mechanism,
>+                        CK_ATTRIBUTE_PTR public_key_template,
>+                        CK_ULONG public_key_count,
>+                        CK_ATTRIBUTE_PTR private_key_template,
>+                        CK_ULONG private_key_count,
>+                        CK_OBJECT_HANDLE_PTR public_key,
>+                        CK_OBJECT_HANDLE_PTR private_key)
>+{
>+	CK_ATTRIBUTE_PTR attrs;
>+	CK_ATTRIBUTE value;
>+	Session *sess;
>+	CK_BBOOL token;
>+
>+	return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
>+	return_val_if_fail (public_key_template, CKR_TEMPLATE_INCOMPLETE);
>+	return_val_if_fail (public_key_count, CKR_TEMPLATE_INCOMPLETE);
>+	return_val_if_fail (private_key_template, CKR_TEMPLATE_INCOMPLETE);
>+	return_val_if_fail (private_key_count, CKR_TEMPLATE_INCOMPLETE);
>+	return_val_if_fail (public_key, CKR_ARGUMENTS_BAD);
>+	return_val_if_fail (private_key, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (mechanism->mechanism != CKM_MOCK_GENERATE)
>+		return CKR_MECHANISM_INVALID;
>+
>+	if (!mechanism->pParameter || mechanism->ulParameterLen != 9 ||
>+	    memcmp (mechanism->pParameter, "generate", 9) != 0)
>+		return CKR_MECHANISM_PARAM_INVALID;
>+
>+	value.type = CKA_VALUE;
>+	value.pValue = "generated";
>+	value.ulValueLen = strlen (value.pValue);
>+
>+	attrs = build_attributes (NULL, public_key_template, public_key_count);
>+	attrs = build_attributes (attrs, &value, 1);
>+
>+	*public_key = ++unique_identifier;
>+	if (find_boolean_attribute (attrs, CKA_TOKEN, &token) && token)
>+		_p11_hash_set (the_objects, handle_to_pointer (*public_key), attrs);
>+	else
>+		_p11_hash_set (sess->objects, handle_to_pointer (*public_key), attrs);
>+
>+	attrs = build_attributes (NULL, private_key_template, private_key_count);
>+	attrs = build_attributes (attrs, &value, 1);
>+
>+	*private_key = ++unique_identifier;
>+	if (find_boolean_attribute (attrs, CKA_TOKEN, &token) && token)
>+		_p11_hash_set (the_objects, handle_to_pointer (*private_key), attrs);
>+	else
>+		_p11_hash_set (sess->objects, handle_to_pointer (*private_key), attrs);
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_GenerateKeyPair__invalid_handle (CK_SESSION_HANDLE session,
>                                         CK_MECHANISM_PTR mechanism,
>                                         CK_ATTRIBUTE_PTR pub_template,
>@@ -763,6 +2759,69 @@ mock_C_GenerateKeyPair__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_WrapKey (CK_SESSION_HANDLE session,
>+                CK_MECHANISM_PTR mechanism,
>+                CK_OBJECT_HANDLE wrapping_key,
>+                CK_OBJECT_HANDLE key,
>+                CK_BYTE_PTR wrapped_key,
>+                CK_ULONG_PTR wrapped_key_len)
>+{
>+	CK_ATTRIBUTE_PTR attrs;
>+	CK_ATTRIBUTE_PTR attr;
>+	Session *sess;
>+	CK_RV rv;
>+
>+	return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
>+	return_val_if_fail (wrapping_key, CKR_OBJECT_HANDLE_INVALID);
>+	return_val_if_fail (key, CKR_OBJECT_HANDLE_INVALID);
>+	return_val_if_fail (wrapped_key_len, CKR_WRAPPED_KEY_LEN_RANGE);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	rv = lookup_object (sess, wrapping_key, &attrs, NULL);
>+	if (rv == CKR_OBJECT_HANDLE_INVALID)
>+		return CKR_WRAPPING_KEY_HANDLE_INVALID;
>+	else if (rv != CKR_OK)
>+		return rv;
>+
>+	rv = lookup_object (sess, key, &attrs, NULL);
>+	if (rv == CKR_OBJECT_HANDLE_INVALID)
>+		return CKR_WRAPPING_KEY_HANDLE_INVALID;
>+	else if (rv != CKR_OK)
>+		return rv;
>+
>+	if (mechanism->mechanism != CKM_MOCK_WRAP)
>+		return CKR_MECHANISM_INVALID;
>+
>+	if (mechanism->pParameter == NULL ||
>+	    mechanism->ulParameterLen != 4 ||
>+	    memcmp (mechanism->pParameter, "wrap", 4) != 0) {
>+		return CKR_MECHANISM_PARAM_INVALID;
>+	}
>+
>+	attr = find_attribute (attrs, CKA_VALUE);
>+	if (attr == NULL)
>+		return CKR_WRAPPED_KEY_INVALID;
>+
>+	if (!wrapped_key) {
>+		*wrapped_key_len = attr->ulValueLen;
>+		return CKR_OK;
>+	}
>+
>+	if (*wrapped_key_len < attr->ulValueLen) {
>+		*wrapped_key_len = attr->ulValueLen;
>+		return CKR_BUFFER_TOO_SMALL;
>+	}
>+
>+	memcpy (wrapped_key, attr->pValue, attr->ulValueLen);
>+	*wrapped_key_len = attr->ulValueLen;
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_WrapKey__invalid_handle (CK_SESSION_HANDLE session,
>                                 CK_MECHANISM_PTR mechanism,
>                                 CK_OBJECT_HANDLE wrapping_key,
>@@ -776,6 +2835,65 @@ mock_C_WrapKey__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_UnwrapKey (CK_SESSION_HANDLE session,
>+                  CK_MECHANISM_PTR mechanism,
>+                  CK_OBJECT_HANDLE unwrapping_key,
>+                  CK_BYTE_PTR wrapped_key,
>+                  CK_ULONG wrapped_key_len,
>+                  CK_ATTRIBUTE_PTR template,
>+                  CK_ULONG count,
>+                  CK_OBJECT_HANDLE_PTR key)
>+{
>+	CK_ATTRIBUTE_PTR attrs;
>+	CK_ATTRIBUTE value;
>+	Session *sess;
>+	CK_BBOOL token;
>+	CK_RV rv;
>+
>+	return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
>+	return_val_if_fail (unwrapping_key, CKR_WRAPPING_KEY_HANDLE_INVALID);
>+	return_val_if_fail (wrapped_key, CKR_WRAPPED_KEY_INVALID);
>+	return_val_if_fail (wrapped_key_len, CKR_WRAPPED_KEY_LEN_RANGE);
>+	return_val_if_fail (key, CKR_ARGUMENTS_BAD);
>+	return_val_if_fail (template, CKR_TEMPLATE_INCOMPLETE);
>+	return_val_if_fail (count, CKR_TEMPLATE_INCONSISTENT);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	rv = lookup_object (sess, unwrapping_key, &attrs, NULL);
>+	if (rv == CKR_OBJECT_HANDLE_INVALID)
>+		return CKR_WRAPPING_KEY_HANDLE_INVALID;
>+	else if (rv != CKR_OK)
>+		return rv;
>+
>+	if (mechanism->mechanism != CKM_MOCK_WRAP)
>+		return CKR_MECHANISM_INVALID;
>+
>+	if (mechanism->pParameter == NULL ||
>+	    mechanism->ulParameterLen != 4 ||
>+	    memcmp (mechanism->pParameter, "wrap", 4) != 0) {
>+		return CKR_MECHANISM_PARAM_INVALID;
>+	}
>+
>+	value.type = CKA_VALUE;
>+	value.pValue = wrapped_key;
>+	value.ulValueLen = wrapped_key_len;
>+
>+	attrs = build_attributes (NULL, template, count);
>+	attrs = build_attributes (attrs, &value, 1);
>+
>+	*key = ++unique_identifier;
>+	if (find_boolean_attribute (attrs, CKA_TOKEN, &token) && token)
>+		_p11_hash_set (the_objects, handle_to_pointer (*key), attrs);
>+	else
>+		_p11_hash_set (sess->objects, handle_to_pointer (*key), attrs);
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_UnwrapKey__invalid_handle (CK_SESSION_HANDLE session,
>                                   CK_MECHANISM_PTR mechanism,
>                                   CK_OBJECT_HANDLE unwrapping_key,
>@@ -789,6 +2907,60 @@ mock_C_UnwrapKey__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_DeriveKey (CK_SESSION_HANDLE session,
>+                  CK_MECHANISM_PTR mechanism,
>+                  CK_OBJECT_HANDLE base_key,
>+                  CK_ATTRIBUTE_PTR template,
>+                  CK_ULONG count,
>+                  CK_OBJECT_HANDLE_PTR key)
>+{
>+	CK_ATTRIBUTE_PTR attrs, copy;
>+	CK_ATTRIBUTE value;
>+	Session *sess;
>+	CK_BBOOL token;
>+	CK_RV rv;
>+
>+	return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
>+	return_val_if_fail (count, CKR_TEMPLATE_INCOMPLETE);
>+	return_val_if_fail (template, CKR_TEMPLATE_INCOMPLETE);
>+	return_val_if_fail (key, CKR_ARGUMENTS_BAD);
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	rv = lookup_object (sess, base_key, &attrs, NULL);
>+	if (rv == CKR_OBJECT_HANDLE_INVALID)
>+		return CKR_KEY_HANDLE_INVALID;
>+	else if (rv != CKR_OK)
>+		return rv;
>+
>+	if (mechanism->mechanism != CKM_MOCK_DERIVE)
>+		return CKR_MECHANISM_INVALID;
>+
>+	if (mechanism->pParameter == NULL ||
>+	    mechanism->ulParameterLen != 6 ||
>+	    memcmp (mechanism->pParameter, "derive", 6) != 0) {
>+		return CKR_MECHANISM_PARAM_INVALID;
>+	}
>+
>+	value.type = CKA_VALUE;
>+	value.pValue = "derived";
>+	value.ulValueLen = strlen (value.pValue);
>+
>+	copy = build_attributes (NULL, template, count);
>+	copy = build_attributes (copy, &value, 1);
>+
>+	*key = ++unique_identifier;
>+	if (find_boolean_attribute (copy, CKA_TOKEN, &token) && token)
>+		_p11_hash_set (the_objects, handle_to_pointer (*key), copy);
>+	else
>+		_p11_hash_set (sess->objects, handle_to_pointer (*key), copy);
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_DeriveKey__invalid_handle (CK_SESSION_HANDLE session,
>                                   CK_MECHANISM_PTR mechanism,
>                                   CK_OBJECT_HANDLE base_key,
>@@ -800,6 +2972,25 @@ mock_C_DeriveKey__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_SeedRandom (CK_SESSION_HANDLE session,
>+                   CK_BYTE_PTR seed,
>+                   CK_ULONG seed_len)
>+{
>+	Session *sess;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	if (seed_len > sizeof (sess->random_seed))
>+		return CKR_RANDOM_SEED_NOT_SUPPORTED;
>+
>+	memcpy (sess->random_seed, seed, seed_len);
>+	sess->random_seed_len = seed_len;
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_SeedRandom__invalid_handle (CK_SESSION_HANDLE session,
>                                    CK_BYTE_PTR seed,
>                                    CK_ULONG seed_len)
>@@ -808,6 +2999,30 @@ mock_C_SeedRandom__invalid_handle (CK_SESSION_HANDLE session,
> }
> 
> CK_RV
>+mock_C_GenerateRandom (CK_SESSION_HANDLE session,
>+                       CK_BYTE_PTR random_data,
>+                       CK_ULONG random_len)
>+{
>+	Session *sess;
>+	CK_ULONG block;
>+
>+	sess = _p11_hash_get (the_sessions, handle_to_pointer (session));
>+	if (!sess)
>+		return CKR_SESSION_HANDLE_INVALID;
>+
>+	while (random_len > 0) {
>+		block = sess->random_seed_len;
>+		if (block > random_len)
>+			block = random_len;
>+		memcpy (random_data, sess->random_seed, block);
>+		random_data += block;
>+		random_len -= block;
>+	}
>+
>+	return CKR_OK;
>+}
>+
>+CK_RV
> mock_C_GenerateRandom__invalid_handle (CK_SESSION_HANDLE session,
>                                        CK_BYTE_PTR random_data,
>                                        CK_ULONG random_len)
>@@ -887,6 +3102,78 @@ CK_FUNCTION_LIST mock_module_no_slots = {
> 	mock_C_WaitForSlotEvent__no_event,
> };
> 
>+CK_FUNCTION_LIST mock_module = {
>+	{ CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },  /* version */
>+	mock_C_Initialize,
>+	mock_C_Finalize,
>+	mock_C_GetInfo,
>+	mock_C_GetFunctionList,
>+	mock_C_GetSlotList,
>+	mock_C_GetSlotInfo,
>+	mock_C_GetTokenInfo,
>+	mock_C_GetMechanismList,
>+	mock_C_GetMechanismInfo,
>+	mock_C_InitToken__specific_args,
>+	mock_C_InitPIN__specific_args,
>+	mock_C_SetPIN__specific_args,
>+	mock_C_OpenSession,
>+	mock_C_CloseSession,
>+	mock_C_CloseAllSessions,
>+	mock_C_GetSessionInfo,
>+	mock_C_GetOperationState,
>+	mock_C_SetOperationState,
>+	mock_C_Login,
>+	mock_C_Logout,
>+	mock_C_CreateObject,
>+	mock_C_CopyObject,
>+	mock_C_DestroyObject,
>+	mock_C_GetObjectSize,
>+	mock_C_GetAttributeValue,
>+	mock_C_SetAttributeValue,
>+	mock_C_FindObjectsInit,
>+	mock_C_FindObjects,
>+	mock_C_FindObjectsFinal,
>+	mock_C_EncryptInit,
>+	mock_C_Encrypt,
>+	mock_C_EncryptUpdate,
>+	mock_C_EncryptFinal,
>+	mock_C_DecryptInit,
>+	mock_C_Decrypt,
>+	mock_C_DecryptUpdate,
>+	mock_C_DecryptFinal,
>+	mock_C_DigestInit,
>+	mock_C_Digest,
>+	mock_C_DigestUpdate,
>+	mock_C_DigestKey,
>+	mock_C_DigestFinal,
>+	mock_C_SignInit,
>+	mock_C_Sign,
>+	mock_C_SignUpdate,
>+	mock_C_SignFinal,
>+	mock_C_SignRecoverInit,
>+	mock_C_SignRecover,
>+	mock_C_VerifyInit,
>+	mock_C_Verify,
>+	mock_C_VerifyUpdate,
>+	mock_C_VerifyFinal,
>+	mock_C_VerifyRecoverInit,
>+	mock_C_VerifyRecover,
>+	mock_C_DigestEncryptUpdate,
>+	mock_C_DecryptDigestUpdate,
>+	mock_C_SignEncryptUpdate,
>+	mock_C_DecryptVerifyUpdate,
>+	mock_C_GenerateKey,
>+	mock_C_GenerateKeyPair,
>+	mock_C_WrapKey,
>+	mock_C_UnwrapKey,
>+	mock_C_DeriveKey,
>+	mock_C_SeedRandom,
>+	mock_C_GenerateRandom,
>+	mock_C_GetFunctionStatus,
>+	mock_C_CancelFunction,
>+	mock_C_WaitForSlotEvent,
>+};
>+
> void
> mock_module_init (void)
> {
>diff --git a/tests/mock-module.h b/tests/mock-module.h
>index 9557f70..7b1b44b 100644
>--- a/tests/mock-module.h
>+++ b/tests/mock-module.h
>@@ -26,274 +26,594 @@
> 
> #include "pkcs11.h"
> 
>+extern CK_FUNCTION_LIST    mock_module;
>+
> extern CK_FUNCTION_LIST    mock_module_no_slots;
> 
>+/*
>+ * Some dumb crypto mechanisms for simple testing.
>+ *
>+ * CKM_MOCK_CAPITALIZE (encrypt/decrypt)
>+ *     capitalizes to encrypt
>+ *     lowercase to decrypt
>+ *
>+ * CKM_MOCK_PREFIX (sign/verify)
>+ *     sign prefixes data with key label
>+ *     verify unprefixes data with key label.
>+ *
>+ * CKM_MOCK_GENERATE (generate-pair)
>+ *     generates a pair of keys, mechanism param should be 'generate'
>+ *
>+ * CKM_MOCK_WRAP (wrap key)
>+ *     wraps key by returning value, mechanism param should be 'wrap'
>+ *
>+ * CKM_MOCK_DERIVE (derive-key)
>+ *     derives key by setting value to 'derived'.
>+ *     mechanism param should be 'derive'
>+ *
>+ * CKM_MOCK_COUNT (digest)
>+ *     counts the number of bytes, and returns a CK_ULONG 'hash'
>+ */
>+
>+enum {
>+	CKM_MOCK_CAPITALIZE = (CKM_VENDOR_DEFINED | 1),
>+	CKM_MOCK_PREFIX = (CKM_VENDOR_DEFINED | 2),
>+	CKM_MOCK_GENERATE = (CKM_VENDOR_DEFINED | 3),
>+	CKM_MOCK_WRAP = (CKM_VENDOR_DEFINED | 4),
>+	CKM_MOCK_DERIVE = (CKM_VENDOR_DEFINED | 5),
>+	CKM_MOCK_COUNT = (CKM_VENDOR_DEFINED | 6),
>+
>+	MOCK_SLOT_ONE_ID = 52,
>+	MOCK_SLOT_TWO_ID = 134,
>+
>+	MOCK_PRIVATE_KEY_CAPITALIZE = 3,
>+	MOCK_PUBLIC_KEY_CAPITALIZE = 4,
>+	MOCK_PRIVATE_KEY_PREFIX = 5,
>+	MOCK_PUBLIC_KEY_PREFIX = 6
>+};
>+
> void        mock_module_init                              (void);
> 
>+typedef int (* MockEnumerator)                            (CK_OBJECT_HANDLE handle,
>+                                                           CK_ATTRIBUTE_PTR attrs,
>+                                                           CK_ULONG n_attrs,
>+                                                           void *user_data);
>+
>+void        mock_module_enumerate_objects                 (CK_SESSION_HANDLE session,
>+                                                           MockEnumerator func,
>+                                                           void *user_data);
>+
> CK_RV       mock_C_Initialize                             (CK_VOID_PTR init_args);
> 
>+CK_RV       mock_C_Initialize__fails                      (CK_VOID_PTR init_args);
>+
> CK_RV       mock_C_Finalize                               (CK_VOID_PTR reserved);
> 
> CK_RV       mock_C_GetInfo                                (CK_INFO_PTR info);
> 
> CK_RV       mock_C_GetFunctionList                        (CK_FUNCTION_LIST_PTR_PTR list);
> 
>+CK_RV       mock_C_GetSlotList                            (CK_BBOOL token_present,
>+                                                           CK_SLOT_ID_PTR slot_list,
>+                                                           CK_ULONG_PTR count);
>+
> CK_RV       mock_C_GetSlotList__no_tokens                 (CK_BBOOL token_present,
>                                                            CK_SLOT_ID_PTR slot_list,
>                                                            CK_ULONG_PTR count);
> 
>-CK_RV       mock_C_GetSlotInfo__invalid_slotid            (CK_SLOT_ID id,
>+CK_RV       mock_C_GetSlotInfo                            (CK_SLOT_ID slot_id,
>+                                                           CK_SLOT_INFO_PTR info);
>+
>+CK_RV       mock_C_GetSlotInfo__invalid_slotid            (CK_SLOT_ID slot_id,
>                                                            CK_SLOT_INFO_PTR info);
> 
>-CK_RV       mock_C_GetTokenInfo__invalid_slotid           (CK_SLOT_ID id,
>+CK_RV       mock_C_GetTokenInfo                           (CK_SLOT_ID slot_id,
>                                                            CK_TOKEN_INFO_PTR info);
> 
>-CK_RV       mock_C_GetMechanismList__invalid_slotid       (CK_SLOT_ID id,
>+CK_RV       mock_C_GetTokenInfo__invalid_slotid           (CK_SLOT_ID slot_id,
>+                                                           CK_TOKEN_INFO_PTR info);
>+
>+CK_RV       mock_C_GetMechanismList                       (CK_SLOT_ID slot_id,
>+                                                           CK_MECHANISM_TYPE_PTR mechanism_list,
>+                                                           CK_ULONG_PTR count);
>+
>+CK_RV       mock_C_GetMechanismList__invalid_slotid       (CK_SLOT_ID slot_id,
>                                                            CK_MECHANISM_TYPE_PTR mechanism_list,
>                                                            CK_ULONG_PTR count);
> 
>-CK_RV       mock_C_GetMechanismInfo__invalid_slotid       (CK_SLOT_ID id,
>+CK_RV       mock_C_GetMechanismInfo                       (CK_SLOT_ID slot_id,
>+                                                           CK_MECHANISM_TYPE type,
>+                                                           CK_MECHANISM_INFO_PTR info);
>+
>+CK_RV       mock_C_GetMechanismInfo__invalid_slotid       (CK_SLOT_ID slot_id,
>                                                            CK_MECHANISM_TYPE type,
>                                                            CK_MECHANISM_INFO_PTR info);
> 
>-CK_RV       mock_C_InitToken__invalid_slotid              (CK_SLOT_ID id,
>+CK_RV       mock_C_InitToken__specific_args               (CK_SLOT_ID slot_id,
>+                                                           CK_UTF8CHAR_PTR pin,
>+                                                           CK_ULONG pin_len,
>+                                                           CK_UTF8CHAR_PTR label);
>+
>+CK_RV       mock_C_InitToken__invalid_slotid              (CK_SLOT_ID slot_id,
>                                                            CK_UTF8CHAR_PTR pin,
>                                                            CK_ULONG pin_len,
>                                                            CK_UTF8CHAR_PTR label);
> 
>+CK_RV       mock_C_WaitForSlotEvent                       (CK_FLAGS flags,
>+                                                           CK_SLOT_ID_PTR slot,
>+                                                           CK_VOID_PTR reserved);
>+
> CK_RV       mock_C_WaitForSlotEvent__no_event             (CK_FLAGS flags,
>                                                            CK_SLOT_ID_PTR slot,
>                                                            CK_VOID_PTR reserved);
> 
>-CK_RV       mock_C_OpenSession__invalid_slotid            (CK_SLOT_ID id,
>+CK_RV       mock_C_OpenSession__invalid_slotid            (CK_SLOT_ID slot_id,
>                                                            CK_FLAGS flags,
>                                                            CK_VOID_PTR user_data,
>                                                            CK_NOTIFY callback,
>                                                            CK_SESSION_HANDLE_PTR session);
> 
>+CK_RV       mock_C_OpenSession                            (CK_SLOT_ID slot_id,
>+                                                           CK_FLAGS flags,
>+                                                           CK_VOID_PTR user_data,
>+                                                           CK_NOTIFY callback,
>+                                                           CK_SESSION_HANDLE_PTR session);
>+
>+CK_RV       mock_C_CloseSession                           (CK_SESSION_HANDLE session);
>+
> CK_RV       mock_C_CloseSession__invalid_handle           (CK_SESSION_HANDLE session);
> 
>-CK_RV       mock_C_CloseAllSessions__invalid_slotid       (CK_SLOT_ID id);
>+CK_RV       mock_C_CloseAllSessions                       (CK_SLOT_ID slot_id);
>+
>+CK_RV       mock_C_CloseAllSessions__invalid_slotid       (CK_SLOT_ID slot_id);
>+
>+CK_RV       mock_C_GetFunctionStatus                      (CK_SESSION_HANDLE session);
> 
> CK_RV       mock_C_GetFunctionStatus__not_parallel        (CK_SESSION_HANDLE session);
> 
>+CK_RV       mock_C_CancelFunction                         (CK_SESSION_HANDLE session);
>+
> CK_RV       mock_C_CancelFunction__not_parallel           (CK_SESSION_HANDLE session);
> 
>+CK_RV       mock_C_GetSessionInfo                         (CK_SESSION_HANDLE session,
>+                                                           CK_SESSION_INFO_PTR info);
>+
> CK_RV       mock_C_GetSessionInfo__invalid_handle         (CK_SESSION_HANDLE session,
>                                                            CK_SESSION_INFO_PTR info);
> 
>+CK_RV       mock_C_InitPIN__specific_args                 (CK_SESSION_HANDLE session,
>+                                                           CK_UTF8CHAR_PTR pin,
>+                                                           CK_ULONG pin_len);
>+
> CK_RV       mock_C_InitPIN__invalid_handle                (CK_SESSION_HANDLE session,
>                                                            CK_UTF8CHAR_PTR pin,
>                                                            CK_ULONG pin_len);
> 
>+CK_RV       mock_C_SetPIN__specific_args                  (CK_SESSION_HANDLE session,
>+                                                           CK_UTF8CHAR_PTR old_pin,
>+                                                           CK_ULONG old_pin_len,
>+                                                           CK_UTF8CHAR_PTR new_pin,
>+                                                           CK_ULONG new_pin_len);
>+
> CK_RV       mock_C_SetPIN__invalid_handle                 (CK_SESSION_HANDLE session,
>                                                            CK_UTF8CHAR_PTR old_pin,
>                                                            CK_ULONG old_pin_len,
>                                                            CK_UTF8CHAR_PTR new_pin,
>                                                            CK_ULONG new_pin_len);
> 
>+CK_RV       mock_C_GetOperationState                      (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR operation_state,
>+                                                           CK_ULONG_PTR operation_state_len);
>+
> CK_RV       mock_C_GetOperationState__invalid_handle      (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR operation_state,
>                                                            CK_ULONG_PTR operation_state_len);
> 
>+CK_RV       mock_C_SetOperationState                      (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR operation_state,
>+                                                           CK_ULONG operation_state_len,
>+                                                           CK_OBJECT_HANDLE encryption_key,
>+                                                           CK_OBJECT_HANDLE authentication_key);
>+
> CK_RV       mock_C_SetOperationState__invalid_handle      (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR operation_state,
>                                                            CK_ULONG operation_state_len,
>                                                            CK_OBJECT_HANDLE encryption_key,
>                                                            CK_OBJECT_HANDLE authentication_key);
> 
>+CK_RV       mock_C_Login                                  (CK_SESSION_HANDLE session,
>+                                                           CK_USER_TYPE user_type,
>+                                                           CK_UTF8CHAR_PTR pin,
>+                                                           CK_ULONG pin_len);
>+
> CK_RV       mock_C_Login__invalid_handle                  (CK_SESSION_HANDLE session,
>                                                            CK_USER_TYPE user_type,
>                                                            CK_UTF8CHAR_PTR pin,
>                                                            CK_ULONG pin_len);
> 
>+CK_RV       mock_C_Logout                                 (CK_SESSION_HANDLE session);
>+
> CK_RV       mock_C_Logout__invalid_handle                 (CK_SESSION_HANDLE session);
> 
>+CK_RV       mock_C_CreateObject                           (CK_SESSION_HANDLE session,
>+                                                           CK_ATTRIBUTE_PTR template,
>+                                                           CK_ULONG count,
>+                                                           CK_OBJECT_HANDLE_PTR object);
>+
> CK_RV       mock_C_CreateObject__invalid_handle           (CK_SESSION_HANDLE session,
>                                                            CK_ATTRIBUTE_PTR template,
>                                                            CK_ULONG count,
>                                                            CK_OBJECT_HANDLE_PTR new_object);
> 
>+CK_RV       mock_C_CopyObject                             (CK_SESSION_HANDLE session,
>+                                                           CK_OBJECT_HANDLE object,
>+                                                           CK_ATTRIBUTE_PTR template,
>+                                                           CK_ULONG count,
>+                                                           CK_OBJECT_HANDLE_PTR new_object);
>+
> CK_RV       mock_C_CopyObject__invalid_handle             (CK_SESSION_HANDLE session,
>                                                            CK_OBJECT_HANDLE object,
>                                                            CK_ATTRIBUTE_PTR template,
>                                                            CK_ULONG count,
>                                                            CK_OBJECT_HANDLE_PTR new_object);
> 
>+CK_RV       mock_C_DestroyObject                          (CK_SESSION_HANDLE session,
>+                                                           CK_OBJECT_HANDLE object);
>+
> CK_RV       mock_C_DestroyObject__invalid_handle          (CK_SESSION_HANDLE session,
>                                                            CK_OBJECT_HANDLE object);
> 
>+CK_RV       mock_C_GetObjectSize                          (CK_SESSION_HANDLE session,
>+                                                           CK_OBJECT_HANDLE object,
>+                                                           CK_ULONG_PTR size);
>+
> CK_RV       mock_C_GetObjectSize__invalid_handle          (CK_SESSION_HANDLE session,
>                                                            CK_OBJECT_HANDLE object,
>                                                            CK_ULONG_PTR size);
> 
>+CK_RV       mock_C_GetAttributeValue                      (CK_SESSION_HANDLE session,
>+                                                           CK_OBJECT_HANDLE object,
>+                                                           CK_ATTRIBUTE_PTR template,
>+                                                           CK_ULONG count);
>+
> CK_RV       mock_C_GetAttributeValue__invalid_handle      (CK_SESSION_HANDLE session,
>                                                            CK_OBJECT_HANDLE object,
>                                                            CK_ATTRIBUTE_PTR template,
>                                                            CK_ULONG count);
> 
>+CK_RV       mock_C_SetAttributeValue                      (CK_SESSION_HANDLE session,
>+                                                           CK_OBJECT_HANDLE object,
>+                                                           CK_ATTRIBUTE_PTR template,
>+                                                           CK_ULONG count);
>+
> CK_RV       mock_C_SetAttributeValue__invalid_handle      (CK_SESSION_HANDLE session,
>                                                            CK_OBJECT_HANDLE object,
>                                                            CK_ATTRIBUTE_PTR template,
>                                                            CK_ULONG count);
> 
>+CK_RV       mock_C_FindObjectsInit                        (CK_SESSION_HANDLE session,
>+                                                           CK_ATTRIBUTE_PTR template,
>+                                                           CK_ULONG count);
>+
> CK_RV       mock_C_FindObjectsInit__invalid_handle        (CK_SESSION_HANDLE session,
>                                                            CK_ATTRIBUTE_PTR template,
>                                                            CK_ULONG count);
> 
>+CK_RV       mock_C_FindObjects                            (CK_SESSION_HANDLE session,
>+                                                           CK_OBJECT_HANDLE_PTR objects,
>+                                                           CK_ULONG max_object_count,
>+                                                           CK_ULONG_PTR object_count);
>+
> CK_RV       mock_C_FindObjects__invalid_handle            (CK_SESSION_HANDLE session,
>                                                            CK_OBJECT_HANDLE_PTR objects,
>                                                            CK_ULONG max_count,
>                                                            CK_ULONG_PTR count);
> 
>+CK_RV       mock_C_FindObjectsFinal                       (CK_SESSION_HANDLE session);
>+
> CK_RV       mock_C_FindObjectsFinal__invalid_handle       (CK_SESSION_HANDLE session);
> 
>+CK_RV       mock_C_EncryptInit                            (CK_SESSION_HANDLE session,
>+                                                           CK_MECHANISM_PTR mechanism,
>+                                                           CK_OBJECT_HANDLE key);
>+
> CK_RV       mock_C_EncryptInit__invalid_handle            (CK_SESSION_HANDLE session,
>                                                            CK_MECHANISM_PTR mechanism,
>                                                            CK_OBJECT_HANDLE key);
> 
>+CK_RV       mock_C_Encrypt                                (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR data,
>+                                                           CK_ULONG data_len,
>+                                                           CK_BYTE_PTR encrypted_data,
>+                                                           CK_ULONG_PTR encrypted_data_len);
>+
> CK_RV       mock_C_Encrypt__invalid_handle                (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR data,
>                                                            CK_ULONG data_len,
>                                                            CK_BYTE_PTR encrypted_data,
>                                                            CK_ULONG_PTR encrypted_data_len);
> 
>+CK_RV       mock_C_EncryptUpdate                          (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR part,
>+                                                           CK_ULONG part_len,
>+                                                           CK_BYTE_PTR encrypted_part,
>+                                                           CK_ULONG_PTR encrypted_part_len);
>+
> CK_RV       mock_C_EncryptUpdate__invalid_handle          (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR part,
>                                                            CK_ULONG part_len,
>                                                            CK_BYTE_PTR encrypted_part,
>                                                            CK_ULONG_PTR encrypted_part_len);
> 
>+CK_RV       mock_C_EncryptFinal                           (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR last_encrypted_part,
>+                                                           CK_ULONG_PTR last_encrypted_part_len);
>+
> CK_RV       mock_C_EncryptFinal__invalid_handle           (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR last_part,
>                                                            CK_ULONG_PTR last_part_len);
> 
>+CK_RV       mock_C_DecryptInit                            (CK_SESSION_HANDLE session,
>+                                                           CK_MECHANISM_PTR mechanism,
>+                                                           CK_OBJECT_HANDLE key);
>+
> CK_RV       mock_C_DecryptInit__invalid_handle            (CK_SESSION_HANDLE session,
>                                                            CK_MECHANISM_PTR mechanism,
>                                                            CK_OBJECT_HANDLE key);
> 
>+CK_RV       mock_C_Decrypt                                (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR encrypted_data,
>+                                                           CK_ULONG encrypted_data_len,
>+                                                           CK_BYTE_PTR data,
>+                                                           CK_ULONG_PTR data_len);
>+
> CK_RV       mock_C_Decrypt__invalid_handle                (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR enc_data,
>                                                            CK_ULONG enc_data_len,
>                                                            CK_BYTE_PTR data,
>                                                            CK_ULONG_PTR data_len);
> 
>+CK_RV       mock_C_DecryptUpdate                          (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR encrypted_part,
>+                                                           CK_ULONG encrypted_part_len,
>+                                                           CK_BYTE_PTR part,
>+                                                           CK_ULONG_PTR part_len);
>+
> CK_RV       mock_C_DecryptUpdate__invalid_handle          (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR enc_part,
>                                                            CK_ULONG enc_part_len,
>                                                            CK_BYTE_PTR part,
>                                                            CK_ULONG_PTR part_len);
> 
>+CK_RV       mock_C_DecryptFinal                           (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR last_part,
>+                                                           CK_ULONG_PTR last_part_len);
>+
> CK_RV       mock_C_DecryptFinal__invalid_handle           (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR last_part,
>                                                            CK_ULONG_PTR last_part_len);
> 
>+CK_RV       mock_C_DigestInit                             (CK_SESSION_HANDLE session,
>+                                                           CK_MECHANISM_PTR mechanism);
>+
> CK_RV       mock_C_DigestInit__invalid_handle             (CK_SESSION_HANDLE session,
>                                                            CK_MECHANISM_PTR mechanism);
> 
>+CK_RV       mock_C_Digest                                 (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR data,
>+                                                           CK_ULONG data_len,
>+                                                           CK_BYTE_PTR digest,
>+                                                           CK_ULONG_PTR digest_len);
>+
> CK_RV       mock_C_Digest__invalid_handle                 (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR data,
>                                                            CK_ULONG data_len,
>                                                            CK_BYTE_PTR digest,
>                                                            CK_ULONG_PTR digest_len);
> 
>+CK_RV       mock_C_DigestUpdate                            (CK_SESSION_HANDLE session,
>+                                                            CK_BYTE_PTR part,
>+                                                            CK_ULONG part_len);
>+
> CK_RV       mock_C_DigestUpdate__invalid_handle           (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR part,
>                                                            CK_ULONG part_len);
> 
>+CK_RV       mock_C_DigestKey                              (CK_SESSION_HANDLE session,
>+                                                           CK_OBJECT_HANDLE key);
>+
> CK_RV       mock_C_DigestKey__invalid_handle              (CK_SESSION_HANDLE session,
>                                                            CK_OBJECT_HANDLE key);
> 
>+CK_RV       mock_C_DigestFinal                            (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR digest,
>+                                                           CK_ULONG_PTR digest_len);
>+
> CK_RV       mock_C_DigestFinal__invalid_handle            (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR digest,
>                                                            CK_ULONG_PTR digest_len);
> 
>+CK_RV       mock_C_SignInit                               (CK_SESSION_HANDLE session,
>+                                                           CK_MECHANISM_PTR mechanism,
>+                                                           CK_OBJECT_HANDLE key);
>+
> CK_RV       mock_C_SignInit__invalid_handle               (CK_SESSION_HANDLE session,
>                                                            CK_MECHANISM_PTR mechanism,
>                                                            CK_OBJECT_HANDLE key);
> 
>+CK_RV       mock_C_Sign                                   (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR data,
>+                                                           CK_ULONG data_len,
>+                                                           CK_BYTE_PTR signature,
>+                                                           CK_ULONG_PTR signature_len);
>+
> CK_RV       mock_C_Sign__invalid_handle                   (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR data,
>                                                            CK_ULONG data_len,
>                                                            CK_BYTE_PTR signature,
>                                                            CK_ULONG_PTR signature_len);
> 
>+CK_RV       mock_C_SignUpdate                             (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR part,
>+                                                           CK_ULONG part_len);
>+
> CK_RV       mock_C_SignUpdate__invalid_handle             (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR part,
>                                                            CK_ULONG part_len);
> 
>+CK_RV       mock_C_SignFinal                              (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR signature,
>+                                                           CK_ULONG_PTR signature_len);
>+
> CK_RV       mock_C_SignFinal__invalid_handle              (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR signature,
>                                                            CK_ULONG_PTR signature_len);
> 
>+CK_RV       mock_C_SignRecoverInit                        (CK_SESSION_HANDLE session,
>+                                                           CK_MECHANISM_PTR mechanism,
>+                                                           CK_OBJECT_HANDLE key);
>+
> CK_RV       mock_C_SignRecoverInit__invalid_handle        (CK_SESSION_HANDLE session,
>                                                            CK_MECHANISM_PTR mechanism,
>                                                            CK_OBJECT_HANDLE key);
> 
>+CK_RV       mock_C_SignRecover                            (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR data,
>+                                                           CK_ULONG data_len,
>+                                                           CK_BYTE_PTR signature,
>+                                                           CK_ULONG_PTR signature_len);
>+
> CK_RV       mock_C_SignRecover__invalid_handle            (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR data,
>                                                            CK_ULONG data_len,
>                                                            CK_BYTE_PTR signature,
>                                                            CK_ULONG_PTR signature_len);
> 
>+CK_RV       mock_C_VerifyInit                             (CK_SESSION_HANDLE session,
>+                                                           CK_MECHANISM_PTR mechanism,
>+                                                           CK_OBJECT_HANDLE key);
>+
> CK_RV       mock_C_VerifyInit__invalid_handle             (CK_SESSION_HANDLE session,
>                                                            CK_MECHANISM_PTR mechanism,
>                                                            CK_OBJECT_HANDLE key);
> 
>+CK_RV       mock_C_Verify                                 (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR data,
>+                                                           CK_ULONG data_len,
>+                                                           CK_BYTE_PTR signature,
>+                                                           CK_ULONG signature_len);
>+
> CK_RV       mock_C_Verify__invalid_handle                 (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR data,
>                                                            CK_ULONG data_len,
>                                                            CK_BYTE_PTR signature,
>                                                            CK_ULONG signature_len);
> 
>+CK_RV       mock_C_VerifyUpdate                           (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR part,
>+                                                           CK_ULONG part_len);
>+
> CK_RV       mock_C_VerifyUpdate__invalid_handle           (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR part,
>                                                            CK_ULONG part_len);
> 
>+CK_RV       mock_C_VerifyFinal                            (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR signature,
>+                                                           CK_ULONG signature_len);
>+
> CK_RV       mock_C_VerifyFinal__invalid_handle            (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR signature,
>                                                            CK_ULONG signature_len);
> 
>+CK_RV       mock_C_VerifyRecoverInit                      (CK_SESSION_HANDLE session,
>+                                                           CK_MECHANISM_PTR mechanism,
>+                                                           CK_OBJECT_HANDLE key);
>+
> CK_RV       mock_C_VerifyRecoverInit__invalid_handle      (CK_SESSION_HANDLE session,
>                                                            CK_MECHANISM_PTR mechanism,
>                                                            CK_OBJECT_HANDLE key);
> 
>+CK_RV       mock_C_VerifyRecover                          (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR signature,
>+                                                           CK_ULONG signature_len,
>+                                                           CK_BYTE_PTR data,
>+                                                           CK_ULONG_PTR data_len);
>+
> CK_RV       mock_C_VerifyRecover__invalid_handle          (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR signature,
>                                                            CK_ULONG signature_len,
>                                                            CK_BYTE_PTR data,
>                                                            CK_ULONG_PTR data_len);
> 
>+CK_RV       mock_C_DigestEncryptUpdate                    (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR part,
>+                                                           CK_ULONG part_len,
>+                                                           CK_BYTE_PTR encrypted_part,
>+                                                           CK_ULONG_PTR encrypted_part_len);
>+
> CK_RV       mock_C_DigestEncryptUpdate__invalid_handle    (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR part,
>                                                            CK_ULONG part_len,
>                                                            CK_BYTE_PTR enc_part,
>                                                            CK_ULONG_PTR enc_part_len);
> 
>+CK_RV       mock_C_DecryptDigestUpdate                    (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR encrypted_part,
>+                                                           CK_ULONG encrypted_part_len,
>+                                                           CK_BYTE_PTR part,
>+                                                           CK_ULONG_PTR part_len);
>+
> CK_RV       mock_C_DecryptDigestUpdate__invalid_handle    (CK_SESSION_HANDLE session,
>                                                            CK_BYTE_PTR enc_part,
>                                                            CK_ULONG enc_part_len,
>                                                            CK_BYTE_PTR part,
>                                                            CK_ULONG_PTR part_len);
> 
>+CK_RV       mock_C_SignEncryptUpdate                      (CK_SESSION_HANDLE session,
>+                                                           CK_BYTE_PTR part,
>+                                                           CK_ULONG part_len,
>+                                                           CK_BYTE_PTR encrypted_part,
>+                                                           CK_ULONG_PTR encrypted_part_len);
>+
> CK_RV       mock_C_SignEncryptUpdate__invalid_handle       (CK_SESSION_HANDLE session,
>                                                             CK_BYTE_PTR part,
>                                                             CK_ULONG part_len,
>                                                             CK_BYTE_PTR enc_part,
>                                                             CK_ULONG_PTR enc_part_len);
> 
>+CK_RV       mock_C_DecryptVerifyUpdate                     (CK_SESSION_HANDLE session,
>+                                                            CK_BYTE_PTR encrypted_part,
>+                                                            CK_ULONG encrypted_part_len,
>+                                                            CK_BYTE_PTR part,
>+                                                            CK_ULONG_PTR part_len);
>+
> CK_RV       mock_C_DecryptVerifyUpdate__invalid_handle     (CK_SESSION_HANDLE session,
>                                                             CK_BYTE_PTR enc_part,
>                                                             CK_ULONG enc_part_len,
>                                                             CK_BYTE_PTR part,
>                                                             CK_ULONG_PTR part_len);
> 
>+CK_RV       mock_C_GenerateKey                             (CK_SESSION_HANDLE session,
>+                                                            CK_MECHANISM_PTR mechanism,
>+                                                            CK_ATTRIBUTE_PTR template,
>+                                                            CK_ULONG count,
>+                                                            CK_OBJECT_HANDLE_PTR key);
>+
> CK_RV       mock_C_GenerateKey__invalid_handle             (CK_SESSION_HANDLE session,
>                                                             CK_MECHANISM_PTR mechanism,
>                                                             CK_ATTRIBUTE_PTR template,
>                                                             CK_ULONG count,
>                                                             CK_OBJECT_HANDLE_PTR key);
> 
>+CK_RV       mock_C_GenerateKeyPair                         (CK_SESSION_HANDLE session,
>+                                                            CK_MECHANISM_PTR mechanism,
>+                                                            CK_ATTRIBUTE_PTR public_key_template,
>+                                                            CK_ULONG public_key_count,
>+                                                            CK_ATTRIBUTE_PTR private_key_template,
>+                                                            CK_ULONG private_key_count,
>+                                                            CK_OBJECT_HANDLE_PTR public_key,
>+                                                            CK_OBJECT_HANDLE_PTR private_key);
>+
> CK_RV       mock_C_GenerateKeyPair__invalid_handle         (CK_SESSION_HANDLE session,
>                                                             CK_MECHANISM_PTR mechanism,
>                                                             CK_ATTRIBUTE_PTR pub_template,
>@@ -303,6 +623,13 @@ CK_RV       mock_C_GenerateKeyPair__invalid_handle         (CK_SESSION_HANDLE se
>                                                             CK_OBJECT_HANDLE_PTR pub_key,
>                                                             CK_OBJECT_HANDLE_PTR priv_key);
> 
>+CK_RV       mock_C_WrapKey                                 (CK_SESSION_HANDLE session,
>+                                                            CK_MECHANISM_PTR mechanism,
>+                                                            CK_OBJECT_HANDLE wrapping_key,
>+                                                            CK_OBJECT_HANDLE key,
>+                                                            CK_BYTE_PTR wrapped_key,
>+                                                            CK_ULONG_PTR wrapped_key_len);
>+
> CK_RV       mock_C_WrapKey__invalid_handle                 (CK_SESSION_HANDLE session,
>                                                             CK_MECHANISM_PTR mechanism,
>                                                             CK_OBJECT_HANDLE wrapping_key,
>@@ -310,6 +637,15 @@ CK_RV       mock_C_WrapKey__invalid_handle                 (CK_SESSION_HANDLE se
>                                                             CK_BYTE_PTR wrapped_key,
>                                                             CK_ULONG_PTR wrapped_key_len);
> 
>+CK_RV       mock_C_UnwrapKey                               (CK_SESSION_HANDLE session,
>+                                                            CK_MECHANISM_PTR mechanism,
>+                                                            CK_OBJECT_HANDLE unwrapping_key,
>+                                                            CK_BYTE_PTR wrapped_key,
>+                                                            CK_ULONG wrapped_key_len,
>+                                                            CK_ATTRIBUTE_PTR template,
>+                                                            CK_ULONG count,
>+                                                            CK_OBJECT_HANDLE_PTR key);
>+
> CK_RV       mock_C_UnwrapKey__invalid_handle               (CK_SESSION_HANDLE session,
>                                                             CK_MECHANISM_PTR mechanism,
>                                                             CK_OBJECT_HANDLE unwrapping_key,
>@@ -319,6 +655,13 @@ CK_RV       mock_C_UnwrapKey__invalid_handle               (CK_SESSION_HANDLE se
>                                                             CK_ULONG count,
>                                                             CK_OBJECT_HANDLE_PTR key);
> 
>+CK_RV       mock_C_DeriveKey                               (CK_SESSION_HANDLE session,
>+                                                            CK_MECHANISM_PTR mechanism,
>+                                                            CK_OBJECT_HANDLE base_key,
>+                                                            CK_ATTRIBUTE_PTR template,
>+                                                            CK_ULONG count,
>+                                                            CK_OBJECT_HANDLE_PTR key);
>+
> CK_RV       mock_C_DeriveKey__invalid_handle               (CK_SESSION_HANDLE session,
>                                                             CK_MECHANISM_PTR mechanism,
>                                                             CK_OBJECT_HANDLE base_key,
>@@ -326,10 +669,18 @@ CK_RV       mock_C_DeriveKey__invalid_handle               (CK_SESSION_HANDLE se
>                                                             CK_ULONG count,
>                                                             CK_OBJECT_HANDLE_PTR key);
> 
>+CK_RV       mock_C_SeedRandom                              (CK_SESSION_HANDLE session,
>+                                                            CK_BYTE_PTR seed,
>+                                                            CK_ULONG seed_len);
>+
> CK_RV       mock_C_SeedRandom__invalid_handle              (CK_SESSION_HANDLE session,
>                                                             CK_BYTE_PTR seed,
>                                                             CK_ULONG seed_len);
> 
>+CK_RV       mock_C_GenerateRandom                          (CK_SESSION_HANDLE session,
>+                                                            CK_BYTE_PTR random_data,
>+                                                            CK_ULONG random_len);
>+
> CK_RV       mock_C_GenerateRandom__invalid_handle          (CK_SESSION_HANDLE session,
>                                                             CK_BYTE_PTR random_data,
>                                                             CK_ULONG random_len);
>diff --git a/tests/test-buffer.c b/tests/test-buffer.c
>index b9a9927..8af6ac8 100644
>--- a/tests/test-buffer.c
>+++ b/tests/test-buffer.c
>@@ -53,8 +53,8 @@ test_init_uninit (CuTest *tc)
> 	CuAssertIntEquals (tc, 0, buffer.buf.length);
> 	CuAssertIntEquals (tc, 0, buffer.buf.flags);
> 	CuAssertTrue (tc, buffer.allocated >= 10);
>-	CuAssertPtrNotNull (tc, buffer.free);
>-	CuAssertPtrNotNull (tc, buffer.realloc);
>+	CuAssertPtrNotNull (tc, buffer.ffree);
>+	CuAssertPtrNotNull (tc, buffer.frealloc);
> 
> 	CuAssertPtrEquals (tc, _p11_buffer_to_output (&buffer.buf), &buffer);
> 
>@@ -75,8 +75,8 @@ test_new_free (CuTest *tc)
> 	CuAssertIntEquals (tc, 0, buf->length);
> 	CuAssertIntEquals (tc, 0, buf->flags);
> 	CuAssertTrue (tc, buffer->allocated == 0);
>-	CuAssertPtrNotNull (tc, buffer->free);
>-	CuAssertPtrNotNull (tc, buffer->realloc);
>+	CuAssertPtrNotNull (tc, buffer->ffree);
>+	CuAssertPtrNotNull (tc, buffer->frealloc);
> 
> 	p11_buffer_free (buf);
> }
>@@ -136,8 +136,8 @@ test_init_for_data (CuTest *tc)
> 	CuAssertIntEquals (tc, 4, buffer.buf.length);
> 	CuAssertIntEquals (tc, 0, buffer.buf.flags);
> 	CuAssertIntEquals (tc, 4, buffer.allocated);
>-	CuAssertPtrEquals (tc, mock_free, buffer.free);
>-	CuAssertPtrEquals (tc, mock_realloc, buffer.realloc);
>+	CuAssertPtrEquals (tc, mock_free, buffer.ffree);
>+	CuAssertPtrEquals (tc, mock_realloc, buffer.frealloc);
> 
> 	CuAssertIntEquals (tc, 0, mock_realloced);
> 	CuAssertIntEquals (tc, 0, mock_freed);
>diff --git a/tests/test-init.c b/tests/test-init.c
>index d872afa..506d602 100644
>--- a/tests/test-init.c
>+++ b/tests/test-init.c
>@@ -280,7 +280,7 @@ test_load_and_initialize (CuTest *tc)
> 	rv = (module->C_GetInfo) (&info);
> 	CuAssertTrue (tc, rv == CKR_OK);
> 
>-	ret = memcmp (info.manufacturerID, "MOCK MANUFACTURER              ", 32);
>+	ret = memcmp (info.manufacturerID, "MOCK MANUFACTURER               ", 32);
> 	CuAssertTrue (tc, ret == 0);
> 
> 	rv = p11_kit_finalize_module (module);
>diff --git a/tests/test-rpc.c b/tests/test-rpc.c
>new file mode 100644
>index 0000000..b4bc614
>--- /dev/null
>+++ b/tests/test-rpc.c
>@@ -0,0 +1,2275 @@
>+/*
>+ * Copyright (c) 2012 Stefan Walter
>+ * Copyright (c) 2012 Red Hat Inc.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ *
>+ *     * Redistributions of source code must retain the above
>+ *       copyright notice, this list of conditions and the
>+ *       following disclaimer.
>+ *     * Redistributions in binary form must reproduce the
>+ *       above copyright notice, this list of conditions and
>+ *       the following disclaimer in the documentation and/or
>+ *       other materials provided with the distribution.
>+ *     * The names of contributors to this software may not be
>+ *       used to endorse or promote products derived from this
>+ *       software without specific prior written permission.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
>+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
>+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
>+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
>+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
>+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
>+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
>+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
>+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
>+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
>+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
>+ * DAMAGE.
>+ *
>+ * Author: Stef Walter <stef@thewalter.net>
>+ */
>+
>+#include "config.h"
>+#include "CuTest.h"
>+
>+#include <sys/types.h>
>+
>+#include "p11-kit/p11-kit.h"
>+#include "p11-kit/private.h"
>+#include "p11-kit/rpc.h"
>+#include "p11-kit/rpc-private.h"
>+
>+#include "mock-module.h"
>+
>+#include <assert.h>
>+#include <string.h>
>+#include <stdio.h>
>+#include <stdlib.h>
>+
>+static CK_FUNCTION_LIST module;
>+static int rpc_initialized = 0;
>+
>+static CK_RV
>+rpc_initialize (P11RpcClientVtable *vtable,
>+                void *init_reserved)
>+{
>+	CuTest *tc = vtable->data;
>+
>+	CuAssertIntEquals (tc, 0, rpc_initialized);
>+	rpc_initialized = 1;
>+
>+	return CKR_OK;
>+}
>+
>+static CK_RV
>+rpc_initialize_fails (P11RpcClientVtable *vtable,
>+                      void *init_reserved)
>+{
>+	CuTest *tc = vtable->data;
>+
>+	CuAssertIntEquals (tc, 0, rpc_initialized);
>+	return CKR_FUNCTION_FAILED;
>+}
>+
>+static CK_RV
>+rpc_initialize_device_removed (P11RpcClientVtable *vtable,
>+                               void *init_reserved)
>+{
>+	CuTest *tc = vtable->data;
>+
>+	CuAssertIntEquals (tc, 0, rpc_initialized);
>+	return CKR_DEVICE_REMOVED;
>+}
>+
>+static CK_RV
>+rpc_transport (P11RpcClientVtable *vtable,
>+               P11Buffer *request,
>+               P11Buffer *response)
>+{
>+	static P11RpcServerVtable server = { NULL, };
>+	CuTest *tc = vtable->data;
>+	int ret;
>+
>+	/* Just pass directly to the server code */
>+	ret = p11_rpc_server_handle (&server, &module, request, response);
>+	CuAssertTrue (tc, ret >= 0);
>+
>+	return CKR_OK;
>+}
>+
>+static void
>+rpc_finalize (P11RpcClientVtable *vtable,
>+              void *fini_reserved)
>+{
>+	CuTest *tc = vtable->data;
>+
>+	CuAssertIntEquals (tc, 1, rpc_initialized);
>+	rpc_initialized = 0;
>+}
>+
>+static void
>+test_initialize (CuTest *tc)
>+{
>+	P11RpcClientVtable vtable = { tc, rpc_initialize, rpc_transport, rpc_finalize };
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_FUNCTION_LIST_PTR check;
>+	CK_RV rv;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, &mock_module_no_slots, sizeof (CK_FUNCTION_LIST));
>+
>+	rpc_module = p11_rpc_client_register (&vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	rv = p11_kit_initialize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, rpc_initialized, 1);
>+
>+	rv = (rpc_module->C_GetFunctionList) (&check);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertPtrEquals (tc, check, rpc_module);
>+
>+	rv = p11_kit_finalize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, rpc_initialized, 0);
>+}
>+
>+static void
>+test_not_initialized (CuTest *tc)
>+{
>+	P11RpcClientVtable vtable = { tc, rpc_initialize, rpc_transport, rpc_finalize };
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_INFO info;
>+	CK_RV rv;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, &mock_module_no_slots, sizeof (CK_FUNCTION_LIST));
>+
>+	rpc_module = p11_rpc_client_register (&vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	rv = (rpc_module->C_GetInfo) (&info);
>+	CuAssertTrue (tc, rv == CKR_CRYPTOKI_NOT_INITIALIZED);
>+}
>+
>+static void
>+test_initialize_fails_on_client (CuTest *tc)
>+{
>+	P11RpcClientVtable vtable = { tc, rpc_initialize_fails, rpc_transport, rpc_finalize };
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_RV rv;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, &mock_module_no_slots, sizeof (CK_FUNCTION_LIST));
>+
>+	rpc_module = p11_rpc_client_register (&vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	rv = p11_kit_initialize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_FUNCTION_FAILED);
>+	CuAssertIntEquals (tc, rpc_initialized, 0);
>+}
>+
>+static CK_RV
>+rpc_transport_fails (P11RpcClientVtable *vtable,
>+                     P11Buffer *request,
>+                     P11Buffer *response)
>+{
>+	return CKR_FUNCTION_REJECTED;
>+}
>+
>+static void
>+test_transport_fails (CuTest *tc)
>+{
>+	P11RpcClientVtable vtable = { tc, rpc_initialize, rpc_transport_fails, rpc_finalize };
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_RV rv;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, &mock_module_no_slots, sizeof (CK_FUNCTION_LIST));
>+
>+	rpc_module = p11_rpc_client_register (&vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	rv = p11_kit_initialize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_FUNCTION_REJECTED);
>+	CuAssertIntEquals (tc, rpc_initialized, 0);
>+}
>+
>+static void
>+test_initialize_fails_on_server (CuTest *tc)
>+{
>+	P11RpcClientVtable vtable = { tc, rpc_initialize, rpc_transport, rpc_finalize };
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_RV rv;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, &mock_module_no_slots, sizeof (CK_FUNCTION_LIST));
>+	module.C_Initialize = mock_C_Initialize__fails;
>+
>+	rpc_module = p11_rpc_client_register (&vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	rv = p11_kit_initialize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_FUNCTION_FAILED);
>+	CuAssertIntEquals (tc, rpc_initialized, 0);
>+}
>+
>+static CK_RV
>+rpc_transport_bad_parse (P11RpcClientVtable *vtable,
>+                         P11Buffer *request,
>+                         P11Buffer *response)
>+{
>+	CuTest *tc = vtable->data;
>+	int rc;
>+
>+	/* Just zero bytes is an invalid message */
>+	rc = p11_buffer_reset (response, 2);
>+	CuAssertTrue (tc, rc >= 0);
>+
>+	memset (response->data, 0, 2);
>+	response->length = 2;
>+	return CKR_OK;
>+}
>+
>+static void
>+test_transport_bad_parse (CuTest *tc)
>+{
>+	P11RpcClientVtable vtable = { tc, rpc_initialize, rpc_transport_bad_parse, rpc_finalize };
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_RV rv;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, &mock_module_no_slots, sizeof (CK_FUNCTION_LIST));
>+
>+	rpc_module = p11_rpc_client_register (&vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	p11_kit_be_quiet ();
>+
>+	rv = p11_kit_initialize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_DEVICE_ERROR);
>+	CuAssertIntEquals (tc, rpc_initialized, 0);
>+
>+	_p11_kit_be_loud ();
>+}
>+
>+static CK_RV
>+rpc_transport_short_error (P11RpcClientVtable *vtable,
>+                           P11Buffer *request,
>+                           P11Buffer *response)
>+{
>+	CuTest *tc = vtable->data;
>+	int rc;
>+
>+	unsigned char data[] = {
>+		0x00, 0x00, 0x00, 0x00,       /* RPC_CALL_ERROR */
>+		0x00, 0x00, 0x00, 0x01, 0x75, /* signature 'u' */
>+		0x00, 0x01,                   /* short error */
>+	};
>+
>+	rc = p11_buffer_reset (response, sizeof (data));
>+	CuAssertTrue (tc, rc >= 0);
>+
>+	memcpy (response->data, data, sizeof (data));
>+	response->length = sizeof (data);
>+	return CKR_OK;
>+}
>+
>+static void
>+test_transport_short_error (CuTest *tc)
>+{
>+	P11RpcClientVtable vtable = { tc, rpc_initialize, rpc_transport_short_error, rpc_finalize };
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_RV rv;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, &mock_module_no_slots, sizeof (CK_FUNCTION_LIST));
>+
>+	rpc_module = p11_rpc_client_register (&vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	p11_kit_be_quiet ();
>+
>+	rv = p11_kit_initialize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_DEVICE_ERROR);
>+	CuAssertIntEquals (tc, rpc_initialized, 0);
>+
>+	_p11_kit_be_loud ();
>+}
>+
>+static CK_RV
>+rpc_transport_invalid_error (P11RpcClientVtable *vtable,
>+                             P11Buffer *request,
>+                             P11Buffer *response)
>+{
>+	CuTest *tc = vtable->data;
>+	int rc;
>+
>+	unsigned char data[] = {
>+		0x00, 0x00, 0x00, 0x00,       /* RPC_CALL_ERROR */
>+		0x00, 0x00, 0x00, 0x01, 0x75, /* signature 'u' */
>+		0x00, 0x00, 0x00, 0x00,       /* a CKR_OK error*/
>+		0x00, 0x00, 0x00, 0x00,
>+	};
>+
>+	rc = p11_buffer_reset (response, sizeof (data));
>+	CuAssertTrue (tc, rc >= 0);
>+	memcpy (response->data, data, sizeof (data));
>+	response->length = sizeof (data);
>+	return CKR_OK;
>+}
>+
>+static void
>+test_transport_invalid_error (CuTest *tc)
>+{
>+	P11RpcClientVtable vtable = { tc, rpc_initialize, rpc_transport_invalid_error, rpc_finalize };
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_RV rv;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, &mock_module_no_slots, sizeof (CK_FUNCTION_LIST));
>+
>+	rpc_module = p11_rpc_client_register (&vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	p11_kit_be_quiet ();
>+
>+	rv = p11_kit_initialize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_DEVICE_ERROR);
>+	CuAssertIntEquals (tc, rpc_initialized, 0);
>+
>+	_p11_kit_be_loud ();
>+}
>+
>+static CK_RV
>+rpc_transport_wrong_response (P11RpcClientVtable *vtable,
>+                              P11Buffer *request,
>+                              P11Buffer *response)
>+{
>+	CuTest *tc = vtable->data;
>+	int rc;
>+
>+	unsigned char data[] = {
>+		0x00, 0x00, 0x00, 0x02,       /* RPC_CALL_C_Finalize */
>+		0x00, 0x00, 0x00, 0x00,       /* signature '' */
>+	};
>+
>+	rc = p11_buffer_reset (response, sizeof (data));
>+	CuAssertTrue (tc, rc >= 0);
>+	memcpy (response->data, data, sizeof (data));
>+	response->length = sizeof (data);
>+	return CKR_OK;
>+}
>+
>+static void
>+test_transport_wrong_response (CuTest *tc)
>+{
>+	P11RpcClientVtable vtable = { tc, rpc_initialize, rpc_transport_wrong_response, rpc_finalize };
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_RV rv;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, &mock_module_no_slots, sizeof (CK_FUNCTION_LIST));
>+
>+	rpc_module = p11_rpc_client_register (&vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	p11_kit_be_quiet ();
>+
>+	rv = p11_kit_initialize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_DEVICE_ERROR);
>+	CuAssertIntEquals (tc, rpc_initialized, 0);
>+
>+	_p11_kit_be_loud ();
>+}
>+
>+static CK_RV
>+rpc_transport_bad_contents (P11RpcClientVtable *vtable,
>+                            P11Buffer *request,
>+                            P11Buffer *response)
>+{
>+	CuTest *tc = vtable->data;
>+	int rc;
>+
>+	unsigned char data[] = {
>+		0x00, 0x00, 0x00, 0x02,       /* RPC_CALL_C_GetInfo */
>+		0x00, 0x00, 0x00, 0x05,       /* signature 'vsusv' */
>+		'v', 's', 'u', 's', 'v',
>+		0x00, 0x00, 0x00, 0x00,       /* invalid data */
>+	};
>+
>+	rc = p11_buffer_reset (response, sizeof (data));
>+	CuAssertTrue (tc, rc >= 0);
>+	memcpy (response->data, data, sizeof (data));
>+	response->length = sizeof (data);
>+	return CKR_OK;
>+}
>+
>+static void
>+test_transport_bad_contents (CuTest *tc)
>+{
>+	P11RpcClientVtable vtable = { tc, rpc_initialize, rpc_transport_bad_contents, rpc_finalize };
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_RV rv;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, &mock_module_no_slots, sizeof (CK_FUNCTION_LIST));
>+
>+	rpc_module = p11_rpc_client_register (&vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	p11_kit_be_quiet ();
>+
>+	rv = p11_kit_initialize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_DEVICE_ERROR);
>+	CuAssertIntEquals (tc, rpc_initialized, 0);
>+
>+	_p11_kit_be_loud ();
>+}
>+
>+static P11RpcClientVtable test_normal_vtable = {
>+	NULL,
>+	rpc_initialize,
>+	rpc_transport,
>+	rpc_finalize,
>+};
>+
>+static P11RpcClientVtable test_device_removed_vtable = {
>+	NULL,
>+	rpc_initialize_device_removed,
>+	rpc_transport,
>+	rpc_finalize,
>+};
>+
>+static CK_FUNCTION_LIST_PTR
>+setup_test_rpc_module (CuTest *tc,
>+                       P11RpcClientVtable *vtable,
>+                       CK_FUNCTION_LIST_PTR module_template,
>+                       CK_SESSION_HANDLE *session)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_RV rv;
>+
>+	vtable->data = tc;
>+
>+	/* Build up our own function list */
>+	memcpy (&module, module_template, sizeof (CK_FUNCTION_LIST));
>+
>+	rpc_module = p11_rpc_client_register (vtable);
>+	CuAssertPtrNotNull (tc, rpc_module);
>+
>+	rv = p11_kit_initialize_module (rpc_module);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	if (session) {
>+		rv = (rpc_module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_RW_SESSION | CKF_SERIAL_SESSION,
>+		                                  NULL, NULL, session);
>+		CuAssertTrue (tc, rv == CKR_OK);
>+	}
>+
>+	return rpc_module;
>+}
>+
>+static void
>+teardown_test_rpc_module (CuTest *tc,
>+                          CK_FUNCTION_LIST_PTR rpc_module)
>+{
>+	p11_kit_finalize_module (rpc_module);
>+}
>+
>+static void
>+test_get_info_stand_in (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_INFO info;
>+	CK_RV rv;
>+	char *string;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_device_removed_vtable,
>+	                                    &mock_module_no_slots, NULL);
>+
>+	rv = (rpc_module->C_GetInfo) (&info);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, CRYPTOKI_VERSION_MAJOR, info.cryptokiVersion.major);
>+	CuAssertIntEquals (tc, CRYPTOKI_VERSION_MINOR, info.cryptokiVersion.minor);
>+	string = p11_kit_space_strdup (info.manufacturerID, sizeof (info.manufacturerID));
>+	CuAssertStrEquals (tc, "p11-kit", string);
>+	free (string);
>+	string = p11_kit_space_strdup (info.libraryDescription, sizeof (info.libraryDescription));
>+	CuAssertStrEquals (tc, "p11-kit (no connection)", string);
>+	free (string);
>+	CuAssertIntEquals (tc, 0, info.flags);
>+	CuAssertIntEquals (tc, 1, info.libraryVersion.major);
>+	CuAssertIntEquals (tc, 1, info.libraryVersion.minor);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_info (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_INFO info;
>+	CK_RV rv;
>+	char *string;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module_no_slots, NULL);
>+
>+	rv = (rpc_module->C_GetInfo) (&info);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, CRYPTOKI_VERSION_MAJOR, info.cryptokiVersion.major);
>+	CuAssertIntEquals (tc, CRYPTOKI_VERSION_MINOR, info.cryptokiVersion.minor);
>+	string = p11_kit_space_strdup (info.manufacturerID, sizeof (info.manufacturerID));
>+	CuAssertStrEquals (tc, "MOCK MANUFACTURER", string);
>+	free (string);
>+	string = p11_kit_space_strdup (info.libraryDescription, sizeof (info.libraryDescription));
>+	CuAssertStrEquals (tc, "MOCK LIBRARY", string);
>+	free (string);
>+	CuAssertIntEquals (tc, 0, info.flags);
>+	CuAssertIntEquals (tc, 45, info.libraryVersion.major);
>+	CuAssertIntEquals (tc, 145, info.libraryVersion.minor);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_slot_list (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SLOT_ID slot_list[8];
>+	CK_ULONG count;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, NULL);
>+
>+	/* Normal module has 2 slots, one with token present */
>+	rv = (rpc_module->C_GetSlotList) (CK_TRUE, NULL, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 1, count);
>+	rv = (rpc_module->C_GetSlotList) (CK_FALSE, NULL, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 2, count);
>+
>+	count = 8;
>+	rv = (rpc_module->C_GetSlotList) (CK_TRUE, slot_list, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 1, count);
>+	CuAssertIntEquals (tc, MOCK_SLOT_ONE_ID, slot_list[0]);
>+
>+	count = 8;
>+	rv = (rpc_module->C_GetSlotList) (CK_FALSE, slot_list, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 2, count);
>+	CuAssertIntEquals (tc, MOCK_SLOT_ONE_ID, slot_list[0]);
>+	CuAssertIntEquals (tc, MOCK_SLOT_TWO_ID, slot_list[1]);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_slot_list_no_device (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SLOT_ID slot_list[8];
>+	CK_ULONG count;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_device_removed_vtable,
>+	                                    &mock_module, NULL);
>+
>+	rv = (rpc_module->C_GetSlotList) (CK_TRUE, NULL, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 0, count);
>+	rv = (rpc_module->C_GetSlotList) (CK_FALSE, NULL, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 0, count);
>+
>+	count = 8;
>+	rv = (rpc_module->C_GetSlotList) (CK_TRUE, slot_list, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 0, count);
>+
>+	count = 8;
>+	rv = (rpc_module->C_GetSlotList) (CK_FALSE, slot_list, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 0, count);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_slot_info (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SLOT_INFO info;
>+	char *string;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, NULL);
>+
>+	rv = (rpc_module->C_GetSlotInfo) (MOCK_SLOT_ONE_ID, &info);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	string = p11_kit_space_strdup (info.slotDescription, sizeof (info.slotDescription));
>+	CuAssertStrEquals (tc, "TEST SLOT", string);
>+	free (string);
>+	string = p11_kit_space_strdup (info.manufacturerID, sizeof (info.manufacturerID));
>+	CuAssertStrEquals (tc, "TEST MANUFACTURER", string);
>+	free (string);
>+	CuAssertIntEquals (tc, CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE, info.flags);
>+	CuAssertIntEquals (tc, 55, info.hardwareVersion.major);
>+	CuAssertIntEquals (tc, 155, info.hardwareVersion.minor);
>+	CuAssertIntEquals (tc, 65, info.firmwareVersion.major);
>+	CuAssertIntEquals (tc, 165, info.firmwareVersion.minor);
>+
>+	rv = (rpc_module->C_GetSlotInfo) (MOCK_SLOT_TWO_ID, &info);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, CKF_REMOVABLE_DEVICE, info.flags);
>+
>+	rv = (rpc_module->C_GetSlotInfo) (0, &info);
>+	CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_token_info (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_TOKEN_INFO info;
>+	char *string;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, NULL);
>+
>+	rv = (rpc_module->C_GetTokenInfo) (MOCK_SLOT_ONE_ID, &info);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	string = p11_kit_space_strdup (info.label, sizeof (info.label));
>+	CuAssertStrEquals (tc, "TEST LABEL", string);
>+	free (string);
>+	string = p11_kit_space_strdup (info.manufacturerID, sizeof (info.manufacturerID));
>+	CuAssertStrEquals (tc, "TEST MANUFACTURER", string);
>+	free (string);
>+	string = p11_kit_space_strdup (info.model, sizeof (info.model));
>+	CuAssertStrEquals (tc, "TEST MODEL", string);
>+	free (string);
>+	string = p11_kit_space_strdup (info.serialNumber, sizeof (info.serialNumber));
>+	CuAssertStrEquals (tc, "TEST SERIAL", string);
>+	free (string);
>+	CuAssertIntEquals (tc, CKF_LOGIN_REQUIRED | CKF_USER_PIN_INITIALIZED | CKF_CLOCK_ON_TOKEN | CKF_TOKEN_INITIALIZED, info.flags);
>+	CuAssertIntEquals (tc, 1, info.ulMaxSessionCount);
>+	CuAssertIntEquals (tc, 2, info.ulSessionCount);
>+	CuAssertIntEquals (tc, 3, info.ulMaxRwSessionCount);
>+	CuAssertIntEquals (tc, 4, info.ulRwSessionCount);
>+	CuAssertIntEquals (tc, 5, info.ulMaxPinLen);
>+	CuAssertIntEquals (tc, 6, info.ulMinPinLen);
>+	CuAssertIntEquals (tc, 7, info.ulTotalPublicMemory);
>+	CuAssertIntEquals (tc, 8, info.ulFreePublicMemory);
>+	CuAssertIntEquals (tc, 9, info.ulTotalPrivateMemory);
>+	CuAssertIntEquals (tc, 10, info.ulFreePrivateMemory);
>+	CuAssertIntEquals (tc, 75, info.hardwareVersion.major);
>+	CuAssertIntEquals (tc, 175, info.hardwareVersion.minor);
>+	CuAssertIntEquals (tc, 85, info.firmwareVersion.major);
>+	CuAssertIntEquals (tc, 185, info.firmwareVersion.minor);
>+	CuAssertTrue (tc, memcmp (info.utcTime, "1999052509195900", sizeof (info.utcTime)) == 0);
>+
>+	rv = (rpc_module->C_GetTokenInfo) (MOCK_SLOT_TWO_ID, &info);
>+	CuAssertTrue (tc, rv == CKR_TOKEN_NOT_PRESENT);
>+
>+	rv = (rpc_module->C_GetTokenInfo) (0, &info);
>+	CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_mechanism_list (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_MECHANISM_TYPE mechs[8];
>+	CK_ULONG count;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, NULL);
>+
>+	rv = (rpc_module->C_GetMechanismList) (MOCK_SLOT_ONE_ID, NULL, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 2, count);
>+	rv = (rpc_module->C_GetMechanismList) (MOCK_SLOT_TWO_ID, NULL, &count);
>+	CuAssertTrue (tc, rv == CKR_TOKEN_NOT_PRESENT);
>+	rv = (rpc_module->C_GetMechanismList) (0, NULL, &count);
>+	CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID);
>+
>+	count = 8;
>+	rv = (rpc_module->C_GetMechanismList) (MOCK_SLOT_ONE_ID, mechs, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 2, count);
>+	CuAssertIntEquals (tc, mechs[0], CKM_MOCK_CAPITALIZE);
>+	CuAssertIntEquals (tc, mechs[1], CKM_MOCK_PREFIX);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_mechanism_info (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_MECHANISM_INFO info;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, NULL);
>+
>+	rv = (rpc_module->C_GetMechanismInfo) (MOCK_SLOT_ONE_ID, CKM_MOCK_CAPITALIZE, &info);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 512, info.ulMinKeySize);
>+	CuAssertIntEquals (tc, 4096, info.ulMaxKeySize);
>+	CuAssertIntEquals (tc, CKF_ENCRYPT | CKF_DECRYPT, info.flags);
>+
>+	rv = (rpc_module->C_GetMechanismInfo) (MOCK_SLOT_ONE_ID, CKM_MOCK_PREFIX, &info);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, 2048, info.ulMinKeySize);
>+	CuAssertIntEquals (tc, 2048, info.ulMaxKeySize);
>+	CuAssertIntEquals (tc, CKF_SIGN | CKF_VERIFY, info.flags);
>+
>+	rv = (rpc_module->C_GetMechanismInfo) (MOCK_SLOT_TWO_ID, CKM_MOCK_PREFIX, &info);
>+	CuAssertTrue (tc, rv == CKR_TOKEN_NOT_PRESENT);
>+	rv = (rpc_module->C_GetMechanismInfo) (MOCK_SLOT_ONE_ID, 0, &info);
>+	CuAssertTrue (tc, rv == CKR_MECHANISM_INVALID);
>+	rv = (rpc_module->C_GetMechanismInfo) (0, CKM_MOCK_PREFIX, &info);
>+	CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_init_token (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, NULL);
>+
>+	rv = (rpc_module->C_InitToken) (MOCK_SLOT_ONE_ID, (CK_UTF8CHAR_PTR)"TEST PIN", 8, (CK_UTF8CHAR_PTR)"TEST LABEL");
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_InitToken) (MOCK_SLOT_ONE_ID, (CK_UTF8CHAR_PTR)"OTHER", 5, (CK_UTF8CHAR_PTR)"TEST LABEL");
>+	CuAssertTrue (tc, rv == CKR_PIN_INVALID);
>+	rv = (rpc_module->C_InitToken) (MOCK_SLOT_TWO_ID, (CK_UTF8CHAR_PTR)"TEST PIN", 8, (CK_UTF8CHAR_PTR)"TEST LABEL");
>+	CuAssertTrue (tc, rv == CKR_TOKEN_NOT_PRESENT);
>+	rv = (rpc_module->C_InitToken) (0, (CK_UTF8CHAR_PTR)"TEST PIN", 8, (CK_UTF8CHAR_PTR)"TEST LABEL");
>+	CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_wait_for_slot_event (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SLOT_ID slot;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, NULL);
>+
>+	rv = (rpc_module->C_WaitForSlotEvent) (0, &slot, NULL);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, slot, MOCK_SLOT_TWO_ID);
>+
>+	rv = (rpc_module->C_WaitForSlotEvent) (CKF_DONT_BLOCK, &slot, NULL);
>+	CuAssertTrue (tc, rv == CKR_NO_EVENT);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_open_close_session (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, NULL);
>+
>+	rv = (rpc_module->C_OpenSession) (MOCK_SLOT_TWO_ID, CKF_SERIAL_SESSION, NULL, NULL, &session);
>+	CuAssertTrue (tc, rv == CKR_TOKEN_NOT_PRESENT);
>+	rv = (rpc_module->C_OpenSession) (0, CKF_SERIAL_SESSION, NULL, NULL, &session);
>+	CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID);
>+
>+	rv = (rpc_module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_SERIAL_SESSION, NULL, NULL, &session);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertTrue (tc, session != 0);
>+
>+	rv = (rpc_module->C_CloseSession) (session);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_CloseSession) (session);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_close_all_sessions (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, NULL);
>+
>+	rv = (rpc_module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_SERIAL_SESSION, NULL, NULL, &session);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertTrue (tc, session != 0);
>+
>+	rv = (rpc_module->C_CloseAllSessions) (MOCK_SLOT_ONE_ID);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_CloseSession) (session);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_function_status (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_GetFunctionStatus) (session);
>+	CuAssertTrue (tc, rv == CKR_FUNCTION_NOT_PARALLEL);
>+
>+	rv = (rpc_module->C_GetFunctionStatus) (0);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_cancel_function (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_CancelFunction) (session);
>+	CuAssertTrue (tc, rv == CKR_FUNCTION_NOT_PARALLEL);
>+
>+	rv = (rpc_module->C_CancelFunction) (0);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_session_info (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_SESSION_INFO info;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, NULL);
>+
>+	rv = (rpc_module->C_GetSessionInfo) (0, &info);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_SERIAL_SESSION, NULL, NULL, &session);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertTrue (tc, session != 0);
>+
>+	rv = (rpc_module->C_GetSessionInfo) (session, &info);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, MOCK_SLOT_ONE_ID, info.slotID);
>+	CuAssertIntEquals (tc, CKS_RO_PUBLIC_SESSION, info.state);
>+	CuAssertIntEquals (tc, CKF_SERIAL_SESSION, info.flags);
>+	CuAssertIntEquals (tc, 1414, info.ulDeviceError);
>+
>+	rv = (rpc_module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_RW_SESSION | CKF_SERIAL_SESSION, NULL, NULL, &session);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertTrue (tc, session != 0);
>+
>+	rv = (rpc_module->C_GetSessionInfo) (session, &info);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+	CuAssertIntEquals (tc, MOCK_SLOT_ONE_ID, info.slotID);
>+	CuAssertIntEquals (tc, CKS_RW_PUBLIC_SESSION, info.state);
>+	CuAssertIntEquals (tc, CKF_SERIAL_SESSION | CKF_RW_SESSION, info.flags);
>+	CuAssertIntEquals (tc, 1414, info.ulDeviceError);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_init_pin (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_InitPIN) (0, (CK_UTF8CHAR_PTR)"TEST PIN", 8);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_InitPIN) (session, (CK_UTF8CHAR_PTR)"TEST PIN", 8);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_InitPIN) (session, (CK_UTF8CHAR_PTR)"OTHER", 5);
>+	CuAssertTrue (tc, rv == CKR_PIN_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_set_pin (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_SetPIN) (0, (CK_UTF8CHAR_PTR)"booo", 4, (CK_UTF8CHAR_PTR)"TEST PIN", 8);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_SetPIN) (session, (CK_UTF8CHAR_PTR)"booo", 4, (CK_UTF8CHAR_PTR)"TEST PIN", 8);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_SetPIN) (session, (CK_UTF8CHAR_PTR)"other", 5, (CK_UTF8CHAR_PTR)"OTHER", 5);
>+	CuAssertTrue (tc, rv == CKR_PIN_INCORRECT);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_operation_state (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_BYTE state[128];
>+	CK_ULONG state_len;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	state_len = sizeof (state);
>+	rv = (rpc_module->C_GetOperationState) (0, state, &state_len);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	state_len = sizeof (state);
>+	rv = (rpc_module->C_GetOperationState) (session, state, &state_len);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_SetOperationState) (session, state, state_len, 355, 455);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_SetOperationState) (0, state, state_len, 355, 455);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_login_logout (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_Login) (0, CKU_USER, (CK_UTF8CHAR_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_USER, (CK_UTF8CHAR_PTR)"bo", 2);
>+	CuAssertTrue (tc, rv == CKR_PIN_INCORRECT);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_USER, (CK_UTF8CHAR_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_Logout) (session);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_Logout) (session);
>+	CuAssertTrue (tc, rv == CKR_USER_NOT_LOGGED_IN);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_attribute_value (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_ATTRIBUTE attrs[8];
>+	char label[32];
>+	CK_OBJECT_CLASS klass;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	attrs[0].type = CKA_CLASS;
>+	attrs[0].pValue = &klass;
>+	attrs[0].ulValueLen = sizeof (klass);
>+	attrs[1].type = CKA_LABEL;
>+	attrs[1].pValue = label;
>+	attrs[1].ulValueLen = 2; /* too small */
>+	attrs[2].type = CKA_BITS_PER_PIXEL;
>+	attrs[2].pValue = NULL;
>+	attrs[2].ulValueLen = 0;
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, MOCK_PRIVATE_KEY_CAPITALIZE, attrs, 3);
>+	CuAssertTrue (tc, rv == CKR_USER_NOT_LOGGED_IN);
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2);
>+	CuAssertTrue (tc, rv == CKR_BUFFER_TOO_SMALL);
>+
>+	/* Get right size */
>+	attrs[1].pValue = NULL;
>+	attrs[1].ulValueLen = 0;
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 3);
>+	CuAssertTrue (tc, rv == CKR_ATTRIBUTE_TYPE_INVALID);
>+
>+	CuAssertIntEquals (tc, CKO_PUBLIC_KEY, klass);
>+	CuAssertIntEquals (tc, 21, attrs[1].ulValueLen);
>+	CuAssertPtrEquals (tc, NULL, attrs[1].pValue);
>+	attrs[1].pValue = label;
>+	attrs[1].ulValueLen = sizeof (label);
>+	CuAssertTrue (tc, (CK_ULONG)-1 == attrs[2].ulValueLen);
>+	CuAssertPtrEquals (tc, NULL, attrs[2].pValue);
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 3);
>+	CuAssertTrue (tc, rv == CKR_ATTRIBUTE_TYPE_INVALID);
>+
>+	CuAssertIntEquals (tc, CKO_PUBLIC_KEY, klass);
>+	CuAssertIntEquals (tc, 21, attrs[1].ulValueLen);
>+	CuAssertPtrEquals (tc, label, attrs[1].pValue);
>+	CuAssertTrue (tc, memcmp (label, "Public Capitalize Key", attrs[1].ulValueLen) == 0);
>+	CuAssertTrue (tc, (CK_ULONG)-1 == attrs[2].ulValueLen);
>+	CuAssertPtrEquals (tc, NULL, attrs[2].pValue);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_set_attribute_value (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_ATTRIBUTE attrs[8];
>+	char label[32];
>+	CK_ULONG bits;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	strcpy (label, "Blahooo");
>+	bits = 1555;
>+
>+	attrs[0].type = CKA_LABEL;
>+	attrs[0].pValue = label;
>+	attrs[0].ulValueLen = strlen (label);
>+	attrs[1].type = CKA_BITS_PER_PIXEL;
>+	attrs[1].pValue = &bits;
>+	attrs[1].ulValueLen = sizeof (bits);
>+
>+	rv = (rpc_module->C_SetAttributeValue) (session, MOCK_PRIVATE_KEY_CAPITALIZE, attrs, 2);
>+	CuAssertTrue (tc, rv == CKR_USER_NOT_LOGGED_IN);
>+
>+	rv = (rpc_module->C_SetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	memset (label, 0, sizeof (label));
>+	bits = 0;
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, bits, 1555);
>+	CuAssertIntEquals (tc, 7, attrs[0].ulValueLen);
>+	CuAssertTrue (tc, memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_create_object (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_OBJECT_HANDLE object;
>+	CK_ATTRIBUTE attrs[8];
>+	char label[32];
>+	CK_ULONG bits;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	strcpy (label, "Blahooo");
>+	bits = 1555;
>+
>+	attrs[0].type = CKA_LABEL;
>+	attrs[0].pValue = label;
>+	attrs[0].ulValueLen = strlen (label);
>+	attrs[1].type = CKA_BITS_PER_PIXEL;
>+	attrs[1].pValue = &bits;
>+	attrs[1].ulValueLen = sizeof (bits);
>+
>+	rv = (rpc_module->C_CreateObject) (0, attrs, 2, &object);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_CreateObject) (session, attrs, 2, &object);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	attrs[0].ulValueLen = sizeof (label);
>+	memset (label, 0, sizeof (label));
>+	bits = 0;
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, object, attrs, 2);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, bits, 1555);
>+	CuAssertIntEquals (tc, 7, attrs[0].ulValueLen);
>+	CuAssertTrue (tc, memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_copy_object (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_OBJECT_HANDLE object;
>+	CK_ATTRIBUTE attrs[8];
>+	char label[32];
>+	CK_ULONG bits;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	bits = 1555;
>+
>+	attrs[0].type = CKA_BITS_PER_PIXEL;
>+	attrs[0].pValue = &bits;
>+	attrs[0].ulValueLen = sizeof (bits);
>+
>+	rv = (rpc_module->C_CopyObject) (session, 1333, attrs, 1, &object);
>+	CuAssertTrue (tc, rv == CKR_OBJECT_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_CopyObject) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 1, &object);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	attrs[1].type = CKA_LABEL;
>+	attrs[1].pValue = label;
>+	attrs[1].ulValueLen = sizeof (label);
>+	bits = 0;
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, object, attrs, 2);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, bits, 1555);
>+	CuAssertIntEquals (tc, 21, attrs[1].ulValueLen);
>+	CuAssertTrue (tc, memcmp (label, "Public Capitalize Key", attrs[1].ulValueLen) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_destroy_object (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_ATTRIBUTE attrs[8];
>+	char label[32];
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	attrs[0].type = CKA_LABEL;
>+	attrs[0].pValue = label;
>+	attrs[0].ulValueLen = sizeof (label);
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 1);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_DestroyObject) (0, MOCK_PUBLIC_KEY_CAPITALIZE);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_DestroyObject) (session, MOCK_PUBLIC_KEY_CAPITALIZE);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 1);
>+	CuAssertTrue (tc, rv == CKR_OBJECT_HANDLE_INVALID);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_get_object_size (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_ULONG size;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_GetObjectSize) (session, 1333, &size);
>+	CuAssertTrue (tc, rv == CKR_OBJECT_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_GetObjectSize) (session, MOCK_PUBLIC_KEY_CAPITALIZE, &size);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	/* The number here is the length of all attributes added up */
>+	CuAssertIntEquals (tc, 44, size);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_find_objects (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_OBJECT_CLASS klass = CKO_PUBLIC_KEY;
>+	CK_ATTRIBUTE attr = { CKA_CLASS, &klass, sizeof (klass) };
>+	CK_OBJECT_HANDLE objects[16];
>+	CK_ULONG count;
>+	CK_ULONG i;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_FindObjectsInit) (0, &attr, 1);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_FindObjectsInit) (session, &attr, 1);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_FindObjects) (0, objects, 16, &count);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_FindObjects) (session, objects, 16, &count);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertTrue (tc, count < 16);
>+
>+	/* Make sure we get the capitalize public key */
>+	for (i = 0; i < count; i++) {
>+		if (objects[i] == MOCK_PUBLIC_KEY_CAPITALIZE)
>+			break;
>+	}
>+	CuAssertTrue (tc, i != count);
>+
>+	/* Make sure we get the prefix public key */
>+	for (i = 0; i < count; i++) {
>+		if (objects[i] == MOCK_PUBLIC_KEY_PREFIX)
>+			break;
>+	}
>+	CuAssertTrue (tc, i != count);
>+
>+	/* Make sure all public keys */
>+	for (i = 0; i < count; i++) {
>+		klass = (CK_ULONG)-1;
>+		rv = (rpc_module->C_GetAttributeValue) (session, objects[i], &attr, 1);
>+		CuAssertTrue (tc, rv == CKR_OK);
>+		CuAssertIntEquals (tc, CKO_PUBLIC_KEY, klass);
>+	}
>+
>+	rv = (rpc_module->C_FindObjectsFinal) (session);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_FindObjectsFinal) (session);
>+	CuAssertTrue (tc, rv == CKR_OPERATION_NOT_INITIALIZED);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_encrypt (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
>+	CK_BYTE data[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_KEY_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_Encrypt) (0, (CK_BYTE_PTR)"blah", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_Encrypt) (session, (CK_BYTE_PTR)"blah", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 4, length);
>+	CuAssertTrue (tc, memcmp (data, "BLAH", 4) == 0);
>+
>+	rv = (rpc_module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_EncryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_EncryptUpdate) (session, (CK_BYTE_PTR)"sLurm", 5, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 5, length);
>+	CuAssertTrue (tc, memcmp (data, "SLURM", 5) == 0);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_EncryptFinal) (0, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_EncryptFinal) (session, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_decrypt (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
>+	CK_BYTE data[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_KEY_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_Decrypt) (0, (CK_BYTE_PTR)"bLAH", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_Decrypt) (session, (CK_BYTE_PTR)"BLAh", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 4, length);
>+	CuAssertTrue (tc, memcmp (data, "blah", 4) == 0);
>+
>+	rv = (rpc_module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DecryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DecryptUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 5, length);
>+	CuAssertTrue (tc, memcmp (data, "slurm", 5) == 0);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DecryptFinal) (0, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DecryptFinal) (session, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_digest (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_COUNT, NULL, 0 };
>+	CK_BYTE digest[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_DigestInit) (0, &mech);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_DigestInit) (session, &mech);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (digest);
>+	rv = (rpc_module->C_Digest) (0, (CK_BYTE_PTR)"bLAH", 4, digest, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (digest);
>+	rv = (rpc_module->C_Digest) (session, (CK_BYTE_PTR)"BLAh", 4, digest, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 1, length);
>+	CuAssertTrue (tc, memcmp (digest, "4", 1) == 0);
>+
>+	rv = (rpc_module->C_DigestInit) (session, &mech);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_DigestUpdate) (0, (CK_BYTE_PTR)"blah", 4);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_DigestUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	/* Adds the the value of object handle to hash: 6 */
>+	CuAssertIntEquals (tc, 6, MOCK_PUBLIC_KEY_PREFIX);
>+	rv = (rpc_module->C_DigestKey) (session, MOCK_PUBLIC_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_DigestUpdate) (session, (CK_BYTE_PTR)"Other", 5);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (digest);
>+	rv = (rpc_module->C_DigestFinal) (0, digest, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (digest);
>+	rv = (rpc_module->C_DigestFinal) (session, digest, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 2, length);
>+	CuAssertTrue (tc, memcmp (digest, "16", 2) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_sign (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_PREFIX, "prefix:", 7 };
>+	CK_BYTE signature[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_SignInit) (0, &mech, MOCK_PRIVATE_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_SignInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (signature);
>+	rv = (rpc_module->C_Sign) (0, (CK_BYTE_PTR)"bLAH", 4, signature, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (signature);
>+	rv = (rpc_module->C_Sign) (session, (CK_BYTE_PTR)"BLAh", 4, signature, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 13, length);
>+	CuAssertTrue (tc, memcmp (signature, "prefix:value4", 13) == 0);
>+
>+	rv = (rpc_module->C_SignInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_SignUpdate) (0, (CK_BYTE_PTR)"blah", 4);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_SignUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_SignUpdate) (session, (CK_BYTE_PTR)"Other", 5);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (signature);
>+	rv = (rpc_module->C_SignFinal) (0, signature, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (signature);
>+	rv = (rpc_module->C_SignFinal) (session, signature, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 14, length);
>+	CuAssertTrue (tc, memcmp (signature, "prefix:value10", 2) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_sign_recover (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_PREFIX, "prefix:", 7 };
>+	CK_BYTE signature[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_SignRecoverInit) (0, &mech, MOCK_PRIVATE_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_SignRecoverInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (signature);
>+	rv = (rpc_module->C_SignRecover) (0, (CK_BYTE_PTR)"bLAH", 4, signature, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (signature);
>+	rv = (rpc_module->C_SignRecover) (session, (CK_BYTE_PTR)"BLAh", 4, signature, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 16, length);
>+	CuAssertTrue (tc, memcmp (signature, "prefix:valueBLAh", 16) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_verify (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_PREFIX, "prefix:", 7 };
>+	CK_BYTE signature[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_VerifyInit) (0, &mech, MOCK_PUBLIC_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_VerifyInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = 13;
>+	memcpy (signature, "prefix:value4", length);
>+	rv = (rpc_module->C_Verify) (0, (CK_BYTE_PTR)"bLAH", 4, signature, 5);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_Verify) (session, (CK_BYTE_PTR)"BLAh", 4, signature, length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_VerifyInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_VerifyUpdate) (0, (CK_BYTE_PTR)"blah", 4);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_VerifyUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_VerifyUpdate) (session, (CK_BYTE_PTR)"Other", 5);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = 14;
>+	memcpy (signature, "prefix:value10", length);
>+
>+	rv = (rpc_module->C_VerifyFinal) (session, signature, 5);
>+	CuAssertTrue (tc, rv == CKR_SIGNATURE_LEN_RANGE);
>+
>+	rv = (rpc_module->C_VerifyFinal) (session, signature, length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_verify_recover (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_PREFIX, "prefix:", 7 };
>+	CK_BYTE data[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_VerifyRecoverInit) (0, &mech, MOCK_PUBLIC_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_VerifyRecoverInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_VerifyRecover) (0, (CK_BYTE_PTR)"prefix:valueBLah", 16, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_VerifyRecover) (session, (CK_BYTE_PTR)"prefix:valueBLah", 16, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 4, length);
>+	CuAssertTrue (tc, memcmp (data, "BLah", 4) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_digest_encrypt (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
>+	CK_MECHANISM dmech = { CKM_MOCK_COUNT, NULL, 0 };
>+	CK_BYTE data[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_DigestInit) (session, &dmech);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DigestEncryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DigestEncryptUpdate) (session, (CK_BYTE_PTR)"blah", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 4, length);
>+	CuAssertTrue (tc, memcmp (data, "BLAH", 4) == 0);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_EncryptFinal) (session, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DigestFinal) (session, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 1, length);
>+	CuAssertTrue (tc, memcmp (data, "4", 1) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_decrypt_digest (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
>+	CK_MECHANISM dmech = { CKM_MOCK_COUNT, NULL, 0 };
>+	CK_BYTE data[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_DigestInit) (session, &dmech);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DecryptDigestUpdate) (0, (CK_BYTE_PTR)"BLAH", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DecryptDigestUpdate) (session, (CK_BYTE_PTR)"BLAH", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 4, length);
>+	CuAssertTrue (tc, memcmp (data, "blah", 4) == 0);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DecryptFinal) (session, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DigestFinal) (session, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 1, length);
>+	CuAssertTrue (tc, memcmp (data, "4", 1) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_sign_encrypt (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
>+	CK_MECHANISM smech = { CKM_MOCK_PREFIX, "p:", 2 };
>+	CK_BYTE data[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_SignInit) (session, &smech, MOCK_PRIVATE_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_SignEncryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_SignEncryptUpdate) (session, (CK_BYTE_PTR)"blah", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 4, length);
>+	CuAssertTrue (tc, memcmp (data, "BLAH", 4) == 0);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_EncryptFinal) (session, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_SignFinal) (session, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 8, length);
>+	CuAssertTrue (tc, memcmp (data, "p:value4", 1) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_decrypt_verify (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
>+	CK_MECHANISM vmech = { CKM_MOCK_PREFIX, "p:", 2 };
>+	CK_BYTE data[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_VerifyInit) (session, &vmech, MOCK_PUBLIC_KEY_PREFIX);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DecryptVerifyUpdate) (0, (CK_BYTE_PTR)"BLAH", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DecryptVerifyUpdate) (session, (CK_BYTE_PTR)"BLAH", 4, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 4, length);
>+	CuAssertTrue (tc, memcmp (data, "blah", 4) == 0);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_DecryptFinal) (session, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_VerifyFinal) (session, (CK_BYTE_PTR)"p:value4", 8);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_generate_key (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_OBJECT_HANDLE object;
>+	CK_MECHANISM mech = { CKM_MOCK_GENERATE, NULL, 0 };
>+	CK_ATTRIBUTE attrs[8];
>+	char label[32];
>+	char value[64];
>+	CK_ULONG bits;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	strcpy (label, "Blahooo");
>+	bits = 1555;
>+
>+	attrs[0].type = CKA_LABEL;
>+	attrs[0].pValue = label;
>+	attrs[0].ulValueLen = strlen (label);
>+	attrs[1].type = CKA_BITS_PER_PIXEL;
>+	attrs[1].pValue = &bits;
>+	attrs[1].ulValueLen = sizeof (bits);
>+
>+	rv = (rpc_module->C_GenerateKey) (session, &mech, attrs, 2, &object);
>+	CuAssertTrue (tc, rv == CKR_MECHANISM_PARAM_INVALID);
>+
>+	mech.pParameter = "generate";
>+	mech.ulParameterLen = 9;
>+
>+	rv = (rpc_module->C_GenerateKey) (session, &mech, attrs, 2, &object);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	attrs[0].ulValueLen = sizeof (label);
>+	memset (label, 0, sizeof (label));
>+	bits = 0;
>+	attrs[2].type = CKA_VALUE;
>+	attrs[2].pValue = value;
>+	attrs[2].ulValueLen = sizeof (value);
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, object, attrs, 3);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, bits, 1555);
>+	CuAssertIntEquals (tc, 7, attrs[0].ulValueLen);
>+	CuAssertTrue (tc, memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0);
>+	CuAssertIntEquals (tc, 9, attrs[2].ulValueLen);
>+	CuAssertTrue (tc, memcmp (value, "generated", attrs[2].ulValueLen) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_generate_key_pair (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_OBJECT_HANDLE pub_object;
>+	CK_OBJECT_HANDLE priv_object;
>+	CK_MECHANISM mech = { CKM_MOCK_GENERATE, "generated", 9 };
>+	CK_ATTRIBUTE pub_attrs[8];
>+	CK_ATTRIBUTE priv_attrs[8];
>+	char pub_label[32];
>+	char pub_value[64];
>+	char priv_label[32];
>+	char priv_value[64];
>+	CK_ULONG pub_bits;
>+	CK_ULONG priv_bits;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	strcpy (pub_label, "Blahooo");
>+	pub_bits = 1555;
>+	pub_attrs[0].type = CKA_LABEL;
>+	pub_attrs[0].pValue = pub_label;
>+	pub_attrs[0].ulValueLen = strlen (pub_label);
>+	pub_attrs[1].type = CKA_BITS_PER_PIXEL;
>+	pub_attrs[1].pValue = &pub_bits;
>+	pub_attrs[1].ulValueLen = sizeof (pub_bits);
>+
>+	strcpy (priv_label, "Private");
>+	priv_bits = 1666;
>+	priv_attrs[0].type = CKA_LABEL;
>+	priv_attrs[0].pValue = priv_label;
>+	priv_attrs[0].ulValueLen = strlen (priv_label);
>+	priv_attrs[1].type = CKA_BITS_PER_PIXEL;
>+	priv_attrs[1].pValue = &priv_bits;
>+	priv_attrs[1].ulValueLen = sizeof (priv_bits);
>+
>+	rv = (rpc_module->C_GenerateKeyPair) (0, &mech, pub_attrs, 2, priv_attrs, 2,
>+	                                      &pub_object, &priv_object);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	mech.pParameter = "generate";
>+	mech.ulParameterLen = 9;
>+
>+	rv = (rpc_module->C_GenerateKeyPair) (session, &mech, pub_attrs, 2, priv_attrs, 2,
>+	                                      &pub_object, &priv_object);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	pub_bits = 0;
>+	pub_attrs[0].ulValueLen = sizeof (pub_label);
>+	memset (pub_label, 0, sizeof (pub_label));
>+	pub_attrs[2].type = CKA_VALUE;
>+	pub_attrs[2].pValue = pub_value;
>+	pub_attrs[2].ulValueLen = sizeof (pub_value);
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, pub_object, pub_attrs, 3);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 1555, pub_bits);
>+	CuAssertIntEquals (tc, 7, pub_attrs[0].ulValueLen);
>+	CuAssertTrue (tc, memcmp (pub_label, "Blahooo", pub_attrs[0].ulValueLen) == 0);
>+	CuAssertIntEquals (tc, 9, pub_attrs[2].ulValueLen);
>+	CuAssertTrue (tc, memcmp (pub_value, "generated", pub_attrs[2].ulValueLen) == 0);
>+
>+	priv_bits = 0;
>+	priv_attrs[0].ulValueLen = sizeof (priv_label);
>+	memset (priv_label, 0, sizeof (priv_label));
>+	priv_attrs[2].type = CKA_VALUE;
>+	priv_attrs[2].pValue = priv_value;
>+	priv_attrs[2].ulValueLen = sizeof (priv_value);
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, priv_object, priv_attrs, 3);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 1666, priv_bits);
>+	CuAssertIntEquals (tc, 7, priv_attrs[0].ulValueLen);
>+	CuAssertTrue (tc, memcmp (priv_label, "Private", priv_attrs[0].ulValueLen) == 0);
>+	CuAssertIntEquals (tc, 9, priv_attrs[2].ulValueLen);
>+	CuAssertTrue (tc, memcmp (priv_value, "generated", priv_attrs[2].ulValueLen) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_wrap_key (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_MECHANISM mech = { CKM_MOCK_WRAP, NULL, 0 };
>+	CK_BYTE data[128];
>+	CK_ULONG length;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	length = sizeof (data);
>+	rv = (rpc_module->C_WrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX, MOCK_PUBLIC_KEY_PREFIX, data, &length);
>+	CuAssertTrue (tc, rv == CKR_MECHANISM_PARAM_INVALID);
>+
>+	mech.pParameter = "wrap";
>+	mech.ulParameterLen = 4;
>+
>+	rv = (rpc_module->C_WrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX, MOCK_PUBLIC_KEY_PREFIX, data, &length);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, 5, length);
>+	CuAssertTrue (tc, memcmp (data, "value", 5) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_unwrap_key (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_OBJECT_HANDLE object;
>+	CK_MECHANISM mech = { CKM_MOCK_WRAP, NULL, 0 };
>+	CK_ATTRIBUTE attrs[8];
>+	char label[32];
>+	char value[64];
>+	CK_ULONG bits;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	strcpy (label, "Blahooo");
>+	bits = 1555;
>+
>+	attrs[0].type = CKA_LABEL;
>+	attrs[0].pValue = label;
>+	attrs[0].ulValueLen = strlen (label);
>+	attrs[1].type = CKA_BITS_PER_PIXEL;
>+	attrs[1].pValue = &bits;
>+	attrs[1].ulValueLen = sizeof (bits);
>+
>+	rv = (rpc_module->C_UnwrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX,
>+	                                (CK_BYTE_PTR)"wheee", 5, attrs, 2, &object);
>+	CuAssertTrue (tc, rv == CKR_MECHANISM_PARAM_INVALID);
>+
>+	mech.pParameter = "wrap";
>+	mech.ulParameterLen = 4;
>+
>+	rv = (rpc_module->C_UnwrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX,
>+	                                (CK_BYTE_PTR)"wheee", 5, attrs, 2, &object);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	attrs[0].ulValueLen = sizeof (label);
>+	memset (label, 0, sizeof (label));
>+	bits = 0;
>+	attrs[2].type = CKA_VALUE;
>+	attrs[2].pValue = value;
>+	attrs[2].ulValueLen = sizeof (value);
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, object, attrs, 3);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, bits, 1555);
>+	CuAssertIntEquals (tc, 7, attrs[0].ulValueLen);
>+	CuAssertTrue (tc, memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0);
>+	CuAssertIntEquals (tc, 5, attrs[2].ulValueLen);
>+	CuAssertTrue (tc, memcmp (value, "wheee", attrs[2].ulValueLen) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_derive_key (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_OBJECT_HANDLE object;
>+	CK_MECHANISM mech = { CKM_MOCK_DERIVE, NULL, 0 };
>+	CK_ATTRIBUTE attrs[8];
>+	char label[32];
>+	char value[64];
>+	CK_ULONG bits;
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	strcpy (label, "Blahooo");
>+	bits = 1555;
>+
>+	attrs[0].type = CKA_LABEL;
>+	attrs[0].pValue = label;
>+	attrs[0].ulValueLen = strlen (label);
>+	attrs[1].type = CKA_BITS_PER_PIXEL;
>+	attrs[1].pValue = &bits;
>+	attrs[1].ulValueLen = sizeof (bits);
>+
>+	rv = (rpc_module->C_DeriveKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX,
>+	                                attrs, 2, &object);
>+	CuAssertTrue (tc, rv == CKR_MECHANISM_PARAM_INVALID);
>+
>+	mech.pParameter = "derive";
>+	mech.ulParameterLen = 6;
>+
>+	rv = (rpc_module->C_DeriveKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX,
>+	                                attrs, 2, &object);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	attrs[0].ulValueLen = sizeof (label);
>+	memset (label, 0, sizeof (label));
>+	bits = 0;
>+	attrs[2].type = CKA_VALUE;
>+	attrs[2].pValue = value;
>+	attrs[2].ulValueLen = sizeof (value);
>+
>+	rv = (rpc_module->C_GetAttributeValue) (session, object, attrs, 3);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertIntEquals (tc, bits, 1555);
>+	CuAssertIntEquals (tc, 7, attrs[0].ulValueLen);
>+	CuAssertTrue (tc, memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0);
>+	CuAssertIntEquals (tc, 7, attrs[2].ulValueLen);
>+	CuAssertTrue (tc, memcmp (value, "derived", attrs[2].ulValueLen) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+static void
>+test_random (CuTest *tc)
>+{
>+	CK_FUNCTION_LIST_PTR rpc_module;
>+	CK_SESSION_HANDLE session = 0;
>+	CK_BYTE data[10];
>+	CK_RV rv;
>+
>+	rpc_module = setup_test_rpc_module (tc, &test_normal_vtable,
>+	                                    &mock_module, &session);
>+
>+	rv = (rpc_module->C_SeedRandom) (0, (CK_BYTE_PTR)"seed", 4);
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_SeedRandom) (session, (CK_BYTE_PTR)"seed", 4);
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	rv = (rpc_module->C_GenerateRandom) (0, data, sizeof (data));
>+	CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID);
>+
>+	rv = (rpc_module->C_GenerateRandom) (session, data, sizeof (data));
>+	CuAssertTrue (tc, rv == CKR_OK);
>+
>+	CuAssertTrue (tc, memcmp (data, "seedseedse", sizeof (data)) == 0);
>+
>+	teardown_test_rpc_module (tc, rpc_module);
>+}
>+
>+
>+int
>+main (void)
>+{
>+	CK_MECHANISM_TYPE mechanisms[] = {
>+		CKM_MOCK_CAPITALIZE,
>+		CKM_MOCK_PREFIX,
>+		CKM_MOCK_GENERATE,
>+		CKM_MOCK_WRAP,
>+		CKM_MOCK_DERIVE,
>+		CKM_MOCK_COUNT,
>+		0,
>+	};
>+
>+	CuString *output = CuStringNew ();
>+	CuSuite* suite = CuSuiteNew ();
>+	int ret;
>+
>+	setenv ("P11_KIT_STRICT", "1", 1);
>+	mock_module_init ();
>+	_p11_library_init ();
>+
>+	/* Override the mechanisms that the RPC mechanism will handle */
>+	_p11_rpc_mechanisms_override_supported = mechanisms;
>+
>+	SUITE_ADD_TEST (suite, test_initialize_fails_on_client);
>+	SUITE_ADD_TEST (suite, test_initialize_fails_on_server);
>+	SUITE_ADD_TEST (suite, test_initialize);
>+	SUITE_ADD_TEST (suite, test_not_initialized);
>+	SUITE_ADD_TEST (suite, test_transport_fails);
>+	SUITE_ADD_TEST (suite, test_transport_bad_parse);
>+	SUITE_ADD_TEST (suite, test_transport_short_error);
>+	SUITE_ADD_TEST (suite, test_transport_invalid_error);
>+	SUITE_ADD_TEST (suite, test_transport_wrong_response);
>+	SUITE_ADD_TEST (suite, test_transport_bad_contents);
>+	SUITE_ADD_TEST (suite, test_get_info);
>+	SUITE_ADD_TEST (suite, test_get_info_stand_in);
>+	SUITE_ADD_TEST (suite, test_get_slot_list);
>+	SUITE_ADD_TEST (suite, test_get_slot_list_no_device);
>+	SUITE_ADD_TEST (suite, test_get_slot_info);
>+	SUITE_ADD_TEST (suite, test_get_token_info);
>+	SUITE_ADD_TEST (suite, test_get_mechanism_list);
>+	SUITE_ADD_TEST (suite, test_get_mechanism_info);
>+	SUITE_ADD_TEST (suite, test_init_token);
>+	SUITE_ADD_TEST (suite, test_wait_for_slot_event);
>+	SUITE_ADD_TEST (suite, test_open_close_session);
>+	SUITE_ADD_TEST (suite, test_close_all_sessions);
>+	SUITE_ADD_TEST (suite, test_get_function_status);
>+	SUITE_ADD_TEST (suite, test_cancel_function);
>+	SUITE_ADD_TEST (suite, test_get_session_info);
>+	SUITE_ADD_TEST (suite, test_init_pin);
>+	SUITE_ADD_TEST (suite, test_set_pin);
>+	SUITE_ADD_TEST (suite, test_operation_state);
>+	SUITE_ADD_TEST (suite, test_login_logout);
>+	SUITE_ADD_TEST (suite, test_get_attribute_value);
>+	SUITE_ADD_TEST (suite, test_set_attribute_value);
>+	SUITE_ADD_TEST (suite, test_create_object);
>+	SUITE_ADD_TEST (suite, test_copy_object);
>+	SUITE_ADD_TEST (suite, test_destroy_object);
>+	SUITE_ADD_TEST (suite, test_get_object_size);
>+	SUITE_ADD_TEST (suite, test_find_objects);
>+	SUITE_ADD_TEST (suite, test_encrypt);
>+	SUITE_ADD_TEST (suite, test_decrypt);
>+	SUITE_ADD_TEST (suite, test_digest);
>+	SUITE_ADD_TEST (suite, test_sign);
>+	SUITE_ADD_TEST (suite, test_sign_recover);
>+	SUITE_ADD_TEST (suite, test_verify);
>+	SUITE_ADD_TEST (suite, test_verify_recover);
>+	SUITE_ADD_TEST (suite, test_digest_encrypt);
>+	SUITE_ADD_TEST (suite, test_decrypt_digest);
>+	SUITE_ADD_TEST (suite, test_sign_encrypt);
>+	SUITE_ADD_TEST (suite, test_decrypt_verify);
>+	SUITE_ADD_TEST (suite, test_generate_key);
>+	SUITE_ADD_TEST (suite, test_generate_key_pair);
>+	SUITE_ADD_TEST (suite, test_wrap_key);
>+	SUITE_ADD_TEST (suite, test_unwrap_key);
>+	SUITE_ADD_TEST (suite, test_derive_key);
>+	SUITE_ADD_TEST (suite, test_random);
>+
>+	CuSuiteRun (suite);
>+	CuSuiteSummary (suite, output);
>+	CuSuiteDetails (suite, output);
>+	printf ("%s\n", output->buffer);
>+	ret = suite->failCount;
>+	CuSuiteDelete (suite);
>+	CuStringDelete (output);
>+
>+	return ret;
>+}
>-- 
>1.7.12
>

Actions: View | Splinter Review

Attachments on bug 54105: 66160 | 66161

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.