File 2672-crypto-Refactor-map-creation-with-enif_mak... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 2672-crypto-Refactor-map-creation-with-enif_make_map_from.patch of Package erlang (Revision a678cd3ed0e09b30f6d421d2e5c6d79e)

Currently displaying revision a678cd3ed0e09b30f6d421d2e5c6d79e , Show latest

From 7c51c1e02d9e3ce3515e46b14842bc7baae9401f Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Tue, 24 Oct 2023 20:16:41 +0200
Subject: [PATCH 2/3] crypto: Refactor map creation with
 enif_make_map_from_arrays

instead of repeated calls to enif_make_map_put
---
 lib/crypto/c_src/api_ng.c | 28 +++++++++-------------
 lib/crypto/c_src/cipher.c | 36 +++++++++++++++-------------
 lib/crypto/c_src/common.c | 25 ++++++++++----------
 lib/crypto/c_src/hash.c   | 19 +++++++--------
 lib/crypto/c_src/info.c   | 50 ++++++++++++++++-----------------------
 5 files changed, 72 insertions(+), 86 deletions(-)

diff --git a/lib/crypto/c_src/api_ng.c b/lib/crypto/c_src/api_ng.c
index cc9259c71c..2c792d65dc 100644
--- a/lib/crypto/c_src/api_ng.c
+++ b/lib/crypto/c_src/api_ng.c
@@ -986,28 +986,22 @@ ERL_NIF_TERM ng_crypto_one_time_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
 ERL_NIF_TERM ng_crypto_get_data_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (Context) -> map */
     struct evp_cipher_ctx *ctx_res;
+    ERL_NIF_TERM keys[4] = {
+        atom_size, atom_padding_size, atom_padding_type, atom_encrypt
+    };
+    ERL_NIF_TERM values[4];
     ERL_NIF_TERM ret;
+    int ok;
 
     if (!enif_get_resource(env, argv[0], (ErlNifResourceType*)evp_cipher_ctx_rtype, (void**)&ctx_res))
         return EXCP_BADARG_N(env, 0, "Bad State");
 
-    ret = enif_make_new_map(env);
-
-    enif_make_map_put(env, ret, atom_size,
-                      enif_make_int(env, ctx_res->size),
-                      &ret);
-
-    enif_make_map_put(env, ret, atom_padding_size,
-                      enif_make_int(env, ctx_res->padded_size),
-                      &ret);
-
-    enif_make_map_put(env, ret, atom_padding_type,
-                      ctx_res->padding,
-                      &ret);
-
-    enif_make_map_put(env, ret, atom_encrypt,
-                      (ctx_res->encflag) ? atom_true : atom_false,
-                      &ret);
+    values[0] = enif_make_int(env, ctx_res->size);
+    values[1] = enif_make_int(env, ctx_res->padded_size);
+    values[2] = ctx_res->padding;
+    values[3] = (ctx_res->encflag) ? atom_true : atom_false;
+    ok = enif_make_map_from_arrays(env, keys, values, 4, &ret);
+    ASSERT(ok); (void)ok;
 
     return ret;
 }
diff --git a/lib/crypto/c_src/cipher.c b/lib/crypto/c_src/cipher.c
index 30f4c595ff..4619a7700c 100644
--- a/lib/crypto/c_src/cipher.c
+++ b/lib/crypto/c_src/cipher.c
@@ -246,6 +246,9 @@ ERL_NIF_TERM cipher_info_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]
     ERL_NIF_TERM         ret, ret_mode;
     unsigned             type;
     unsigned long        mode;
+    ERL_NIF_TERM keys[6];
+    ERL_NIF_TERM vals[6];
+    int ok;
 
     if ((cipherp = get_cipher_type_no_key(argv[0])) == NULL)
         return enif_make_badarg(env);
@@ -255,26 +258,22 @@ ERL_NIF_TERM cipher_info_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]
     if ((cipher = cipherp->cipher.p) == NULL)
         return enif_raise_exception(env, atom_notsup);
 
-    ret = enif_make_new_map(env);
-
     type = EVP_CIPHER_type(cipher);
-    enif_make_map_put(env, ret, atom_type,
-        type == NID_undef ? atom_undefined : enif_make_int(env, type),
-        &ret);
-
-    enif_make_map_put(env, ret, atom_key_length,
-        enif_make_int(env, EVP_CIPHER_key_length(cipher)), &ret);
-    enif_make_map_put(env, ret, atom_iv_length,
-        enif_make_int(env, EVP_CIPHER_iv_length(cipher)), &ret);
-    enif_make_map_put(env, ret, atom_block_size,
-        enif_make_int(env, EVP_CIPHER_block_size(cipher)), &ret);
-    enif_make_map_put(env, ret, atom_prop_aead, 
+
+    keys[0] = atom_type;
+    vals[0] = (type == NID_undef ? atom_undefined : enif_make_int(env, type));
+    keys[1] = atom_key_length;
+    vals[1] = enif_make_int(env, EVP_CIPHER_key_length(cipher));
+    keys[2] = atom_iv_length;
+    vals[2] = enif_make_int(env, EVP_CIPHER_iv_length(cipher));
+    keys[3] = atom_block_size;
+    vals[3] = enif_make_int(env, EVP_CIPHER_block_size(cipher));
+    keys[4] = atom_prop_aead;
 #if defined(HAVE_AEAD)
-            (((EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0) ? atom_true : atom_false), 
+    vals[4] = (((EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0) ? atom_true : atom_false);
 #else
-            atom_false,
+    vals[4] = atom_false;
 #endif
-            &ret);
 
     mode = EVP_CIPHER_mode(cipher);
     switch (mode) {
@@ -338,8 +337,11 @@ ERL_NIF_TERM cipher_info_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]
             ret_mode = atom_undefined;
             break;
     }
+    keys[5] = atom_mode;
+    vals[5] = ret_mode;
 
-    enif_make_map_put(env, ret, atom_mode, ret_mode, &ret);
+    ok = enif_make_map_from_arrays(env, keys, vals, 6, &ret);
+    ASSERT(ok); (void)ok;
 
     return ret;
 }
diff --git a/lib/crypto/c_src/common.c b/lib/crypto/c_src/common.c
index 7ce12682db..56595b10b5 100644
--- a/lib/crypto/c_src/common.c
+++ b/lib/crypto/c_src/common.c
@@ -61,19 +61,18 @@ ERL_NIF_TERM raise_exception(ErlNifEnv* env, ERL_NIF_TERM id, int arg_num, char*
 #endif
 
     /* Make the data for exception */
-    file_info = enif_make_new_map(env);
-    enif_make_map_put(env, file_info,
-                      enif_make_atom(env,"c_file_name"),
-                      enif_make_string(env, file, (ERL_NIF_LATIN1)),
-                      &file_info);
-    enif_make_map_put(env, file_info,
-                      enif_make_atom(env,"c_file_line_num"),
-                      enif_make_int(env, line),
-                      &file_info);
-    enif_make_map_put(env, file_info,
-                      enif_make_atom(env,"c_function_arg_num"),
-                      enif_make_int(env, arg_num),
-                      &file_info);
+    {
+        ERL_NIF_TERM keys[3], vals[3];
+        int ok;
+        keys[0] = enif_make_atom(env,"c_file_name");
+        vals[0] = enif_make_string(env, file, ERL_NIF_LATIN1);
+        keys[1] = enif_make_atom(env,"c_file_line_num");
+        vals[1] = enif_make_int(env, line);
+        keys[2] = enif_make_atom(env,"c_function_arg_num");
+        vals[2] = enif_make_int(env, arg_num);
+        ok = enif_make_map_from_arrays(env, keys, vals, 3, &file_info);
+        ASSERT(ok); (void)ok;
+    }
     exception =
         enif_make_tuple3(env,
                          id,
diff --git a/lib/crypto/c_src/hash.c b/lib/crypto/c_src/hash.c
index e80f2a2522..b0c1a00fda 100644
--- a/lib/crypto/c_src/hash.c
+++ b/lib/crypto/c_src/hash.c
@@ -73,7 +73,10 @@ ERL_NIF_TERM hash_info_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {/* (Type) */
     struct digest_type_t *digp = NULL;
     const EVP_MD         *md;
-    ERL_NIF_TERM         ret;
+    ERL_NIF_TERM keys[3] = { atom_type, atom_size, atom_block_size };
+    ERL_NIF_TERM values[3];
+    ERL_NIF_TERM ret;
+    int ok;
 
     ASSERT(argc == 1);
 
@@ -85,15 +88,11 @@ ERL_NIF_TERM hash_info_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     if ((md = digp->md.p) == NULL)
         return atom_notsup;
 
-    ret = enif_make_new_map(env);
-
-    enif_make_map_put(env, ret, atom_type,
-        enif_make_int(env, EVP_MD_type(md)), &ret);
-    enif_make_map_put(env, ret, atom_size,
-        enif_make_int(env, EVP_MD_size(md)), &ret);
-    enif_make_map_put(env, ret, atom_block_size,
-        enif_make_int(env, EVP_MD_block_size(md)), &ret);
-
+    values[0] = enif_make_int(env, EVP_MD_type(md));
+    values[1] = enif_make_int(env, EVP_MD_size(md));
+    values[2] = enif_make_int(env, EVP_MD_block_size(md));
+    ok = enif_make_map_from_arrays(env, keys, values, 3, &ret);
+    ASSERT(ok); (void)ok;
     return ret;
 }
 
diff --git a/lib/crypto/c_src/info.c b/lib/crypto/c_src/info.c
index f78984b7e6..ce764f0df5 100644
--- a/lib/crypto/c_src/info.c
+++ b/lib/crypto/c_src/info.c
@@ -107,41 +107,33 @@ const char* resource_name(const char *name, ErlNifBinary* buf)
 
 ERL_NIF_TERM info_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
 {/* () */
+    ERL_NIF_TERM keys[5], vals[5];
     ERL_NIF_TERM  ret;
-
-    ret = enif_make_new_map(env);
-    
-    enif_make_map_put(env, ret,
-                      enif_make_atom(env,"compile_type"),
-                      enif_make_atom(env, COMPILE_TYPE),
-                      &ret);
-
-    enif_make_map_put(env, ret,
-                      enif_make_atom(env, "link_type"),
-                      enif_make_atom(env, LINK_TYPE),
-                      &ret);
-
-    enif_make_map_put(env, ret,
-                      enif_make_atom(env, "cryptolib_version_compiled"),
+    size_t cnt;
+    int ok;
+
+    keys[0] = enif_make_atom(env,"compile_type");
+    vals[0] = enif_make_atom(env, COMPILE_TYPE);
+    keys[1] = enif_make_atom(env, "link_type");
+    vals[1] = enif_make_atom(env, LINK_TYPE);
+    keys[2] = enif_make_atom(env, "cryptolib_version_compiled");
 #ifdef OPENSSL_VERSION_TEXT
-                      enif_make_string(env, OPENSSL_VERSION_TEXT, ERL_NIF_LATIN1),
+    vals[2] = enif_make_string(env, OPENSSL_VERSION_TEXT, ERL_NIF_LATIN1);
 #else
-                      /* Just to be really safe for versions/clones unknown to me lacking this macro */
-                      atom_undefined,
+    /* Just to be really safe for versions/clones unknown to me lacking this macro */
+    vals[2] = atom_undefined;
 #endif
-                      &ret);
-
-    enif_make_map_put(env, ret,
-                      enif_make_atom(env, "cryptolib_version_linked"),
-                      enif_make_string(env, OpenSSL_version(OPENSSL_VERSION), ERL_NIF_LATIN1),
-                      &ret);
-
+    keys[3] = enif_make_atom(env, "cryptolib_version_linked");
+    vals[3] = enif_make_string(env, OpenSSL_version(OPENSSL_VERSION), ERL_NIF_LATIN1);
 #ifdef HAS_3_0_API
-    enif_make_map_put(env, ret,
-                      enif_make_atom(env, "fips_provider_available"),
-                      OSSL_PROVIDER_available(NULL, "fips") ? atom_true : atom_false,
-                      &ret);
+    keys[4] = enif_make_atom(env, "fips_provider_available");
+    vals[4] = OSSL_PROVIDER_available(NULL, "fips") ? atom_true : atom_false;
+    cnt = 5;
+#else
+    cnt = 4;
 #endif
+    ok = enif_make_map_from_arrays(env, keys, vals, cnt, &ret);
+    ASSERT(ok); (void)ok;
 
     return ret;
 }
-- 
2.35.3

Places

File 2672-crypto-Refactor-map-creation-with-enif_make_map_from.patch of Package erlang (Revision a678cd3ed0e09b30f6d421d2e5c6d79e)

Places