KEYS: Introduce a search context structure

Search functions pass around a bunch of arguments, each of which gets copied
with each call.  Introduce a search context structure to hold these.

Whilst we're at it, create a search flag that indicates whether the search
should be directly to the description or whether it should iterate through all
keys looking for a non-description match.

This will be useful when keyrings use a generic data struct with generic
routines to manage their content as the search terms can just be passed
through to the iterator callback function.

Also, for future use, the data to be supplied to the match function is
separated from the description pointer in the search context.  This makes it
clear which is being supplied.

Signed-off-by: David Howells <dhowells@redhat.com>

1 files changed, 27 insertions, 29 deletions

diff --git a/security/keys/request_key.c b/security/keys/request_key.c
index 586cb79ee82d..ab75df4745af 100644
--- a/security/keys/request_key.c
+++ b/security/keys/request_key.c
@@ -345,38 +345,34 @@ static void construct_get_dest_keyring(struct key **_dest_keyring)
  * May return a key that's already under construction instead if there was a
  * race between two thread calling request_key().
  */
-static int construct_alloc_key(struct key_type *type,
-                               const char *description,
+static int construct_alloc_key(struct keyring_search_context *ctx,
                                struct key *dest_keyring,
                                unsigned long flags,
                                struct key_user *user,
                                struct key **_key)
 {
-        const struct keyring_index_key index_key = {
-                .type           = type,
-                .description    = description,
-                .desc_len       = strlen(description),
-        };
-        const struct cred *cred = current_cred();
         unsigned long prealloc;
         struct key *key;
         key_perm_t perm;
         key_ref_t key_ref;
         int ret;
 
-        kenter("%s,%s,,,", type->name, description);
+        kenter("%s,%s,,,",
+               ctx->index_key.type->name, ctx->index_key.description);
 
         *_key = NULL;
         mutex_lock(&user->cons_lock);
 
         perm = KEY_POS_VIEW | KEY_POS_SEARCH | KEY_POS_LINK | KEY_POS_SETATTR;
         perm |= KEY_USR_VIEW;
-        if (type->read)
+        if (ctx->index_key.type->read)
                 perm |= KEY_POS_READ;
-        if (type == &key_type_keyring || type->update)
+        if (ctx->index_key.type == &key_type_keyring ||
+            ctx->index_key.type->update)
                 perm |= KEY_POS_WRITE;
 
-        key = key_alloc(type, description, cred->fsuid, cred->fsgid, cred,
+        key = key_alloc(ctx->index_key.type, ctx->index_key.description,
+                        ctx->cred->fsuid, ctx->cred->fsgid, ctx->cred,
                         perm, flags);
         if (IS_ERR(key))
                 goto alloc_failed;
@@ -384,7 +380,7 @@ static int construct_alloc_key(struct key_type *type,
         set_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);
 
         if (dest_keyring) {
-                ret = __key_link_begin(dest_keyring, &index_key, &prealloc);
+                ret = __key_link_begin(dest_keyring, &ctx->index_key, &prealloc);
                 if (ret < 0)
                         goto link_prealloc_failed;
         }
@@ -394,8 +390,7 @@ static int construct_alloc_key(struct key_type *type,
          * waited for locks */
         mutex_lock(&key_construction_mutex);
 
-        key_ref = search_process_keyrings(type, description, type->match,
-                                          false, cred);
+        key_ref = search_process_keyrings(ctx);
         if (!IS_ERR(key_ref))
                 goto key_already_present;
 
@@ -404,7 +399,7 @@ static int construct_alloc_key(struct key_type *type,
 
         mutex_unlock(&key_construction_mutex);
         if (dest_keyring)
-                __key_link_end(dest_keyring, &index_key, prealloc);
+                __key_link_end(dest_keyring, &ctx->index_key, prealloc);
         mutex_unlock(&user->cons_lock);
         *_key = key;
         kleave(" = 0 [%d]", key_serial(key));
@@ -420,7 +415,7 @@ key_already_present:
                 ret = __key_link_check_live_key(dest_keyring, key);
                 if (ret == 0)
                         __key_link(dest_keyring, key, &prealloc);
-                __key_link_end(dest_keyring, &index_key, prealloc);
+                __key_link_end(dest_keyring, &ctx->index_key, prealloc);
                 if (ret < 0)
                         goto link_check_failed;
         }
@@ -449,8 +444,7 @@ alloc_failed:
 /*
  * Commence key construction.
  */
-static struct key *construct_key_and_link(struct key_type *type,
-                                          const char *description,
+static struct key *construct_key_and_link(struct keyring_search_context *ctx,
                                           const char *callout_info,
                                           size_t callout_len,
                                           void *aux,
@@ -469,8 +463,7 @@ static struct key *construct_key_and_link(struct key_type *type,
 
         construct_get_dest_keyring(&dest_keyring);
 
-        ret = construct_alloc_key(type, description, dest_keyring, flags, user,
-                                  &key);
+        ret = construct_alloc_key(ctx, dest_keyring, flags, user, &key);
         key_user_put(user);
 
         if (ret == 0) {
@@ -534,18 +527,24 @@ struct key *request_key_and_link(struct key_type *type,
                                  struct key *dest_keyring,
                                  unsigned long flags)
 {
-        const struct cred *cred = current_cred();
+        struct keyring_search_context ctx = {
+                .index_key.type         = type,
+                .index_key.description  = description,
+                .cred                   = current_cred(),
+                .match                  = type->match,
+                .match_data             = description,
+                .flags                  = KEYRING_SEARCH_LOOKUP_DIRECT,
+        };
         struct key *key;
         key_ref_t key_ref;
         int ret;
 
         kenter("%s,%s,%p,%zu,%p,%p,%lx",
-               type->name, description, callout_info, callout_len, aux,
-               dest_keyring, flags);
+               ctx.index_key.type->name, ctx.index_key.description,
+               callout_info, callout_len, aux, dest_keyring, flags);
 
         /* search all the process keyrings for a key */
-        key_ref = search_process_keyrings(type, description, type->match,
-                                          false, cred);
+        key_ref = search_process_keyrings(&ctx);
 
         if (!IS_ERR(key_ref)) {
                 key = key_ref_to_ptr(key_ref);
@@ -568,9 +567,8 @@ struct key *request_key_and_link(struct key_type *type,
                 if (!callout_info)
                         goto error;
 
-                key = construct_key_and_link(type, description, callout_info,
-                                             callout_len, aux, dest_keyring,
-                                             flags);
+                key = construct_key_and_link(&ctx, callout_info, callout_len,
+                                             aux, dest_keyring, flags);
         }
 
 error: