Fix tevent_req error checking.

When possible using a macro that correctly deals with tstate

6 files changed, 45 insertions, 117 deletions

diff --git a/server/providers/ldap/ldap_auth.c b/server/providers/ldap/ldap_auth.c
index 275c89452..a9f03a763 100644
--- a/server/providers/ldap/ldap_auth.c
+++ b/server/providers/ldap/ldap_auth.c
@@ -386,12 +386,8 @@ static int get_user_dn_recv(struct tevent_req *req,
 {
     struct get_user_dn_state *state = tevent_req_data(req,
                                            struct get_user_dn_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        return err;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     *dn = talloc_steal(memctx, state->dn);
     if (!*dn) return ENOMEM;
@@ -535,9 +531,15 @@ int auth_recv(struct tevent_req *req,
     uint64_t err;
 
     if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err == ETIMEDOUT) *result = SDAP_UNAVAIL;
-        else *result = SDAP_ERROR;
-        return EOK;
+        switch (tstate) {
+        case TEVENT_REQ_USER_ERROR:
+            if (err == ETIMEDOUT) *result = SDAP_UNAVAIL;
+            else *result = SDAP_ERROR;
+            return err;
+        default:
+            *result = SDAP_ERROR;
+            return EIO;
+        }
     }
 
     if (sh != NULL) {
diff --git a/server/providers/ldap/ldap_id.c b/server/providers/ldap/ldap_id.c
index 307f1e701..3268d7344 100644
--- a/server/providers/ldap/ldap_id.c
+++ b/server/providers/ldap/ldap_id.c
@@ -176,7 +176,7 @@ static void users_get_done(struct tevent_req *req)
     struct be_req *breq = tevent_req_callback_data(req, struct be_req);
     struct sdap_id_ctx *ctx;
     enum tevent_req_state tstate;
-    uint64_t err;
+    uint64_t err = EIO;
     int dp_err = DP_ERR_OK;
     const char *error = NULL;
     int ret = EOK;
@@ -347,7 +347,7 @@ static void groups_get_done(struct tevent_req *req)
     struct be_req *breq = tevent_req_callback_data(req, struct be_req);
     struct sdap_id_ctx *ctx;
     enum tevent_req_state tstate;
-    uint64_t err;
+    uint64_t err = EIO;
     int dp_err = DP_ERR_OK;
     const char *error = NULL;
     int ret = EOK;
@@ -493,7 +493,7 @@ static void groups_by_user_done(struct tevent_req *req)
     struct be_req *breq = tevent_req_callback_data(req, struct be_req);
     struct sdap_id_ctx *ctx;
     enum tevent_req_state tstate;
-    uint64_t err;
+    uint64_t err = EIO;
     int dp_err = DP_ERR_OK;
     const char *error = NULL;
     int ret = EOK;
diff --git a/server/providers/ldap/ldap_id_enum.c b/server/providers/ldap/ldap_id_enum.c
index 39b242434..b7035efe5 100644
--- a/server/providers/ldap/ldap_id_enum.c
+++ b/server/providers/ldap/ldap_id_enum.c
@@ -179,6 +179,9 @@ static void ldap_id_enum_users_done(struct tevent_req *subreq)
     uint64_t err = 0;
 
     if (tevent_req_is_error(subreq, &tstate, &err)) {
+        if (tstate != TEVENT_REQ_USER_ERROR) {
+            err = EIO;
+        }
         goto fail;
     }
     talloc_zfree(subreq);
@@ -210,9 +213,12 @@ static void ldap_id_enum_groups_done(struct tevent_req *subreq)
     struct global_enum_state *state = tevent_req_data(req,
                                                  struct global_enum_state);
     enum tevent_req_state tstate;
-    uint64_t err;
+    uint64_t err = 0;
 
     if (tevent_req_is_error(subreq, &tstate, &err)) {
+        if (tstate != TEVENT_REQ_USER_ERROR) {
+            err = EIO;
+        }
         goto fail;
     }
     talloc_zfree(subreq);
diff --git a/server/providers/ldap/sdap_async.c b/server/providers/ldap/sdap_async.c
index e02f37875..9e35c6432 100644
--- a/server/providers/ldap/sdap_async.c
+++ b/server/providers/ldap/sdap_async.c
@@ -601,14 +601,10 @@ int sdap_exop_modify_passwd_recv(struct tevent_req *req,
 {
     struct sdap_exop_modify_passwd_state *state = tevent_req_data(req,
                                          struct sdap_exop_modify_passwd_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
     *result = SDAP_ERROR;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        return err;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     if (state->result == LDAP_SUCCESS) {
         *result = SDAP_SUCCESS;
@@ -702,13 +698,8 @@ int sdap_get_rootdse_recv(struct tevent_req *req,
 {
     struct sdap_get_rootdse_state *state = tevent_req_data(req,
                                              struct sdap_get_rootdse_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err) return err;
-        return EIO;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     *rootdse = talloc_steal(memctx, state->rootdse);
 
@@ -912,13 +903,8 @@ int sdap_get_generic_recv(struct tevent_req *req,
 {
     struct sdap_get_generic_state *state = tevent_req_data(req,
                                             struct sdap_get_generic_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err) return err;
-        return EIO;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     *reply_count = state->reply_count;
     *reply = talloc_steal(mem_ctx, state->reply);
diff --git a/server/providers/ldap/sdap_async_accounts.c b/server/providers/ldap/sdap_async_accounts.c
index b38f6d62d..bf6f852c8 100644
--- a/server/providers/ldap/sdap_async_accounts.c
+++ b/server/providers/ldap/sdap_async_accounts.c
@@ -299,13 +299,8 @@ static int sdap_save_user_recv(struct tevent_req *req,
 {
     struct sdap_save_user_state *state = tevent_req_data(req,
                                             struct sdap_save_user_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (!err) return EIO;
-        return err;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     if (timestamp) {
         *timestamp = talloc_steal(mem_ctx, state->timestamp);
@@ -460,13 +455,8 @@ static int sdap_save_users_recv(struct tevent_req *req,
 {
     struct sdap_save_users_state *state  = tevent_req_data(req,
                                                struct sdap_save_users_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err) return err;
-        return EIO;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     if (timestamp) {
         *timestamp = talloc_steal(mem_ctx, state->higher_timestamp);
@@ -595,13 +585,8 @@ int sdap_get_users_recv(struct tevent_req *req,
 {
     struct sdap_get_users_state *state = tevent_req_data(req,
                                             struct sdap_get_users_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err) return err;
-        return EIO;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     if (timestamp) {
         *timestamp = talloc_steal(mem_ctx, state->higher_timestamp);
@@ -1020,13 +1005,8 @@ static int sdap_save_group_recv(struct tevent_req *req,
 {
     struct sdap_save_group_state *state = tevent_req_data(req,
                                             struct sdap_save_group_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (!err) return EIO;
-        return err;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     if ( timestamp ) {
         *timestamp = talloc_steal(mem_ctx, state->timestamp);
@@ -1146,13 +1126,8 @@ static void sdap_save_grpmem_done(struct tevent_req *subreq)
 
 static int sdap_save_grpmem_recv(struct tevent_req *req)
 {
-    enum tevent_req_state tstate;
-    uint64_t err;
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (!err) return EIO;
-        return err;
-    }
     return EOK;
 }
 
@@ -1385,13 +1360,8 @@ static int sdap_save_groups_recv(struct tevent_req *req,
 {
     struct sdap_save_groups_state *state = tevent_req_data(req,
                                               struct sdap_save_groups_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err) return err;
-        return EIO;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     if (timestamp) {
         *timestamp = talloc_steal(mem_ctx, state->higher_timestamp);
@@ -1520,13 +1490,8 @@ int sdap_get_groups_recv(struct tevent_req *req,
 {
     struct sdap_get_groups_state *state = tevent_req_data(req,
                                             struct sdap_get_groups_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err) return err;
-        return EIO;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     if (timestamp) {
         *timestamp = talloc_steal(mem_ctx, state->higher_timestamp);
@@ -1647,13 +1612,8 @@ static void sdap_initgr_rfc2307_done(struct tevent_req *subreq)
 
 static int sdap_initgr_rfc2307_recv(struct tevent_req *req)
 {
-    enum tevent_req_state tstate;
-    uint64_t err;
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err) return err;
-        return EIO;
-    }
     return EOK;
 }
 
@@ -1846,13 +1806,8 @@ static void sdap_initgr_nested_done(struct tevent_req *subreq)
 
 static int sdap_initgr_nested_recv(struct tevent_req *req)
 {
-    enum tevent_req_state tstate;
-    uint64_t err;
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err) return err;
-        return EIO;
-    }
     return EOK;
 }
 
@@ -2147,13 +2102,7 @@ static void sdap_get_initgr_done(struct tevent_req *subreq)
 
 int sdap_get_initgr_recv(struct tevent_req *req)
 {
-    enum tevent_req_state tstate;
-    uint64_t err;
-
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err) return err;
-        return EIO;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     return EOK;
 }
diff --git a/server/providers/ldap/sdap_async_connection.c b/server/providers/ldap/sdap_async_connection.c
index 5adb7c38f..9f53ad6f0 100644
--- a/server/providers/ldap/sdap_async_connection.c
+++ b/server/providers/ldap/sdap_async_connection.c
@@ -205,7 +205,7 @@ int sdap_connect_recv(struct tevent_req *req,
     struct sdap_connect_state *state = tevent_req_data(req,
                                                   struct sdap_connect_state);
     enum tevent_req_state tstate;
-    uint64_t err;
+    uint64_t err = EIO;
 
     if (tevent_req_is_error(req, &tstate, &err)) {
         /* if tstate shows in progress, it is because
@@ -401,14 +401,9 @@ static int simple_bind_recv(struct tevent_req *req, int *ldaperr)
 {
     struct simple_bind_state *state = tevent_req_data(req,
                                             struct simple_bind_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        *ldaperr = LDAP_OTHER;
-        if (err) return err;
-        return EIO;
-    }
+    *ldaperr = LDAP_OTHER;
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     *ldaperr = state->result;
     return EOK;
@@ -537,13 +532,12 @@ static int sasl_bind_recv(struct tevent_req *req, int *ldaperr)
     struct sasl_bind_state *state = tevent_req_data(req,
                                             struct sasl_bind_state);
     enum tevent_req_state tstate;
-    uint64_t err;
+    uint64_t err = EIO;
 
     if (tevent_req_is_error(req, &tstate, &err)) {
         if (tstate != TEVENT_REQ_IN_PROGRESS) {
             *ldaperr = LDAP_OTHER;
-            if (err) return err;
-            return EIO;
+            return err;
         }
     }
 
@@ -755,13 +749,12 @@ int sdap_kinit_recv(struct tevent_req *req, enum sdap_result *result)
     struct sdap_kinit_state *state = tevent_req_data(req,
                                                 struct sdap_kinit_state);
     enum tevent_req_state tstate;
-    uint64_t err;
+    uint64_t err = EIO;
 
     if (tevent_req_is_error(req, &tstate, &err)) {
         if (tstate != TEVENT_REQ_IN_PROGRESS) {
             *result = SDAP_ERROR;
-            if (err) return err;
-            return EIO;
+            return err;
         }
     }
 
@@ -852,13 +845,10 @@ int sdap_auth_recv(struct tevent_req *req, enum sdap_result *result)
 {
     struct sdap_auth_state *state = tevent_req_data(req,
                                                  struct sdap_auth_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        *result = SDAP_ERROR;
-        return err;
-    }
+    *result = SDAP_ERROR;
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
     switch (state->result) {
         case LDAP_SUCCESS:
             *result = SDAP_AUTH_SUCCESS;
@@ -870,7 +860,7 @@ int sdap_auth_recv(struct tevent_req *req, enum sdap_result *result)
             *result = SDAP_AUTH_PW_EXPIRED;
             break;
         default:
-            *result = SDAP_ERROR;
+            break;
     }
 
     return EOK;
@@ -1128,13 +1118,8 @@ int sdap_cli_connect_recv(struct tevent_req *req,
 {
     struct sdap_cli_connect_state *state = tevent_req_data(req,
                                              struct sdap_cli_connect_state);
-    enum tevent_req_state tstate;
-    uint64_t err;
 
-    if (tevent_req_is_error(req, &tstate, &err)) {
-        if (err) return err;
-        return EIO;
-    }
+    TEVENT_REQ_RETURN_ON_ERROR(req);
 
     if (gsh) {
         *gsh = talloc_steal(memctx, state->sh);