From 01f5a4c3169f19d8648a80e913bc4d570e96346d Mon Sep 17 00:00:00 2001 From: Stef Walter Date: Fri, 5 Dec 2008 02:37:04 +0000 Subject: Added config file support. --- src/module.c | 75 ++++++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 48 insertions(+), 27 deletions(-) (limited to 'src/module.c') diff --git a/src/module.c b/src/module.c index c20bd3c..e2b2185 100644 --- a/src/module.c +++ b/src/module.c @@ -11,9 +11,13 @@ static void *module = NULL; CK_FUNCTION_LIST_PTR p11t_module_funcs = NULL; + +static const char *init_string = NULL; static CK_C_INITIALIZE_ARGS init_args; +static void (*init_func)(void) = NULL; static int is_initialized = 0; + static CK_RV create_mutex(void **mutex) { @@ -162,12 +166,6 @@ p11t_module_load(const char *filename) 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(p11t_module_funcs->version.major != CRYPTOKI_VERSION_MAJOR) - p11t_msg_fatal("incompatible version of pkcs11 module: %d.%d", - (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) @@ -178,7 +176,7 @@ p11t_module_load(const char *filename) p11t_msg_print("function lists returned directly and recursively differ"); } -static void +static int initialize_common(const char *mode) { CK_RV rv; @@ -193,34 +191,38 @@ initialize_common(const char *mode) { if(rv != CKR_CANT_LOCK) p11t_msg_print("C_Initialize failed (%s): %s", mode, p11t_msg_rv(rv)); + return 0; } else { is_initialized = 1; + return 1; } } static void -initialize_locking_1(const char *initstr) +initialize_locking_1(void) { /** - Locking: no threads */ memset(&init_args, 0, sizeof (init_args)); - init_args.pReserved = (void*)initstr; - initialize_common("locking mode 1: no threads"); + init_args.pReserved = (void*)init_string; + if(initialize_common("locking mode 1: no threads")) + init_func = initialize_locking_1; } static void -initialize_locking_2(const char *initstr) +initialize_locking_2(void) { /** - Locking: os locking */ memset(&init_args, 0, sizeof (init_args)); init_args.flags = CKF_OS_LOCKING_OK; - init_args.pReserved = (void*)initstr; - initialize_common("locking mode 2: os locking"); + init_args.pReserved = (void*)init_string; + if(initialize_common("locking mode 2: os locking")) + init_func = initialize_locking_2; } static void -initialize_locking_3(const char *initstr) +initialize_locking_3(void) { /** - Locking: app locking */ memset(&init_args, 0, sizeof (init_args)); @@ -229,12 +231,13 @@ initialize_locking_3(const char *initstr) init_args.DestroyMutex = destroy_mutex; init_args.LockMutex = lock_mutex; init_args.UnlockMutex = unlock_mutex; - init_args.pReserved = (void*)initstr; - initialize_common("locking mode 3: app locking"); + init_args.pReserved = (void*)init_string; + if(initialize_common("locking mode 3: app locking")) + init_func = initialize_locking_3; } static void -initialize_locking_4(const char *initstr) +initialize_locking_4(void) { /** - Locking: either locking */ memset(&init_args, 0, sizeof (init_args)); @@ -243,12 +246,13 @@ initialize_locking_4(const char *initstr) init_args.DestroyMutex = destroy_mutex; init_args.LockMutex = lock_mutex; init_args.UnlockMutex = unlock_mutex; - init_args.pReserved = (void*)initstr; - initialize_common("locking mode 4: either locking"); + init_args.pReserved = (void*)init_string; + if(initialize_common("locking mode 4: either locking")) + init_func = initialize_locking_4; } void -p11t_module_initialize(const char *initstr) +p11t_module_initialize(void) { CK_INFO info; CK_RV rv; @@ -257,24 +261,30 @@ p11t_module_initialize(const char *initstr) /** - Calls without initializing */ rv = (p11t_module_funcs->C_GetInfo)(&info); - p11t_check_returns("shouldn't run without initialize: %s", rv, CKR_CRYPTOKI_NOT_INITIALIZED); + p11t_check_returns("C_GetInfo: shouldn't run without initialize", rv, CKR_CRYPTOKI_NOT_INITIALIZED); /** - NULL argument */ rv = (p11t_module_funcs->C_Initialize) (NULL); p11t_check_returns("should succeed with null argument", rv, CKR_OK); + is_initialized = 1; p11t_module_finalize(); /** - Multiple initialize with C_Finalize between */ - initialize_locking_1(initstr); + initialize_locking_1(); + p11t_module_finalize(); + initialize_locking_2(); p11t_module_finalize(); - initialize_locking_2(initstr); + initialize_locking_3(); p11t_module_finalize(); - initialize_locking_3(initstr); + initialize_locking_4(); p11t_module_finalize(); - initialize_locking_4(initstr); + /* Actually initialize with whatever succeeded last */ + if(!init_func) + p11t_msg_fatal("no initialize succeded cannot continue"); + (init_func)(); if(!is_initialized) - p11t_msg_fatal("liberal locking strategy failed, can't continue"); + p11t_msg_fatal("couldn't initialize pkcs11 module"); /** - Double initialize in a row */ rv = (p11t_module_funcs->C_Initialize) (&init_args); @@ -296,6 +306,10 @@ p11t_module_finalize(void) /** C_Finalize */ if(is_initialized) { + /** - With invalid argument */ + rv = p11t_module_funcs->C_Finalize(&rv); + p11t_check_returns("C_Finalize bad argument", rv, CKR_ARGUMENTS_BAD); + /** - Normal call */ assert(p11t_module_funcs); rv = p11t_module_funcs->C_Finalize(NULL); @@ -305,7 +319,7 @@ p11t_module_finalize(void) /** - Double finalize in a row */ rv = p11t_module_funcs->C_Finalize(NULL); - p11t_check_returns("C_Finalize", rv, CKR_CRYPTOKI_NOT_INITIALIZED); + p11t_check_returns("C_Finalize not initialized", rv, CKR_CRYPTOKI_NOT_INITIALIZED); } void @@ -315,3 +329,10 @@ p11t_module_unload(void) dlclose(module); module = NULL; } + +void +p11t_module_config(const char *name, const char *value) +{ + if(strcmp(name, "init-string") == 0) + init_string = value; +} -- cgit v1.2.3