auth: Moved cache_key from passdb_module to auth_passdb.

This is in preparation for the next changeset, which moves
default/override_fields also to auth_passdb.

diff --git a/src/auth/auth-request.c b/src/auth/auth-request.c
index 7ed45168ff8f404e9dd7d66f6f0e4b2c7454add0..59ec8c935c28cdc1977bdfa71bd77451fe0bd671 100644 (file)
--- a/src/auth/auth-request.c
+++ b/src/auth/auth-request.c
@@ -409,7 +409,7 @@ void auth_request_continue(struct auth_request *request,
 static void auth_request_save_cache(struct auth_request *request,
                                    enum passdb_result result)
 {
-       struct passdb_module *passdb = request->passdb->passdb;
+       struct auth_passdb *passdb = request->passdb;
        const char *encoded_password;
        string_t *str;
 
@@ -467,7 +467,7 @@ static void auth_request_save_cache(struct auth_request *request,
                if (*request->passdb_password != '{') {
                        /* cached passwords must have a known scheme */
                        str_append_c(str, '{');
-                       str_append(str, passdb->default_pass_scheme);
+                       str_append(str, passdb->passdb->default_pass_scheme);
                        str_append_c(str, '}');
                }
                str_append_tabescaped(str, request->passdb_password);
@@ -706,7 +706,7 @@ auth_request_verify_plain_callback_finish(enum passdb_result result,
 void auth_request_verify_plain_callback(enum passdb_result result,
                                        struct auth_request *request)
 {
-       struct passdb_module *passdb = request->passdb->passdb;
+       struct auth_passdb *passdb = request->passdb;
 
        i_assert(request->state == AUTH_REQUEST_STATE_PASSDB);
 
@@ -767,7 +767,7 @@ void auth_request_verify_plain(struct auth_request *request,
                               const char *password,
                               verify_plain_callback_t *callback)
 {
-       struct passdb_module *passdb;
+       struct auth_passdb *passdb;
        enum passdb_result result;
        const char *cache_key;
 
@@ -785,7 +785,7 @@ void auth_request_verify_plain(struct auth_request *request,
                return;
        }
 
-        passdb = request->passdb->passdb;
+        passdb = request->passdb;
        if (request->mech_password == NULL)
                request->mech_password = p_strdup(request->pool, password);
        else
@@ -802,16 +802,16 @@ void auth_request_verify_plain(struct auth_request *request,
        auth_request_set_state(request, AUTH_REQUEST_STATE_PASSDB);
        request->credentials_scheme = NULL;
 
-       if (passdb->iface.verify_plain == NULL) {
+       if (passdb->passdb->iface.verify_plain == NULL) {
                /* we're deinitializing and just want to get rid of this
                   request */
                auth_request_verify_plain_callback(
                        PASSDB_RESULT_INTERNAL_FAILURE, request);
-       } else if (passdb->blocking) {
+       } else if (passdb->passdb->blocking) {
                passdb_blocking_verify_plain(request);
        } else {
-               passdb_template_export(passdb->default_fields_tmpl, request);
-               passdb->iface.verify_plain(request, password,
+               passdb_template_export(passdb->passdb->default_fields_tmpl, request);
+               passdb->passdb->iface.verify_plain(request, password,
                                           auth_request_verify_plain_callback);
        }
 }
@@ -871,7 +871,7 @@ void auth_request_lookup_credentials_callback(enum passdb_result result,
                                              size_t size,
                                              struct auth_request *request)
 {
-       struct passdb_module *passdb = request->passdb->passdb;
+       struct auth_passdb *passdb = request->passdb;
        const char *cache_cred, *cache_scheme;
 
        i_assert(request->state == AUTH_REQUEST_STATE_PASSDB);
@@ -908,7 +908,7 @@ void auth_request_lookup_credentials(struct auth_request *request,
                                     const char *scheme,
                                     lookup_credentials_callback_t *callback)
 {
-       struct passdb_module *passdb;
+       struct auth_passdb *passdb;
        const char *cache_key, *cache_cred, *cache_scheme;
        enum passdb_result result;
 
@@ -918,7 +918,7 @@ void auth_request_lookup_credentials(struct auth_request *request,
                callback(PASSDB_RESULT_USER_UNKNOWN, NULL, 0, request);
                return;
        }
-       passdb = request->passdb->passdb;
+       passdb = request->passdb;
 
        request->credentials_scheme = p_strdup(request->pool, scheme);
        request->private_callback.lookup_credentials = callback;
@@ -938,18 +938,18 @@ void auth_request_lookup_credentials(struct auth_request *request,
 
        auth_request_set_state(request, AUTH_REQUEST_STATE_PASSDB);
 
-       if (passdb->iface.lookup_credentials == NULL) {
+       if (passdb->passdb->iface.lookup_credentials == NULL) {
                /* this passdb doesn't support credentials */
                auth_request_log_debug(request, AUTH_SUBSYS_DB,
                        "passdb doesn't support credential lookups");
                auth_request_lookup_credentials_callback(
                                        PASSDB_RESULT_SCHEME_NOT_AVAILABLE,
                                        &uchar_nul, 0, request);
-       } else if (passdb->blocking) {
+       } else if (passdb->passdb->blocking) {
                passdb_blocking_lookup_credentials(request);
        } else {
-               passdb_template_export(passdb->default_fields_tmpl, request);
-               passdb->iface.lookup_credentials(request,
+               passdb_template_export(passdb->passdb->default_fields_tmpl, request);
+               passdb->passdb->iface.lookup_credentials(request,
                        auth_request_lookup_credentials_callback);
        }
 }
@@ -958,7 +958,7 @@ void auth_request_set_credentials(struct auth_request *request,
                                  const char *scheme, const char *data,
                                  set_credentials_callback_t *callback)
 {
-       struct passdb_module *passdb = request->passdb->passdb;
+       struct auth_passdb *passdb = request->passdb;
        const char *cache_key, *new_credentials;
 
        cache_key = passdb_cache == NULL ? NULL : passdb->cache_key;
@@ -968,11 +968,11 @@ void auth_request_set_credentials(struct auth_request *request,
        request->private_callback.set_credentials = callback;
 
        new_credentials = t_strdup_printf("{%s}%s", scheme, data);
-       if (passdb->blocking)
+       if (passdb->passdb->blocking)
                passdb_blocking_set_credentials(request, new_credentials);
-       else if (passdb->iface.set_credentials != NULL) {
-               passdb->iface.set_credentials(request, new_credentials,
-                                             callback);
+       else if (passdb->passdb->iface.set_credentials != NULL) {
+               passdb->passdb->iface.set_credentials(request, new_credentials,
+                                                     callback);
        } else {
                /* this passdb doesn't support credentials update */
                callback(FALSE, request);
@@ -982,7 +982,7 @@ void auth_request_set_credentials(struct auth_request *request,
 static void auth_request_userdb_save_cache(struct auth_request *request,
                                           enum userdb_result result)
 {
-       struct userdb_module *userdb = request->userdb->userdb;
+       struct auth_userdb *userdb = request->userdb;
        string_t *str;
        const char *cache_value;
 
@@ -1060,22 +1060,22 @@ static bool auth_request_lookup_user_cache(struct auth_request *request,
 void auth_request_userdb_callback(enum userdb_result result,
                                  struct auth_request *request)
 {
-       struct userdb_module *userdb = request->userdb->userdb;
+       struct auth_userdb *userdb = request->userdb;
        struct auth_userdb *next_userdb;
        enum auth_db_rule result_rule;
        bool userdb_continue = FALSE;
 
        switch (result) {
        case USERDB_RESULT_OK:
-               result_rule = request->userdb->result_success;
+               result_rule = userdb->result_success;
                break;
        case USERDB_RESULT_INTERNAL_FAILURE:
                auth_request_stats_add_tempfail(request);
-               result_rule = request->userdb->result_internalfail;
+               result_rule = userdb->result_internalfail;
                break;
        case USERDB_RESULT_USER_UNKNOWN:
        default:
-               result_rule = request->userdb->result_failure;
+               result_rule = userdb->result_failure;
                break;
        }
 
@@ -1101,7 +1101,7 @@ void auth_request_userdb_callback(enum userdb_result result,
                break;
        }
 
-       next_userdb = request->userdb->next;
+       next_userdb = userdb->next;
        while (next_userdb != NULL &&
               auth_request_want_skip_userdb(request, next_userdb))
                next_userdb = next_userdb->next;
@@ -1114,7 +1114,7 @@ void auth_request_userdb_callback(enum userdb_result result,
                if (result == USERDB_RESULT_OK) {
                        /* this userdb lookup succeeded, preserve its extra
                           fields */
-                       userdb_template_export(userdb->override_fields_tmpl, request);
+                       userdb_template_export(userdb->userdb->override_fields_tmpl, request);
                        auth_fields_snapshot(request->userdb_reply);
                } else {
                        /* this userdb lookup failed, remove any extra fields
@@ -1129,7 +1129,7 @@ void auth_request_userdb_callback(enum userdb_result result,
        }
 
        if (request->userdb_success)
-               userdb_template_export(userdb->override_fields_tmpl, request);
+               userdb_template_export(userdb->userdb->override_fields_tmpl, request);
        else if (request->userdbs_seen_internal_failure ||
                 result == USERDB_RESULT_INTERNAL_FAILURE) {
                /* one of the userdb lookups failed. the user might have been
@@ -1170,7 +1170,7 @@ void auth_request_userdb_callback(enum userdb_result result,
 void auth_request_lookup_user(struct auth_request *request,
                              userdb_callback_t *callback)
 {
-       struct userdb_module *userdb = request->userdb->userdb;
+       struct auth_userdb *userdb = request->userdb;
        const char *cache_key;
 
        request->private_callback.userdb = callback;
@@ -1181,7 +1181,7 @@ void auth_request_lookup_user(struct auth_request *request,
                /* we still want to set default_fields. these override any
                   existing fields set by previous userdbs (because if that is
                   unwanted, ":protected" can be used). */
-               userdb_template_export(userdb->default_fields_tmpl, request);
+               userdb_template_export(userdb->userdb->default_fields_tmpl, request);
        }
 
        /* (for now) auth_cache is shared between passdb and userdb */
@@ -1196,14 +1196,14 @@ void auth_request_lookup_user(struct auth_request *request,
                }
        }
 
-       if (userdb->iface->lookup == NULL) {
+       if (userdb->userdb->iface->lookup == NULL) {
                /* we are deinitializing */
                auth_request_userdb_callback(USERDB_RESULT_INTERNAL_FAILURE,
                                             request);
-       } else if (userdb->blocking)
+       } else if (userdb->userdb->blocking)
                userdb_blocking_lookup(request);
        else
-               userdb->iface->lookup(request, auth_request_userdb_callback);
+               userdb->userdb->iface->lookup(request, auth_request_userdb_callback);
 }
 
 static char *

diff --git a/src/auth/auth.c b/src/auth/auth.c
index 39c62f1fa2d00d5f68f79d171b3a57c05a1bcada..bc3dc0bc7617189b20d9953c28db6521833d5cd9 100644 (file)
--- a/src/auth/auth.c
+++ b/src/auth/auth.c
@@ -87,6 +87,10 @@ auth_passdb_preinit(struct auth *auth, const struct auth_passdb_settings *set,
        *dest = auth_passdb;
 
        auth_passdb->passdb = passdb_preinit(auth->pool, set);
+       /* make sure any %variables in default_fields exist in cache_key */
+       auth_passdb->cache_key =
+               p_strconcat(auth->pool, auth_passdb->passdb->default_cache_key,
+                           set->default_fields, NULL);
 }
 
 static void
@@ -108,6 +112,10 @@ auth_userdb_preinit(struct auth *auth, const struct auth_userdb_settings *set)
        *dest = auth_userdb;
 
        auth_userdb->userdb = userdb_preinit(auth->pool, set);
+       /* make sure any %variables in default_fields exist in cache_key */
+       auth_userdb->cache_key =
+               p_strconcat(auth->pool, auth_userdb->userdb->default_cache_key,
+                           set->default_fields, NULL);
 }
 
 static bool auth_passdb_list_have_verify_plain(const struct auth *auth)
@@ -264,15 +272,23 @@ auth_preinit(const struct auth_settings *set, const char *service, pool_t pool,
        return auth;
 }
 
+static void auth_passdb_init(struct auth_passdb *passdb)
+{
+       passdb_init(passdb->passdb);
+
+       i_assert(passdb->passdb->default_pass_scheme != NULL ||
+                passdb->cache_key == NULL);
+}
+
 static void auth_init(struct auth *auth)
 {
        struct auth_passdb *passdb;
        struct auth_userdb *userdb;
 
        for (passdb = auth->masterdbs; passdb != NULL; passdb = passdb->next)
-               passdb_init(passdb->passdb);
+               auth_passdb_init(passdb);
        for (passdb = auth->passdbs; passdb != NULL; passdb = passdb->next)
-               passdb_init(passdb->passdb);
+               auth_passdb_init(passdb);
        for (userdb = auth->userdbs; userdb != NULL; userdb = userdb->next)
                userdb_init(userdb->userdb);
 }

diff --git a/src/auth/auth.h b/src/auth/auth.h
index f219ac1529e6e9c27261765bab25421ac632f8dd..b80eb719e8bdda1bdd79ed08ea43467ed1a127ea 100644 (file)
--- a/src/auth/auth.h
+++ b/src/auth/auth.h
@@ -32,6 +32,9 @@ struct auth_passdb {
        const struct auth_passdb_settings *set;
        struct passdb_module *passdb;
 
+       /* The caching key for this passdb, or NULL if caching isn't wanted. */
+       const char *cache_key;
+
        enum auth_passdb_skip skip;
        enum auth_db_rule result_success;
        enum auth_db_rule result_failure;
@@ -44,6 +47,9 @@ struct auth_userdb {
        const struct auth_userdb_settings *set;
        struct userdb_module *userdb;
 
+       /* The caching key for this userdb, or NULL if caching isn't wanted. */
+       const char *cache_key;
+
        enum auth_userdb_skip skip;
        enum auth_db_rule result_success;
        enum auth_db_rule result_failure;

diff --git a/src/auth/passdb-bsdauth.c b/src/auth/passdb-bsdauth.c
index 727faeb0e76086d1f12da83e576a0d29bc7829e5..68ccae3d41b3d88b7dec9ebbb6ef3456dbd1a2b3 100644 (file)
--- a/src/auth/passdb-bsdauth.c
+++ b/src/auth/passdb-bsdauth.c
@@ -67,7 +67,7 @@ bsdauth_preinit(pool_t pool, const char *args)
        if (strcmp(args, "blocking=no") == 0)
                module->blocking = FALSE;
        else if (strncmp(args, "cache_key=", 10) == 0)
-               module->cache_key = auth_cache_parse_key(pool, args + 10);
+               module->default_cache_key = auth_cache_parse_key(pool, args + 10);
        else if (*args != '\0')
                i_fatal("passdb bsdauth: Unknown setting: %s", args);
        return module;

diff --git a/src/auth/passdb-dict.c b/src/auth/passdb-dict.c
index 88a0909fcc3b7cc4ea63ed3bb97c7b4c630946bb..a82ed18f8f73e54993fc600b8ce73f5fccb35e55 100644 (file)
--- a/src/auth/passdb-dict.c
+++ b/src/auth/passdb-dict.c
@@ -159,7 +159,7 @@ passdb_dict_preinit(pool_t pool, const char *args)
        module->conn = conn = db_dict_init(args);
 
        module->module.blocking = TRUE;
-       module->module.cache_key = auth_cache_parse_key(pool,
+       module->module.default_cache_key = auth_cache_parse_key(pool,
                db_dict_parse_cache_key(&conn->set.keys, &conn->set.passdb_fields,
                                        &conn->set.parsed_passdb_objects));
        module->module.default_pass_scheme = conn->set.default_pass_scheme;

diff --git a/src/auth/passdb-ldap.c b/src/auth/passdb-ldap.c
index 5e7b9de50fe2a609b601594cc97e7c20825a1937..9ef7e4b5abf1c7e015062846281cecd2dca20ae9 100644 (file)
--- a/src/auth/passdb-ldap.c
+++ b/src/auth/passdb-ldap.c
@@ -436,7 +436,7 @@ passdb_ldap_preinit(pool_t pool, const char *args)
                          &conn->pass_attr_map,
                          conn->set.auth_bind ? "password" : NULL);
        module->module.blocking = conn->set.blocking;
-       module->module.cache_key =
+       module->module.default_cache_key =
                auth_cache_parse_key(pool,
                                     t_strconcat(conn->set.base,
                                                 conn->set.pass_attrs,

diff --git a/src/auth/passdb-pam.c b/src/auth/passdb-pam.c
index b66668be1b691068a6d4196f7c228422847aa3fb..f00eb50d873776eed41d5705998025ab697320f3 100644 (file)
--- a/src/auth/passdb-pam.c
+++ b/src/auth/passdb-pam.c
@@ -352,7 +352,7 @@ pam_preinit(pool_t pool, const char *args)
                else if (strcmp(t_args[i], "setcred=yes") == 0)
                        module->pam_setcred = TRUE;
                else if (strncmp(t_args[i], "cache_key=", 10) == 0) {
-                       module->module.cache_key =
+                       module->module.default_cache_key =
                                auth_cache_parse_key(pool, t_args[i] + 10);
                } else if (strcmp(t_args[i], "blocking=yes") == 0) {
                        /* ignore, for backwards compatibility */

diff --git a/src/auth/passdb-passwd-file.c b/src/auth/passdb-passwd-file.c
index d2ca69724034fbcd1ac8f620f99916cba8015570..b12a8c552c4db8433acf1c933a79b2906a70f367 100644 (file)
--- a/src/auth/passdb-passwd-file.c
+++ b/src/auth/passdb-passwd-file.c
@@ -152,9 +152,9 @@ passwd_file_preinit(pool_t pool, const char *args)
        module->username_format = format;
 
        if (!module->pwf->vars)
-               module->module.cache_key = format;
+               module->module.default_cache_key = format;
        else {
-               module->module.cache_key = auth_cache_parse_key(pool,
+               module->module.default_cache_key = auth_cache_parse_key(pool,
                        t_strconcat(format, module->pwf->path, NULL));
        }
 

diff --git a/src/auth/passdb-passwd.c b/src/auth/passdb-passwd.c
index 4d4f9f64c3e3a2469214011ecb506fbf895adc28..9271b05f8e2a6e87bf259ec6cc9a572309d10ada 100644 (file)
--- a/src/auth/passdb-passwd.c
+++ b/src/auth/passdb-passwd.c
@@ -99,7 +99,7 @@ passwd_preinit(pool_t pool, const char *args)
        else if (*args != '\0')
                i_fatal("passdb passwd: Unknown setting: %s", args);
 
-       module->cache_key = PASSWD_CACHE_KEY;
+       module->default_cache_key = PASSWD_CACHE_KEY;
        module->default_pass_scheme = PASSWD_PASS_SCHEME;
        return module;
 }

diff --git a/src/auth/passdb-shadow.c b/src/auth/passdb-shadow.c
index ae416e2c380d38febe85ebb708eb53eb9634fd72..b089696ca01701a8dad563c22cd1d440de07cd40 100644 (file)
--- a/src/auth/passdb-shadow.c
+++ b/src/auth/passdb-shadow.c
@@ -97,7 +97,7 @@ shadow_preinit(pool_t pool, const char *args)
        else if (*args != '\0')
                i_fatal("passdb shadow: Unknown setting: %s", args);
 
-       module->cache_key = SHADOW_CACHE_KEY;
+       module->default_cache_key = SHADOW_CACHE_KEY;
        module->default_pass_scheme = SHADOW_PASS_SCHEME;
        return module;
 }

diff --git a/src/auth/passdb-sql.c b/src/auth/passdb-sql.c
index aeefedf4f5b69c17d0e4c9996e1b781074157565..81a3ba61dc439b0467e341777812cbc04bcd9369 100644 (file)
--- a/src/auth/passdb-sql.c
+++ b/src/auth/passdb-sql.c
@@ -254,7 +254,7 @@ passdb_sql_preinit(pool_t pool, const char *args)
        module = p_new(pool, struct sql_passdb_module, 1);
        module->conn = conn = db_sql_init(args, FALSE);
 
-       module->module.cache_key =
+       module->module.default_cache_key =
                auth_cache_parse_key(pool, conn->set.password_query);
        module->module.default_pass_scheme = conn->set.default_pass_scheme;
        return &module->module;

diff --git a/src/auth/passdb-vpopmail.c b/src/auth/passdb-vpopmail.c
index 3d2b452c6c3fcff7a620c5a9c0885119934dae9f..3fb8b57a2094971798769d3012e8cf0980d08179 100644 (file)
--- a/src/auth/passdb-vpopmail.c
+++ b/src/auth/passdb-vpopmail.c
@@ -184,7 +184,7 @@ vpopmail_preinit(pool_t pool, const char *args)
        tmp = t_strsplit_spaces(args, " ");
        for (; *tmp != NULL; tmp++) {
                if (strncmp(*tmp, "cache_key=", 10) == 0) {
-                       module->module.cache_key =
+                       module->module.default_cache_key =
                                auth_cache_parse_key(pool, *tmp + 10);
                } else if (strncmp(*tmp, "webmail=", 8) == 0) {
                        if (net_addr2ip(*tmp + 8, &module->webmail_ip) < 0)

diff --git a/src/auth/passdb.c b/src/auth/passdb.c
index a425aa1691a348229c54203004438ece902d254d..0b5ddb588bcc5c6a139f326b35634a447edccd01 100644 (file)
--- a/src/auth/passdb.c
+++ b/src/auth/passdb.c
@@ -227,13 +227,6 @@ passdb_preinit(pool_t pool, const struct auth_passdb_settings *set)
                passdb_template_build(pool, set->default_fields);
        passdb->override_fields_tmpl =
                passdb_template_build(pool, set->override_fields);
-       if (passdb->cache_key != NULL &&
-           !passdb_template_is_empty(passdb->default_fields_tmpl)) {
-               /* make sure any %variables in default_fields exist
-                  in cache_key */
-               passdb->cache_key = p_strconcat(pool, passdb->cache_key,
-                                               set->default_fields, NULL);
-       }
 
        array_append(&passdb_modules, &passdb, 1);
        return passdb;
@@ -244,9 +237,6 @@ void passdb_init(struct passdb_module *passdb)
        if (passdb->iface.init != NULL && passdb->init_refcount == 0)
                passdb->iface.init(passdb);
        passdb->init_refcount++;
-
-       i_assert(passdb->default_pass_scheme != NULL ||
-                passdb->cache_key == NULL);
 }
 
 void passdb_deinit(struct passdb_module *passdb)

diff --git a/src/auth/passdb.h b/src/auth/passdb.h
index a0609c42591827f06d1e36c411bb2a82faadcc69..2de5a42bb5a410f8c7f4bdc39299edc92f2bee8e 100644 (file)
--- a/src/auth/passdb.h
+++ b/src/auth/passdb.h
@@ -54,8 +54,10 @@ struct passdb_module_interface {
 
 struct passdb_module {
        const char *args;
-       /* The caching key for this module, or NULL if caching isn't wanted. */
-       const char *cache_key;
+       /* The default caching key for this module, or NULL if caching isn't
+          wanted. This is updated by settings in auth_passdb. */
+#define default_cache_key cache_key /* FIXME: remove in v2.3 - for API backwards compatibility */
+       const char *default_cache_key;
        /* Default password scheme for this module.
           If cache_key is set, must not be NULL. */
        const char *default_pass_scheme;

diff --git a/src/auth/userdb-dict.c b/src/auth/userdb-dict.c
index cabacb83ebe3581aa9b4ebfed5f8c3438df63cd6..6ccd198bdc1b55c8a1baadd5e4166120ca9b1023 100644 (file)
--- a/src/auth/userdb-dict.c
+++ b/src/auth/userdb-dict.c
@@ -162,7 +162,7 @@ userdb_dict_preinit(pool_t pool, const char *args)
        module->conn = conn = db_dict_init(args);
 
        module->module.blocking = TRUE;
-       module->module.cache_key = auth_cache_parse_key(pool,
+       module->module.default_cache_key = auth_cache_parse_key(pool,
                db_dict_parse_cache_key(&conn->set.keys, &conn->set.userdb_fields,
                                        &conn->set.parsed_userdb_objects));
        return &module->module;

diff --git a/src/auth/userdb-ldap.c b/src/auth/userdb-ldap.c
index 146eae5191ba20d8466146f297c1a0b09aad6636..670f3e6571be87ad90438675e4ae6ca3e8106a0c 100644 (file)
--- a/src/auth/userdb-ldap.c
+++ b/src/auth/userdb-ldap.c
@@ -266,7 +266,7 @@ userdb_ldap_preinit(pool_t pool, const char *args)
                          &conn->iterate_attr_names,
                          &conn->iterate_attr_map, NULL);
        module->module.blocking = conn->set.blocking;
-       module->module.cache_key =
+       module->module.default_cache_key =
                auth_cache_parse_key(pool,
                                     t_strconcat(conn->set.base,
                                                 conn->set.user_attrs,

diff --git a/src/auth/userdb-nss.c b/src/auth/userdb-nss.c
index d020f97ed6a9acb765af089f96b46308c807ebbd..4d42d10e0a1623faeb4758b0bce611a6f1dd93e2 100644 (file)
--- a/src/auth/userdb-nss.c
+++ b/src/auth/userdb-nss.c
@@ -127,7 +127,7 @@ userdb_nss_preinit(pool_t pool, const char *args)
                i_fatal("userdb nss: Missing service");
        userdb_nss_load_module(module, pool);
 
-       module->module.cache_key = USER_CACHE_KEY;
+       module->module.default_cache_key = USER_CACHE_KEY;
        return &module->module;
 }
 

diff --git a/src/auth/userdb-passwd-file.c b/src/auth/userdb-passwd-file.c
index 0cdbad632ac0c7d14f056b0fdef9cddc0d718f46..52389209fd889ceb61a503691bc83b96bfa30478 100644 (file)
--- a/src/auth/userdb-passwd-file.c
+++ b/src/auth/userdb-passwd-file.c
@@ -193,9 +193,9 @@ passwd_file_preinit(pool_t pool, const char *args)
        module->username_format = format;
 
        if (!module->pwf->vars)
-               module->module.cache_key = PASSWD_FILE_CACHE_KEY;
+               module->module.default_cache_key = PASSWD_FILE_CACHE_KEY;
        else {
-               module->module.cache_key =
+               module->module.default_cache_key =
                        auth_cache_parse_key(pool,
                                             t_strconcat(PASSWD_FILE_CACHE_KEY,
                                                         module->pwf->path,

diff --git a/src/auth/userdb-passwd.c b/src/auth/userdb-passwd.c
index f372ab9b894601fa7cbc9db5db9f54001106a41e..e6f9b802be20472839aa9aa984f083fa95f0ec59 100644 (file)
--- a/src/auth/userdb-passwd.c
+++ b/src/auth/userdb-passwd.c
@@ -207,7 +207,7 @@ passwd_passwd_preinit(pool_t pool, const char *args)
        const char *value;
 
        module = p_new(pool, struct passwd_userdb_module, 1);
-       module->module.cache_key = USER_CACHE_KEY;
+       module->module.default_cache_key = USER_CACHE_KEY;
        module->tmpl = userdb_template_build(pool, "passwd", args);
        module->module.blocking = TRUE;
 

diff --git a/src/auth/userdb-sql.c b/src/auth/userdb-sql.c
index a16229345c80150e8d7b4f542691d2153929ef4b..80d6fa887cb1d306ca72dfd37557f29b35ee3948 100644 (file)
--- a/src/auth/userdb-sql.c
+++ b/src/auth/userdb-sql.c
@@ -257,7 +257,7 @@ userdb_sql_preinit(pool_t pool, const char *args)
        module = p_new(pool, struct sql_userdb_module, 1);
        module->conn = db_sql_init(args, TRUE);
 
-       module->module.cache_key =
+       module->module.default_cache_key =
                auth_cache_parse_key(pool, module->conn->set.user_query);
        return &module->module;
 }

diff --git a/src/auth/userdb-vpopmail.c b/src/auth/userdb-vpopmail.c
index af6e9a80002999c2a87677d8c2883c9413341be3..45eeafc5966d53deed1f8828719684e8db5f9533 100644 (file)
--- a/src/auth/userdb-vpopmail.c
+++ b/src/auth/userdb-vpopmail.c
@@ -146,7 +146,8 @@ vpopmail_preinit(pool_t pool, const char *args)
 
        for (tmp = t_strsplit(args, " "); *tmp != NULL; tmp++) {
                if (strncmp(*tmp, "cache_key=", 10) == 0)
-                       module->module.cache_key = p_strdup(pool, *tmp + 10);
+                       module->module.default_cache_key =
+                               p_strdup(pool, *tmp + 10);
                else if (strncmp(*tmp, "quota_template=", 15) == 0) {
                        p = strchr(*tmp + 15, '=');
                        if (p == NULL) {

diff --git a/src/auth/userdb.c b/src/auth/userdb.c
index 4d30005f9a454dae4c188b9a003e80beb06ff3c9..afc9d151d08b7502011db617fe78b2f1a8d9f73d 100644 (file)
--- a/src/auth/userdb.c
+++ b/src/auth/userdb.c
@@ -171,13 +171,6 @@ userdb_preinit(pool_t pool, const struct auth_userdb_settings *set)
        userdb->override_fields_tmpl =
                userdb_template_build(pool, set->driver,
                                      set->override_fields);
-       if (userdb->cache_key != NULL &&
-           !userdb_template_is_empty(userdb->default_fields_tmpl)) {
-               /* make sure any %variables in default_fields exist
-                  in cache_key */
-               userdb->cache_key = p_strconcat(pool, userdb->cache_key,
-                                               set->default_fields, NULL);
-       }
 
        array_append(&userdb_modules, &userdb, 1);
        return userdb;

diff --git a/src/auth/userdb.h b/src/auth/userdb.h
index a980db1101b96118a5971f1f682639ced8a838f2..4f189a282e2d5b0e99298ba112a8b0dd63fae90c 100644 (file)
--- a/src/auth/userdb.h
+++ b/src/auth/userdb.h
@@ -22,8 +22,10 @@ typedef void userdb_iter_callback_t(const char *user, void *context);
 
 struct userdb_module {
        const char *args;
-       /* The caching key for this module, or NULL if caching isn't wanted. */
-       const char *cache_key;
+       /* The default caching key for this module, or NULL if caching isn't
+          wanted. This is updated by settings in auth_userdb. */
+#define default_cache_key cache_key /* FIXME: remove in v2.3 - for API backwards compatibility */
+       const char *default_cache_key;
 
        /* If blocking is set to TRUE, use child processes to access
           this userdb. */