Add GetInfo, GetSlotInfo, GetTokenInfo, GetSlotList tests.

1 files changed, 45 insertions, 19 deletions

diff --git a/src/module.c b/src/module.c
index 8677c22..c20bd3c 100644
--- a/src/module.c
+++ b/src/module.c
@@ -10,7 +10,7 @@
 #include <string.h>
 
 static void *module = NULL;
-CK_FUNCTION_LIST_PTR p11_funcs = NULL;
+CK_FUNCTION_LIST_PTR p11t_module_funcs = NULL;
 static CK_C_INITIALIZE_ARGS init_args;
 static int is_initialized = 0;
 
@@ -144,6 +144,7 @@ unlock_mutex (void *mutex)
 void
 p11t_module_load(const char *filename)
 {
+	CK_FUNCTION_LIST_PTR list;
 	CK_C_GetFunctionList get_function_list;
 	CK_RV rv;
 
@@ -157,15 +158,24 @@ p11t_module_load(const char *filename)
 		p11t_msg_fatal("couldn't find C_GetFunctionList function in library: %s: %s", filename, dlerror());
 
 	/* Get the function list */
-	rv = (get_function_list)(&p11_funcs);
+	rv = (get_function_list)(&p11t_module_funcs);
 	if(rv != CKR_OK)
 		p11t_msg_fatal("couldn't get function list: %s", p11t_msg_rv(rv));
 
 	/* Make sure we have a compatible version */
-	if(p11_funcs->version.major != CRYPTOKI_VERSION_MAJOR)
+	if(p11t_module_funcs->version.major != CRYPTOKI_VERSION_MAJOR)
 		p11t_msg_fatal("incompatible version of pkcs11 module: %d.%d",
-		               (int)p11_funcs->version.major,
-		               (int)p11_funcs->version.minor);
+		               (int)p11t_module_funcs->version.major,
+		               (int)p11t_module_funcs->version.minor);
+
+	/** C_GetFunctionList */
+	rv = (p11t_module_funcs->C_GetFunctionList)(&list);
+	if(rv != CKR_OK)
+		p11t_msg_print("C_GetFunctionList call through function list failed: %s", p11t_msg_rv(rv));
+
+	/** - See if returns same data as library entry point */
+	if(!memcmp(list, p11t_module_funcs, sizeof(*list)) != 0)
+		p11t_msg_print("function lists returned directly and recursively differ");
 }
 
 static void
@@ -173,9 +183,12 @@ initialize_common(const char *mode)
 {
 	CK_RV rv;
 
-	assert(p11_funcs);
+	/** C_Initialize **/
+
+	assert(p11t_module_funcs);
 
-	rv = (p11_funcs->C_Initialize) (&init_args);
+	/** - Normal call */
+	rv = (p11t_module_funcs->C_Initialize) (&init_args);
 	if (rv != CKR_OK)
 	{
 		if(rv != CKR_CANT_LOCK)
@@ -190,6 +203,7 @@ initialize_common(const char *mode)
 static void
 initialize_locking_1(const char *initstr)
 {
+	/** - Locking: no threads */
 	memset(&init_args, 0, sizeof (init_args));
 	init_args.pReserved = (void*)initstr;
 	initialize_common("locking mode 1: no threads");
@@ -198,6 +212,7 @@ initialize_locking_1(const char *initstr)
 static void
 initialize_locking_2(const char *initstr)
 {
+	/** - Locking: os locking */
 	memset(&init_args, 0, sizeof (init_args));
 	init_args.flags = CKF_OS_LOCKING_OK;
 	init_args.pReserved = (void*)initstr;
@@ -207,6 +222,7 @@ initialize_locking_2(const char *initstr)
 static void
 initialize_locking_3(const char *initstr)
 {
+	/** - Locking: app locking */
 	memset(&init_args, 0, sizeof (init_args));
 	init_args.flags = 0;
 	init_args.CreateMutex = create_mutex;
@@ -220,6 +236,7 @@ initialize_locking_3(const char *initstr)
 static void
 initialize_locking_4(const char *initstr)
 {
+	/** - Locking: either locking */
 	memset(&init_args, 0, sizeof (init_args));
 	init_args.flags = CKF_OS_LOCKING_OK;
 	init_args.CreateMutex = create_mutex;
@@ -236,14 +253,18 @@ p11t_module_initialize(const char *initstr)
 	CK_INFO info;
 	CK_RV rv;
 
-	assert(p11_funcs);
+	assert(p11t_module_funcs);
 
-	/* Some invalid use without initializing */
-	rv = (p11_funcs->C_GetInfo)(&info);
-	if(rv != CKR_CRYPTOKI_NOT_INITIALIZED)
-		p11t_msg_print("shouldn't run without initialize: %s", p11t_msg_rv(rv));
+	/** - Calls without initializing */
+	rv = (p11t_module_funcs->C_GetInfo)(&info);
+	p11t_check_returns("shouldn't run without initialize: %s", rv, CKR_CRYPTOKI_NOT_INITIALIZED);
 
-	/* The various different locking modes */
+	/** - NULL argument */
+	rv = (p11t_module_funcs->C_Initialize) (NULL);
+	p11t_check_returns("should succeed with null argument", rv, CKR_OK);
+	p11t_module_finalize();
+
+	/** - Multiple initialize with C_Finalize between */
 	initialize_locking_1(initstr);
 	p11t_module_finalize();
 	initialize_locking_2(initstr);
@@ -255,8 +276,8 @@ p11t_module_initialize(const char *initstr)
 	if(!is_initialized)
 		p11t_msg_fatal("liberal locking strategy failed, can't continue");
 
-	/* Double initialize */
-	rv = (p11_funcs->C_Initialize) (&init_args);
+	/** - Double initialize in a row */
+	rv = (p11t_module_funcs->C_Initialize) (&init_args);
 	if (rv != CKR_CRYPTOKI_ALREADY_INITIALIZED)
 	{
 		p11t_msg_print("double initialize should return CKR_CRYPTOKI_ALREADY_INITIALIZED: %s", p11t_msg_rv(rv));
@@ -272,14 +293,19 @@ p11t_module_finalize(void)
 {
 	CK_RV rv;
 
+	/** C_Finalize */
 	if(is_initialized)
 	{
-		assert(p11_funcs);
-		rv = p11_funcs->C_Finalize(NULL);
-		if(rv != CKR_OK)
-			p11t_msg_print("C_Finalize failed: %s", p11t_msg_rv(rv));
+		/** - Normal call */
+		assert(p11t_module_funcs);
+		rv = p11t_module_funcs->C_Finalize(NULL);
+		p11t_check_returns("C_Finalize", rv, CKR_OK);
 		is_initialized = 0;
 	}
+
+	/** - Double finalize in a row */
+	rv = p11t_module_funcs->C_Finalize(NULL);
+	p11t_check_returns("C_Finalize", rv, CKR_CRYPTOKI_NOT_INITIALIZED);
 }
 
 void