Added a get_name() function to plugin_t, create_plugin_enumerator enumerates over plugin_t

src/libstrongswan/plugins/aes/aes_plugin.c

@@ -18,8 +18,6 @@
 #include <library.h>
 #include "aes_crypter.h"
 
-static const char *plugin_name = "aes";
-
 typedef struct private_aes_plugin_t private_aes_plugin_t;
 
 /**
@@ -33,6 +31,12 @@ struct private_aes_plugin_t {
 	aes_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_aes_plugin_t *this)
+{
+	return "aes";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_aes_plugin_t *this)
 {
@@ -51,12 +55,13 @@ plugin_t *aes_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
-	lib->crypto->add_crypter(lib->crypto, ENCR_AES_CBC, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_AES_CBC, get_name(this),
 							 (crypter_constructor_t)aes_crypter_create);
 
 	return &this->public.plugin;

src/libstrongswan/plugins/af_alg/af_alg_crypter.c

@@ -92,7 +92,7 @@ static struct {
 /**
  * See header.
  */
-void af_alg_crypter_probe()
+void af_alg_crypter_probe(char *plugin)
 {
 	encryption_algorithm_t prev = -1;
 	af_alg_ops_t *ops;
@@ -106,7 +106,7 @@ void af_alg_crypter_probe()
 			if (ops)
 			{
 				ops->destroy(ops);
-				lib->crypto->add_crypter(lib->crypto, algs[i].id, af_alg_plugin_name,
+				lib->crypto->add_crypter(lib->crypto, algs[i].id, plugin,
 								(crypter_constructor_t)af_alg_crypter_create);
 			}
 		}

src/libstrongswan/plugins/af_alg/af_alg_crypter.h

@@ -48,7 +48,9 @@ af_alg_crypter_t *af_alg_crypter_create(encryption_algorithm_t algo,
 
 /**
  * Probe algorithms and register af_alg_crypter_create().
+ *
+ * @param plugin		plugin name to register algorithms for
  */
-void af_alg_crypter_probe();
+void af_alg_crypter_probe(char *plugin);
 
 #endif /** AF_ALG_CRYPTER_H_ @}*/

src/libstrongswan/plugins/af_alg/af_alg_hasher.c

@@ -59,7 +59,7 @@ static struct {
 /**
  * See header.
  */
-void af_alg_hasher_probe()
+void af_alg_hasher_probe(char *plugin)
 {
 	af_alg_ops_t *ops;
 	int i;
@@ -70,7 +70,7 @@ void af_alg_hasher_probe()
 		if (ops)
 		{
 			ops->destroy(ops);
-			lib->crypto->add_hasher(lib->crypto, algs[i].id, af_alg_plugin_name,
+			lib->crypto->add_hasher(lib->crypto, algs[i].id, plugin,
 							(hasher_constructor_t)af_alg_hasher_create);
 		}
 	}

src/libstrongswan/plugins/af_alg/af_alg_hasher.h

@@ -46,7 +46,9 @@ af_alg_hasher_t *af_alg_hasher_create(hash_algorithm_t algo);
 
 /**
  * Probe algorithms and register af_alg_hasher_create().
+ *
+ * @param plugin		plugin name to register algorithms for
  */
-void af_alg_hasher_probe();
+void af_alg_hasher_probe(char *plugin);
 
 #endif /** af_alg_HASHER_H_ @}*/

src/libstrongswan/plugins/af_alg/af_alg_ops.c

@@ -21,8 +21,6 @@
 
 #include <debug.h>
 
-const char *af_alg_plugin_name = "af-alg";
-
 typedef struct private_af_alg_ops_t private_af_alg_ops_t;
 
 /**

src/libstrongswan/plugins/af_alg/af_alg_ops.h

@@ -33,8 +33,6 @@
 #define SOL_ALG 279
 #endif /* SOL_ALG */
 
-extern const char *af_alg_plugin_name;
-
 typedef struct af_alg_ops_t af_alg_ops_t;
 
 /**

src/libstrongswan/plugins/af_alg/af_alg_plugin.c

@@ -35,6 +35,12 @@ struct private_af_alg_plugin_t {
 	af_alg_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_af_alg_plugin_t *this)
+{
+	return "af-alg";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_af_alg_plugin_t *this)
 {
@@ -60,15 +66,16 @@ plugin_t *af_alg_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
-	af_alg_hasher_probe();
-	af_alg_signer_probe();
-	af_alg_prf_probe();
-	af_alg_crypter_probe();
+	af_alg_hasher_probe(get_name(this));
+	af_alg_signer_probe(get_name(this));
+	af_alg_prf_probe(get_name(this));
+	af_alg_crypter_probe(get_name(this));
 
 	return &this->public.plugin;
 }

src/libstrongswan/plugins/af_alg/af_alg_prf.c

@@ -70,7 +70,7 @@ static struct {
 /**
  * See header.
  */
-void af_alg_prf_probe()
+void af_alg_prf_probe(char *plugin)
 {
 	af_alg_ops_t *ops;
 	int i;
@@ -81,7 +81,7 @@ void af_alg_prf_probe()
 		if (ops)
 		{
 			ops->destroy(ops);
-			lib->crypto->add_prf(lib->crypto, algs[i].id, af_alg_plugin_name,
+			lib->crypto->add_prf(lib->crypto, algs[i].id, plugin,
 							(prf_constructor_t)af_alg_prf_create);
 		}
 	}

src/libstrongswan/plugins/af_alg/af_alg_prf.h

@@ -46,7 +46,9 @@ af_alg_prf_t *af_alg_prf_create(pseudo_random_function_t algo);
 
 /**
  * Probe algorithms and register af_alg_prf_create().
+ *
+ * @param plugin		plugin name to register algorithms for
  */
-void af_alg_prf_probe();
+void af_alg_prf_probe(char *plugin);
 
 #endif /** AF_ALG_PRF_H_ @}*/

src/libstrongswan/plugins/af_alg/af_alg_signer.c

@@ -71,7 +71,7 @@ static struct {
 /**
  * See header.
  */
-void af_alg_signer_probe()
+void af_alg_signer_probe(char *plugin)
 {
 	af_alg_ops_t *ops;
 	int i;
@@ -82,7 +82,7 @@ void af_alg_signer_probe()
 		if (ops)
 		{
 			ops->destroy(ops);
-			lib->crypto->add_signer(lib->crypto, algs[i].id, af_alg_plugin_name,
+			lib->crypto->add_signer(lib->crypto, algs[i].id, plugin,
 							(signer_constructor_t)af_alg_signer_create);
 		}
 	}

src/libstrongswan/plugins/af_alg/af_alg_signer.h

@@ -46,7 +46,9 @@ af_alg_signer_t *af_alg_signer_create(integrity_algorithm_t algo);
 
 /**
  * Probe algorithms and register af_alg_signer_create().
+ *
+ * @param plugin		plugin name to register algorithms for
  */
-void af_alg_signer_probe();
+void af_alg_signer_probe(char *plugin);
 
 #endif /** AF_ALG_SIGNER_H_ @}*/

src/libstrongswan/plugins/agent/agent_plugin.c

@@ -31,6 +31,12 @@ struct private_agent_plugin_t {
 	agent_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_agent_plugin_t *this)
+{
+	return "agent";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_agent_plugin_t *this)
 {
@@ -49,6 +55,7 @@ plugin_t *agent_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/blowfish/blowfish_plugin.c

@@ -19,8 +19,6 @@
 #include <library.h>
 #include "blowfish_crypter.h"
 
-static const char *plugin_name = "blowfish";
-
 typedef struct private_blowfish_plugin_t private_blowfish_plugin_t;
 
 /**
@@ -34,6 +32,12 @@ struct private_blowfish_plugin_t {
 	blowfish_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_blowfish_plugin_t *this)
+{
+	return "blowfish";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_blowfish_plugin_t *this)
 {
@@ -52,12 +56,13 @@ plugin_t *blowfish_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
-	lib->crypto->add_crypter(lib->crypto, ENCR_BLOWFISH, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_BLOWFISH, get_name(this),
 							 (crypter_constructor_t)blowfish_crypter_create);
 
 	return &this->public.plugin;

src/libstrongswan/plugins/ccm/ccm_plugin.c

@@ -19,8 +19,6 @@
 
 #include "ccm_aead.h"
 
-static const char *plugin_name = "ccm";
-
 typedef struct private_ccm_plugin_t private_ccm_plugin_t;
 
 /**
@@ -34,6 +32,12 @@ struct private_ccm_plugin_t {
 	ccm_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_ccm_plugin_t *this)
+{
+	return "ccm";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_ccm_plugin_t *this)
 {
@@ -52,29 +56,34 @@ plugin_t *ccm_plugin_create()
 	crypter_t *crypter;
 
 	INIT(this,
-		.public.plugin.destroy = _destroy,
+		.public = {
+			.plugin = {
+				.get_name = _get_name,
+				.destroy = _destroy,
+			},
+		},
 	);
 
 	crypter = lib->crypto->create_crypter(lib->crypto, ENCR_AES_CBC, 0);
 	if (crypter)
 	{
 		crypter->destroy(crypter);
-		lib->crypto->add_aead(lib->crypto, ENCR_AES_CCM_ICV8, plugin_name,
+		lib->crypto->add_aead(lib->crypto, ENCR_AES_CCM_ICV8, get_name(this),
 						(aead_constructor_t)ccm_aead_create);
-		lib->crypto->add_aead(lib->crypto, ENCR_AES_CCM_ICV12, plugin_name,
+		lib->crypto->add_aead(lib->crypto, ENCR_AES_CCM_ICV12, get_name(this),
 						(aead_constructor_t)ccm_aead_create);
-		lib->crypto->add_aead(lib->crypto, ENCR_AES_CCM_ICV16, plugin_name,
+		lib->crypto->add_aead(lib->crypto, ENCR_AES_CCM_ICV16, get_name(this),
 						(aead_constructor_t)ccm_aead_create);
 	}
 	crypter = lib->crypto->create_crypter(lib->crypto, ENCR_CAMELLIA_CBC, 0);
 	if (crypter)
 	{
 		crypter->destroy(crypter);
-		lib->crypto->add_aead(lib->crypto, ENCR_CAMELLIA_CCM_ICV8, plugin_name,
+		lib->crypto->add_aead(lib->crypto, ENCR_CAMELLIA_CCM_ICV8, get_name(this),
 						(aead_constructor_t)ccm_aead_create);
-		lib->crypto->add_aead(lib->crypto, ENCR_CAMELLIA_CCM_ICV12, plugin_name,
+		lib->crypto->add_aead(lib->crypto, ENCR_CAMELLIA_CCM_ICV12, get_name(this),
 						(aead_constructor_t)ccm_aead_create);
-		lib->crypto->add_aead(lib->crypto, ENCR_CAMELLIA_CCM_ICV16, plugin_name,
+		lib->crypto->add_aead(lib->crypto, ENCR_CAMELLIA_CCM_ICV16, get_name(this),
 						(aead_constructor_t)ccm_aead_create);
 	}
 

src/libstrongswan/plugins/constraints/constraints_plugin.c

@@ -36,6 +36,12 @@ struct private_constraints_plugin_t {
 	constraints_validator_t *validator;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_constraints_plugin_t *this)
+{
+	return "constraints";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_constraints_plugin_t *this)
 {
@@ -54,6 +60,7 @@ plugin_t *constraints_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/ctr/ctr_plugin.c

@@ -19,8 +19,6 @@
 
 #include "ctr_ipsec_crypter.h"
 
-static const char *plugin_name = "ctr";
-
 typedef struct private_ctr_plugin_t private_ctr_plugin_t;
 
 /**
@@ -34,6 +32,12 @@ struct private_ctr_plugin_t {
 	ctr_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_ctr_plugin_t *this)
+{
+	return "ctr";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_ctr_plugin_t *this)
 {
@@ -54,6 +58,7 @@ plugin_t *ctr_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
@@ -63,14 +68,14 @@ plugin_t *ctr_plugin_create()
 	if (crypter)
 	{
 		crypter->destroy(crypter);
-		lib->crypto->add_crypter(lib->crypto, ENCR_AES_CTR, plugin_name,
+		lib->crypto->add_crypter(lib->crypto, ENCR_AES_CTR, get_name(this),
 						(crypter_constructor_t)ctr_ipsec_crypter_create);
 	}
 	crypter = lib->crypto->create_crypter(lib->crypto, ENCR_CAMELLIA_CBC, 16);
 	if (crypter)
 	{
 		crypter->destroy(crypter);
-		lib->crypto->add_crypter(lib->crypto, ENCR_CAMELLIA_CTR, plugin_name,
+		lib->crypto->add_crypter(lib->crypto, ENCR_CAMELLIA_CTR, get_name(this),
 						(crypter_constructor_t)ctr_ipsec_crypter_create);
 	}
 	return &this->public.plugin;

src/libstrongswan/plugins/curl/curl_plugin.c

@@ -34,6 +34,12 @@ struct private_curl_plugin_t {
 	curl_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_curl_plugin_t *this)
+{
+	return "curl";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_curl_plugin_t *this)
 {
@@ -54,6 +60,7 @@ plugin_t *curl_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/des/des_plugin.c

@@ -18,8 +18,6 @@
 #include <library.h>
 #include "des_crypter.h"
 
-static const char *plugin_name = "des";
-
 typedef struct private_des_plugin_t private_des_plugin_t;
 
 /**
@@ -33,6 +31,12 @@ struct private_des_plugin_t {
 	des_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_des_plugin_t *this)
+{
+	return "des";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_des_plugin_t *this)
 {
@@ -51,16 +55,17 @@ plugin_t *des_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
-	lib->crypto->add_crypter(lib->crypto, ENCR_3DES, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_3DES, get_name(this),
 							 (crypter_constructor_t)des_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_DES, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_DES, get_name(this),
 							 (crypter_constructor_t)des_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_DES_ECB, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_DES_ECB, get_name(this),
 							 (crypter_constructor_t)des_crypter_create);
 
 	return &this->public.plugin;

src/libstrongswan/plugins/dnskey/dnskey_plugin.c

@@ -31,6 +31,12 @@ struct private_dnskey_plugin_t {
 	dnskey_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_dnskey_plugin_t *this)
+{
+	return "dnskey";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_dnskey_plugin_t *this)
 {
@@ -49,6 +55,7 @@ plugin_t *dnskey_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/fips_prf/fips_prf_plugin.c

@@ -18,8 +18,6 @@
 #include <library.h>
 #include "fips_prf.h"
 
-static const char *plugin_name = "fips-prf";
-
 typedef struct private_fips_prf_plugin_t private_fips_prf_plugin_t;
 
 /**
@@ -33,6 +31,12 @@ struct private_fips_prf_plugin_t {
 	fips_prf_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_fips_prf_plugin_t *this)
+{
+	return "fips-prf";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_fips_prf_plugin_t *this)
 {
@@ -52,6 +56,7 @@ plugin_t *fips_prf_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
@@ -61,7 +66,7 @@ plugin_t *fips_prf_plugin_create()
 	if (prf)
 	{
 		prf->destroy(prf);
-		lib->crypto->add_prf(lib->crypto, PRF_FIPS_SHA1_160, plugin_name,
+		lib->crypto->add_prf(lib->crypto, PRF_FIPS_SHA1_160, get_name(this),
 							 (prf_constructor_t)fips_prf_create);
 	}
 

src/libstrongswan/plugins/gcm/gcm_plugin.c

@@ -19,8 +19,6 @@
 
 #include "gcm_aead.h"
 
-static const char *plugin_name = "gcm";
-
 typedef struct private_gcm_plugin_t private_gcm_plugin_t;
 
 /**
@@ -34,6 +32,12 @@ struct private_gcm_plugin_t {
 	gcm_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_gcm_plugin_t *this)
+{
+	return "gcm";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_gcm_plugin_t *this)
 {
@@ -52,18 +56,23 @@ plugin_t *gcm_plugin_create()
 	crypter_t *crypter;
 
 	INIT(this,
-		.public.plugin.destroy = _destroy,
+		.public = {
+			.plugin = {
+				.get_name = _get_name,
+				.destroy = _destroy,
+			},
+		},
 	);
 
 	crypter = lib->crypto->create_crypter(lib->crypto, ENCR_AES_CBC, 0);
 	if (crypter)
 	{
 		crypter->destroy(crypter);
-		lib->crypto->add_aead(lib->crypto, ENCR_AES_GCM_ICV8, plugin_name,
+		lib->crypto->add_aead(lib->crypto, ENCR_AES_GCM_ICV8, get_name(this),
 						(aead_constructor_t)gcm_aead_create);
-		lib->crypto->add_aead(lib->crypto, ENCR_AES_GCM_ICV12, plugin_name,
+		lib->crypto->add_aead(lib->crypto, ENCR_AES_GCM_ICV12, get_name(this),
 						(aead_constructor_t)gcm_aead_create);
-		lib->crypto->add_aead(lib->crypto, ENCR_AES_GCM_ICV16, plugin_name,
+		lib->crypto->add_aead(lib->crypto, ENCR_AES_GCM_ICV16, get_name(this),
 						(aead_constructor_t)gcm_aead_create);
 	}
 

src/libstrongswan/plugins/gcrypt/gcrypt_plugin.c

@@ -29,8 +29,6 @@
 #include <errno.h>
 #include <gcrypt.h>
 
-static const char *plugin_name = "gcrypt";
-
 typedef struct private_gcrypt_plugin_t private_gcrypt_plugin_t;
 
 /**
@@ -95,6 +93,12 @@ static struct gcry_thread_cbs thread_functions = {
 	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_gcrypt_plugin_t *this)
+{
+	return "gcrypt";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_gcrypt_plugin_t *this)
 {
@@ -144,85 +148,86 @@ plugin_t *gcrypt_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
 	/* hashers */
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA1, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA1, get_name(this),
 					(hasher_constructor_t)gcrypt_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_MD4, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_MD4, get_name(this),
 					(hasher_constructor_t)gcrypt_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_MD5, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_MD5, get_name(this),
 					(hasher_constructor_t)gcrypt_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA224, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA224, get_name(this),
 					(hasher_constructor_t)gcrypt_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA256, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA256, get_name(this),
 					(hasher_constructor_t)gcrypt_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA384, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA384, get_name(this),
 					(hasher_constructor_t)gcrypt_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA512, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA512, get_name(this),
 					(hasher_constructor_t)gcrypt_hasher_create);
 
 	/* crypters */
-	lib->crypto->add_crypter(lib->crypto, ENCR_3DES, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_3DES, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_CAST, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_CAST, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_BLOWFISH, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_BLOWFISH, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_DES, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_DES, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_DES_ECB, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_DES_ECB, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_AES_CBC, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_AES_CBC, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_AES_CTR, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_AES_CTR, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
 #ifdef HAVE_GCRY_CIPHER_CAMELLIA
-	lib->crypto->add_crypter(lib->crypto, ENCR_CAMELLIA_CBC, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_CAMELLIA_CBC, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_CAMELLIA_CTR, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_CAMELLIA_CTR, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
 #endif /* HAVE_GCRY_CIPHER_CAMELLIA */
-	lib->crypto->add_crypter(lib->crypto, ENCR_SERPENT_CBC, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_SERPENT_CBC, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_TWOFISH_CBC, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_TWOFISH_CBC, get_name(this),
 					(crypter_constructor_t)gcrypt_crypter_create);
 
 	/* random numbers */
-	lib->crypto->add_rng(lib->crypto, RNG_WEAK, plugin_name,
+	lib->crypto->add_rng(lib->crypto, RNG_WEAK, get_name(this),
 						 (rng_constructor_t)gcrypt_rng_create);
-	lib->crypto->add_rng(lib->crypto, RNG_STRONG, plugin_name,
+	lib->crypto->add_rng(lib->crypto, RNG_STRONG, get_name(this),
 						 (rng_constructor_t)gcrypt_rng_create);
-	lib->crypto->add_rng(lib->crypto, RNG_TRUE, plugin_name,
+	lib->crypto->add_rng(lib->crypto, RNG_TRUE, get_name(this),
 						 (rng_constructor_t)gcrypt_rng_create);
 
 	/* diffie hellman groups, using modp */
-	lib->crypto->add_dh(lib->crypto, MODP_2048_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_2048_BIT, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_2048_224, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_2048_224, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_2048_256, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_2048_256, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_1536_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_1536_BIT, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_3072_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_3072_BIT, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_4096_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_4096_BIT, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_6144_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_6144_BIT, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_8192_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_8192_BIT, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_1024_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_1024_BIT, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_1024_160, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_1024_160, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_768_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_768_BIT, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create);
-	lib->crypto->add_dh(lib->crypto, MODP_CUSTOM, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_CUSTOM, get_name(this),
 					(dh_constructor_t)gcrypt_dh_create_custom);
 
 	/* RSA */

src/libstrongswan/plugins/gmp/gmp_plugin.c

@@ -20,8 +20,6 @@
 #include "gmp_rsa_private_key.h"
 #include "gmp_rsa_public_key.h"
 
-static const char *plugin_name = "gmp";
-
 typedef struct private_gmp_plugin_t private_gmp_plugin_t;
 
 /**
@@ -35,6 +33,12 @@ struct private_gmp_plugin_t {
 	gmp_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_gmp_plugin_t *this)
+{
+	return "gmp";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_gmp_plugin_t *this)
 {
@@ -61,35 +65,36 @@ plugin_t *gmp_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
-	lib->crypto->add_dh(lib->crypto, MODP_2048_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_2048_BIT, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_2048_224, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_2048_224, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_2048_256, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_2048_256, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_1536_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_1536_BIT, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_3072_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_3072_BIT, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_4096_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_4096_BIT, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_6144_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_6144_BIT, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_8192_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_8192_BIT, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_1024_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_1024_BIT, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_1024_160, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_1024_160, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_768_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_768_BIT, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create);
 
-	lib->crypto->add_dh(lib->crypto, MODP_CUSTOM, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_CUSTOM, get_name(this),
 						(dh_constructor_t)gmp_diffie_hellman_create_custom);
 
 	lib->creds->add_builder(lib->creds, CRED_PRIVATE_KEY, KEY_RSA, FALSE,

src/libstrongswan/plugins/hmac/hmac_plugin.c

@@ -19,8 +19,6 @@
 #include "hmac_signer.h"
 #include "hmac_prf.h"
 
-static const char *plugin_name = "hmac";
-
 typedef struct private_hmac_plugin_t private_hmac_plugin_t;
 
 /**
@@ -34,6 +32,12 @@ struct private_hmac_plugin_t {
 	hmac_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_hmac_plugin_t *this)
+{
+	return "hmac";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_hmac_plugin_t *this)
 {
@@ -55,6 +59,7 @@ plugin_t *hmac_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
@@ -64,24 +69,24 @@ plugin_t *hmac_plugin_create()
 	if (hasher)
 	{
 		hasher->destroy(hasher);
-		lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA1, plugin_name,
+		lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA1, get_name(this),
 						(prf_constructor_t)hmac_prf_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA1_96, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA1_96, get_name(this),
 						(signer_constructor_t)hmac_signer_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA1_128, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA1_128, get_name(this),
 						(signer_constructor_t)hmac_signer_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA1_160, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA1_160, get_name(this),
 						(signer_constructor_t)hmac_signer_create);
 	}
 	hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA256);
 	if (hasher)
 	{
 		hasher->destroy(hasher);
-		lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA2_256, plugin_name,
+		lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA2_256, get_name(this),
 						(prf_constructor_t)hmac_prf_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_256_128, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_256_128, get_name(this),
 						(signer_constructor_t)hmac_signer_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_256_256, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_256_256, get_name(this),
 						(signer_constructor_t)hmac_signer_create);
 
 	}
@@ -89,31 +94,31 @@ plugin_t *hmac_plugin_create()
 	if (hasher)
 	{
 		hasher->destroy(hasher);
-		lib->crypto->add_prf(lib->crypto, PRF_HMAC_MD5, plugin_name,
+		lib->crypto->add_prf(lib->crypto, PRF_HMAC_MD5, get_name(this),
 						(prf_constructor_t)hmac_prf_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_MD5_96, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_MD5_96, get_name(this),
 						(signer_constructor_t)hmac_signer_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_MD5_128, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_MD5_128, get_name(this),
 						(signer_constructor_t)hmac_signer_create);
 	}
 	hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA384);
 	if (hasher)
 	{
 		hasher->destroy(hasher);
-		lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA2_384, plugin_name,
+		lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA2_384, get_name(this),
 						(prf_constructor_t)hmac_prf_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_384_192, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_384_192, get_name(this),
 						(signer_constructor_t)hmac_signer_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_384_384, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_384_384, get_name(this),
 						(signer_constructor_t)hmac_signer_create);
 	}
 	hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA512);
 	if (hasher)
 	{
 		hasher->destroy(hasher);
-		lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA2_512, plugin_name,
+		lib->crypto->add_prf(lib->crypto, PRF_HMAC_SHA2_512, get_name(this),
 						(prf_constructor_t)hmac_prf_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_512_256, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_HMAC_SHA2_512_256, get_name(this),
 						(signer_constructor_t)hmac_signer_create);
 	}
 

src/libstrongswan/plugins/ldap/ldap_plugin.c

@@ -31,6 +31,12 @@ struct private_ldap_plugin_t {
 	ldap_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_ldap_plugin_t *this)
+{
+	return "ldap";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_ldap_plugin_t *this)
 {
@@ -49,6 +55,7 @@ plugin_t *ldap_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/md4/md4_plugin.c

@@ -18,8 +18,6 @@
 #include <library.h>
 #include "md4_hasher.h"
 
-static const char *plugin_name = "md4";
-
 typedef struct private_md4_plugin_t private_md4_plugin_t;
 
 /**
@@ -33,6 +31,12 @@ struct private_md4_plugin_t {
 	md4_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_md4_plugin_t *this)
+{
+	return "md4";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_md4_plugin_t *this)
 {
@@ -51,12 +55,13 @@ plugin_t *md4_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
-	lib->crypto->add_hasher(lib->crypto, HASH_MD4, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_MD4, get_name(this),
 							(hasher_constructor_t)md4_hasher_create);
 
 	return &this->public.plugin;

src/libstrongswan/plugins/md5/md5_plugin.c

@@ -18,8 +18,6 @@
 #include <library.h>
 #include "md5_hasher.h"
 
-static const char *plugin_name = "md5";
-
 typedef struct private_md5_plugin_t private_md5_plugin_t;
 
 /**
@@ -33,6 +31,12 @@ struct private_md5_plugin_t {
 	md5_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_md5_plugin_t *this)
+{
+	return "md5";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_md5_plugin_t *this)
 {
@@ -51,12 +55,13 @@ plugin_t *md5_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
-	lib->crypto->add_hasher(lib->crypto, HASH_MD5, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_MD5, get_name(this),
 							(hasher_constructor_t)md5_hasher_create);
 
 	return &this->public.plugin;

src/libstrongswan/plugins/mysql/mysql_plugin.c

@@ -32,6 +32,12 @@ struct private_mysql_plugin_t {
 	mysql_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_mysql_plugin_t *this)
+{
+	return "mysql";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_mysql_plugin_t *this)
 {
@@ -57,6 +63,7 @@ plugin_t *mysql_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/openssl/openssl_plugin.c

@@ -41,8 +41,6 @@
 #include "openssl_x509.h"
 #include "openssl_crl.h"
 
-static const char *plugin_name = "openssl";
-
 typedef struct private_openssl_plugin_t private_openssl_plugin_t;
 
 /**
@@ -195,6 +193,12 @@ static void threading_cleanup()
 	mutex = NULL;
 }
 
+METHOD(plugin_t, get_name, char*,
+	private_openssl_plugin_t *this)
+{
+	return "openssl";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_openssl_plugin_t *this)
 {
@@ -250,6 +254,7 @@ plugin_t *openssl_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
@@ -274,85 +279,85 @@ plugin_t *openssl_plugin_create()
 	}
 
 	/* crypter */
-	lib->crypto->add_crypter(lib->crypto, ENCR_AES_CBC, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_AES_CBC, get_name(this),
 					(crypter_constructor_t)openssl_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_CAMELLIA_CBC, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_CAMELLIA_CBC, get_name(this),
 					(crypter_constructor_t)openssl_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_3DES, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_3DES, get_name(this),
 					(crypter_constructor_t)openssl_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_RC5, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_RC5, get_name(this),
 					(crypter_constructor_t)openssl_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_IDEA, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_IDEA, get_name(this),
 					(crypter_constructor_t)openssl_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_CAST, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_CAST, get_name(this),
 					(crypter_constructor_t)openssl_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_BLOWFISH, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_BLOWFISH, get_name(this),
 					(crypter_constructor_t)openssl_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_DES, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_DES, get_name(this),
 					(crypter_constructor_t)openssl_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_DES_ECB, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_DES_ECB, get_name(this),
 					(crypter_constructor_t)openssl_crypter_create);
-	lib->crypto->add_crypter(lib->crypto, ENCR_NULL, plugin_name,
+	lib->crypto->add_crypter(lib->crypto, ENCR_NULL, get_name(this),
 					(crypter_constructor_t)openssl_crypter_create);
 
 	/* hasher */
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA1, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA1, get_name(this),
 					(hasher_constructor_t)openssl_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_MD2, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_MD2, get_name(this),
 					(hasher_constructor_t)openssl_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_MD4, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_MD4, get_name(this),
 					(hasher_constructor_t)openssl_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_MD5, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_MD5, get_name(this),
 					(hasher_constructor_t)openssl_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA224, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA224, get_name(this),
 					(hasher_constructor_t)openssl_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA256, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA256, get_name(this),
 					(hasher_constructor_t)openssl_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA384, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA384, get_name(this),
 					(hasher_constructor_t)openssl_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA512, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA512, get_name(this),
 					(hasher_constructor_t)openssl_hasher_create);
 
 	/* prf */
-	lib->crypto->add_prf(lib->crypto, PRF_KEYED_SHA1, plugin_name,
+	lib->crypto->add_prf(lib->crypto, PRF_KEYED_SHA1, get_name(this),
 					(prf_constructor_t)openssl_sha1_prf_create);
 
 	/* (ec) diffie hellman */
-	lib->crypto->add_dh(lib->crypto, MODP_2048_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_2048_BIT, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_2048_224, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_2048_224, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_2048_256, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_2048_256, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_1536_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_1536_BIT, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
 #ifndef OPENSSL_NO_EC
-	lib->crypto->add_dh(lib->crypto, ECP_256_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, ECP_256_BIT, get_name(this),
 						(dh_constructor_t)openssl_ec_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, ECP_384_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, ECP_384_BIT, get_name(this),
 						(dh_constructor_t)openssl_ec_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, ECP_521_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, ECP_521_BIT, get_name(this),
 						(dh_constructor_t)openssl_ec_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, ECP_224_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, ECP_224_BIT, get_name(this),
 						(dh_constructor_t)openssl_ec_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, ECP_192_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, ECP_192_BIT, get_name(this),
 						(dh_constructor_t)openssl_ec_diffie_hellman_create);
 #endif /* OPENSSL_NO_EC */
-	lib->crypto->add_dh(lib->crypto, MODP_3072_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_3072_BIT, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_4096_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_4096_BIT, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_6144_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_6144_BIT, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_8192_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_8192_BIT, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_1024_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_1024_BIT, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_1024_160, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_1024_160, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_768_BIT, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_768_BIT, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
-	lib->crypto->add_dh(lib->crypto, MODP_CUSTOM, plugin_name,
+	lib->crypto->add_dh(lib->crypto, MODP_CUSTOM, get_name(this),
 						(dh_constructor_t)openssl_diffie_hellman_create);
 
 	/* rsa */

src/libstrongswan/plugins/padlock/padlock_plugin.c

@@ -23,8 +23,6 @@
 #include <library.h>
 #include <debug.h>
 
-static const char *plugin_name = "padlock";
-
 typedef struct private_padlock_plugin_t private_padlock_plugin_t;
 typedef enum padlock_feature_t padlock_feature_t;
 
@@ -103,6 +101,12 @@ static padlock_feature_t get_padlock_features()
 	return 0;
 }
 
+METHOD(plugin_t, get_name, char*,
+	private_padlock_plugin_t *this)
+{
+	return "padlock";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_padlock_plugin_t *this)
 {
@@ -138,6 +142,7 @@ plugin_t *padlock_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
@@ -163,21 +168,21 @@ plugin_t *padlock_plugin_create()
 
 	if (this->features & PADLOCK_RNG_ENABLED)
 	{
-		lib->crypto->add_rng(lib->crypto, RNG_TRUE, plugin_name,
+		lib->crypto->add_rng(lib->crypto, RNG_TRUE, get_name(this),
 						(rng_constructor_t)padlock_rng_create);
-		lib->crypto->add_rng(lib->crypto, RNG_STRONG, plugin_name,
+		lib->crypto->add_rng(lib->crypto, RNG_STRONG, get_name(this),
 						(rng_constructor_t)padlock_rng_create);
-		lib->crypto->add_rng(lib->crypto, RNG_WEAK, plugin_name,
+		lib->crypto->add_rng(lib->crypto, RNG_WEAK, get_name(this),
 						(rng_constructor_t)padlock_rng_create);
 	}
 	if (this->features & PADLOCK_ACE2_ENABLED)
 	{
-		lib->crypto->add_crypter(lib->crypto, ENCR_AES_CBC, plugin_name,
+		lib->crypto->add_crypter(lib->crypto, ENCR_AES_CBC, get_name(this),
 						(crypter_constructor_t)padlock_aes_crypter_create);
 	}
 	if (this->features & PADLOCK_PHE_ENABLED)
 	{
-		lib->crypto->add_hasher(lib->crypto, HASH_SHA1, plugin_name,
+		lib->crypto->add_hasher(lib->crypto, HASH_SHA1, get_name(this),
 						(hasher_constructor_t)padlock_sha1_hasher_create);
 	}
 	return &this->public.plugin;

src/libstrongswan/plugins/pem/pem_plugin.c

@@ -33,6 +33,12 @@ struct private_pem_plugin_t {
 	pem_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_pem_plugin_t *this)
+{
+	return "pem";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_pem_plugin_t *this)
 {
@@ -55,6 +61,7 @@ plugin_t *pem_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/pgp/pgp_plugin.c

@@ -33,6 +33,12 @@ struct private_pgp_plugin_t {
 	pgp_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_pgp_plugin_t *this)
+{
+	return "pgp";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_pgp_plugin_t *this)
 {
@@ -59,6 +65,7 @@ plugin_t *pgp_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/pkcs1/pkcs1_plugin.c

@@ -32,6 +32,12 @@ struct private_pkcs1_plugin_t {
 	pkcs1_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_pkcs1_plugin_t *this)
+{
+	return "pkcs1";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_pkcs1_plugin_t *this)
 {
@@ -55,6 +61,7 @@ plugin_t *pkcs1_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/pkcs11/pkcs11_plugin.c

@@ -26,8 +26,6 @@
 #include "pkcs11_public_key.h"
 #include "pkcs11_hasher.h"
 
-static const char *plugin_name = "pkcs11";
-
 typedef struct private_pkcs11_plugin_t private_pkcs11_plugin_t;
 
 /**
@@ -103,6 +101,12 @@ static void token_event_cb(private_pkcs11_plugin_t *this, pkcs11_library_t *p11,
 	}
 }
 
+METHOD(plugin_t, get_name, char*,
+	private_pkcs11_plugin_t *this)
+{
+	return "pkcs11";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_pkcs11_plugin_t *this)
 {
@@ -136,6 +140,7 @@ plugin_t *pkcs11_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
@@ -148,17 +153,17 @@ plugin_t *pkcs11_plugin_create()
 	if (lib->settings->get_bool(lib->settings,
 							"libstrongswan.plugins.pkcs11.use_hasher", FALSE))
 	{
-		lib->crypto->add_hasher(lib->crypto, HASH_MD2, plugin_name,
+		lib->crypto->add_hasher(lib->crypto, HASH_MD2, get_name(this),
 					(hasher_constructor_t)pkcs11_hasher_create);
-		lib->crypto->add_hasher(lib->crypto, HASH_MD5, plugin_name,
+		lib->crypto->add_hasher(lib->crypto, HASH_MD5, get_name(this),
 					(hasher_constructor_t)pkcs11_hasher_create);
-		lib->crypto->add_hasher(lib->crypto, HASH_SHA1, plugin_name,
+		lib->crypto->add_hasher(lib->crypto, HASH_SHA1, get_name(this),
 					(hasher_constructor_t)pkcs11_hasher_create);
-		lib->crypto->add_hasher(lib->crypto, HASH_SHA256, plugin_name,
+		lib->crypto->add_hasher(lib->crypto, HASH_SHA256, get_name(this),
 					(hasher_constructor_t)pkcs11_hasher_create);
-		lib->crypto->add_hasher(lib->crypto, HASH_SHA384, plugin_name,
+		lib->crypto->add_hasher(lib->crypto, HASH_SHA384, get_name(this),
 					(hasher_constructor_t)pkcs11_hasher_create);
-		lib->crypto->add_hasher(lib->crypto, HASH_SHA512, plugin_name,
+		lib->crypto->add_hasher(lib->crypto, HASH_SHA512, get_name(this),
 					(hasher_constructor_t)pkcs11_hasher_create);
 	}
 

src/libstrongswan/plugins/plugin.h

@@ -28,6 +28,13 @@ typedef struct plugin_t plugin_t;
  */
 struct plugin_t {
 
+	/**
+	 * Get the name of the plugin.
+	 *
+	 * @return		plugin name
+	 */
+	char* (*get_name)(plugin_t *this);
+
 	/**
 	 * Destroy a plugin instance.
 	 */

src/libstrongswan/plugins/plugin_loader.c

@@ -43,11 +43,6 @@ struct private_plugin_loader_t {
 	 * list of loaded plugins
 	 */
 	linked_list_t *plugins;
-
-	/**
-	 * names of loaded plugins
-	 */
-	linked_list_t *names;
 };
 
 /**
@@ -151,12 +146,12 @@ static bool plugin_loaded(private_plugin_loader_t *this, char *name)
 {
 	enumerator_t *enumerator;
 	bool found = FALSE;
-	char *current;
+	plugin_t *plugin;
 
-	enumerator = this->names->create_enumerator(this->names);
-	while (enumerator->enumerate(enumerator, &current))
+	enumerator = this->plugins->create_enumerator(this->plugins);
+	while (enumerator->enumerate(enumerator, &plugin))
 	{
-		if (streq(name, current))
+		if (streq(plugin->get_name(plugin), name))
 		{
 			found = TRUE;
 			break;
@@ -201,7 +196,6 @@ METHOD(plugin_loader_t, load_plugins, bool,
 		if (plugin)
 		{
 			this->plugins->insert_last(this->plugins, plugin);
-			this->names->insert_last(this->names, token);
 		}
 		else
 		{
@@ -210,8 +204,8 @@ METHOD(plugin_loader_t, load_plugins, bool,
 				critical_failed = TRUE;
 				DBG1(DBG_LIB, "loading critical plugin '%s' failed", token);
 			}
-			free(token);
 		}
+		free(token);
 	}
 	enumerator->destroy(enumerator);
 	return !critical_failed;
@@ -221,7 +215,6 @@ METHOD(plugin_loader_t, unload, void,
 	private_plugin_loader_t *this)
 {
 	plugin_t *plugin;
-	char *name;
 
 	/* unload plugins in reverse order */
 	while (this->plugins->remove_last(this->plugins,
@@ -229,23 +222,18 @@ METHOD(plugin_loader_t, unload, void,
 	{
 		plugin->destroy(plugin);
 	}
-	while (this->names->remove_last(this->names, (void**)&name) == SUCCESS)
-	{
-		free(name);
-	}
 }
 
 METHOD(plugin_loader_t, create_plugin_enumerator, enumerator_t*,
 	private_plugin_loader_t *this)
 {
-	return this->names->create_enumerator(this->names);
+	return this->plugins->create_enumerator(this->plugins);
 }
 
 METHOD(plugin_loader_t, destroy, void,
 	private_plugin_loader_t *this)
 {
 	this->plugins->destroy_offset(this->plugins, offsetof(plugin_t, destroy));
-	this->names->destroy_function(this->names, free);
 	free(this);
 }
 
@@ -264,7 +252,6 @@ plugin_loader_t *plugin_loader_create()
 			.destroy = _destroy,
 		},
 		.plugins = linked_list_create(),
-		.names = linked_list_create(),
 	);
 
 	return &this->public;

src/libstrongswan/plugins/plugin_loader.h

@@ -49,9 +49,9 @@ struct plugin_loader_t {
 	void (*unload)(plugin_loader_t *this);
 
 	/**
-	 * Create an enumerator over all loaded plugin names.
+	 * Create an enumerator over all loaded plugins.
 	 *
-	 * @return				enumerator over char*
+	 * @return				enumerator over plugin_t*
 	 */
 	enumerator_t* (*create_plugin_enumerator)(plugin_loader_t *this);
 

src/libstrongswan/plugins/pubkey/pubkey_plugin.c

@@ -31,6 +31,12 @@ struct private_pubkey_plugin_t {
 	pubkey_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_pubkey_plugin_t *this)
+{
+	return "pubkey";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_pubkey_plugin_t *this)
 {
@@ -49,6 +55,7 @@ plugin_t *pubkey_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/random/random_plugin.c

@@ -18,8 +18,6 @@
 #include <library.h>
 #include "random_rng.h"
 
-static const char *plugin_name = "random";
-
 typedef struct private_random_plugin_t private_random_plugin_t;
 
 /**
@@ -33,6 +31,12 @@ struct private_random_plugin_t {
 	random_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_random_plugin_t *this)
+{
+	return "random";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_random_plugin_t *this)
 {
@@ -51,14 +55,15 @@ plugin_t *random_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
-	lib->crypto->add_rng(lib->crypto, RNG_STRONG, plugin_name,
+	lib->crypto->add_rng(lib->crypto, RNG_STRONG, get_name(this),
 						 (rng_constructor_t)random_rng_create);
-	lib->crypto->add_rng(lib->crypto, RNG_TRUE, plugin_name,
+	lib->crypto->add_rng(lib->crypto, RNG_TRUE, get_name(this),
 						 (rng_constructor_t)random_rng_create);
 
 	return &this->public.plugin;

src/libstrongswan/plugins/revocation/revocation_plugin.c

@@ -36,6 +36,12 @@ struct private_revocation_plugin_t {
 	revocation_validator_t *validator;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_revocation_plugin_t *this)
+{
+	return "revocation";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_revocation_plugin_t *this)
 {
@@ -54,6 +60,7 @@ plugin_t *revocation_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/sha1/sha1_plugin.c

@@ -19,8 +19,6 @@
 #include "sha1_hasher.h"
 #include "sha1_prf.h"
 
-static const char *plugin_name = "sha1";
-
 typedef struct private_sha1_plugin_t private_sha1_plugin_t;
 
 /**
@@ -34,6 +32,12 @@ struct private_sha1_plugin_t {
 	sha1_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_sha1_plugin_t *this)
+{
+	return "sha1";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_sha1_plugin_t *this)
 {
@@ -54,14 +58,15 @@ plugin_t *sha1_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA1, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA1, get_name(this),
 							(hasher_constructor_t)sha1_hasher_create);
-	lib->crypto->add_prf(lib->crypto, PRF_KEYED_SHA1, plugin_name,
+	lib->crypto->add_prf(lib->crypto, PRF_KEYED_SHA1, get_name(this),
 							(prf_constructor_t)sha1_prf_create);
 
 	return &this->public.plugin;

src/libstrongswan/plugins/sha2/sha2_plugin.c

@@ -18,8 +18,6 @@
 #include <library.h>
 #include "sha2_hasher.h"
 
-static const char *plugin_name = "sha2";
-
 typedef struct private_sha2_plugin_t private_sha2_plugin_t;
 
 /**
@@ -33,6 +31,12 @@ struct private_sha2_plugin_t {
 	sha2_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_sha2_plugin_t *this)
+{
+	return "sha2";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_sha2_plugin_t *this)
 {
@@ -51,18 +55,19 @@ plugin_t *sha2_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
 	);
 
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA224, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA224, get_name(this),
 							(hasher_constructor_t)sha2_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA256, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA256, get_name(this),
 							(hasher_constructor_t)sha2_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA384, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA384, get_name(this),
 							(hasher_constructor_t)sha2_hasher_create);
-	lib->crypto->add_hasher(lib->crypto, HASH_SHA512, plugin_name,
+	lib->crypto->add_hasher(lib->crypto, HASH_SHA512, get_name(this),
 							(hasher_constructor_t)sha2_hasher_create);
 
 	return &this->public.plugin;

src/libstrongswan/plugins/soup/soup_plugin.c

@@ -34,6 +34,12 @@ struct private_soup_plugin_t {
 	soup_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_soup_plugin_t *this)
+{
+	return "soup";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_soup_plugin_t *this)
 {
@@ -58,6 +64,7 @@ plugin_t *soup_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/sqlite/sqlite_plugin.c

@@ -31,6 +31,12 @@ struct private_sqlite_plugin_t {
 	sqlite_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_sqlite_plugin_t *this)
+{
+	return "sqlite";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_sqlite_plugin_t *this)
 {
@@ -49,6 +55,7 @@ plugin_t *sqlite_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/test_vectors/test_vectors_plugin.c

@@ -104,6 +104,12 @@ struct private_test_vectors_plugin_t {
 	test_vectors_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_test_vectors_plugin_t *this)
+{
+	return "test-vectors";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_test_vectors_plugin_t *this)
 {
@@ -121,6 +127,7 @@ plugin_t *test_vectors_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/x509/x509_plugin.c

@@ -36,6 +36,12 @@ struct private_x509_plugin_t {
 	x509_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_x509_plugin_t *this)
+{
+	return "x509";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_x509_plugin_t *this)
 {
@@ -72,6 +78,7 @@ plugin_t *x509_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},

src/libstrongswan/plugins/xcbc/xcbc_plugin.c

@@ -19,8 +19,6 @@
 #include "xcbc_signer.h"
 #include "xcbc_prf.h"
 
-static const char *plugin_name = "xcbc";
-
 typedef struct private_xcbc_plugin_t private_xcbc_plugin_t;
 
 /**
@@ -34,6 +32,12 @@ struct private_xcbc_plugin_t {
 	xcbc_plugin_t public;
 };
 
+METHOD(plugin_t, get_name, char*,
+	private_xcbc_plugin_t *this)
+{
+	return "xcbc";
+}
+
 METHOD(plugin_t, destroy, void,
 	private_xcbc_plugin_t *this)
 {
@@ -55,6 +59,7 @@ plugin_t *xcbc_plugin_create()
 	INIT(this,
 		.public = {
 			.plugin = {
+				.get_name = _get_name,
 				.destroy = _destroy,
 			},
 		},
@@ -64,18 +69,18 @@ plugin_t *xcbc_plugin_create()
 	if (crypter)
 	{
 		crypter->destroy(crypter);
-		lib->crypto->add_prf(lib->crypto, PRF_AES128_XCBC, plugin_name,
+		lib->crypto->add_prf(lib->crypto, PRF_AES128_XCBC, get_name(this),
 						(prf_constructor_t)xcbc_prf_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_AES_XCBC_96, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_AES_XCBC_96, get_name(this),
 						(signer_constructor_t)xcbc_signer_create);
 	}
 	crypter = lib->crypto->create_crypter(lib->crypto, ENCR_CAMELLIA_CBC, 16);
 	if (crypter)
 	{
 		crypter->destroy(crypter);
-		lib->crypto->add_prf(lib->crypto, PRF_CAMELLIA128_XCBC, plugin_name,
+		lib->crypto->add_prf(lib->crypto, PRF_CAMELLIA128_XCBC, get_name(this),
 						(prf_constructor_t)xcbc_prf_create);
-		lib->crypto->add_signer(lib->crypto, AUTH_CAMELLIA_XCBC_96, plugin_name,
+		lib->crypto->add_signer(lib->crypto, AUTH_CAMELLIA_XCBC_96, get_name(this),
 						(signer_constructor_t)xcbc_signer_create);
 	}
 	return &this->public.plugin;