From e069e53495d77bc737abd80fb2e7799fa6245e0f Mon Sep 17 00:00:00 2001

From: Jakub Hrozek <jhrozek@redhat.com>

Date: Tue, 24 Mar 2015 23:24:50 +0100

Subject: [PATCH 05/13] cache_req: Extend cache_req with wildcard lookups

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

Related:

    https://fedorahosted.org/sssd/ticket/2553

Adds two new functions to the cache_req API:

    - cache_req_user_by_filter_send

    - cache_req_group_by_filter_send

These functions can be used to retrieve users or groups that match a

specified filter.

Also renames a variable to avoid constant confusion -- the variable is

only used for debug output.

Reviewed-by: Pavel Březina <pbrezina@redhat.com>

---

 src/responder/common/responder_cache_req.c  | 156 ++++++++++-

 src/responder/common/responder_cache_req.h  |  24 +-

 src/tests/cmocka/test_responder_cache_req.c | 414 +++++++++++++++++++++++++++-

 3 files changed, 579 insertions(+), 15 deletions(-)

diff --git a/src/responder/common/responder_cache_req.c b/src/responder/common/responder_cache_req.c

index dd81abadf71c5e10e7bc2ea2490429a49bdc0270..e7099f171d7ef39af7b146a524dadc38a9165e22 100644

--- a/src/responder/common/responder_cache_req.c

+++ b/src/responder/common/responder_cache_req.c

@@ -28,6 +28,44 @@

 #include "responder/common/responder_cache_req.h"

 #include "providers/data_provider.h"

+static errno_t updated_users_by_filter(TALLOC_CTX *mem_ctx,

+                                       struct sss_domain_info *domain,

+                                       const char *name_filter,

+                                       time_t since,

+                                       struct ldb_result **_res)

+{

+    int ret;

+    char *recent_filter;

+

+    recent_filter = talloc_asprintf(mem_ctx, "(%s>=%lu)",

+                                    SYSDB_LAST_UPDATE, since);

+    ret = sysdb_enumpwent_filter_with_views(mem_ctx, domain,

+                                            name_filter, recent_filter,

+                                            _res);

+    talloc_free(recent_filter);

+

+    return ret;

+}

+

+static errno_t updated_groups_by_filter(TALLOC_CTX *mem_ctx,

+                                        struct sss_domain_info *domain,

+                                        const char *name_filter,

+                                        time_t since,

+                                        struct ldb_result **_res)

+{

+    int ret;

+    char *recent_filter;

+

+    recent_filter = talloc_asprintf(mem_ctx, "(%s>=%lu)",

+                                    SYSDB_LAST_UPDATE, since);

+    ret = sysdb_enumgrent_filter_with_views(mem_ctx, domain,

+                                            name_filter, recent_filter,

+                                            _res);

+    talloc_free(recent_filter);

+

+    return ret;

+}

+

 struct cache_req_input {

     enum cache_req_type type;

@@ -51,6 +89,8 @@ struct cache_req_input {

     /* Fully qualified object name used in debug messages. */

     const char *debug_fqn;

+    /* Time when the request started. Useful for by-filter lookups */

+    time_t req_start;

 };

 struct cache_req_input *

@@ -68,11 +108,14 @@ cache_req_input_create(TALLOC_CTX *mem_ctx,

     }

     input->type = type;

+    input->req_start = time(NULL);

     /* Check that input parameters match selected type. */

     switch (input->type) {

     case CACHE_REQ_USER_BY_NAME:

     case CACHE_REQ_GROUP_BY_NAME:

+    case CACHE_REQ_USER_BY_FILTER:

+    case CACHE_REQ_GROUP_BY_FILTER:

     case CACHE_REQ_INITGROUPS:

         if (name == NULL) {

             DEBUG(SSSDBG_CRIT_FAILURE, "Bug: name cannot be NULL!\n");

@@ -121,9 +164,18 @@ cache_req_input_create(TALLOC_CTX *mem_ctx,

     case CACHE_REQ_INITGROUPS:

         input->dp_type = SSS_DP_INITGROUPS;

         break;

+

     case CACHE_REQ_USER_BY_CERT:

         input->dp_type = SSS_DP_CERT;

         break;

+

+    case CACHE_REQ_USER_BY_FILTER:

+        input->dp_type = SSS_DP_WILDCARD_USER;

+        break;

+

+    case CACHE_REQ_GROUP_BY_FILTER:

+        input->dp_type = SSS_DP_WILDCARD_GROUP;

+        break;

     }

     return input;

@@ -157,7 +209,7 @@ cache_req_input_set_domain(struct cache_req_input *input,

 {

     TALLOC_CTX *tmp_ctx = NULL;

     const char *name = NULL;

-    const char *fqn = NULL;

+    const char *debug_fqn = NULL;

     errno_t ret;

     tmp_ctx = talloc_new(NULL);

@@ -171,6 +223,8 @@ cache_req_input_set_domain(struct cache_req_input *input,

     switch (input->type) {

     case CACHE_REQ_USER_BY_NAME:

     case CACHE_REQ_GROUP_BY_NAME:

+    case CACHE_REQ_USER_BY_FILTER:

+    case CACHE_REQ_GROUP_BY_FILTER:

     case CACHE_REQ_INITGROUPS:

         name = sss_get_cased_name(tmp_ctx, input->orig_name,

                                   domain->case_sensitive);

@@ -185,8 +239,8 @@ cache_req_input_set_domain(struct cache_req_input *input,

             goto done;

         }

-        fqn = talloc_asprintf(tmp_ctx, "%s@%s", name, domain->name);

-        if (fqn == NULL) {

+        debug_fqn = talloc_asprintf(tmp_ctx, "%s@%s", name, domain->name);

+        if (debug_fqn == NULL) {

             ret = ENOMEM;

             goto done;

         }

@@ -194,16 +248,16 @@ cache_req_input_set_domain(struct cache_req_input *input,

         break;

     case CACHE_REQ_USER_BY_ID:

-        fqn = talloc_asprintf(tmp_ctx, "UID:%d@%s", input->id, domain->name);

-        if (fqn == NULL) {

+        debug_fqn = talloc_asprintf(tmp_ctx, "UID:%d@%s", input->id, domain->name);

+        if (debug_fqn == NULL) {

             ret = ENOMEM;

             goto done;

         }

         break;

     case CACHE_REQ_GROUP_BY_ID:

-        fqn = talloc_asprintf(tmp_ctx, "GID:%d@%s", input->id, domain->name);

-        if (fqn == NULL) {

+        debug_fqn = talloc_asprintf(tmp_ctx, "GID:%d@%s", input->id, domain->name);

+        if (debug_fqn == NULL) {

             ret = ENOMEM;

             goto done;

         }

@@ -211,10 +265,10 @@ cache_req_input_set_domain(struct cache_req_input *input,

     case CACHE_REQ_USER_BY_CERT:

         /* certificates might be quite long, only use the last 10 charcters

          * for logging */

-        fqn = talloc_asprintf(tmp_ctx, "CERT:%s@%s",

-                              get_last_x_chars(input->cert, 10),

-                              domain->name);

-        if (fqn == NULL) {

+        debug_fqn = talloc_asprintf(tmp_ctx, "CERT:%s@%s",

+                                    get_last_x_chars(input->cert, 10),

+                                    domain->name);

+        if (debug_fqn == NULL) {

             ret = ENOMEM;

             goto done;

         }

@@ -223,7 +277,7 @@ cache_req_input_set_domain(struct cache_req_input *input,

     input->domain = domain;

     input->dom_objname = talloc_steal(input, name);

-    input->debug_fqn = talloc_steal(input, fqn);

+    input->debug_fqn = talloc_steal(input, debug_fqn);

     ret = EOK;

@@ -257,6 +311,10 @@ static errno_t cache_req_check_ncache(struct cache_req_input *input,

     case CACHE_REQ_USER_BY_CERT:

         ret = sss_ncache_check_cert(ncache, neg_timeout, input->cert);

         break;

+    case CACHE_REQ_USER_BY_FILTER:

+    case CACHE_REQ_GROUP_BY_FILTER:

+        ret = EOK;

+        break;

     }

     if (ret == EEXIST) {

@@ -282,6 +340,10 @@ static void cache_req_add_to_ncache(struct cache_req_input *input,

         ret = sss_ncache_set_group(ncache, false, input->domain,

                                    input->dom_objname);

         break;

+    case CACHE_REQ_USER_BY_FILTER:

+    case CACHE_REQ_GROUP_BY_FILTER:

+        /* Nothing to do, adding a wildcard request to ncache doesn't

+         * make sense */

     case CACHE_REQ_USER_BY_ID:

     case CACHE_REQ_GROUP_BY_ID:

     case CACHE_REQ_USER_BY_CERT:

@@ -308,6 +370,10 @@ static void cache_req_add_to_ncache_global(struct cache_req_input *input,

     errno_t ret = ERR_INTERNAL;

     switch (input->type) {

+    case CACHE_REQ_USER_BY_FILTER:

+    case CACHE_REQ_GROUP_BY_FILTER:

+        /* Nothing to do, adding a wildcard request to ncache doesn't

+         * make sense */

     case CACHE_REQ_USER_BY_NAME:

     case CACHE_REQ_GROUP_BY_NAME:

     case CACHE_REQ_INITGROUPS:

@@ -377,6 +443,18 @@ static errno_t cache_req_get_object(TALLOC_CTX *mem_ctx,

         ret = sysdb_search_user_by_cert(mem_ctx, input->domain,

                                         input->cert, &result);

         break;

+    case CACHE_REQ_USER_BY_FILTER:

+        one_item_only = false;

+        ret = updated_users_by_filter(mem_ctx, input->domain,

+                                      input->dom_objname, input->req_start,

+                                      &result);

+        break;

+    case CACHE_REQ_GROUP_BY_FILTER:

+        one_item_only = false;

+        ret = updated_groups_by_filter(mem_ctx, input->domain,

+                                       input->dom_objname, input->req_start,

+                                       &result);

+        break;

     }

     if (ret != EOK) {

@@ -397,6 +475,19 @@ done:

     return ret;

 }

+/* Return true if the request bypasses cache or false if the cache_req

+ * code can leverage sysdb for this request.

+ */

+static bool cache_req_bypass_cache(struct cache_req_input *input)

+{

+    if (input->type == CACHE_REQ_USER_BY_FILTER ||

+            input->type == CACHE_REQ_GROUP_BY_FILTER) {

+        return true;

+    }

+

+    return false;

+}

+

 struct cache_req_cache_state {

     /* input data */

     struct tevent_context *ev;

@@ -504,7 +595,8 @@ static errno_t cache_req_cache_check(struct tevent_req *req)

     state = tevent_req_data(req, struct cache_req_cache_state);

-    if (state->result == NULL || state->result->count == 0) {

+    if (state->result == NULL || state->result->count == 0 ||

+            cache_req_bypass_cache(state->input) == true) {

         ret = ENOENT;

     } else {

         if (state->input->type == CACHE_REQ_INITGROUPS) {

@@ -1059,3 +1151,41 @@ cache_req_initgr_by_name_send(TALLOC_CTX *mem_ctx,

                                           neg_timeout, cache_refresh_percent,

                                           domain, input);

 }

+

+struct tevent_req *

+cache_req_user_by_filter_send(TALLOC_CTX *mem_ctx,

+                              struct tevent_context *ev,

+                              struct resp_ctx *rctx,

+                              const char *domain,

+                              const char *filter)

+{

+    struct cache_req_input *input;

+

+    input = cache_req_input_create(mem_ctx, CACHE_REQ_USER_BY_FILTER,

+                                   filter, 0, NULL);

+    if (input == NULL) {

+        return NULL;

+    }

+

+    return cache_req_steal_input_and_send(mem_ctx, ev, rctx, NULL,

+                                          0, 0, domain, input);

+}

+

+struct tevent_req *

+cache_req_group_by_filter_send(TALLOC_CTX *mem_ctx,

+                               struct tevent_context *ev,

+                               struct resp_ctx *rctx,

+                               const char *domain,

+                               const char *filter)

+{

+    struct cache_req_input *input;

+

+    input = cache_req_input_create(mem_ctx, CACHE_REQ_GROUP_BY_FILTER,

+                                   filter, 0, NULL);

+    if (input == NULL) {

+        return NULL;

+    }

+

+    return cache_req_steal_input_and_send(mem_ctx, ev, rctx, NULL,

+                                          0, 0, domain, input);

+}

diff --git a/src/responder/common/responder_cache_req.h b/src/responder/common/responder_cache_req.h

index 84a9dde7d9df066e44b1352e0a4557f02d08cc15..9e3f88a1427f3dcbde9f81df2ec647821b7aa931 100644

--- a/src/responder/common/responder_cache_req.h

+++ b/src/responder/common/responder_cache_req.h

@@ -33,7 +33,9 @@ enum cache_req_type {

     CACHE_REQ_GROUP_BY_NAME,

     CACHE_REQ_GROUP_BY_ID,

     CACHE_REQ_INITGROUPS,

-    CACHE_REQ_USER_BY_CERT

+    CACHE_REQ_USER_BY_CERT,

+    CACHE_REQ_USER_BY_FILTER,

+    CACHE_REQ_GROUP_BY_FILTER,

 };

 struct cache_req_input;

@@ -143,4 +145,24 @@ cache_req_initgr_by_name_send(TALLOC_CTX *mem_ctx,

 #define cache_req_initgr_by_name_recv(mem_ctx, req, _result, _domain, _name) \

     cache_req_recv(mem_ctx, req, _result, _domain, _name)

+struct tevent_req *

+cache_req_user_by_filter_send(TALLOC_CTX *mem_ctx,

+                              struct tevent_context *ev,

+                              struct resp_ctx *rctx,

+                              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)

+

+struct tevent_req *

+cache_req_group_by_filter_send(TALLOC_CTX *mem_ctx,

+                              struct tevent_context *ev,

+                              struct resp_ctx *rctx,

+                              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)

+

 #endif /* RESPONDER_CACHE_H_ */

diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c

index e30deed1c6bc4023a4f2154db21fe1339e9bb3c5..31b6694668607815652f45bc93210554fd2ac918 100644

--- a/src/tests/cmocka/test_responder_cache_req.c

+++ b/src/tests/cmocka/test_responder_cache_req.c

@@ -38,6 +38,9 @@

 #define TEST_GROUP_NAME "test-group"

 #define TEST_GROUP_ID 1000

+#define TEST_USER_NAME2 "test-user2"

+#define TEST_GROUP_NAME2 "test-group2"

+

 #define new_single_domain_test(test) \

     cmocka_unit_test_setup_teardown(test_ ## test, \

                                     test_single_domain_setup, \

@@ -1694,6 +1697,405 @@ void test_group_by_id_missing_notfound(void **state)

     assert_true(test_ctx->dp_called);

 }

+static void cache_req_user_by_filter_test_done(struct tevent_req *req)

+{

+    struct cache_req_test_ctx *ctx = NULL;

+

+    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);

+    talloc_zfree(req);

+    ctx->tctx->done = true;

+}

+

+void test_users_by_filter_valid(void **state)

+{

+    struct cache_req_test_ctx *test_ctx = NULL;

+    TALLOC_CTX *req_mem_ctx = NULL;

+    struct tevent_req *req = NULL;

+    const char *ldbname = NULL;

+    errno_t ret;

+

+    test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);

+    test_ctx->create_user = true;

+

+    ret = sysdb_store_user(test_ctx->tctx->dom, TEST_USER_NAME2, "pwd", 1001, 1001,

+                           NULL, NULL, NULL, "cn="TEST_USER_NAME2",dc=test", NULL,

+                           NULL, 1000, time(NULL));

+    assert_int_equal(ret, EOK);

+

+    req_mem_ctx = talloc_new(global_talloc_context);

+    check_leaks_push(req_mem_ctx);

+

+    /* Filters always go to DP */

+    will_return(__wrap_sss_dp_get_account_send, test_ctx);

+    mock_account_recv_simple();

+

+    req = cache_req_user_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,

+                                        test_ctx->rctx,

+                                        test_ctx->tctx->dom->name,

+                                        "test*");

+    assert_non_null(req);

+    tevent_req_set_callback(req, cache_req_user_by_filter_test_done, test_ctx);

+

+    ret = test_ev_loop(test_ctx->tctx);

+    assert_int_equal(ret, ERR_OK);

+    assert_true(check_leaks_pop(req_mem_ctx));

+

+    assert_non_null(test_ctx->result);

+    assert_int_equal(test_ctx->result->count, 2);

+

+    ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[0],

+                                          SYSDB_NAME, NULL);

+    assert_non_null(ldbname);

+    assert_string_equal(ldbname, TEST_USER_NAME2);

+

+    ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[1],

+                                          SYSDB_NAME, NULL);

+    assert_non_null(ldbname);

+    assert_string_equal(ldbname, TEST_USER_NAME);

+}

+

+void test_users_by_filter_filter_old(void **state)

+{

+    struct cache_req_test_ctx *test_ctx = NULL;

+    TALLOC_CTX *req_mem_ctx = NULL;

+    struct tevent_req *req = NULL;

+    const char *ldbname = NULL;

+    errno_t ret;

+

+    test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);

+    test_ctx->create_user = true;

+

+    /* This user was updated in distant past, so it wont't be reported by

+     * the filter search */

+    ret = sysdb_store_user(test_ctx->tctx->dom, TEST_USER_NAME2, "pwd", 1001, 1001,

+                           NULL, NULL, NULL, "cn="TEST_USER_NAME2",dc=test", NULL,

+                           NULL, 1000, 1);

+    assert_int_equal(ret, EOK);

+

+    req_mem_ctx = talloc_new(global_talloc_context);

+    check_leaks_push(req_mem_ctx);

+

+    /* Filters always go to DP */

+    will_return(__wrap_sss_dp_get_account_send, test_ctx);

+    mock_account_recv_simple();

+

+    req = cache_req_user_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,

+                                        test_ctx->rctx,

+                                        test_ctx->tctx->dom->name,

+                                        "test*");

+    assert_non_null(req);

+    tevent_req_set_callback(req, cache_req_user_by_filter_test_done, test_ctx);

+

+    ret = test_ev_loop(test_ctx->tctx);

+    assert_int_equal(ret, ERR_OK);

+    assert_true(check_leaks_pop(req_mem_ctx));

+

+    assert_non_null(test_ctx->result);

+    assert_int_equal(test_ctx->result->count, 1);

+

+    ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[0],

+                                          SYSDB_NAME, NULL);

+    assert_non_null(ldbname);

+    assert_string_equal(ldbname, TEST_USER_NAME);

+}

+

+void test_users_by_filter_notfound(void **state)

+{

+    struct cache_req_test_ctx *test_ctx = NULL;

+    TALLOC_CTX *req_mem_ctx = NULL;

+    struct tevent_req *req = NULL;

+    errno_t ret;

+

+    test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);

+

+    req_mem_ctx = talloc_new(global_talloc_context);

+    check_leaks_push(req_mem_ctx);

+

+    /* Filters always go to DP */

+    will_return(__wrap_sss_dp_get_account_send, test_ctx);

+    mock_account_recv_simple();

+

+    req = cache_req_user_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,

+                                        test_ctx->rctx,

+                                        test_ctx->tctx->dom->name,

+                                        "nosuchuser*");

+    assert_non_null(req);

+    tevent_req_set_callback(req, cache_req_user_by_filter_test_done, test_ctx);

+

+    ret = test_ev_loop(test_ctx->tctx);

+    assert_int_equal(ret, ENOENT);

+    assert_true(check_leaks_pop(req_mem_ctx));

+}

+

+static void test_users_by_filter_multiple_domains_valid(void **state)

+{

+    struct cache_req_test_ctx *test_ctx = NULL;

+    struct sss_domain_info *domain = NULL;

+    TALLOC_CTX *req_mem_ctx = NULL;

+    struct tevent_req *req = NULL;

+    const char *ldbname = NULL;

+    errno_t ret;

+

+    test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);

+

+    domain = find_domain_by_name(test_ctx->tctx->dom,

+                                 "responder_cache_req_test_d", true);

+    assert_non_null(domain);

+

+    ret = sysdb_store_user(domain, TEST_USER_NAME, "pwd", 1000, 1000,

+                           NULL, NULL, NULL, "cn="TEST_USER_NAME",dc=test", NULL,

+                           NULL, 1000, time(NULL));

+    assert_int_equal(ret, EOK);

+

+    ret = sysdb_store_user(domain, TEST_USER_NAME2, "pwd", 1001, 1001,

+                           NULL, NULL, NULL, "cn="TEST_USER_NAME2",dc=test", NULL,

+                           NULL, 1000, time(NULL));

+    assert_int_equal(ret, EOK);

+

+    req_mem_ctx = talloc_new(global_talloc_context);

+    check_leaks_push(req_mem_ctx);

+

+    /* Filters always go to DP */

+    will_return(__wrap_sss_dp_get_account_send, test_ctx);

+    mock_account_recv_simple();

+

+    req = cache_req_user_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,

+                                        test_ctx->rctx,

+                                        domain->name,

+                                        "test*");

+    assert_non_null(req);

+    tevent_req_set_callback(req, cache_req_user_by_filter_test_done, test_ctx);

+

+    ret = test_ev_loop(test_ctx->tctx);

+    assert_int_equal(ret, ERR_OK);

+    assert_true(check_leaks_pop(req_mem_ctx));

+

+    assert_non_null(test_ctx->result);

+    assert_int_equal(test_ctx->result->count, 2);

+

+    ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[0],

+                                          SYSDB_NAME, NULL);

+    assert_non_null(ldbname);

+    assert_string_equal(ldbname, TEST_USER_NAME2);

+

+    ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[1],

+                                          SYSDB_NAME, NULL);

+    assert_non_null(ldbname);

+    assert_string_equal(ldbname, TEST_USER_NAME);

+}

+

+static void test_users_by_filter_multiple_domains_notfound(void **state)

+{

+    struct cache_req_test_ctx *test_ctx = NULL;

+    struct sss_domain_info *domain = NULL;

+    TALLOC_CTX *req_mem_ctx = NULL;

+    struct tevent_req *req = NULL;

+    errno_t ret;

+

+    test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);

+

+    domain = find_domain_by_name(test_ctx->tctx->dom,

+                                 "responder_cache_req_test_d", true);

+    assert_non_null(domain);

+

+    req_mem_ctx = talloc_new(global_talloc_context);

+    check_leaks_push(req_mem_ctx);

+

+    /* Filters always go to DP */

+    will_return(__wrap_sss_dp_get_account_send, test_ctx);

+    mock_account_recv_simple();

+

+    req = cache_req_user_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,

+                                        test_ctx->rctx,

+                                        domain->name,

+                                        "nosuchuser*");

+    assert_non_null(req);

+    tevent_req_set_callback(req, cache_req_user_by_filter_test_done, test_ctx);

+

+    ret = test_ev_loop(test_ctx->tctx);

+    assert_int_equal(ret, ENOENT);

+    assert_true(check_leaks_pop(req_mem_ctx));

+}

+

+static void cache_req_group_by_filter_test_done(struct tevent_req *req)

+{

+    struct cache_req_test_ctx *ctx = NULL;

+

+    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);

+    talloc_zfree(req);

+    ctx->tctx->done = true;

+}

+

+void test_groups_by_filter_valid(void **state)

+{

+    struct cache_req_test_ctx *test_ctx = NULL;

+    TALLOC_CTX *req_mem_ctx = NULL;

+    struct tevent_req *req = NULL;

+    const char *ldbname = NULL;

+    errno_t ret;

+

+    test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);

+    test_ctx->create_group = true;

+

+    ret = sysdb_store_group(test_ctx->tctx->dom, TEST_GROUP_NAME2,

+                            1001, NULL, 1001, time(NULL));

+    assert_int_equal(ret, EOK);

+

+    req_mem_ctx = talloc_new(global_talloc_context);

+    check_leaks_push(req_mem_ctx);

+

+    /* Filters always go to DP */

+    will_return(__wrap_sss_dp_get_account_send, test_ctx);

+    mock_account_recv_simple();

+

+    req = cache_req_group_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,

+                                         test_ctx->rctx,

+                                         test_ctx->tctx->dom->name,

+                                         "test*");

+    assert_non_null(req);

+    tevent_req_set_callback(req, cache_req_group_by_filter_test_done, test_ctx);

+

+    ret = test_ev_loop(test_ctx->tctx);

+    assert_int_equal(ret, ERR_OK);

+    assert_true(check_leaks_pop(req_mem_ctx));

+

+    assert_non_null(test_ctx->result);

+    assert_int_equal(test_ctx->result->count, 2);

+

+    ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[0],

+                                          SYSDB_NAME, NULL);

+    assert_non_null(ldbname);

+    assert_string_equal(ldbname, TEST_GROUP_NAME2);

+

+    ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[1],

+                                          SYSDB_NAME, NULL);

+    assert_non_null(ldbname);

+    assert_string_equal(ldbname, TEST_GROUP_NAME);

+}

+

+void test_groups_by_filter_notfound(void **state)

+{

+    struct cache_req_test_ctx *test_ctx = NULL;

+    TALLOC_CTX *req_mem_ctx = NULL;

+    struct tevent_req *req = NULL;

+    errno_t ret;

+

+    test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);

+

+    req_mem_ctx = talloc_new(global_talloc_context);

+    check_leaks_push(req_mem_ctx);

+

+    /* Filters always go to DP */

+    will_return(__wrap_sss_dp_get_account_send, test_ctx);

+    mock_account_recv_simple();

+

+    req = cache_req_group_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,

+                                        test_ctx->rctx,

+                                        test_ctx->tctx->dom->name,

+                                        "nosuchgroup*");

+    assert_non_null(req);

+    tevent_req_set_callback(req, cache_req_group_by_filter_test_done, test_ctx);

+

+    ret = test_ev_loop(test_ctx->tctx);

+    assert_int_equal(ret, ENOENT);

+    assert_true(check_leaks_pop(req_mem_ctx));

+}

+

+void test_groups_by_filter_multiple_domains_valid(void **state)

+{

+    struct cache_req_test_ctx *test_ctx = NULL;

+    struct sss_domain_info *domain = NULL;

+    TALLOC_CTX *req_mem_ctx = NULL;

+    struct tevent_req *req = NULL;

+    const char *ldbname = NULL;

+    errno_t ret;

+

+    test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);

+

+    domain = find_domain_by_name(test_ctx->tctx->dom,

+                                 "responder_cache_req_test_d", true);

+    assert_non_null(domain);

+

+    ret = sysdb_store_group(domain, TEST_GROUP_NAME,

+                            1000, NULL, 1000, time(NULL));

+    assert_int_equal(ret, EOK);

+

+    ret = sysdb_store_group(domain, TEST_GROUP_NAME2,

+                            1001, NULL, 1001, time(NULL));

+    assert_int_equal(ret, EOK);

+

+    req_mem_ctx = talloc_new(global_talloc_context);

+    check_leaks_push(req_mem_ctx);

+

+    /* Filters always go to DP */

+    will_return(__wrap_sss_dp_get_account_send, test_ctx);

+    mock_account_recv_simple();

+

+    req = cache_req_group_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,