From cd75c360f244c96b9ee10e01ee3a66fad13183c8 Mon Sep 17 00:00:00 2001 From: Timo Sirainen Date: Sun, 8 Dec 2013 20:48:03 +0200 Subject: [PATCH] auth: Added userdb result_success/failure/tempfail and skip settings, similar to passdb's. --- src/auth/auth-master-connection.c | 4 +- src/auth/auth-postfix-connection.c | 4 +- src/auth/auth-request-handler.c | 4 +- src/auth/auth-request.c | 106 ++++++++++++++++++++++++----- src/auth/auth-request.h | 4 +- src/auth/auth-settings.c | 16 ++++- src/auth/auth-settings.h | 8 ++- src/auth/auth-worker-client.c | 3 +- src/auth/auth.c | 40 ++++++++--- src/auth/auth.h | 31 ++++++--- src/auth/userdb-blocking.c | 2 +- src/auth/userdb-dict.c | 2 - src/auth/userdb-ldap.c | 2 - src/auth/userdb-nss.c | 1 - src/auth/userdb-passwd-file.c | 1 - src/auth/userdb-passwd.c | 1 - src/auth/userdb-sql.c | 2 - src/auth/userdb-static.c | 1 - src/auth/userdb-vpopmail.c | 1 - 19 files changed, 172 insertions(+), 61 deletions(-) diff --git a/src/auth/auth-master-connection.c b/src/auth/auth-master-connection.c index 37ac37f4f2..9bc918f80f 100644 --- 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 339f56283b..25f2436851 100644 --- 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 518f293752..65be9e114d 100644 --- 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 ce02ceee67..a6ab2eb5b4 100644 --- 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 6319707dea..8526f3f70e 100644 --- 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 8b86e2fb64..10abdac10f 100644 --- 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 c5876f54e6..d3dfd84736 100644 --- 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 b0b39a010e..70dcc56ad2 100644 --- 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 2c7dca4d1a..aab94e3c26 100644 --- 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 f2e40577c4..f219ac1529 100644 --- 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 fdd24f797e..04f335e52e 100644 --- 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 8ceedf1df7..ef91c60e7f 100644 --- 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 0d66e74a70..9a640ed925 100644 --- 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 39416e82d4..0e5d470903 100644 --- 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 09d0a82833..40167365f9 100644 --- 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 1a8146cb47..22a5d3a5c6 100644 --- 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 2638f980fa..0f9d7f59b7 100644 --- 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 26b777861f..a1aa72815f 100644 --- 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 f07da1dd0d..023de2066d 100644 --- 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); -- 2.47.3