Return the dp error from the providers

2 files changed, 47 insertions, 26 deletions

diff --git a/server/providers/ldap/ldap_auth.c b/server/providers/ldap/ldap_auth.c
index 80726e778..a70817d9e 100644
--- a/server/providers/ldap/ldap_auth.c
+++ b/server/providers/ldap/ldap_auth.c
@@ -328,7 +328,7 @@ struct sdap_pam_chpass_state {
 
 static void sdap_auth4chpass_done(struct tevent_req *req);
 static void sdap_pam_chpass_done(struct tevent_req *req);
-static void sdap_pam_auth_reply(struct be_req *breq, int result);
+static void sdap_pam_auth_reply(struct be_req *breq, int dp_err, int result);
 
 static void sdap_pam_chpass_send(struct be_req *breq)
 {
@@ -337,6 +337,7 @@ static void sdap_pam_chpass_send(struct be_req *breq)
     struct tevent_req *subreq;
     struct pam_data *pd;
     struct dp_opt_blob authtok;
+    int dp_err = DP_ERR_FATAL;
 
     ctx = talloc_get_type(breq->be_ctx->bet_info[BET_CHPASS].pvt_bet_data,
                           struct sdap_auth_ctx);
@@ -345,6 +346,7 @@ static void sdap_pam_chpass_send(struct be_req *breq)
     if (be_is_offline(ctx->be)) {
         DEBUG(4, ("Backend is marked offline, retry later!\n"));
         pd->pam_status = PAM_AUTHINFO_UNAVAIL;
+        dp_err = DP_ERR_OFFLINE;
         goto done;
     }
 
@@ -383,8 +385,9 @@ static void sdap_pam_chpass_send(struct be_req *breq)
 
     tevent_req_set_callback(subreq, sdap_auth4chpass_done, state);
     return;
+
 done:
-    sdap_pam_auth_reply(breq, pd->pam_status);
+    sdap_pam_auth_reply(breq, dp_err, pd->pam_status);
 }
 
 static void sdap_auth4chpass_done(struct tevent_req *req)
@@ -393,6 +396,7 @@ static void sdap_auth4chpass_done(struct tevent_req *req)
                     tevent_req_callback_data(req, struct sdap_pam_chpass_state);
     struct tevent_req *subreq;
     enum sdap_result result;
+    int dp_err = DP_ERR_FATAL;
     int ret;
 
     ret = auth_recv(req, &result, state, &state->sh, &state->dn);
@@ -421,13 +425,13 @@ static void sdap_auth4chpass_done(struct tevent_req *req)
 
         tevent_req_set_callback(subreq, sdap_pam_chpass_done, state);
         return;
-        break;
+
     default:
         state->pd->pam_status = PAM_SYSTEM_ERR;
     }
 
 done:
-    sdap_pam_auth_reply(state->breq, state->pd->pam_status);
+    sdap_pam_auth_reply(state->breq, dp_err, state->pd->pam_status);
 }
 
 static void sdap_pam_chpass_done(struct tevent_req *req)
@@ -435,6 +439,7 @@ static void sdap_pam_chpass_done(struct tevent_req *req)
     struct sdap_pam_chpass_state *state =
                     tevent_req_callback_data(req, struct sdap_pam_chpass_state);
     enum sdap_result result;
+    int dp_err = DP_ERR_FATAL;
     int ret;
 
     ret = sdap_exop_modify_passwd_recv(req, &result);
@@ -447,13 +452,14 @@ static void sdap_pam_chpass_done(struct tevent_req *req)
     switch (result) {
     case SDAP_SUCCESS:
         state->pd->pam_status = PAM_SUCCESS;
+        dp_err = DP_ERR_OK;
         break;
     default:
         state->pd->pam_status = PAM_SYSTEM_ERR;
     }
 
 done:
-    sdap_pam_auth_reply(state->breq, state->pd->pam_status);
+    sdap_pam_auth_reply(state->breq, dp_err, state->pd->pam_status);
 }
 /* ==Perform-User-Authentication-and-Password-Caching===================== */
 
@@ -466,7 +472,6 @@ struct sdap_pam_auth_state {
 
 static void sdap_pam_auth_done(struct tevent_req *req);
 static void sdap_password_cache_done(struct tevent_req *req);
-static void sdap_pam_auth_reply(struct be_req *breq, int result);
 
 /* FIXME: convert caller to tevent_req too ?*/
 static void sdap_pam_auth_send(struct be_req *breq)
@@ -475,6 +480,7 @@ static void sdap_pam_auth_send(struct be_req *breq)
     struct sdap_auth_ctx *ctx;
     struct tevent_req *subreq;
     struct pam_data *pd;
+    int dp_err = DP_ERR_FATAL;
 
     ctx = talloc_get_type(breq->be_ctx->bet_info[BET_AUTH].pvt_bet_data,
                           struct sdap_auth_ctx);
@@ -483,6 +489,7 @@ static void sdap_pam_auth_send(struct be_req *breq)
     if (be_is_offline(ctx->be)) {
         DEBUG(4, ("Backend is marked offline, retry later!\n"));
         pd->pam_status = PAM_AUTHINFO_UNAVAIL;
+        dp_err = DP_ERR_OFFLINE;
         goto done;
     }
 
@@ -513,10 +520,11 @@ static void sdap_pam_auth_send(struct be_req *breq)
 
     default:
         pd->pam_status = PAM_SUCCESS;
+        dp_err = DP_ERR_OK;
     }
 
 done:
-    sdap_pam_auth_reply(breq, pd->pam_status);
+    sdap_pam_auth_reply(breq, dp_err, pd->pam_status);
 }
 
 static void sdap_pam_auth_done(struct tevent_req *req)
@@ -525,12 +533,14 @@ static void sdap_pam_auth_done(struct tevent_req *req)
                     tevent_req_callback_data(req, struct sdap_pam_auth_state);
     struct tevent_req *subreq;
     enum sdap_result result;
+    int dp_err = DP_ERR_OK;
     int ret;
 
     ret = auth_recv(req, &result, NULL, NULL, NULL);
     talloc_zfree(req);
     if (ret) {
         state->pd->pam_status = PAM_SYSTEM_ERR;
+        dp_err = DP_ERR_FATAL;
         goto done;
     }
 
@@ -549,10 +559,12 @@ static void sdap_pam_auth_done(struct tevent_req *req)
         break;
     default:
         state->pd->pam_status = PAM_SYSTEM_ERR;
+        dp_err = DP_ERR_FATAL;
     }
 
     if (result == SDAP_UNAVAIL) {
         be_mark_offline(state->breq->be_ctx);
+        dp_err = DP_ERR_OFFLINE;
         goto done;
     }
 
@@ -562,6 +574,7 @@ static void sdap_pam_auth_done(struct tevent_req *req)
         char *password = talloc_strndup(state, (char *)
                                         state->password.data,
                                         state->password.length);
+        /* password caching failures are not fatal errors */
         if (!password) {
             DEBUG(2, ("Failed to cache password for %s\n", state->username));
             goto done;
@@ -586,7 +599,7 @@ static void sdap_pam_auth_done(struct tevent_req *req)
     }
 
 done:
-    sdap_pam_auth_reply(state->breq, state->pd->pam_status);
+    sdap_pam_auth_reply(state->breq, dp_err, state->pd->pam_status);
 }
 
 static void sdap_password_cache_done(struct tevent_req *subreq)
@@ -604,14 +617,12 @@ static void sdap_password_cache_done(struct tevent_req *subreq)
         DEBUG(4, ("Password successfully cached for %s\n", state->username));
     }
 
-    sdap_pam_auth_reply(state->breq, state->pd->pam_status);
+    sdap_pam_auth_reply(state->breq, DP_ERR_OK, state->pd->pam_status);
 }
 
-static void sdap_pam_auth_reply(struct be_req *req, int result)
+static void sdap_pam_auth_reply(struct be_req *req, int dp_err, int result)
 {
-    const char *errstr = NULL;
-    if (result) errstr = "Operation failed";
-    req->fn(req, result, errstr);
+    req->fn(req, dp_err, result, NULL);
 }
 
 /* ==Module-Initialization-and-Dispose==================================== */
@@ -619,7 +630,7 @@ static void sdap_pam_auth_reply(struct be_req *req, int result)
 static void sdap_shutdown(struct be_req *req)
 {
     /* TODO: Clean up any internal data */
-    req->fn(req, EOK, NULL);
+    req->fn(req, DP_ERR_OK, EOK, NULL);
 }
 
 struct bet_ops sdap_auth_ops = {
diff --git a/server/providers/ldap/ldap_id.c b/server/providers/ldap/ldap_id.c
index e1a31cf3e..3663f201f 100644
--- a/server/providers/ldap/ldap_id.c
+++ b/server/providers/ldap/ldap_id.c
@@ -47,9 +47,10 @@ struct sdap_id_ctx {
     char *max_group_timestamp;
 };
 
-static void sdap_req_done(struct be_req *req, int ret, const char *err)
+static void sdap_req_done(struct be_req *req, int dp_err,
+                          int error, const char *errstr)
 {
-    return req->fn(req, ret, err);
+    return req->fn(req, dp_err, error, errstr);
 }
 
 static int build_attrs_from_map(TALLOC_CTX *memctx,
@@ -235,6 +236,7 @@ static void users_get_done(struct tevent_req *req)
     struct sdap_id_ctx *ctx;
     enum tevent_req_state tstate;
     uint64_t err;
+    int dp_err = DP_ERR_OK;
     const char *error = NULL;
     int ret = EOK;
 
@@ -244,16 +246,18 @@ static void users_get_done(struct tevent_req *req)
     }
 
     if (ret) {
+        dp_err = DP_ERR_FATAL;
         error = "Enum Users Failed";
 
         if (ret == ETIMEDOUT) {
+            dp_err = DP_ERR_TIMEOUT;
             ctx = talloc_get_type(breq->be_ctx->bet_info[BET_ID].pvt_bet_data,
                                   struct sdap_id_ctx);
             be_mark_offline(ctx->be);
         }
     }
 
-    return sdap_req_done(breq, ret, error);
+    sdap_req_done(breq, dp_err, ret, error);
 }
 
 /* =Groups-Related-Functions-(by-name,by-uid)============================= */
@@ -398,6 +402,7 @@ static void groups_get_done(struct tevent_req *req)
     struct sdap_id_ctx *ctx;
     enum tevent_req_state tstate;
     uint64_t err;
+    int dp_err = DP_ERR_OK;
     const char *error = NULL;
     int ret = EOK;
 
@@ -406,16 +411,18 @@ static void groups_get_done(struct tevent_req *req)
     }
 
     if (ret) {
+        dp_err = DP_ERR_FATAL;
         error = "Enum Groups Failed";
 
         if (ret == ETIMEDOUT) {
+            dp_err = DP_ERR_TIMEOUT;
             ctx = talloc_get_type(breq->be_ctx->bet_info[BET_ID].pvt_bet_data,
                                   struct sdap_id_ctx);
             be_mark_offline(ctx->be);
         }
     }
 
-    return sdap_req_done(breq, ret, error);
+    return sdap_req_done(breq, dp_err, ret, error);
 }
 
 /* =Get-Groups-for-User================================================== */
@@ -535,6 +542,7 @@ static void groups_by_user_done(struct tevent_req *req)
     struct sdap_id_ctx *ctx;
     enum tevent_req_state tstate;
     uint64_t err;
+    int dp_err = DP_ERR_OK;
     const char *error = NULL;
     int ret = EOK;
 
@@ -543,16 +551,18 @@ static void groups_by_user_done(struct tevent_req *req)
     }
 
     if (ret) {
+        dp_err = DP_ERR_FATAL;
         error = "Init Groups Failed";
 
         if (ret == ETIMEDOUT) {
+            dp_err = DP_ERR_TIMEOUT;
             ctx = talloc_get_type(breq->be_ctx->bet_info[BET_ID].pvt_bet_data,
                                   struct sdap_id_ctx);
             be_mark_offline(ctx->be);
         }
     }
 
-    return sdap_req_done(breq, ret, error);
+    return sdap_req_done(breq, dp_err, ret, error);
 }
 
 
@@ -572,7 +582,7 @@ static void sdap_get_account_info(struct be_req *breq)
     ctx = talloc_get_type(breq->be_ctx->bet_info[BET_ID].pvt_bet_data, struct sdap_id_ctx);
 
     if (be_is_offline(ctx->be)) {
-        return sdap_req_done(breq, EAGAIN, "Offline");
+        return sdap_req_done(breq, DP_ERR_OFFLINE, EAGAIN, "Offline");
     }
 
     ar = talloc_get_type(breq->req_data, struct be_acct_req);
@@ -582,7 +592,7 @@ static void sdap_get_account_info(struct be_req *breq)
 
         /* skip enumerations on demand */
         if (strcmp(ar->filter_value, "*") == 0) {
-            return sdap_req_done(breq, EOK, "Success");
+            return sdap_req_done(breq, DP_ERR_OK, EOK, "Success");
         }
 
         req = users_get_send(breq, breq->be_ctx->ev, ctx,
@@ -590,7 +600,7 @@ static void sdap_get_account_info(struct be_req *breq)
                              ar->filter_type,
                              ar->attr_type);
         if (!req) {
-            return sdap_req_done(breq, ENOMEM, "Out of memory");
+            return sdap_req_done(breq, DP_ERR_FATAL, ENOMEM, "Out of memory");
         }
 
         tevent_req_set_callback(req, users_get_done, breq);
@@ -600,7 +610,7 @@ static void sdap_get_account_info(struct be_req *breq)
     case BE_REQ_GROUP: /* group */
 
         if (strcmp(ar->filter_value, "*") == 0) {
-            return sdap_req_done(breq, EOK, "Success");
+            return sdap_req_done(breq, DP_ERR_OK, EOK, "Success");
         }
 
         /* skip enumerations on demand */
@@ -609,7 +619,7 @@ static void sdap_get_account_info(struct be_req *breq)
                               ar->filter_type,
                               ar->attr_type);
         if (!req) {
-            return sdap_req_done(breq, ENOMEM, "Out of memory");
+            return sdap_req_done(breq, DP_ERR_FATAL, ENOMEM, "Out of memory");
         }
 
         tevent_req_set_callback(req, groups_get_done, breq);
@@ -646,7 +656,7 @@ static void sdap_get_account_info(struct be_req *breq)
         err = "Invalid request type";
     }
 
-    if (ret != EOK) return sdap_req_done(breq, ret, err);
+    if (ret != EOK) return sdap_req_done(breq, DP_ERR_FATAL, ret, err);
 }
 
 
@@ -1148,7 +1158,7 @@ static void enum_groups_op_done(struct tevent_req *subreq)
 static void sdap_shutdown(struct be_req *req)
 {
     /* TODO: Clean up any internal data */
-    sdap_req_done(req, EOK, NULL);
+    sdap_req_done(req, DP_ERR_OK, EOK, NULL);
 }
 
 struct bet_ops sdap_id_ops = {