be_refresh: refactor netgroups refresh

This is a preparation to support other object types without
introducing duplicated code.

Reviewed-by: Jakub Hrozek <jhrozek@redhat.com>

1 files changed, 77 insertions, 32 deletions

diff --git a/src/providers/ldap/sdap_refresh.c b/src/providers/ldap/sdap_refresh.c
index 0b9753ee5..29055359f 100644
--- a/src/providers/ldap/sdap_refresh.c
+++ b/src/providers/ldap/sdap_refresh.c
@@ -24,30 +24,34 @@
 #include "providers/ldap/sdap.h"
 #include "providers/ldap/ldap_common.h"
 
-struct sdap_refresh_netgroups_state {
+struct sdap_refresh_state {
     struct tevent_context *ev;
+    struct be_ctx *be_ctx;
+    struct be_acct_req *account_req;
     struct sdap_id_ctx *id_ctx;
     struct sdap_domain *sdom;
+    const char *type;
     char **names;
     size_t index;
 };
 
-static errno_t sdap_refresh_netgroups_step(struct tevent_req *req);
-static void sdap_refresh_netgroups_done(struct tevent_req *subreq);
+static errno_t sdap_refresh_step(struct tevent_req *req);
+static void sdap_refresh_done(struct tevent_req *subreq);
 
-struct tevent_req *sdap_refresh_netgroups_send(TALLOC_CTX *mem_ctx,
-                                               struct tevent_context *ev,
-                                               struct be_ctx *be_ctx,
-                                               struct sss_domain_info *domain,
-                                               char **names,
-                                               void *pvt)
+static struct tevent_req *sdap_refresh_send(TALLOC_CTX *mem_ctx,
+                                            struct tevent_context *ev,
+                                            struct be_ctx *be_ctx,
+                                            struct sss_domain_info *domain,
+                                            int entry_type,
+                                            char **names,
+                                            void *pvt)
 {
-    struct sdap_refresh_netgroups_state *state = NULL;
+    struct sdap_refresh_state *state = NULL;
     struct tevent_req *req = NULL;
     errno_t ret;
 
     req = tevent_req_create(mem_ctx, &state,
-                            struct sdap_refresh_netgroups_state);
+                            struct sdap_refresh_state);
     if (req == NULL) {
         DEBUG(SSSDBG_CRIT_FAILURE, "tevent_req_create() failed\n");
         return NULL;
@@ -59,6 +63,7 @@ struct tevent_req *sdap_refresh_netgroups_send(TALLOC_CTX *mem_ctx,
     }
 
     state->ev = ev;
+    state->be_ctx = be_ctx;
     state->id_ctx = talloc_get_type(pvt, struct sdap_id_ctx);
     state->names = names;
     state->index = 0;
@@ -69,13 +74,34 @@ struct tevent_req *sdap_refresh_netgroups_send(TALLOC_CTX *mem_ctx,
         goto immediately;
     }
 
-    ret = sdap_refresh_netgroups_step(req);
+    switch (entry_type) {
+    case BE_REQ_NETGROUP:
+        state->type = "netgroup";
+        break;
+    default:
+        DEBUG(SSSDBG_CRIT_FAILURE, "Invalid entry type [%d]!\n", entry_type);
+    }
+
+    state->account_req = talloc_zero(state, struct be_acct_req);
+    if (state->account_req == NULL) {
+        ret = ENOMEM;
+        goto immediately;
+    }
+
+    state->account_req->entry_type = entry_type;
+    state->account_req->attr_type = BE_ATTR_CORE;
+    state->account_req->filter_type = BE_FILTER_NAME;
+    state->account_req->extra_value = NULL;
+    state->account_req->domain = domain->name;
+    /* filter will be filled later */
+
+    ret = sdap_refresh_step(req);
     if (ret == EOK) {
         DEBUG(SSSDBG_TRACE_FUNC, "Nothing to refresh\n");
         goto immediately;
     } else if (ret != EAGAIN) {
-        DEBUG(SSSDBG_CRIT_FAILURE, "sdap_refresh_netgroups_step() failed "
-                                    "[%d]: %s\n", ret, sss_strerror(ret));
+        DEBUG(SSSDBG_CRIT_FAILURE, "sdap_refresh_step() failed "
+                                   "[%d]: %s\n", ret, sss_strerror(ret));
         goto immediately;
     }
 
@@ -92,37 +118,37 @@ immediately:
     return req;
 }
 
-static errno_t sdap_refresh_netgroups_step(struct tevent_req *req)
+static errno_t sdap_refresh_step(struct tevent_req *req)
 {
-    struct sdap_refresh_netgroups_state *state = NULL;
+    struct sdap_refresh_state *state = NULL;
     struct tevent_req *subreq = NULL;
-    const char *name = NULL;
     errno_t ret;
 
-    state = tevent_req_data(req, struct sdap_refresh_netgroups_state);
+    state = tevent_req_data(req, struct sdap_refresh_state);
 
     if (state->names == NULL) {
         ret = EOK;
         goto done;
     }
 
-    name = state->names[state->index];
-    if (name == NULL) {
+    state->account_req->filter_value = state->names[state->index];
+    if (state->account_req->filter_value == NULL) {
         ret = EOK;
         goto done;
     }
 
-    DEBUG(SSSDBG_TRACE_FUNC, "Issuing refresh of netgroup %s\n", name);
+    DEBUG(SSSDBG_TRACE_FUNC, "Issuing refresh of %s %s\n",
+          state->type, state->account_req->filter_value);
 
-    subreq = ldap_netgroup_get_send(state, state->ev, state->id_ctx,
-                                    state->sdom, state->id_ctx->conn,
-                                    name, true);
+    subreq = sdap_handle_acct_req_send(state, state->be_ctx,
+                                       state->account_req, state->id_ctx,
+                                       state->sdom, state->id_ctx->conn, true);
     if (subreq == NULL) {
         ret = ENOMEM;
         goto done;
     }
 
-    tevent_req_set_callback(subreq, sdap_refresh_netgroups_done, req);
+    tevent_req_set_callback(subreq, sdap_refresh_done, req);
 
     state->index++;
     ret = EAGAIN;
@@ -131,25 +157,28 @@ done:
     return ret;
 }
 
-static void sdap_refresh_netgroups_done(struct tevent_req *subreq)
+static void sdap_refresh_done(struct tevent_req *subreq)
 {
+    struct sdap_refresh_state *state = NULL;
     struct tevent_req *req = NULL;
+    const char *err_msg = NULL;
     errno_t dp_error;
     int sdap_ret;
     errno_t ret;
 
     req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sdap_refresh_state);
 
-    ret = ldap_netgroup_get_recv(subreq, &dp_error, &sdap_ret);
+    ret = sdap_handle_acct_req_recv(subreq, &dp_error, &err_msg, &sdap_ret);
     talloc_zfree(subreq);
     if (ret != EOK) {
-        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to refresh netgroup [dp_error: %d, "
-              "sdap_ret: %d, errno: %d]: %s\n",
-              dp_error, sdap_ret, ret, sss_strerror(ret));
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to refresh %s [dp_error: %d, "
+              "sdap_ret: %d, errno: %d]: %s\n", state->type,
+              dp_error, sdap_ret, ret, err_msg);
         goto done;
     }
 
-    ret = sdap_refresh_netgroups_step(req);
+    ret = sdap_refresh_step(req);
     if (ret == EAGAIN) {
         return;
     }
@@ -163,9 +192,25 @@ done:
     tevent_req_done(req);
 }
 
-errno_t sdap_refresh_netgroups_recv(struct tevent_req *req)
+static errno_t sdap_refresh_recv(struct tevent_req *req)
 {
     TEVENT_REQ_RETURN_ON_ERROR(req);
 
     return EOK;
 }
+
+struct tevent_req *sdap_refresh_netgroups_send(TALLOC_CTX *mem_ctx,
+                                               struct tevent_context *ev,
+                                               struct be_ctx *be_ctx,
+                                               struct sss_domain_info *domain,
+                                               char **names,
+                                               void *pvt)
+{
+    return sdap_refresh_send(mem_ctx, ev, be_ctx, domain,
+                             BE_REQ_NETGROUP, names, pvt);
+}
+
+errno_t sdap_refresh_netgroups_recv(struct tevent_req *req)
+{
+    return sdap_refresh_recv(req);
+}