auth: Added userdb result_success/failure/tempfail and skip settings, similar to...

diff --git a/src/auth/auth-master-connection.c b/src/auth/auth-master-connection.c
index 37ac37f4f208486237aa3393792a2e1575367a40..9bc918f80fd8a7e50921b4e18df8ca9eaebecc5b 100644 (file)
--- a/src/auth/auth-master-connection.c
+++ b/src/auth/auth-master-connection.c
@@ -252,7 +252,7 @@ user_callback(enum userdb_result result,
        string_t *str;
        const char *value;
 
-       if (auth_request->userdb_lookup_failed)
+       if (auth_request->userdb_lookup_tempfailed)
                result = USERDB_RESULT_INTERNAL_FAILURE;
 
        if (result == USERDB_RESULT_OK) {
@@ -264,7 +264,7 @@ user_callback(enum userdb_result result,
        switch (result) {
        case USERDB_RESULT_INTERNAL_FAILURE:
                str_printfa(str, "FAIL\t%u", auth_request->id);
-               if (auth_request->userdb_lookup_failed) {
+               if (auth_request->userdb_lookup_tempfailed) {
                        value = auth_fields_find(auth_request->userdb_reply,
                                                 "reason");
                        if (value != NULL)

diff --git a/src/auth/auth-postfix-connection.c b/src/auth/auth-postfix-connection.c
index 339f56283b0f7411a99bac6fc264b979e2d25530..25f243685181e6aa0840830fb75d8797d28c915b 100644 (file)
--- a/src/auth/auth-postfix-connection.c
+++ b/src/auth/auth-postfix-connection.c
@@ -69,13 +69,13 @@ user_callback(enum userdb_result result, struct auth_request *auth_request)
        string_t *str;
        const char *value;
 
-       if (auth_request->userdb_lookup_failed)
+       if (auth_request->userdb_lookup_tempfailed)
                result = USERDB_RESULT_INTERNAL_FAILURE;
 
        str = t_str_new(128);
        switch (result) {
        case USERDB_RESULT_INTERNAL_FAILURE:
-               if (auth_request->userdb_lookup_failed)
+               if (auth_request->userdb_lookup_tempfailed)
                        value = auth_fields_find(auth_request->userdb_reply, "reason");
                else
                        value = NULL;

diff --git a/src/auth/auth-request-handler.c b/src/auth/auth-request-handler.c
index 518f2937523fd1c6860c252cf8a82d59a7a5ab03..65be9e114d17f541a39783a9cfd716590f144100 100644 (file)
--- a/src/auth/auth-request-handler.c
+++ b/src/auth/auth-request-handler.c
@@ -633,14 +633,14 @@ static void userdb_callback(enum userdb_result result,
 
        auth_request_set_state(request, AUTH_REQUEST_STATE_FINISHED);
 
-       if (request->userdb_lookup_failed)
+       if (request->userdb_lookup_tempfailed)
                result = USERDB_RESULT_INTERNAL_FAILURE;
 
        str = t_str_new(128);
        switch (result) {
        case USERDB_RESULT_INTERNAL_FAILURE:
                str_printfa(str, "FAIL\t%u", request->id);
-               if (request->userdb_lookup_failed) {
+               if (request->userdb_lookup_tempfailed) {
                        value = auth_fields_find(request->userdb_reply, "reason");
                        if (value != NULL)
                                auth_str_add_keyvalue(str, "reason", value);

diff --git a/src/auth/auth-request.c b/src/auth/auth-request.c
index ce02ceee6765800f50bcbf871af5711e02e000c9..a6ab2eb5b4bdbf6f24e2487e2ae82e7289a37034 100644 (file)
--- a/src/auth/auth-request.c
+++ b/src/auth/auth-request.c
@@ -506,12 +506,27 @@ auth_request_want_skip_passdb(struct auth_request *request,
        i_unreached();
 }
 
+static bool
+auth_request_want_skip_userdb(struct auth_request *request,
+                             struct auth_userdb *userdb)
+{
+       switch (userdb->skip) {
+       case AUTH_USERDB_SKIP_NEVER:
+               return FALSE;
+       case AUTH_USERDB_SKIP_FOUND:
+               return request->userdb_success;
+       case AUTH_USERDB_SKIP_NOTFOUND:
+               return !request->userdb_success;
+       }
+       i_unreached();
+}
+
 static bool
 auth_request_handle_passdb_callback(enum passdb_result *result,
                                    struct auth_request *request)
 {
        struct auth_passdb *next_passdb;
-       enum auth_passdb_rule result_rule;
+       enum auth_db_rule result_rule;
        bool passdb_continue = FALSE;
 
        if (request->passdb_password != NULL) {
@@ -557,22 +572,22 @@ auth_request_handle_passdb_callback(enum passdb_result *result,
        }
 
        switch (result_rule) {
-       case AUTH_PASSDB_RULE_RETURN:
+       case AUTH_DB_RULE_RETURN:
                break;
-       case AUTH_PASSDB_RULE_RETURN_OK:
+       case AUTH_DB_RULE_RETURN_OK:
                request->passdb_success = TRUE;
                break;
-       case AUTH_PASSDB_RULE_RETURN_FAIL:
+       case AUTH_DB_RULE_RETURN_FAIL:
                request->passdb_success = FALSE;
                break;
-       case AUTH_PASSDB_RULE_CONTINUE:
+       case AUTH_DB_RULE_CONTINUE:
                passdb_continue = TRUE;
                break;
-       case AUTH_PASSDB_RULE_CONTINUE_OK:
+       case AUTH_DB_RULE_CONTINUE_OK:
                passdb_continue = TRUE;
                request->passdb_success = TRUE;
                break;
-       case AUTH_PASSDB_RULE_CONTINUE_FAIL:
+       case AUTH_DB_RULE_CONTINUE_FAIL:
                passdb_continue = TRUE;
                request->passdb_success = FALSE;
                break;
@@ -982,26 +997,79 @@ void auth_request_userdb_callback(enum userdb_result result,
                                  struct auth_request *request)
 {
        struct userdb_module *userdb = request->userdb->userdb;
+       struct auth_userdb *next_userdb;
+       enum auth_db_rule result_rule;
+       bool userdb_continue = FALSE;
 
-       if (result != USERDB_RESULT_OK && request->userdb->next != NULL) {
+       switch (result) {
+       case USERDB_RESULT_OK:
+               result_rule = request->userdb->result_success;
+               break;
+       case USERDB_RESULT_INTERNAL_FAILURE:
+               result_rule = request->userdb->result_internalfail;
+               break;
+       case USERDB_RESULT_USER_UNKNOWN:
+       default:
+               result_rule = request->userdb->result_failure;
+               break;
+       }
+
+       switch (result_rule) {
+       case AUTH_DB_RULE_RETURN:
+               break;
+       case AUTH_DB_RULE_RETURN_OK:
+               request->userdb_success = TRUE;
+               break;
+       case AUTH_DB_RULE_RETURN_FAIL:
+               request->userdb_success = FALSE;
+               break;
+       case AUTH_DB_RULE_CONTINUE:
+               userdb_continue = TRUE;
+               break;
+       case AUTH_DB_RULE_CONTINUE_OK:
+               userdb_continue = TRUE;
+               request->userdb_success = TRUE;
+               break;
+       case AUTH_DB_RULE_CONTINUE_FAIL:
+               userdb_continue = TRUE;
+               request->userdb_success = FALSE;
+               break;
+       }
+
+       next_userdb = request->userdb->next;
+       while (next_userdb != NULL &&
+              auth_request_want_skip_userdb(request, next_userdb))
+               next_userdb = next_userdb->next;
+
+       if (userdb_continue && next_userdb != NULL) {
                /* try next userdb. */
                if (result == USERDB_RESULT_INTERNAL_FAILURE)
                        request->userdbs_seen_internal_failure = TRUE;
 
-               request->userdb = request->userdb->next;
+               if (result == USERDB_RESULT_OK) {
+                       /* this userdb lookup succeeded, preserve its extra
+                          fields */
+                       auth_fields_snapshot(request->userdb_reply);
+               } else {
+                       /* this userdb lookup failed, remove any extra fields
+                          it set */
+                       auth_fields_rollback(request->userdb_reply);
+               }
+
+               request->userdb = next_userdb;
                auth_request_lookup_user(request,
                                         request->private_callback.userdb);
                return;
        }
 
-       if (result == USERDB_RESULT_OK)
+       if (request->userdb_success)
                userdb_template_export(userdb->override_fields_tmpl, request);
-       else if (request->userdbs_seen_internal_failure) {
+       else if (request->userdbs_seen_internal_failure ||
+                result == USERDB_RESULT_INTERNAL_FAILURE) {
                /* one of the userdb lookups failed. the user might have been
                   in there, so this is an internal failure */
                result = USERDB_RESULT_INTERNAL_FAILURE;
-       } else if (result == USERDB_RESULT_USER_UNKNOWN &&
-                  request->client_pid != 0) {
+       } else if (request->client_pid != 0) {
                /* this was an actual login attempt, the user should
                   have been found. */
                if (auth_request_get_auth(request)->userdbs->next == NULL) {
@@ -1014,7 +1082,7 @@ void auth_request_userdb_callback(enum userdb_result result,
                }
        }
 
-       if (request->userdb_lookup_failed) {
+       if (request->userdb_lookup_tempfailed) {
                /* no caching */
        } else if (result != USERDB_RESULT_INTERNAL_FAILURE)
                auth_request_userdb_save_cache(request, result);
@@ -1044,6 +1112,8 @@ void auth_request_lookup_user(struct auth_request *request,
 
        request->private_callback.userdb = callback;
        request->userdb_lookup = TRUE;
+       if (request->userdb_reply == NULL)
+               auth_request_init_userdb_reply(request);
 
        /* (for now) auth_cache is shared between passdb and userdb */
        cache_key = passdb_cache == NULL ? NULL : userdb->cache_key;
@@ -1496,19 +1566,19 @@ void auth_request_set_userdb_field(struct auth_request *request,
        if (strcmp(name, "uid") == 0) {
                uid = userdb_parse_uid(request, value);
                if (uid == (uid_t)-1) {
-                       request->userdb_lookup_failed = TRUE;
+                       request->userdb_lookup_tempfailed = TRUE;
                        return;
                }
                value = dec2str(uid);
        } else if (strcmp(name, "gid") == 0) {
                gid = userdb_parse_gid(request, value);
                if (gid == (gid_t)-1) {
-                       request->userdb_lookup_failed = TRUE;
+                       request->userdb_lookup_tempfailed = TRUE;
                        return;
                }
                value = dec2str(gid);
        } else if (strcmp(name, "tempfail") == 0) {
-               request->userdb_lookup_failed = TRUE;
+               request->userdb_lookup_tempfailed = TRUE;
                return;
        } else if (auth_request_try_update_username(request, name, value)) {
                return;
@@ -1549,7 +1619,7 @@ void auth_request_set_userdb_field_values(struct auth_request *request,
                for (; *values != NULL; values++) {
                        gid = userdb_parse_gid(request, *values);
                        if (gid == (gid_t)-1) {
-                               request->userdb_lookup_failed = TRUE;
+                               request->userdb_lookup_tempfailed = TRUE;
                                return;
                        }
 

diff --git a/src/auth/auth-request.h b/src/auth/auth-request.h
index 6319707deafc34a7acf663e1fa60b85d359354e8..8526f3f70ec22415515471426dc49e93e8bf2e81 100644 (file)
--- a/src/auth/auth-request.h
+++ b/src/auth/auth-request.h
@@ -130,10 +130,12 @@ struct auth_request {
           at the end. mechanisms that don't require passdb, but do a passdb
           lookup anyway (e.g. GSSAPI) need to set this to TRUE by default. */
        unsigned int passdb_success:1;
+       /* userdb equivalent of passdb_success */
+       unsigned int userdb_success:1;
        /* the last userdb lookup failed either due to "tempfail" extra field
           or because one of the returned uid/gid fields couldn't be translated
           to a number */
-       unsigned int userdb_lookup_failed:1;
+       unsigned int userdb_lookup_tempfailed:1;
 
        /* ... mechanism specific data ... */
 };

diff --git a/src/auth/auth-settings.c b/src/auth/auth-settings.c
index 8b86e2fb6405178b738eca4cc5eceb3023e07795..10abdac10fb5f64e3d95f7591ef383aecc78f58f 100644 (file)
--- a/src/auth/auth-settings.c
+++ b/src/auth/auth-settings.c
@@ -111,10 +111,12 @@ static const struct setting_define auth_passdb_setting_defines[] = {
        DEF(SET_STR, args),
        DEF(SET_STR, default_fields),
        DEF(SET_STR, override_fields),
+
        DEF(SET_ENUM, skip),
        DEF(SET_ENUM, result_success),
        DEF(SET_ENUM, result_failure),
        DEF(SET_ENUM, result_internalfail),
+
        DEF(SET_BOOL, deny),
        DEF(SET_BOOL, pass),
        DEF(SET_BOOL, master),
@@ -127,10 +129,12 @@ static const struct auth_passdb_settings auth_passdb_default_settings = {
        .args = "",
        .default_fields = "",
        .override_fields = "",
+
        .skip = "never:authenticated:unauthenticated",
        .result_success = "return-ok:return:return-fail:continue:continue-ok:continue-fail",
        .result_failure = "continue:return:return-ok:return-fail:continue-ok:continue-fail",
        .result_internalfail = "continue:return:return-ok:return-fail:continue-ok:continue-fail",
+
        .deny = FALSE,
        .pass = FALSE,
        .master = FALSE
@@ -159,6 +163,11 @@ static const struct setting_define auth_userdb_setting_defines[] = {
        DEF(SET_STR, default_fields),
        DEF(SET_STR, override_fields),
 
+       DEF(SET_ENUM, skip),
+       DEF(SET_ENUM, result_success),
+       DEF(SET_ENUM, result_failure),
+       DEF(SET_ENUM, result_internalfail),
+
        SETTING_DEFINE_LIST_END
 };
 
@@ -166,7 +175,12 @@ static const struct auth_userdb_settings auth_userdb_default_settings = {
        .driver = "",
        .args = "",
        .default_fields = "",
-       .override_fields = ""
+       .override_fields = "",
+
+       .skip = "never:found:notfound",
+       .result_success = "return-ok:return:return-fail:continue:continue-ok:continue-fail",
+       .result_failure = "continue:return:return-ok:return-fail:continue-ok:continue-fail",
+       .result_internalfail = "continue:return:return-ok:return-fail:continue-ok:continue-fail"
 };
 
 const struct setting_parser_info auth_userdb_setting_parser_info = {

diff --git a/src/auth/auth-settings.h b/src/auth/auth-settings.h
index c5876f54e6400912d7a7daa359b5778f00c8e906..d3dfd84736d295dc3d5c4705c86f69fae63d1dc8 100644 (file)
--- a/src/auth/auth-settings.h
+++ b/src/auth/auth-settings.h
@@ -9,12 +9,13 @@ struct auth_passdb_settings {
        const char *args;
        const char *default_fields;
        const char *override_fields;
+
        const char *skip;
        const char *result_success;
        const char *result_failure;
        const char *result_internalfail;
        bool deny;
-       bool pass;
+       bool pass; /* deprecated, use result_success=continue instead */
        bool master;
 };
 
@@ -23,6 +24,11 @@ struct auth_userdb_settings {
        const char *args;
        const char *default_fields;
        const char *override_fields;
+
+       const char *skip;
+       const char *result_success;
+       const char *result_failure;
+       const char *result_internalfail;
 };
 
 struct auth_settings {

diff --git a/src/auth/auth-worker-client.c b/src/auth/auth-worker-client.c
index b0b39a010e757bcf0c927aaaaa58c8e016b418ac..70dcc56ad2ea1f20f1b2fe643a2f1888035d78a9 100644 (file)
--- a/src/auth/auth-worker-client.c
+++ b/src/auth/auth-worker-client.c
@@ -355,7 +355,7 @@ lookup_user_callback(enum userdb_result result,
        case USERDB_RESULT_OK:
                str_append(str, "OK\t");
                auth_fields_append(auth_request->userdb_reply, str, 0, 0);
-               if (auth_request->userdb_lookup_failed)
+               if (auth_request->userdb_lookup_tempfailed)
                        str_append(str, "\ttempfail");
                break;
        }
@@ -409,6 +409,7 @@ auth_worker_handle_user(struct auth_worker_client *client,
                return FALSE;
        }
 
+       auth_request_init_userdb_reply(auth_request);
        auth_request->userdb->userdb->iface->
                lookup(auth_request, lookup_user_callback);
        return TRUE;

diff --git a/src/auth/auth.c b/src/auth/auth.c
index 2c7dca4d1a1dab48c46dee8859e17f9c65bd540e..aab94e3c26cc2b91a2dd1375304c6f73b88846f3 100644 (file)
--- a/src/auth/auth.c
+++ b/src/auth/auth.c
@@ -29,20 +29,31 @@ static enum auth_passdb_skip auth_passdb_skip_parse(const char *str)
        i_unreached();
 }
 
-static enum auth_passdb_rule auth_passdb_rule_parse(const char *str)
+static enum auth_userdb_skip auth_userdb_skip_parse(const char *str)
+{
+       if (strcmp(str, "never") == 0)
+               return AUTH_USERDB_SKIP_NEVER;
+       if (strcmp(str, "found") == 0)
+               return AUTH_USERDB_SKIP_FOUND;
+       if (strcmp(str, "notfound") == 0)
+               return AUTH_USERDB_SKIP_NOTFOUND;
+       i_unreached();
+}
+
+static enum auth_db_rule auth_db_rule_parse(const char *str)
 {
        if (strcmp(str, "return") == 0)
-               return AUTH_PASSDB_RULE_RETURN;
+               return AUTH_DB_RULE_RETURN;
        if (strcmp(str, "return-ok") == 0)
-               return AUTH_PASSDB_RULE_RETURN_OK;
+               return AUTH_DB_RULE_RETURN_OK;
        if (strcmp(str, "return-fail") == 0)
-               return AUTH_PASSDB_RULE_RETURN_FAIL;
+               return AUTH_DB_RULE_RETURN_FAIL;
        if (strcmp(str, "continue") == 0)
-               return AUTH_PASSDB_RULE_CONTINUE;
+               return AUTH_DB_RULE_CONTINUE;
        if (strcmp(str, "continue-ok") == 0)
-               return AUTH_PASSDB_RULE_CONTINUE_OK;
+               return AUTH_DB_RULE_CONTINUE_OK;
        if (strcmp(str, "continue-fail") == 0)
-               return AUTH_PASSDB_RULE_CONTINUE_FAIL;
+               return AUTH_DB_RULE_CONTINUE_FAIL;
        i_unreached();
 }
 
@@ -56,15 +67,15 @@ auth_passdb_preinit(struct auth *auth, const struct auth_passdb_settings *set,
        auth_passdb->set = set;
        auth_passdb->skip = auth_passdb_skip_parse(set->skip);
        auth_passdb->result_success =
-               auth_passdb_rule_parse(set->result_success);
+               auth_db_rule_parse(set->result_success);
        auth_passdb->result_failure =
-               auth_passdb_rule_parse(set->result_failure);
+               auth_db_rule_parse(set->result_failure);
        auth_passdb->result_internalfail =
-               auth_passdb_rule_parse(set->result_internalfail);
+               auth_db_rule_parse(set->result_internalfail);
 
        /* for backwards compatibility: */
        if (set->pass)
-               auth_passdb->result_success = AUTH_PASSDB_RULE_CONTINUE;
+               auth_passdb->result_success = AUTH_DB_RULE_CONTINUE;
 
        for (dest = passdbs; *dest != NULL; dest = &(*dest)->next) ;
        *dest = auth_passdb;
@@ -79,6 +90,13 @@ auth_userdb_preinit(struct auth *auth, const struct auth_userdb_settings *set)
 
        auth_userdb = p_new(auth->pool, struct auth_userdb, 1);
        auth_userdb->set = set;
+       auth_userdb->skip = auth_userdb_skip_parse(set->skip);
+       auth_userdb->result_success =
+               auth_db_rule_parse(set->result_success);
+       auth_userdb->result_failure =
+               auth_db_rule_parse(set->result_failure);
+       auth_userdb->result_internalfail =
+               auth_db_rule_parse(set->result_internalfail);
 
        for (dest = &auth->userdbs; *dest != NULL; dest = &(*dest)->next) ;
        *dest = auth_userdb;

diff --git a/src/auth/auth.h b/src/auth/auth.h
index f2e40577c4deda83a6c3feb2e3dee00c95239bd1..f219ac1529e6e9c27261765bab25421ac632f8dd 100644 (file)
--- a/src/auth/auth.h
+++ b/src/auth/auth.h
@@ -11,13 +11,19 @@ enum auth_passdb_skip {
        AUTH_PASSDB_SKIP_UNAUTHENTICATED
 };
 
-enum auth_passdb_rule {
-       AUTH_PASSDB_RULE_RETURN,
-       AUTH_PASSDB_RULE_RETURN_OK,
-       AUTH_PASSDB_RULE_RETURN_FAIL,
-       AUTH_PASSDB_RULE_CONTINUE,
-       AUTH_PASSDB_RULE_CONTINUE_OK,
-       AUTH_PASSDB_RULE_CONTINUE_FAIL
+enum auth_userdb_skip {
+       AUTH_USERDB_SKIP_NEVER,
+       AUTH_USERDB_SKIP_FOUND,
+       AUTH_USERDB_SKIP_NOTFOUND
+};
+
+enum auth_db_rule {
+       AUTH_DB_RULE_RETURN,
+       AUTH_DB_RULE_RETURN_OK,
+       AUTH_DB_RULE_RETURN_FAIL,
+       AUTH_DB_RULE_CONTINUE,
+       AUTH_DB_RULE_CONTINUE_OK,
+       AUTH_DB_RULE_CONTINUE_FAIL
 };
 
 struct auth_passdb {
@@ -27,9 +33,9 @@ struct auth_passdb {
        struct passdb_module *passdb;
 
        enum auth_passdb_skip skip;
-       enum auth_passdb_rule result_success;
-       enum auth_passdb_rule result_failure;
-       enum auth_passdb_rule result_internalfail;
+       enum auth_db_rule result_success;
+       enum auth_db_rule result_failure;
+       enum auth_db_rule result_internalfail;
 };
 
 struct auth_userdb {
@@ -37,6 +43,11 @@ struct auth_userdb {
 
        const struct auth_userdb_settings *set;
        struct userdb_module *userdb;
+
+       enum auth_userdb_skip skip;
+       enum auth_db_rule result_success;
+       enum auth_db_rule result_failure;
+       enum auth_db_rule result_internalfail;
 };
 
 struct auth {

diff --git a/src/auth/userdb-blocking.c b/src/auth/userdb-blocking.c
index fdd24f797e7e7221a55a968ed22df8ed7f7cee08..04f335e52e051d0b6f3a9b42e2c1b23863cdf76b 100644 (file)
--- a/src/auth/userdb-blocking.c
+++ b/src/auth/userdb-blocking.c
@@ -40,7 +40,7 @@ static bool user_callback(const char *reply, void *context)
        if (*args != '\0') {
                auth_fields_import(request->userdb_reply, args, 0);
                if (auth_fields_exists(request->userdb_reply, "tempfail"))
-                       request->userdb_lookup_failed = TRUE;
+                       request->userdb_lookup_tempfailed = TRUE;
        }
 
         auth_request_userdb_callback(result, request);

diff --git a/src/auth/userdb-dict.c b/src/auth/userdb-dict.c
index 8ceedf1df7227415e6d5ef6a0c0b9a74d8823814..ef91c60e7f2b4391df0d832da70bbdc19e466eb2 100644 (file)
--- a/src/auth/userdb-dict.c
+++ b/src/auth/userdb-dict.c
@@ -34,8 +34,6 @@ dict_query_save_results(struct auth_request *auth_request,
 {
        const char *key, *value, *error;
 
-       auth_request_init_userdb_reply(auth_request);
-
        while (db_dict_value_iter_next(iter, &key, &value)) {
                if (value != NULL)
                        auth_request_set_userdb_field(auth_request, key, value);

diff --git a/src/auth/userdb-ldap.c b/src/auth/userdb-ldap.c
index 0d66e74a706c41056805a3092c75b114ed53c3e9..9a640ed9258dd6c3e874e8ad5be7987eedb7c9ba 100644 (file)
--- a/src/auth/userdb-ldap.c
+++ b/src/auth/userdb-ldap.c
@@ -50,8 +50,6 @@ ldap_query_get_result(struct ldap_connection *conn,
        struct db_ldap_result_iterate_context *ldap_iter;
        const char *name, *const *values;
 
-       auth_request_init_userdb_reply(auth_request);
-
        ldap_iter = db_ldap_result_iterate_init(conn, ldap_request, res, TRUE);
        while (db_ldap_result_iterate_next(ldap_iter, &name, &values)) {
                auth_request_set_userdb_field_values(auth_request,

diff --git a/src/auth/userdb-nss.c b/src/auth/userdb-nss.c
index 39416e82d497865b588e261bbb7864bee8b8d250..0e5d470903e3e2edc627ccea089a60b9ae5e5d67 100644 (file)
--- a/src/auth/userdb-nss.c
+++ b/src/auth/userdb-nss.c
@@ -71,7 +71,6 @@ userdb_nss_lookup(struct auth_request *auth_request,
 
        auth_request_set_field(auth_request, "user", pw.pw_name, NULL);
 
-       auth_request_init_userdb_reply(auth_request);
        auth_request_set_userdb_field(auth_request, "system_groups_user",
                                      pw.pw_name);
        auth_request_set_userdb_field(auth_request, "uid", dec2str(pw.pw_uid));

diff --git a/src/auth/userdb-passwd-file.c b/src/auth/userdb-passwd-file.c
index 09d0a82833d07bc393a3195e91f94648c07a4c97..40167365f9518abaec4206228f13bf8db93a72f1 100644 (file)
--- a/src/auth/userdb-passwd-file.c
+++ b/src/auth/userdb-passwd-file.c
@@ -49,7 +49,6 @@ static void passwd_file_lookup(struct auth_request *auth_request,
                return;
        }
 
-       auth_request_init_userdb_reply(auth_request);
        if (pu->uid != (uid_t)-1) {
                auth_request_set_userdb_field(auth_request, "uid",
                                              dec2str(pu->uid));

diff --git a/src/auth/userdb-passwd.c b/src/auth/userdb-passwd.c
index 1a8146cb47e48394a4146ba2aa3a5f2b991d7996..22a5d3a5c6b2c1d7fc0795a8bc64b9763f3106c9 100644 (file)
--- a/src/auth/userdb-passwd.c
+++ b/src/auth/userdb-passwd.c
@@ -108,7 +108,6 @@ static void passwd_lookup(struct auth_request *auth_request,
 
        auth_request_set_field(auth_request, "user", pw.pw_name, NULL);
 
-       auth_request_init_userdb_reply(auth_request);
        auth_request_set_userdb_field(auth_request, "system_groups_user",
                                      pw.pw_name);
        auth_request_set_userdb_field(auth_request, "uid", dec2str(pw.pw_uid));

diff --git a/src/auth/userdb-sql.c b/src/auth/userdb-sql.c
index 2638f980fa36ca09454cc9f643b5850c2d93d84f..0f9d7f59b735cc194956e3c5498ef098c1c81906 100644 (file)
--- a/src/auth/userdb-sql.c
+++ b/src/auth/userdb-sql.c
@@ -42,8 +42,6 @@ sql_query_get_result(struct sql_result *result,
        const char *name, *value;
        unsigned int i, fields_count;
 
-       auth_request_init_userdb_reply(auth_request);
-
        fields_count = sql_result_get_fields_count(result);
        for (i = 0; i < fields_count; i++) {
                name = sql_result_get_field_name(result, i);

diff --git a/src/auth/userdb-static.c b/src/auth/userdb-static.c
index 26b777861fc2c210cd6fece3490e1b68a5c4d115..a1aa72815ff6d4c1863d219ce162776eeeb36dbe 100644 (file)
--- a/src/auth/userdb-static.c
+++ b/src/auth/userdb-static.c
@@ -29,7 +29,6 @@ static void static_lookup_real(struct auth_request *auth_request,
        struct static_userdb_module *module =
                (struct static_userdb_module *)_module;
 
-       auth_request_init_userdb_reply(auth_request);
        userdb_template_export(module->tmpl, auth_request);
        callback(USERDB_RESULT_OK, auth_request);
 }

diff --git a/src/auth/userdb-vpopmail.c b/src/auth/userdb-vpopmail.c
index f07da1dd0d375d564c0447a88c2b07768f1c148f..023de2066d4ed497d48309c116f34be40735702a 100644 (file)
--- a/src/auth/userdb-vpopmail.c
+++ b/src/auth/userdb-vpopmail.c
@@ -121,7 +121,6 @@ static void vpopmail_lookup(struct auth_request *auth_request,
                }
        }
 
-       auth_request_init_userdb_reply(auth_request);
        auth_request_set_userdb_field(auth_request, "uid", dec2str(uid));
        auth_request_set_userdb_field(auth_request, "gid", dec2str(gid));
        auth_request_set_userdb_field(auth_request, "home", vpw->pw_dir);