From 6a533371d185946e1b49d62a193b81db31a1604f Mon Sep 17 00:00:00 2001 From: Stef Walter Date: Thu, 4 Dec 2008 22:50:10 +0000 Subject: Add GetInfo, GetSlotInfo, GetTokenInfo, GetSlotList tests. --- src/module.c | 64 ++++++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 45 insertions(+), 19 deletions(-) (limited to 'src/module.c') 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 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 -- cgit v1.2.3