crypto/evp/evp_fetch.c: Make it more prominent that these functions are EVP

Reviewed-by: Matt Caswell <matt@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/10257)

1 files changed, 81 insertions, 81 deletions

diff --git a/crypto/evp/evp_fetch.c b/crypto/evp/evp_fetch.c
index 907091fced..f0432be742 100644
--- a/crypto/evp/evp_fetch.c
+++ b/crypto/evp/evp_fetch.c
@@ -22,30 +22,30 @@
 
 #define NAME_SEPARATOR ':'
 
-static void default_method_store_free(void *vstore)
+static void evp_method_store_free(void *vstore)
 {
     ossl_method_store_free(vstore);
 }
 
-static void *default_method_store_new(OPENSSL_CTX *ctx)
+static void *evp_method_store_new(OPENSSL_CTX *ctx)
 {
     return ossl_method_store_new(ctx);
 }
 
 
-static const OPENSSL_CTX_METHOD default_method_store_method = {
-    default_method_store_new,
-    default_method_store_free,
+static const OPENSSL_CTX_METHOD evp_method_store_method = {
+    evp_method_store_new,
+    evp_method_store_free,
 };
 
 /* Data to be passed through ossl_method_construct() */
-struct method_data_st {
+struct evp_method_data_st {
     OPENSSL_CTX *libctx;
     OSSL_METHOD_CONSTRUCT_METHOD *mcm;
-    int operation_id;            /* For get_method_from_store() */
-    int name_id;                 /* For get_method_from_store() */
-    const char *names;           /* For get_method_from_store() */
-    const char *propquery;       /* For get_method_from_store() */
+    int operation_id;            /* For get_evp_method_from_store() */
+    int name_id;                 /* For get_evp_method_from_store() */
+    const char *names;           /* For get_evp_method_from_store() */
+    const char *propquery;       /* For get_evp_method_from_store() */
     void *(*method_from_dispatch)(int name_id, const OSSL_DISPATCH *,
                                   OSSL_PROVIDER *, void *);
     void *method_data;
@@ -119,27 +119,27 @@ static int add_names_to_namemap(OSSL_NAMEMAP *namemap,
 /*
  * Generic routines to fetch / create EVP methods with ossl_method_construct()
  */
-static void *alloc_tmp_method_store(OPENSSL_CTX *ctx)
+static void *alloc_tmp_evp_method_store(OPENSSL_CTX *ctx)
 {
     return ossl_method_store_new(ctx);
 }
 
- static void dealloc_tmp_method_store(void *store)
+ static void dealloc_tmp_evp_method_store(void *store)
 {
     if (store != NULL)
         ossl_method_store_free(store);
 }
 
-static OSSL_METHOD_STORE *get_default_method_store(OPENSSL_CTX *libctx)
+static OSSL_METHOD_STORE *get_evp_method_store(OPENSSL_CTX *libctx)
 {
-    return openssl_ctx_get_data(libctx, OPENSSL_CTX_DEFAULT_METHOD_STORE_INDEX,
-                                &default_method_store_method);
+    return openssl_ctx_get_data(libctx, OPENSSL_CTX_EVP_METHOD_STORE_INDEX,
+                                &evp_method_store_method);
 }
 
 /*
- * To identity the method in the method store, we mix the name identity
- * with the operation identity, with the assumption that we don't have
- * more than 2^24 names or more than 2^8 operation types.
+ * To identity the method in the EVP method store, we mix the name identity
+ * with the operation identity, with the assumption that we don't have more
+ * than 2^24 names or more than 2^8 operation types.
  *
  * The resulting identity is a 32-bit integer, composed like this:
  *
@@ -147,7 +147,7 @@ static OSSL_METHOD_STORE *get_default_method_store(OPENSSL_CTX *libctx)
  * |      name identity     | op id  |
  * +------------------------+--------+
  */
-static uint32_t method_id(unsigned int operation_id, int name_id)
+static uint32_t evp_method_id(unsigned int operation_id, int name_id)
 {
     if (!ossl_assert(name_id < (1 << 24) || operation_id < (1 << 8))
         || !ossl_assert(name_id > 0 && operation_id > 0))
@@ -155,18 +155,18 @@ static uint32_t method_id(unsigned int operation_id, int name_id)
     return ((name_id << 8) & 0xFFFFFF00) | (operation_id & 0x000000FF);
 }
 
-static void *get_method_from_store(OPENSSL_CTX *libctx, void *store,
-                                   void *data)
+static void *get_evp_method_from_store(OPENSSL_CTX *libctx, void *store,
+                                       void *data)
 {
-    struct method_data_st *methdata = data;
+    struct evp_method_data_st *methdata = data;
     void *method = NULL;
     int name_id;
     uint32_t meth_id;
 
     /*
-     * get_method_from_store() is only called to try and get the method
-     * that evp_generic_fetch() is asking for, and the operation id as
-     * well as the name or name id are passed via methdata.
+     * get_evp_method_from_store() is only called to try and get the method
+     * that evp_generic_fetch() is asking for, and the operation id as well
+     * as the name or name id are passed via methdata.
      */
     if ((name_id = methdata->name_id) == 0) {
         OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
@@ -180,11 +180,11 @@ static void *get_method_from_store(OPENSSL_CTX *libctx, void *store,
     }
 
     if (name_id == 0
-        || (meth_id = method_id(methdata->operation_id, name_id)) == 0)
+        || (meth_id = evp_method_id(methdata->operation_id, name_id)) == 0)
         return NULL;
 
     if (store == NULL
-        && (store = get_default_method_store(libctx)) == NULL)
+        && (store = get_evp_method_store(libctx)) == NULL)
         return NULL;
 
     (void)ossl_method_store_fetch(store, meth_id, methdata->propquery,
@@ -197,23 +197,22 @@ static void *get_method_from_store(OPENSSL_CTX *libctx, void *store,
     return method;
 }
 
-static int put_method_in_store(OPENSSL_CTX *libctx, void *store,
-                               void *method, const OSSL_PROVIDER *prov,
-                               int operation_id, const char *names,
-                               const char *propdef, void *data)
+static int put_evp_method_in_store(OPENSSL_CTX *libctx, void *store,
+                                   void *method, const OSSL_PROVIDER *prov,
+                                   int operation_id, const char *names,
+                                   const char *propdef, void *data)
 {
-    struct method_data_st *methdata = data;
+    struct evp_method_data_st *methdata = data;
     OSSL_NAMEMAP *namemap;
     int name_id;
     uint32_t meth_id;
     size_t l = 0;
 
     /*
-     * put_method_in_store() is only called with a method that was
-     * successfully created by construct_method() below, which means
-     * that all the names should already be stored in the namemap with
-     * the same numeric identity, so just use the first to get that
-     * identity.
+     * put_evp_method_in_store() is only called with an EVP method that was
+     * successfully created by construct_method() below, which means that
+     * all the names should already be stored in the namemap with the same
+     * numeric identity, so just use the first to get that identity.
      */
     if (names != NULL) {
         const char *q = strchr(names, NAME_SEPARATOR);
@@ -223,11 +222,11 @@ static int put_method_in_store(OPENSSL_CTX *libctx, void *store,
 
     if ((namemap = ossl_namemap_stored(libctx)) == NULL
         || (name_id = ossl_namemap_name2num_n(namemap, names, l)) == 0
-        || (meth_id = method_id(operation_id, name_id)) == 0)
+        || (meth_id = evp_method_id(operation_id, name_id)) == 0)
         return 0;
 
     if (store == NULL
-        && (store = get_default_method_store(libctx)) == NULL)
+        && (store = get_evp_method_store(libctx)) == NULL)
         return 0;
 
     return ossl_method_store_add(store, prov, meth_id, propdef, method,
@@ -239,16 +238,16 @@ static int put_method_in_store(OPENSSL_CTX *libctx, void *store,
  * The core fetching functionality passes the name of the implementation.
  * This function is responsible to getting an identity number for it.
  */
-static void *construct_method(const char *names, const OSSL_DISPATCH *fns,
-                              OSSL_PROVIDER *prov, void *data)
+static void *construct_evp_method(const char *names, const OSSL_DISPATCH *fns,
+                                  OSSL_PROVIDER *prov, void *data)
 {
     /*
-     * This function is only called if get_method_from_store() returned
+     * This function is only called if get_evp_method_from_store() returned
      * NULL, so it's safe to say that of all the spots to create a new
      * namemap entry, this is it.  Should the name already exist there, we
      * know that ossl_namemap_add() will return its corresponding number.
      */
-    struct method_data_st *methdata = data;
+    struct evp_method_data_st *methdata = data;
     OPENSSL_CTX *libctx = ossl_provider_library_context(prov);
     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
     int name_id = add_names_to_namemap(namemap, names);
@@ -259,25 +258,26 @@ static void *construct_method(const char *names, const OSSL_DISPATCH *fns,
                                           methdata->method_data);
 }
 
-static void destruct_method(void *method, void *data)
+static void destruct_evp_method(void *method, void *data)
 {
-    struct method_data_st *methdata = data;
+    struct evp_method_data_st *methdata = data;
 
     methdata->destruct_method(method);
 }
 
-static void *inner_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
-                                 int name_id, const char *name,
-                                 const char *properties,
-                                 void *(*new_method)(int name_id,
-                                                     const OSSL_DISPATCH *fns,
-                                                     OSSL_PROVIDER *prov,
-                                                     void *method_data),
-                                 void *method_data,
-                                 int (*up_ref_method)(void *),
-                                 void (*free_method)(void *))
+static void *
+inner_evp_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
+                        int name_id, const char *name,
+                        const char *properties,
+                        void *(*new_method)(int name_id,
+                                            const OSSL_DISPATCH *fns,
+                                            OSSL_PROVIDER *prov,
+                                            void *method_data),
+                        void *method_data,
+                        int (*up_ref_method)(void *),
+                        void (*free_method)(void *))
 {
-    OSSL_METHOD_STORE *store = get_default_method_store(libctx);
+    OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
     uint32_t meth_id = 0;
     void *method = NULL;
@@ -304,26 +304,26 @@ static void *inner_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
         name_id = ossl_namemap_name2num(namemap, name);
 
     /*
-     * If we have a name id, calculate a method id with method_id().
+     * If we have a name id, calculate a method id with evp_method_id().
      *
-     * method_id returns 0 if we have too many operations (more than
-     * about 2^8) or too many names (more than about 2^24).  In that
-     * case, we can't create any new method.
+     * evp_method_id returns 0 if we have too many operations (more than
+     * about 2^8) or too many names (more than about 2^24).  In that case,
+     * we can't create any new method.
      */
-    if (name_id != 0 && (meth_id = method_id(operation_id, name_id)) == 0)
+    if (name_id != 0 && (meth_id = evp_method_id(operation_id, name_id)) == 0)
         return NULL;
 
     if (meth_id == 0
         || !ossl_method_store_cache_get(store, meth_id, properties, &method)) {
         OSSL_METHOD_CONSTRUCT_METHOD mcm = {
-            alloc_tmp_method_store,
-            dealloc_tmp_method_store,
-            get_method_from_store,
-            put_method_in_store,
-            construct_method,
-            destruct_method
+            alloc_tmp_evp_method_store,
+            dealloc_tmp_evp_method_store,
+            get_evp_method_from_store,
+            put_evp_method_in_store,
+            construct_evp_method,
+            destruct_evp_method
         };
-        struct method_data_st mcmdata;
+        struct evp_method_data_st mcmdata;
 
         mcmdata.mcm = &mcm;
         mcmdata.libctx = libctx;
@@ -341,13 +341,13 @@ static void *inner_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
                                             &mcm, &mcmdata)) != NULL) {
             /*
              * If construction did create a method for us, we know that
-             * there is a correct name_id and methodid, since those have
-             * already been calculated in get_method_from_store() and
-             * put_method_in_store() above.
+             * there is a correct name_id and meth_id, since those have
+             * already been calculated in get_evp_method_from_store() and
+             * put_evp_method_in_store() above.
              */
             if (name_id == 0)
                 name_id = ossl_namemap_name2num(namemap, name);
-            meth_id = method_id(operation_id, name_id);
+            meth_id = evp_method_id(operation_id, name_id);
             ossl_method_store_cache_set(store, meth_id, properties, method);
         }
     } else {
@@ -367,10 +367,10 @@ void *evp_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
                         int (*up_ref_method)(void *),
                         void (*free_method)(void *))
 {
-    return inner_generic_fetch(libctx,
-                               operation_id, 0, name, properties,
-                               new_method, method_data,
-                               up_ref_method, free_method);
+    return inner_evp_generic_fetch(libctx,
+                                   operation_id, 0, name, properties,
+                                   new_method, method_data,
+                                   up_ref_method, free_method);
 }
 
 /*
@@ -390,15 +390,15 @@ void *evp_generic_fetch_by_number(OPENSSL_CTX *libctx, int operation_id,
                                   int (*up_ref_method)(void *),
                                   void (*free_method)(void *))
 {
-    return inner_generic_fetch(libctx,
-                               operation_id, name_id, NULL, properties,
-                               new_method, method_data,
-                               up_ref_method, free_method);
+    return inner_evp_generic_fetch(libctx,
+                                   operation_id, name_id, NULL, properties,
+                                   new_method, method_data,
+                                   up_ref_method, free_method);
 }
 
 int EVP_set_default_properties(OPENSSL_CTX *libctx, const char *propq)
 {
-    OSSL_METHOD_STORE *store = get_default_method_store(libctx);
+    OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
 
     if (store != NULL)
         return ossl_method_store_set_global_properties(store, propq);