cache_req: encapsulate output data into structure

In enumeration calls we want to get objects from all domains, not
only from the first matched domain. We move the cache search result
into a structure that contains combination of domain and ldb_result.

This is preparation for enumeration support inside cache_req.

Resolves:
https://fedorahosted.org/sssd/ticket/3151

Reviewed-by: Lukáš Slebodník <lslebodn@redhat.com>

11 files changed, 254 insertions, 147 deletions

diff --git a/src/responder/common/cache_req/cache_req.c b/src/responder/common/cache_req/cache_req.c
index 21ac8204b..e71a59a25 100644
--- a/src/responder/common/cache_req/cache_req.c
+++ b/src/responder/common/cache_req/cache_req.c
@@ -256,9 +256,10 @@ struct cache_req_state {
     struct cache_req *cr;
 
     /* work data */
-    struct ldb_result *result;
     struct sss_domain_info *domain;
     struct sss_domain_info *selected_domain;
+    struct cache_req_result **results;
+    size_t num_results;
     bool check_next;
 };
 
@@ -479,21 +480,73 @@ static errno_t cache_req_next_domain(struct tevent_req *req)
     return ENOENT;
 }
 
+static errno_t
+cache_req_add_result(struct cache_req_state *state,
+                     struct cache_req_result *new)
+{
+    struct cache_req_result **results = state->results;
+    size_t index;
+    size_t count;
+
+    /* Make space for new results. */
+    index = state->num_results;
+    count = state->num_results + 1;
+
+    results = talloc_realloc(state, results, struct cache_req_result *, count + 1);
+    if (results == NULL) {
+        return ENOMEM;
+    }
+
+    results[index] = talloc_steal(results, new);
+    results[index + 1] = NULL;
+    state->results = results;
+    state->num_results = count;
+
+    return EOK;
+}
+
+static errno_t
+cache_req_create_and_add_result(struct cache_req_state *state,
+                                struct sss_domain_info *domain,
+                                struct ldb_result *ldb_result,
+                                const char *name)
+{
+    struct cache_req_result *item;
+    errno_t ret;
+
+    CACHE_REQ_DEBUG(SSSDBG_TRACE_FUNC, state->cr,
+                    "Found %u entries in domain %s\n",
+                    ldb_result->count, domain->name);
+
+    item = cache_req_create_result(state, domain, ldb_result, name);
+    if (item == NULL) {
+        return ENOMEM;
+    }
+
+    ret = cache_req_add_result(state, item);
+    if (ret != EOK) {
+        talloc_free(item);
+    }
+
+    return ret;
+}
+
 static void cache_req_done(struct tevent_req *subreq)
 {
     struct cache_req_state *state;
+    struct ldb_result *result;
     struct tevent_req *req;
     errno_t ret;
 
     req = tevent_req_callback_data(subreq, struct tevent_req);
     state = tevent_req_data(req, struct cache_req_state);
 
-    ret = cache_req_search_recv(state, subreq, &state->result);
+    ret = cache_req_search_recv(state, subreq, &result);
     talloc_zfree(subreq);
     if (ret == EOK) {
-        CACHE_REQ_DEBUG(SSSDBG_TRACE_FUNC, state->cr, "Finished: Success\n");
-        tevent_req_done(req);
-        return;
+        ret = cache_req_create_and_add_result(state, state->selected_domain,
+                                          result, state->cr->data->name.lookup);
+        goto done;
     }
 
     if (state->check_next == false) {
@@ -503,16 +556,31 @@ static void cache_req_done(struct tevent_req *subreq)
             return;
         }
 
-        CACHE_REQ_DEBUG(SSSDBG_TRACE_FUNC, state->cr, "Finished: Not found\n");
-        tevent_req_error(req, ret);
-        return;
+        goto done;
     }
 
     ret = cache_req_next_domain(req);
     if (ret != EAGAIN) {
+        goto done;
+    }
+
+    return;
+
+done:
+    switch (ret) {
+    case EOK:
+        CACHE_REQ_DEBUG(SSSDBG_TRACE_FUNC, state->cr, "Finished: Success\n");
+        tevent_req_done(req);
+        break;
+    case ENOENT:
+        CACHE_REQ_DEBUG(SSSDBG_TRACE_FUNC, state->cr, "Finished: Not found\n");
+        tevent_req_error(req, ret);
+        break;
+    default:
         CACHE_REQ_DEBUG(SSSDBG_TRACE_FUNC, state->cr,
                         "Finished: Error %d: %s\n", ret, sss_strerror(ret));
         tevent_req_error(req, ret);
+        break;
     }
 
     return;
@@ -520,36 +588,33 @@ static void cache_req_done(struct tevent_req *subreq)
 
 errno_t cache_req_recv(TALLOC_CTX *mem_ctx,
                        struct tevent_req *req,
-                       struct ldb_result **_result,
-                       struct sss_domain_info **_domain,
-                       char **_name)
+                       struct cache_req_result ***_results)
 {
-    struct cache_req_state *state = NULL;
-    char *name;
+    struct cache_req_state *state;
 
     state = tevent_req_data(req, struct cache_req_state);
 
     TEVENT_REQ_RETURN_ON_ERROR(req);
 
-    if (_name != NULL) {
-        if (state->cr->data->name.lookup == NULL) {
-            *_name = NULL;
-        } else {
-            name = talloc_strdup(mem_ctx, state->cr->data->name.lookup);
-            if (name == NULL) {
-                return ENOMEM;
-            }
-
-            *_name = name;
-        }
+    if (_results != NULL) {
+        *_results = talloc_steal(mem_ctx, state->results);
     }
 
-    if (_result != NULL) {
-        *_result = talloc_steal(mem_ctx, state->result);
-    }
+    return EOK;
+}
 
-    if (_domain != NULL) {
-        *_domain = state->selected_domain;
+errno_t cache_req_single_domain_recv(TALLOC_CTX *mem_ctx,
+                                     struct tevent_req *req,
+                                     struct cache_req_result **_result)
+{
+    struct cache_req_state *state;
+
+    state = tevent_req_data(req, struct cache_req_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    if (_result != NULL) {
+        *_result = talloc_steal(mem_ctx, state->results[0]);
     }
 
     return EOK;
@@ -577,3 +642,32 @@ cache_req_steal_data_and_send(TALLOC_CTX *mem_ctx,
 
     return req;
 }
+
+struct cache_req_result *
+cache_req_create_result(TALLOC_CTX *mem_ctx,
+                        struct sss_domain_info *domain,
+                        struct ldb_result *ldb_result,
+                        const char *lookup_name)
+{
+    struct cache_req_result *result;
+
+    result = talloc_zero(mem_ctx, struct cache_req_result);
+    if (result == NULL) {
+        return NULL;
+    }
+
+    result->domain = domain;
+    result->ldb_result = talloc_steal(result, ldb_result);
+    result->count = ldb_result != NULL ? ldb_result->count : 0;
+    result->msgs = ldb_result != NULL ? ldb_result->msgs : NULL;
+
+    if (lookup_name != NULL) {
+        result->lookup_name = talloc_strdup(result, lookup_name);
+        if (result->lookup_name == NULL) {
+            talloc_free(result);
+            return NULL;
+        }
+    }
+
+    return result;
+}
diff --git a/src/responder/common/cache_req/cache_req.h b/src/responder/common/cache_req/cache_req.h
index d220c5133..54cb8ad1a 100644
--- a/src/responder/common/cache_req/cache_req.h
+++ b/src/responder/common/cache_req/cache_req.h
@@ -69,6 +69,33 @@ cache_req_data_sid(TALLOC_CTX *mem_ctx,
                    const char *sid,
                    const char **attrs);
 
+/* Output data. */
+
+struct cache_req_result {
+    /**
+     * SSSD domain where the result was obtained.
+     */
+    struct sss_domain_info *domain;
+
+    /**
+     * Result from ldb lookup.
+     */
+    struct ldb_result *ldb_result;
+
+    /**
+     * Shortcuts into ldb_result. This shortens the code a little since
+     * callers usually don't don't need to work with ldb_result directly.
+     */
+    unsigned int count;
+    struct ldb_message **msgs;
+
+    /**
+     * If name was used as a lookup parameter, @lookup_name contains name
+     * normalized to @domain rules.
+     */
+    const char *lookup_name;
+};
+
 /* Generic request. */
 
 struct tevent_req *cache_req_send(TALLOC_CTX *mem_ctx,
@@ -81,9 +108,11 @@ struct tevent_req *cache_req_send(TALLOC_CTX *mem_ctx,
 
 errno_t cache_req_recv(TALLOC_CTX *mem_ctx,
                        struct tevent_req *req,
-                       struct ldb_result **_result,
-                       struct sss_domain_info **_domain,
-                       char **_name);
+                       struct cache_req_result ***_results);
+
+errno_t cache_req_single_domain_recv(TALLOC_CTX *mem_ctx,
+                                     struct tevent_req *req,
+                                     struct cache_req_result **_result);
 
 /* Plug-ins. */
 
@@ -96,8 +125,8 @@ cache_req_user_by_name_send(TALLOC_CTX *mem_ctx,
                             const char *domain,
                             const char *name);
 
-#define cache_req_user_by_name_recv(mem_ctx, req, _result, _domain, _name) \
-    cache_req_recv(mem_ctx, req, _result, _domain, _name)
+#define cache_req_user_by_name_recv(mem_ctx, req, _result) \
+    cache_req_single_domain_recv(mem_ctx, req, _result)
 
 struct tevent_req *
 cache_req_user_by_id_send(TALLOC_CTX *mem_ctx,
@@ -108,8 +137,8 @@ cache_req_user_by_id_send(TALLOC_CTX *mem_ctx,
                           const char *domain,
                           uid_t uid);
 
-#define cache_req_user_by_id_recv(mem_ctx, req, _result, _domain) \
-    cache_req_recv(mem_ctx, req, _result, _domain, NULL)
+#define cache_req_user_by_id_recv(mem_ctx, req, _result) \
+    cache_req_single_domain_recv(mem_ctx, req, _result);
 
 struct tevent_req *
 cache_req_user_by_cert_send(TALLOC_CTX *mem_ctx,
@@ -120,8 +149,8 @@ cache_req_user_by_cert_send(TALLOC_CTX *mem_ctx,
                             const char *domain,
                             const char *pem_cert);
 
-#define cache_req_user_by_cert_recv(mem_ctx, req, _result, _domain, _name) \
-    cache_req_recv(mem_ctx, req, _result, _domain, _name)
+#define cache_req_user_by_cert_recv(mem_ctx, req, _result) \
+    cache_req_single_domain_recv(mem_ctx, req, _result)
 
 struct tevent_req *
 cache_req_group_by_name_send(TALLOC_CTX *mem_ctx,
@@ -132,8 +161,8 @@ cache_req_group_by_name_send(TALLOC_CTX *mem_ctx,
                              const char *domain,
                              const char *name);
 
-#define cache_req_group_by_name_recv(mem_ctx, req, _result, _domain, _name) \
-    cache_req_recv(mem_ctx, req, _result, _domain, _name)
+#define cache_req_group_by_name_recv(mem_ctx, req, _result) \
+    cache_req_single_domain_recv(mem_ctx, req, _result)
 
 struct tevent_req *
 cache_req_group_by_id_send(TALLOC_CTX *mem_ctx,
@@ -144,8 +173,8 @@ cache_req_group_by_id_send(TALLOC_CTX *mem_ctx,
                            const char *domain,
                            gid_t gid);
 
-#define cache_req_group_by_id_recv(mem_ctx, req, _result, _domain) \
-    cache_req_recv(mem_ctx, req, _result, _domain, NULL)
+#define cache_req_group_by_id_recv(mem_ctx, req, _result) \
+    cache_req_single_domain_recv(mem_ctx, req, _result)
 
 struct tevent_req *
 cache_req_initgr_by_name_send(TALLOC_CTX *mem_ctx,
@@ -156,8 +185,8 @@ cache_req_initgr_by_name_send(TALLOC_CTX *mem_ctx,
                               const char *domain,
                               const char *name);
 
-#define cache_req_initgr_by_name_recv(mem_ctx, req, _result, _domain, _name) \
-    cache_req_recv(mem_ctx, req, _result, _domain, _name)
+#define cache_req_initgr_by_name_recv(mem_ctx, req, _result) \
+    cache_req_single_domain_recv(mem_ctx, req, _result)
 
 struct tevent_req *
 cache_req_user_by_filter_send(TALLOC_CTX *mem_ctx,
@@ -166,8 +195,8 @@ cache_req_user_by_filter_send(TALLOC_CTX *mem_ctx,
                               const char *domain,
                               const char *filter);
 
-#define cache_req_user_by_filter_recv(mem_ctx, req, _result, _domain) \
-    cache_req_recv(mem_ctx, req, _result, _domain, NULL)
+#define cache_req_user_by_filter_recv(mem_ctx, req, _result) \
+    cache_req_single_domain_recv(mem_ctx, req, _result)
 
 struct tevent_req *
 cache_req_group_by_filter_send(TALLOC_CTX *mem_ctx,
@@ -176,8 +205,8 @@ cache_req_group_by_filter_send(TALLOC_CTX *mem_ctx,
                               const char *domain,
                               const char *filter);
 
-#define cache_req_group_by_filter_recv(mem_ctx, req, _result, _domain) \
-    cache_req_recv(mem_ctx, req, _result, _domain, NULL)
+#define cache_req_group_by_filter_recv(mem_ctx, req, _result) \
+    cache_req_single_domain_recv(mem_ctx, req, _result)
 
 struct tevent_req *
 cache_req_object_by_sid_send(TALLOC_CTX *mem_ctx,
@@ -189,7 +218,7 @@ cache_req_object_by_sid_send(TALLOC_CTX *mem_ctx,
                              const char *sid,
                              const char **attrs);
 
-#define cache_req_object_by_sid_recv(mem_ctx, req, _result, _domain) \
-    cache_req_recv(mem_ctx, req, _result, _domain, NULL)
+#define cache_req_object_by_sid_recv(mem_ctx, req, _result) \
+    cache_req_single_domain_recv(mem_ctx, req, _result)
 
 #endif /* _CACHE_REQ_H_ */
diff --git a/src/responder/common/cache_req/cache_req_private.h b/src/responder/common/cache_req/cache_req_private.h
index d4ac7a909..60a180b6e 100644
--- a/src/responder/common/cache_req/cache_req_private.h
+++ b/src/responder/common/cache_req/cache_req_private.h
@@ -88,4 +88,10 @@ cache_req_steal_data_and_send(TALLOC_CTX *mem_ctx,
                               const char *domain,
                               struct cache_req_data *data);
 
+struct cache_req_result *
+cache_req_create_result(TALLOC_CTX *mem_ctx,
+                        struct sss_domain_info *domain,
+                        struct ldb_result *ldb_result,
+                        const char *lookup_name);
+
 #endif /* _CACHE_REQ_PRIVATE_H_ */
diff --git a/src/responder/ifp/ifp_groups.c b/src/responder/ifp/ifp_groups.c
index a54a4faa4..94d1e84cc 100644
--- a/src/responder/ifp/ifp_groups.c
+++ b/src/responder/ifp/ifp_groups.c
@@ -133,14 +133,13 @@ ifp_groups_find_by_name_done(struct tevent_req *req)
 {
     DBusError *error;
     struct sbus_request *sbus_req;
-    struct sss_domain_info *domain;
-    struct ldb_result *result;
+    struct cache_req_result *result;
     char *object_path;
     errno_t ret;
 
     sbus_req = tevent_req_callback_data(req, struct sbus_request);
 
-    ret = cache_req_group_by_name_recv(sbus_req, req, &result, &domain, NULL);
+    ret = cache_req_group_by_name_recv(sbus_req, req, &result);
     talloc_zfree(req);
     if (ret == ENOENT) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_NOT_FOUND,
@@ -152,7 +151,7 @@ ifp_groups_find_by_name_done(struct tevent_req *req)
         goto done;
     }
 
-    object_path = ifp_groups_build_path_from_msg(sbus_req, domain,
+    object_path = ifp_groups_build_path_from_msg(sbus_req, result->domain,
                                                  result->msgs[0]);
     if (object_path == NULL) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
@@ -203,14 +202,13 @@ ifp_groups_find_by_id_done(struct tevent_req *req)
 {
     DBusError *error;
     struct sbus_request *sbus_req;
-    struct sss_domain_info *domain;
-    struct ldb_result *result;
+    struct cache_req_result *result;
     char *object_path;
     errno_t ret;
 
     sbus_req = tevent_req_callback_data(req, struct sbus_request);
 
-    ret = cache_req_group_by_id_recv(sbus_req, req, &result, &domain);
+    ret = cache_req_group_by_id_recv(sbus_req, req, &result);
     talloc_zfree(req);
     if (ret == ENOENT) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_NOT_FOUND,
@@ -222,7 +220,7 @@ ifp_groups_find_by_id_done(struct tevent_req *req)
         goto done;
     }
 
-    object_path = ifp_groups_build_path_from_msg(sbus_req, domain,
+    object_path = ifp_groups_build_path_from_msg(sbus_req, result->domain,
                                                  result->msgs[0]);
     if (object_path == NULL) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
@@ -289,14 +287,13 @@ static void ifp_groups_list_by_name_done(struct tevent_req *req)
     DBusError *error;
     struct ifp_list_ctx *list_ctx;
     struct sbus_request *sbus_req;
-    struct ldb_result *result;
-    struct sss_domain_info *domain;
+    struct cache_req_result *result;
     errno_t ret;
 
     list_ctx = tevent_req_callback_data(req, struct ifp_list_ctx);
     sbus_req = list_ctx->sbus_req;
 
-    ret = cache_req_group_by_name_recv(sbus_req, req, &result, &domain, NULL);
+    ret = cache_req_group_by_name_recv(sbus_req, req, &result);
     talloc_zfree(req);
     if (ret != EOK && ret != ENOENT) {
         error = sbus_error_new(sbus_req, DBUS_ERROR_FAILED, "Failed to fetch "
@@ -305,7 +302,7 @@ static void ifp_groups_list_by_name_done(struct tevent_req *req)
         return;
     }
 
-    ret = ifp_groups_list_copy(list_ctx, result);
+    ret = ifp_groups_list_copy(list_ctx, result->ldb_result);
     if (ret != EOK) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
                                "Failed to copy domain result");
@@ -373,14 +370,13 @@ static void ifp_groups_list_by_domain_and_name_done(struct tevent_req *req)
     DBusError *error;
     struct ifp_list_ctx *list_ctx;
     struct sbus_request *sbus_req;
-    struct ldb_result *result;
-    struct sss_domain_info *domain;
+    struct cache_req_result *result;
     errno_t ret;
 
     list_ctx = tevent_req_callback_data(req, struct ifp_list_ctx);
     sbus_req = list_ctx->sbus_req;
 
-    ret = cache_req_user_by_name_recv(sbus_req, req, &result, &domain, NULL);
+    ret = cache_req_user_by_name_recv(sbus_req, req, &result);
     talloc_zfree(req);
     if (ret == ENOENT) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_NOT_FOUND,
@@ -392,7 +388,7 @@ static void ifp_groups_list_by_domain_and_name_done(struct tevent_req *req)
         goto done;
     }
 
-    ret = ifp_groups_list_copy(list_ctx, result);
+    ret = ifp_groups_list_copy(list_ctx, result->ldb_result);
     if (ret != EOK) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
                                "Failed to copy domain result");
@@ -627,7 +623,7 @@ static void resolv_ghosts_done(struct tevent_req *subreq)
     req = tevent_req_callback_data(subreq, struct tevent_req);
     state = tevent_req_data(req, struct resolv_ghosts_state);
 
-    ret = cache_req_user_by_name_recv(state, subreq, NULL, NULL, NULL);
+    ret = cache_req_user_by_name_recv(state, subreq, NULL);
     talloc_zfree(subreq);
     if (ret != EOK) {
         goto done;
diff --git a/src/responder/ifp/ifp_users.c b/src/responder/ifp/ifp_users.c
index 1f9042508..e5bc1c193 100644
--- a/src/responder/ifp/ifp_users.c
+++ b/src/responder/ifp/ifp_users.c
@@ -114,14 +114,13 @@ ifp_users_find_by_name_done(struct tevent_req *req)
 {
     DBusError *error;
     struct sbus_request *sbus_req;
-    struct sss_domain_info *domain;
-    struct ldb_result *result;
+    struct cache_req_result *result;
     char *object_path;
     errno_t ret;
 
     sbus_req = tevent_req_callback_data(req, struct sbus_request);
 
-    ret = cache_req_user_by_name_recv(sbus_req, req, &result, &domain, NULL);
+    ret = cache_req_user_by_name_recv(sbus_req, req, &result);
     talloc_zfree(req);
     if (ret == ENOENT) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_NOT_FOUND,
@@ -133,7 +132,7 @@ ifp_users_find_by_name_done(struct tevent_req *req)
         goto done;
     }
 
-    object_path = ifp_users_build_path_from_msg(sbus_req, domain,
+    object_path = ifp_users_build_path_from_msg(sbus_req, result->domain,
                                                 result->msgs[0]);
     if (object_path == NULL) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
@@ -184,14 +183,13 @@ ifp_users_find_by_id_done(struct tevent_req *req)
 {
     DBusError *error;
     struct sbus_request *sbus_req;
-    struct sss_domain_info *domain;
-    struct ldb_result *result;
+    struct cache_req_result *result;
     char *object_path;
     errno_t ret;
 
     sbus_req = tevent_req_callback_data(req, struct sbus_request);
 
-    ret = cache_req_user_by_id_recv(sbus_req, req, &result, &domain);
+    ret = cache_req_user_by_id_recv(sbus_req, req, &result);
     talloc_zfree(req);
     if (ret == ENOENT) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_NOT_FOUND,
@@ -203,7 +201,7 @@ ifp_users_find_by_id_done(struct tevent_req *req)
         goto done;
     }
 
-    object_path = ifp_users_build_path_from_msg(sbus_req, domain,
+    object_path = ifp_users_build_path_from_msg(sbus_req, result->domain,
                                                 result->msgs[0]);
     if (object_path == NULL) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
@@ -269,14 +267,13 @@ static void ifp_users_find_by_cert_done(struct tevent_req *req)
 {
     DBusError *error;
     struct sbus_request *sbus_req;
-    struct sss_domain_info *domain;
-    struct ldb_result *result;
+    struct cache_req_result *result;
     char *object_path;
     errno_t ret;
 
     sbus_req = tevent_req_callback_data(req, struct sbus_request);
 
-    ret = cache_req_user_by_cert_recv(sbus_req, req, &result, &domain, NULL);
+    ret = cache_req_user_by_cert_recv(sbus_req, req, &result);
     talloc_zfree(req);
     if (ret == ENOENT) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_NOT_FOUND,
@@ -288,7 +285,7 @@ static void ifp_users_find_by_cert_done(struct tevent_req *req)
         goto done;
     }
 
-    object_path = ifp_users_build_path_from_msg(sbus_req, domain,
+    object_path = ifp_users_build_path_from_msg(sbus_req, result->domain,
                                                 result->msgs[0]);
     if (object_path == NULL) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
@@ -376,14 +373,13 @@ static void ifp_users_list_by_name_done(struct tevent_req *req)
     DBusError *error;
     struct ifp_list_ctx *list_ctx;
     struct sbus_request *sbus_req;
-    struct ldb_result *result;
-    struct sss_domain_info *domain;
+    struct cache_req_result *result;
     errno_t ret;
 
     list_ctx = tevent_req_callback_data(req, struct ifp_list_ctx);
     sbus_req = list_ctx->sbus_req;
 
-    ret = cache_req_user_by_name_recv(sbus_req, req, &result, &domain, NULL);
+    ret = cache_req_user_by_name_recv(sbus_req, req, &result);
     talloc_zfree(req);
     if (ret != EOK && ret != ENOENT) {
         error = sbus_error_new(sbus_req, DBUS_ERROR_FAILED, "Failed to fetch "
@@ -392,7 +388,7 @@ static void ifp_users_list_by_name_done(struct tevent_req *req)
         return;
     }
 
-    ret = ifp_users_list_copy(list_ctx, result);
+    ret = ifp_users_list_copy(list_ctx, result->ldb_result);
     if (ret != EOK) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
                                "Failed to copy domain result");
@@ -460,15 +456,14 @@ static void ifp_users_list_by_domain_and_name_done(struct tevent_req *req)
     DBusError *error;
     struct ifp_list_ctx *list_ctx;
     struct sbus_request *sbus_req;
-    struct ldb_result *result;
-    struct sss_domain_info *domain;
+    struct cache_req_result *result;
     errno_t ret;
     size_t copy_count, i;
 
     list_ctx = tevent_req_callback_data(req, struct ifp_list_ctx);
     sbus_req = list_ctx->sbus_req;
 
-    ret = cache_req_user_by_name_recv(sbus_req, req, &result, &domain, NULL);
+    ret = cache_req_user_by_name_recv(sbus_req, req, &result);
     talloc_zfree(req);
     if (ret == ENOENT) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_NOT_FOUND,
@@ -710,7 +705,7 @@ static void ifp_users_user_update_groups_list_done(struct tevent_req *req)
 
     sbus_req = tevent_req_callback_data(req, struct sbus_request);
 
-    ret = cache_req_initgr_by_name_recv(sbus_req, req, NULL, NULL, NULL);
+    ret = cache_req_initgr_by_name_recv(sbus_req, req, NULL);
     talloc_zfree(req);
     if (ret == ENOENT) {
         error = sbus_error_new(sbus_req, SBUS_ERROR_NOT_FOUND,
diff --git a/src/responder/ifp/ifpsrv_cmd.c b/src/responder/ifp/ifpsrv_cmd.c
index f248c0d04..3a1a17718 100644
--- a/src/responder/ifp/ifpsrv_cmd.c
+++ b/src/responder/ifp/ifpsrv_cmd.c
@@ -522,19 +522,23 @@ static void ifp_user_get_attr_done(struct tevent_req *subreq)
 {
     struct ifp_user_get_attr_state *state = NULL;
     struct tevent_req *req = NULL;
+    struct cache_req_result *result;
     errno_t ret;
     char *fqdn;
 
     req = tevent_req_callback_data(subreq, struct tevent_req);
     state = tevent_req_data(req, struct ifp_user_get_attr_state);
 
-    ret = cache_req_recv(state, subreq, &state->res, &state->dom,  NULL);
+    ret = cache_req_single_domain_recv(state, subreq, &result);
     talloc_zfree(subreq);
     if (ret != EOK) {
         tevent_req_error(req, ret);
         return;
     }
 
+    state->res = talloc_steal(state, result->ldb_result);
+    talloc_zfree(result);
+
     fqdn = sss_create_internal_fqname(state, state->inp_name,
                                       state->dom->name);
     if (fqdn == NULL) {
diff --git a/src/responder/nss/nsssrv_cmd.c b/src/responder/nss/nsssrv_cmd.c
index faada21eb..29c5cbfef 100644
--- a/src/responder/nss/nsssrv_cmd.c
+++ b/src/responder/nss/nsssrv_cmd.c
@@ -5408,15 +5408,14 @@ static int nss_cmd_getbycert(enum sss_cli_command cmd, struct cli_ctx *cctx)
 static void users_find_by_cert_done(struct tevent_req *req)
 {
     struct cli_ctx *cctx;
-    struct sss_domain_info *domain;
-    struct ldb_result *result;
+    struct cache_req_result *result;
     struct cli_protocol *pctx;
     errno_t ret;
 
     cctx = tevent_req_callback_data(req, struct cli_ctx);
     pctx = talloc_get_type(cctx->protocol_ctx, struct cli_protocol);
 
-    ret = cache_req_user_by_cert_recv(cctx, req, &result, &domain, NULL);
+    ret = cache_req_user_by_cert_recv(cctx, req, &result);
     talloc_zfree(req);
     if (ret == ENOENT || result->count == 0) {
         ret = ENOENT;
@@ -5442,7 +5441,7 @@ static void users_find_by_cert_done(struct tevent_req *req)
         goto done;
     }
 
-    ret = fill_name(pctx->creq->out, cctx->rctx, domain,
+    ret = fill_name(pctx->creq->out, cctx->rctx, result->domain,
                     SSS_ID_TYPE_UID, true, result->msgs[0]);
     if (ret != EOK) {
         DEBUG(SSSDBG_OP_FAILURE, "fill_name failed.\n");
diff --git a/src/responder/pac/pacsrv_cmd.c b/src/responder/pac/pacsrv_cmd.c
index 662791526..ddb8c0c90 100644
--- a/src/responder/pac/pacsrv_cmd.c
+++ b/src/responder/pac/pacsrv_cmd.c
@@ -226,11 +226,10 @@ static void pac_resolve_user_sid_done(struct tevent_req *req)
                                                           struct pac_req_ctx);
     struct cli_ctx *cctx = pr_ctx->cctx;
     errno_t ret;
-    struct sss_domain_info *dom;
-    struct ldb_result *res;
+    struct cache_req_result *result;
     struct sysdb_attrs *user_attrs;
 
-    ret = cache_req_object_by_sid_recv(pr_ctx, req, &res, &dom);
+    ret = cache_req_object_by_sid_recv(pr_ctx, req, &result);
     talloc_zfree(req);
 
     if (ret != EOK) {
@@ -239,10 +238,10 @@ static void pac_resolve_user_sid_done(struct tevent_req *req)
         return;
     }
 
-    if (res->count != 1) {
+    if (result->count != 1) {
         DEBUG(SSSDBG_CRIT_FAILURE,
               "Expected only 1 result for SID lookup, got [%ud].\n",
-              res->count);
+              result->count);
         ret = EINVAL;
         goto done;
     }
@@ -268,7 +267,8 @@ static void pac_resolve_user_sid_done(struct tevent_req *req)
         goto done;
     }
 
-    ret = sysdb_set_entry_attr(dom->sysdb, res->msgs[0]->dn, user_attrs,
+    ret = sysdb_set_entry_attr(result->domain->sysdb,
+                               result->msgs[0]->dn, user_attrs,
                                SYSDB_MOD_REP);
     if (ret != EOK) {
         DEBUG(SSSDBG_OP_FAILURE, "sysdb_set_entry_attr failed.\n");
diff --git a/src/responder/pam/pamsrv_cmd.c b/src/responder/pam/pamsrv_cmd.c
index b7a52b384..ca4c37605 100644
--- a/src/responder/pam/pamsrv_cmd.c
+++ b/src/responder/pam/pamsrv_cmd.c
@@ -1419,21 +1419,19 @@ done:
 static void pam_forwarder_lookup_by_cert_done(struct tevent_req *req)
 {
     int ret;
-    struct ldb_result *res;
-    struct sss_domain_info *domain;
+    struct cache_req_result *result;
     struct pam_auth_req *preq = tevent_req_callback_data(req,
                                                          struct pam_auth_req);
     const char *cert_user;
 
-
-    ret = cache_req_user_by_cert_recv(preq, req, &res, &domain, NULL);
+    ret = cache_req_user_by_cert_recv(preq, req, &result);
     talloc_zfree(req);
     if (ret != EOK && ret != ENOENT) {
         DEBUG(SSSDBG_OP_FAILURE, "cache_req_user_by_cert request failed.\n");
         goto done;
     }
 
-    if (ret == EOK && res->count > 1) {
+    if (ret == EOK && result->count > 1) {
         DEBUG(SSSDBG_CRIT_FAILURE,
               "Search by certificate returned more than one result.\n");
         ret = EINVAL;
@@ -1442,10 +1440,10 @@ static void pam_forwarder_lookup_by_cert_done(struct tevent_req *req)
 
     if (ret == EOK) {
         if (preq->domain == NULL) {
-            preq->domain = domain;
+            preq->domain = result->domain;
         }
 
-        preq->cert_user_obj = talloc_steal(preq, res->msgs[0]);
+        preq->cert_user_obj = talloc_steal(preq, result->msgs[0]);
 
         if (preq->pd->logon_name == NULL) {
             cert_user = ldb_msg_find_attr_as_string(preq->cert_user_obj,
@@ -1465,7 +1463,7 @@ static void pam_forwarder_lookup_by_cert_done(struct tevent_req *req)
                 DEBUG(SSSDBG_OP_FAILURE, "add_pam_cert_response failed.\n");
             }
 
-            preq->pd->domain = talloc_strdup(preq->pd, domain->name);
+            preq->pd->domain = talloc_strdup(preq->pd, result->domain->name);
             if (preq->pd->domain == NULL) {
                 DEBUG(SSSDBG_OP_FAILURE, "talloc_strdup failed.\n");
                 ret = ENOMEM;
diff --git a/src/responder/sudo/sudosrv_get_sudorules.c b/src/responder/sudo/sudosrv_get_sudorules.c
index 3b3c71cbd..52dfd5c70 100644
--- a/src/responder/sudo/sudosrv_get_sudorules.c
+++ b/src/responder/sudo/sudosrv_get_sudorules.c
@@ -605,7 +605,7 @@ struct sudosrv_get_rules_state {
     struct resp_ctx *rctx;
     enum sss_sudo_type type;
     uid_t uid;
-    char *username;
+    const char *username;
     struct sss_domain_info *domain;
     char **groups;
     bool inverse_order;
@@ -669,19 +669,23 @@ immediately:
 static void sudosrv_get_rules_initgr_done(struct tevent_req *subreq)
 {
     struct sudosrv_get_rules_state *state;
+    struct cache_req_result *result;
     struct tevent_req *req;
     errno_t ret;
 
     req = tevent_req_callback_data(subreq, struct tevent_req);
     state = tevent_req_data(req, struct sudosrv_get_rules_state);
 
-    ret = cache_req_initgr_by_name_recv(state, subreq, NULL,
-                                        &state->domain, &state->username);
+    ret = cache_req_initgr_by_name_recv(state, subreq, &result);
     talloc_zfree(subreq);
     if (ret != EOK) {
         goto done;
     }
 
+    state->domain = result->domain;
+    state->username = talloc_steal(state, result->lookup_name);
+    talloc_zfree(result);
+
     ret = sysdb_get_sudo_user_info(state, state->domain, state->username,
                                    NULL, &state->groups);
     if (ret != EOK) {
diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c
index 1598f0c16..d4e54cd47 100644
--- a/src/tests/cmocka/test_responder_cache_req.c
+++ b/src/tests/cmocka/test_responder_cache_req.c
@@ -89,9 +89,7 @@ struct cache_req_test_ctx {
     struct resp_ctx *rctx;
     struct sss_nc_ctx *ncache;
 
-    struct ldb_result *result;
-    struct sss_domain_info *domain;
-    char *name;
+    struct cache_req_result *result;
     bool dp_called;
 
     /* NOTE: Please, instead of adding new create_[user|group] bool,
@@ -123,10 +121,7 @@ static void cache_req_user_by_name_test_done(struct tevent_req *req)
 
     ctx = tevent_req_callback_data(req, struct cache_req_test_ctx);
 
-    ctx->tctx->error = cache_req_user_by_name_recv(ctx, req,
-                                                   &ctx->result,
-                                                   &ctx->domain,
-                                                   &ctx->name);
+    ctx->tctx->error = cache_req_user_by_name_recv(ctx, req, &ctx->result);
     talloc_zfree(req);
 
     ctx->tctx->done = true;
@@ -138,8 +133,7 @@ static void cache_req_user_by_id_test_done(struct tevent_req *req)
 
     ctx = tevent_req_callback_data(req, struct cache_req_test_ctx);
 
-    ctx->tctx->error = cache_req_user_by_id_recv(ctx, req,
-                                                 &ctx->result, &ctx->domain);
+    ctx->tctx->error = cache_req_user_by_id_recv(ctx, req, &ctx->result);
     talloc_zfree(req);
 
     ctx->tctx->done = true;
@@ -151,10 +145,7 @@ static void cache_req_group_by_name_test_done(struct tevent_req *req)
 
     ctx = tevent_req_callback_data(req, struct cache_req_test_ctx);
 
-    ctx->tctx->error = cache_req_group_by_name_recv(ctx, req,
-                                                    &ctx->result,
-                                                    &ctx->domain,
-                                                    &ctx->name);
+    ctx->tctx->error = cache_req_group_by_name_recv(ctx, req, &ctx->result);
     talloc_zfree(req);
 
     ctx->tctx->done = true;
@@ -166,8 +157,7 @@ static void cache_req_group_by_id_test_done(struct tevent_req *req)
 
     ctx = tevent_req_callback_data(req, struct cache_req_test_ctx);
 
-    ctx->tctx->error = cache_req_group_by_id_recv(ctx, req,
-                                                  &ctx->result, &ctx->domain);
+    ctx->tctx->error = cache_req_group_by_id_recv(ctx, req, &ctx->result);
     talloc_zfree(req);
 
     ctx->tctx->done = true;
@@ -179,9 +169,7 @@ static void cache_req_object_by_sid_test_done(struct tevent_req *req)
 
     ctx = tevent_req_callback_data(req, struct cache_req_test_ctx);
 
-    ctx->tctx->error = cache_req_object_by_sid_recv(ctx, req,
-                                                    &ctx->result,
-                                                    &ctx->domain);
+    ctx->tctx->error = cache_req_object_by_sid_recv(ctx, req, &ctx->result);
     talloc_zfree(req);
 
     ctx->tctx->done = true;
@@ -295,8 +283,8 @@ static void check_user(struct cache_req_test_ctx *test_ctx,
                                        SYSDB_UIDNUM, 0);
     assert_int_equal(ldbuid, user->uid);
 
-    assert_non_null(test_ctx->domain);
-    assert_string_equal(exp_dom->name, test_ctx->domain->name);
+    assert_non_null(test_ctx->result->domain);
+    assert_string_equal(exp_dom->name, test_ctx->result->domain->name);
 }
 
 static void prepare_group(struct sss_domain_info *domain,
@@ -370,8 +358,8 @@ static void check_group(struct cache_req_test_ctx *test_ctx,
                                        SYSDB_GIDNUM, 0);
     assert_int_equal(ldbgid, group->gid);
 
-    assert_non_null(test_ctx->domain);
-    assert_string_equal(exp_dom->name, test_ctx->domain->name);
+    assert_non_null(test_ctx->result->domain);
+    assert_string_equal(exp_dom->name, test_ctx->result->domain->name);
 }
 
 static void run_object_by_sid(struct cache_req_test_ctx *test_ctx,
@@ -471,7 +459,6 @@ static int test_single_domain_teardown(void **state)
     test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);
 
     talloc_zfree(test_ctx->result);
-    talloc_zfree(test_ctx->name);
 
     assert_true(check_leaks_pop(test_ctx));
     talloc_zfree(test_ctx);
@@ -518,7 +505,6 @@ static int test_multi_domain_teardown(void **state)
     test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);
 
     talloc_zfree(test_ctx->result);
-    talloc_zfree(test_ctx->name);
 
     reset_ldb_errstrings(test_ctx->tctx->dom);
     assert_true(check_leaks_pop(test_ctx));
@@ -631,8 +617,8 @@ void test_user_by_name_multiple_domains_parse(void **state)
 
     check_user(test_ctx, &users[0], domain);
 
-    assert_non_null(test_ctx->name);
-    assert_string_equal(input_fqn, test_ctx->name);
+    assert_non_null(test_ctx->result->lookup_name);
+    assert_string_equal(input_fqn, test_ctx->result->lookup_name);
 
     talloc_free(input_fqn);
 }
@@ -1144,8 +1130,8 @@ void test_group_by_name_multiple_domains_parse(void **state)
 
     check_group(test_ctx, &groups[0], domain);
 
-    assert_non_null(test_ctx->name);
-    assert_string_equal(input_fqn, test_ctx->name);
+    assert_non_null(test_ctx->result->lookup_name);
+    assert_string_equal(input_fqn, test_ctx->result->lookup_name);
 
     talloc_free(input_fqn);
 }
@@ -1407,9 +1393,7 @@ static void cache_req_user_by_filter_test_done(struct tevent_req *req)
 
     ctx = tevent_req_callback_data(req, struct cache_req_test_ctx);
 
-    ctx->tctx->error = cache_req_user_by_filter_recv(ctx, req,
-                                                     &ctx->result,
-                                                     &ctx->domain);
+    ctx->tctx->error = cache_req_user_by_filter_recv(ctx, req, &ctx->result);
     talloc_zfree(req);
     ctx->tctx->done = true;
 }
@@ -1495,10 +1479,10 @@ void test_users_by_recent_filter_valid(void **state)
     user_names = talloc_zero_array(test_ctx, const char *, num_users);
     assert_non_null(user_names);
     user_names[0] = sss_create_internal_fqname(user_names, users[0].short_name,
-                                               test_ctx->domain->name);
+                                               test_ctx->result->domain->name);
     assert_non_null(user_names[0]);
     user_names[1] = sss_create_internal_fqname(user_names, users[1].short_name,
-                                               test_ctx->domain->name);
+                                               test_ctx->result->domain->name);
     assert_non_null(user_names[1]);
 
     for (int i = 0; i < num_users; ++i) {
@@ -1624,9 +1608,7 @@ static void cache_req_group_by_filter_test_done(struct tevent_req *req)
 
     ctx = tevent_req_callback_data(req, struct cache_req_test_ctx);
 
-    ctx->tctx->error = cache_req_group_by_filter_recv(ctx, req,
-                                                      &ctx->result,
-                                                      &ctx->domain);
+    ctx->tctx->error = cache_req_group_by_filter_recv(ctx, req, &ctx->result);
     talloc_zfree(req);
     ctx->tctx->done = true;
 }
@@ -1716,10 +1698,10 @@ void test_groups_by_recent_filter_valid(void **state)
     group_names = talloc_array(tmp_ctx, const char *, 2);
     assert_non_null(group_names);
     group_names[0] = sss_create_internal_fqname(group_names, groups[0].short_name,
-                                                test_ctx->domain->name);
+                                                test_ctx->result->domain->name);
     assert_non_null(group_names[0]);
     group_names[1] = sss_create_internal_fqname(group_names, groups[1].short_name,
-                                                test_ctx->domain->name);
+                                                test_ctx->result->domain->name);
     assert_non_null(group_names[1]);
 
     ldb_results = talloc_array(tmp_ctx, const char *, 2);