Add features support to af_alg plugin

diff --git a/src/libstrongswan/plugins/af_alg/af_alg_crypter.c b/src/libstrongswan/plugins/af_alg/af_alg_crypter.c
index 7b3c062aa667e8a2e788a11eb8cc51fa8de3276d..9c547140dd5e4b8115f39d927dbd934bc57acbf0 100644 (file)
--- a/src/libstrongswan/plugins/af_alg/af_alg_crypter.c
+++ b/src/libstrongswan/plugins/af_alg/af_alg_crypter.c
@@ -61,7 +61,7 @@ static struct {
        /* size of the keying material (key + nonce for ctr mode) */
        size_t keymat_size;
        size_t iv_size;
-} algs[] = {
+} algs[AF_ALG_CRYPTER] = {
        {ENCR_DES,                      "cbc(des)",                                      8,      8,      8,      8,     },
        {ENCR_DES_ECB,          "ecb(des)",                                      8,      8,      8,      0,     },
        {ENCR_3DES,                     "cbc(des3_ede)",                         8,     24,     24,      8,     },
@@ -92,25 +92,20 @@ static struct {
 /**
  * See header.
  */
-void af_alg_crypter_probe(char *plugin)
+void af_alg_crypter_probe(plugin_feature_t *features, int *pos)
 {
-       encryption_algorithm_t prev = -1;
        af_alg_ops_t *ops;
        int i;
 
        for (i = 0; i < countof(algs); i++)
        {
-               if (prev != algs[i].id)
+               ops = af_alg_ops_create("skcipher", algs[i].name);
+               if (ops)
                {
-                       ops = af_alg_ops_create("skcipher", algs[i].name);
-                       if (ops)
-                       {
-                               ops->destroy(ops);
-                               lib->crypto->add_crypter(lib->crypto, algs[i].id, plugin,
-                                                               (crypter_constructor_t)af_alg_crypter_create);
-                       }
+                       ops->destroy(ops);
+                       features[(*pos)++] = PLUGIN_PROVIDE(CRYPTER,
+                                                                                               algs[i].id, algs[i].key_size);
                }
-               prev = algs[i].id;
        }
 }
 

diff --git a/src/libstrongswan/plugins/af_alg/af_alg_crypter.h b/src/libstrongswan/plugins/af_alg/af_alg_crypter.h
index ed7799cc8923e85378525143ac215fec45e9616e..ad2d42a9746beb95a881e290b377aaa6fb69c7dc 100644 (file)
--- a/src/libstrongswan/plugins/af_alg/af_alg_crypter.h
+++ b/src/libstrongswan/plugins/af_alg/af_alg_crypter.h
@@ -23,8 +23,12 @@
 
 typedef struct af_alg_crypter_t af_alg_crypter_t;
 
+#include <plugins/plugin.h>
 #include <crypto/crypters/crypter.h>
 
+/** Number of crypters */
+#define AF_ALG_CRYPTER 25
+
 /**
  * Implementation of signers using AF_ALG.
  */
@@ -47,10 +51,11 @@ af_alg_crypter_t *af_alg_crypter_create(encryption_algorithm_t algo,
                                                                                size_t key_size);
 
 /**
- * Probe algorithms and register af_alg_crypter_create().
+ * Probe algorithms and return plugin features.
  *
- * @param plugin               plugin name to register algorithms for
+ * @param features             plugin features to create
+ * @param pos                  current position in features
  */
-void af_alg_crypter_probe(char *plugin);
+void af_alg_crypter_probe(plugin_feature_t *features, int *pos);
 
 #endif /** AF_ALG_CRYPTER_H_ @}*/

diff --git a/src/libstrongswan/plugins/af_alg/af_alg_hasher.c b/src/libstrongswan/plugins/af_alg/af_alg_hasher.c
index 11074c4bd435ce43a3b5739062833474320e8702..ef23504971dbdede93416b7740603c348858bcaa 100644 (file)
--- a/src/libstrongswan/plugins/af_alg/af_alg_hasher.c
+++ b/src/libstrongswan/plugins/af_alg/af_alg_hasher.c
@@ -46,7 +46,7 @@ static struct {
        hash_algorithm_t id;
        char *name;
        size_t size;
-} algs[] = {
+} algs[AF_ALG_HASHER] = {
        {HASH_SHA1,                     "sha1",                 HASH_SIZE_SHA1          },
        {HASH_MD5,                      "md5",                  HASH_SIZE_MD5           },
        {HASH_SHA224,           "sha224",               HASH_SIZE_SHA224        },
@@ -59,7 +59,7 @@ static struct {
 /**
  * See header.
  */
-void af_alg_hasher_probe(char *plugin)
+void af_alg_hasher_probe(plugin_feature_t *features, int *pos)
 {
        af_alg_ops_t *ops;
        int i;
@@ -70,8 +70,7 @@ void af_alg_hasher_probe(char *plugin)
                if (ops)
                {
                        ops->destroy(ops);
-                       lib->crypto->add_hasher(lib->crypto, algs[i].id, plugin,
-                                                       (hasher_constructor_t)af_alg_hasher_create);
+                       features[(*pos)++] = PLUGIN_PROVIDE(HASHER, algs[i].id);
                }
        }
 }

diff --git a/src/libstrongswan/plugins/af_alg/af_alg_hasher.h b/src/libstrongswan/plugins/af_alg/af_alg_hasher.h
index f44ba2938560e4bc5cef65c129c82506bc5b0c6a..5b540875ac19d21847953ff6e945d6fc5f944ce4 100644 (file)
--- a/src/libstrongswan/plugins/af_alg/af_alg_hasher.h
+++ b/src/libstrongswan/plugins/af_alg/af_alg_hasher.h
@@ -23,8 +23,12 @@
 
 typedef struct af_alg_hasher_t af_alg_hasher_t;
 
+#include <plugins/plugin.h>
 #include <crypto/hashers/hasher.h>
 
+/** Number of hashers */
+#define AF_ALG_HASHER 7
+
 /**
  * Implementation of hashers using AF_ALG.
  */
@@ -45,10 +49,11 @@ struct af_alg_hasher_t {
 af_alg_hasher_t *af_alg_hasher_create(hash_algorithm_t algo);
 
 /**
- * Probe algorithms and register af_alg_hasher_create().
+ * Probe algorithms and return plugin features.
  *
- * @param plugin               plugin name to register algorithms for
+ * @param features             plugin features to create
+ * @param pos                  current position in deps
  */
-void af_alg_hasher_probe(char *plugin);
+void af_alg_hasher_probe(plugin_feature_t *features, int *pos);
 
 #endif /** af_alg_HASHER_H_ @}*/

diff --git a/src/libstrongswan/plugins/af_alg/af_alg_plugin.c b/src/libstrongswan/plugins/af_alg/af_alg_plugin.c
index 280ea4e9885ae8048a35417a1f312e2011f4caba..445667507ab10818dacfda16e0a4cdbb0526bff4 100644 (file)
--- a/src/libstrongswan/plugins/af_alg/af_alg_plugin.c
+++ b/src/libstrongswan/plugins/af_alg/af_alg_plugin.c
@@ -41,18 +41,31 @@ METHOD(plugin_t, get_name, char*,
        return "af-alg";
 }
 
+METHOD(plugin_t, get_features, int,
+       private_af_alg_plugin_t *this, plugin_feature_t *features[])
+{
+       static plugin_feature_t f[AF_ALG_HASHER + AF_ALG_SIGNER +
+                                                         AF_ALG_PRF + AF_ALG_CRYPTER + 4] = {};
+       static int count = 0;
+
+       if (!count)
+       {       /* initialize only once */
+               f[count++] = PLUGIN_REGISTER(HASHER, af_alg_hasher_create);
+               af_alg_hasher_probe(f, &count);
+               f[count++] = PLUGIN_REGISTER(SIGNER, af_alg_signer_create);
+               af_alg_signer_probe(f, &count);
+               f[count++] = PLUGIN_REGISTER(PRF, af_alg_prf_create);
+               af_alg_prf_probe(f, &count);
+               f[count++] = PLUGIN_REGISTER(CRYPTER, af_alg_crypter_create);
+               af_alg_crypter_probe(f, &count);
+       }
+       *features = f;
+       return count;
+}
+
 METHOD(plugin_t, destroy, void,
        private_af_alg_plugin_t *this)
 {
-       lib->crypto->remove_hasher(lib->crypto,
-                                       (hasher_constructor_t)af_alg_hasher_create);
-       lib->crypto->remove_signer(lib->crypto,
-                                       (signer_constructor_t)af_alg_signer_create);
-       lib->crypto->remove_prf(lib->crypto,
-                                       (prf_constructor_t)af_alg_prf_create);
-       lib->crypto->remove_crypter(lib->crypto,
-                                       (crypter_constructor_t)af_alg_crypter_create);
-
        free(this);
 }
 
@@ -67,16 +80,11 @@ plugin_t *af_alg_plugin_create()
                .public = {
                        .plugin = {
                                .get_name = _get_name,
-                               .reload = (void*)return_false,
+                               .get_features = _get_features,
                                .destroy = _destroy,
                        },
                },
        );
 
-       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;
 }

diff --git a/src/libstrongswan/plugins/af_alg/af_alg_prf.c b/src/libstrongswan/plugins/af_alg/af_alg_prf.c
index 673ca5e7a76a28aaa397abffbe4372c932c0dda0..a7912291f6f75845304d115700bb1a7919ee5506 100644 (file)
--- a/src/libstrongswan/plugins/af_alg/af_alg_prf.c
+++ b/src/libstrongswan/plugins/af_alg/af_alg_prf.c
@@ -57,7 +57,7 @@ static struct {
        char *name;
        size_t block_size;
        bool xcbc;
-} algs[] = {
+} algs[AF_ALG_PRF] = {
        {PRF_HMAC_SHA1,                 "hmac(sha1)",           20,             FALSE,  },
        {PRF_HMAC_SHA2_256,             "hmac(sha256)",         32,             FALSE,  },
        {PRF_HMAC_MD5,                  "hmac(md5)",            16,             FALSE,  },
@@ -70,7 +70,7 @@ static struct {
 /**
  * See header.
  */
-void af_alg_prf_probe(char *plugin)
+void af_alg_prf_probe(plugin_feature_t *features, int *pos)
 {
        af_alg_ops_t *ops;
        int i;
@@ -81,8 +81,7 @@ void af_alg_prf_probe(char *plugin)
                if (ops)
                {
                        ops->destroy(ops);
-                       lib->crypto->add_prf(lib->crypto, algs[i].id, plugin,
-                                                       (prf_constructor_t)af_alg_prf_create);
+                       features[(*pos)++] = PLUGIN_PROVIDE(PRF, algs[i].id);
                }
        }
 }

diff --git a/src/libstrongswan/plugins/af_alg/af_alg_prf.h b/src/libstrongswan/plugins/af_alg/af_alg_prf.h
index d3275e7be8ae470ad06ac44c2e07e814f49145b6..2f6cf0cf193da4903ecf8762d5a44a3235dbd095 100644 (file)
--- a/src/libstrongswan/plugins/af_alg/af_alg_prf.h
+++ b/src/libstrongswan/plugins/af_alg/af_alg_prf.h
@@ -23,8 +23,12 @@
 
 typedef struct af_alg_prf_t af_alg_prf_t;
 
+#include <plugins/plugin.h>
 #include <crypto/prfs/prf.h>
 
+/** Number of PRFs */
+#define AF_ALG_PRF 7
+
 /**
  * Implementation of PRFs using AF_ALG.
  */
@@ -45,10 +49,11 @@ struct af_alg_prf_t {
 af_alg_prf_t *af_alg_prf_create(pseudo_random_function_t algo);
 
 /**
- * Probe algorithms and register af_alg_prf_create().
+ * Probe algorithms and return plugin features.
  *
- * @param plugin               plugin name to register algorithms for
+ * @param features             plugin features to create
+ * @param pos                  current position in features
  */
-void af_alg_prf_probe(char *plugin);
+void af_alg_prf_probe(plugin_feature_t *features, int *pos);
 
 #endif /** AF_ALG_PRF_H_ @}*/

diff --git a/src/libstrongswan/plugins/af_alg/af_alg_signer.c b/src/libstrongswan/plugins/af_alg/af_alg_signer.c
index 34534a06bac71c533c7220fc94bbef2ae6328d1a..6cd79f8f2fc283a9f80f04f34c5d6a6eb8421dbf 100644 (file)
--- a/src/libstrongswan/plugins/af_alg/af_alg_signer.c
+++ b/src/libstrongswan/plugins/af_alg/af_alg_signer.c
@@ -52,7 +52,7 @@ static struct {
        char *name;
        size_t block_size;
        size_t key_size;
-} algs[] = {
+} algs[AF_ALG_SIGNER] = {
        {AUTH_HMAC_SHA1_96,                     "hmac(sha1)",           12,             20,     },
        {AUTH_HMAC_SHA1_128,            "hmac(sha1)",           16,             20,     },
        {AUTH_HMAC_SHA1_160,            "hmac(sha1)",           20,             20,     },
@@ -71,7 +71,7 @@ static struct {
 /**
  * See header.
  */
-void af_alg_signer_probe(char *plugin)
+void af_alg_signer_probe(plugin_feature_t *features, int *pos)
 {
        af_alg_ops_t *ops;
        int i;
@@ -82,8 +82,7 @@ void af_alg_signer_probe(char *plugin)
                if (ops)
                {
                        ops->destroy(ops);
-                       lib->crypto->add_signer(lib->crypto, algs[i].id, plugin,
-                                                       (signer_constructor_t)af_alg_signer_create);
+                       features[(*pos)++] = PLUGIN_PROVIDE(SIGNER, algs[i].id);
                }
        }
 }

diff --git a/src/libstrongswan/plugins/af_alg/af_alg_signer.h b/src/libstrongswan/plugins/af_alg/af_alg_signer.h
index 21487a11853a7336ef1a5a34f671c46d8f53ed53..deced7110003cd8bb03183627aaee3962fea4b5f 100644 (file)
--- a/src/libstrongswan/plugins/af_alg/af_alg_signer.h
+++ b/src/libstrongswan/plugins/af_alg/af_alg_signer.h
@@ -23,8 +23,12 @@
 
 typedef struct af_alg_signer_t af_alg_signer_t;
 
+#include <plugins/plugin.h>
 #include <crypto/signers/signer.h>
 
+/** Number of signers */
+#define AF_ALG_SIGNER 13
+
 /**
  * Implementation of signers using AF_ALG.
  */
@@ -45,10 +49,11 @@ struct af_alg_signer_t {
 af_alg_signer_t *af_alg_signer_create(integrity_algorithm_t algo);
 
 /**
- * Probe algorithms and register af_alg_signer_create().
+ * Probe algorithms and return plugin features.
  *
- * @param plugin               plugin name to register algorithms for
+ * @param features             plugin features to create
+ * @param pos                  current position in features
  */
-void af_alg_signer_probe(char *plugin);
+void af_alg_signer_probe(plugin_feature_t *features, int *pos);
 
 #endif /** AF_ALG_SIGNER_H_ @}*/