Added config file support.

1 files changed, 48 insertions, 27 deletions

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;
+}