auth: passdb/userdb backends no longer know about struct auth_passdb/auth_userdb.

--HG--
branch : HEAD

diff --git a/src/auth/auth-master-connection.c b/src/auth/auth-master-connection.c
index d4aa33a5e65d9b0c9029b24aa68bd0bbdd7ae348..03fc41fe0657103825aa00cf67f9b841006262d7 100644 (file)
--- a/src/auth/auth-master-connection.c
+++ b/src/auth/auth-master-connection.c
@@ -319,7 +319,7 @@ static void master_input_list_callback(const char *user, void *context)
                }
 
                /* continue iterating next userdb */
-               ctx->iter = userdb_blocking_iter_init(ctx->userdb,
+               ctx->iter = userdb_blocking_iter_init(ctx->userdb->userdb,
                                        master_input_list_callback, ctx);
                userdb_blocking_iter_next(ctx->iter);
                return;
@@ -372,7 +372,7 @@ master_input_list(struct auth_master_connection *conn, const char *args)
 
        io_remove(&conn->io);
        o_stream_set_flush_callback(conn->output, master_output_list, ctx);
-       ctx->iter = userdb_blocking_iter_init(ctx->userdb,
+       ctx->iter = userdb_blocking_iter_init(ctx->userdb->userdb,
                                              master_input_list_callback, ctx);
        return TRUE;
 }

diff --git a/src/auth/auth-worker-client.c b/src/auth/auth-worker-client.c
index ad42066f1fef5db3bc32fc5c6f1090fc306de4f8..7da14c45da64506bf49446e8070635e2bbd3ab35 100644 (file)
--- a/src/auth/auth-worker-client.c
+++ b/src/auth/auth-worker-client.c
@@ -504,7 +504,7 @@ auth_worker_handle_list(struct auth_worker_client *client,
                                    auth_worker_list_output, ctx);
        client->refcount++;
        ctx->iter = ctx->userdb->iface->
-               iterate_init(userdb, list_iter_callback, ctx);
+               iterate_init(userdb->userdb, list_iter_callback, ctx);
        ctx->userdb->iface->iterate_next(ctx->iter);
 }
 

diff --git a/src/auth/auth.c b/src/auth/auth.c
index 0d657821b21cf709acfc3dd9cbcc8c93b0bc4988..0139260127cfd48db83f87f011b3d7d75149dca6 100644 (file)
--- a/src/auth/auth.c
+++ b/src/auth/auth.c
@@ -204,11 +204,11 @@ void auth_init(struct auth *auth)
        const char *const *mechanisms;
 
        for (passdb = auth->masterdbs; passdb != NULL; passdb = passdb->next)
-               passdb_init(passdb);
+               passdb_init(passdb->passdb, passdb->set);
        for (passdb = auth->passdbs; passdb != NULL; passdb = passdb->next)
-               passdb_init(passdb);
+               passdb_init(passdb->passdb, passdb->set);
        for (userdb = auth->userdbs; userdb != NULL; userdb = userdb->next)
-               userdb_init(userdb);
+               userdb_init(userdb->userdb, userdb->set);
        /* caching is handled only by the main auth process */
        if (!worker)
                passdb_cache_init(auth->set);
@@ -248,11 +248,11 @@ void auth_deinit(struct auth **_auth)
        *_auth = NULL;
 
        for (passdb = auth->masterdbs; passdb != NULL; passdb = passdb->next)
-               passdb_deinit(passdb);
+               passdb_deinit(passdb->passdb);
        for (passdb = auth->passdbs; passdb != NULL; passdb = passdb->next)
-               passdb_deinit(passdb);
+               passdb_deinit(passdb->passdb);
        for (userdb = auth->userdbs; userdb != NULL; userdb = userdb->next)
-               userdb_deinit(userdb);
+               userdb_deinit(userdb->userdb);
 
        auth_request_handler_deinit();
        passdb_cache_deinit();

diff --git a/src/auth/passdb-bsdauth.c b/src/auth/passdb-bsdauth.c
index 708dc3dcd6c0d9c63b7e8a915c4221f879a33fef..6c5b880f5d55ea78687cf168ed7e755a521ceb8d 100644 (file)
--- a/src/auth/passdb-bsdauth.c
+++ b/src/auth/passdb-bsdauth.c
@@ -49,17 +49,16 @@ bsdauth_verify_plain(struct auth_request *request, const char *password,
 }
 
 static struct passdb_module *
-bsdauth_preinit(struct auth_passdb *auth_passdb, const char *args)
+bsdauth_preinit(pool_t pool, const char *args)
 {
        struct passdb_module *module;
 
-       module = p_new(auth_passdb->pool, struct passdb_module, 1);
+       module = p_new(pool, struct passdb_module, 1);
        module->default_pass_scheme = "PLAIN"; /* same reason as PAM */
 
-       if (strncmp(args, "cache_key=", 10) == 0) {
-               module->cache_key =
-                       auth_cache_parse_key(auth_passdb->pool, args + 10);
-       } else if (*args != '\0')
+       if (strncmp(args, "cache_key=", 10) == 0)
+               module->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-checkpassword.c b/src/auth/passdb-checkpassword.c
index d0ca024d4843d5240440ab9d8cad17c646ae82a6..aa7f7aaf91483dd70c25d2d32b8865845ef1a53e 100644 (file)
--- a/src/auth/passdb-checkpassword.c
+++ b/src/auth/passdb-checkpassword.c
@@ -235,13 +235,12 @@ checkpassword_verify_plain(struct auth_request *request, const char *password,
 }
 
 static struct passdb_module *
-checkpassword_preinit(struct auth_passdb *auth_passdb, const char *args)
+checkpassword_preinit(pool_t pool, const char *args)
 {
        struct checkpassword_passdb_module *module;
 
-       module = p_new(auth_passdb->pool,
-                      struct checkpassword_passdb_module, 1);
-       module->checkpassword_path = p_strdup(auth_passdb->pool, args);
+       module = p_new(pool, struct checkpassword_passdb_module, 1);
+       module->checkpassword_path = p_strdup(pool, args);
        module->checkpassword_reply_path =
                PKG_LIBEXECDIR"/checkpassword-reply";
 

diff --git a/src/auth/passdb-ldap.c b/src/auth/passdb-ldap.c
index 7df6b2d1959078cb9d481fb123f9e8753efbad53..42a1ac9b86d571e64ee2027b79a5dbe3c7af95e7 100644 (file)
--- a/src/auth/passdb-ldap.c
+++ b/src/auth/passdb-ldap.c
@@ -392,12 +392,12 @@ static void ldap_lookup_credentials(struct auth_request *request,
 }
 
 static struct passdb_module *
-passdb_ldap_preinit(struct auth_passdb *auth_passdb, const char *args)
+passdb_ldap_preinit(pool_t pool, const char *args)
 {
        struct ldap_passdb_module *module;
        struct ldap_connection *conn;
 
-       module = p_new(auth_passdb->pool, struct ldap_passdb_module, 1);
+       module = p_new(pool, struct ldap_passdb_module, 1);
        module->conn = conn = db_ldap_init(args);
        conn->pass_attr_map =
                hash_table_create(default_pool, conn->pool, 0, str_hash,
@@ -407,7 +407,7 @@ passdb_ldap_preinit(struct auth_passdb *auth_passdb, const char *args)
                          conn->pass_attr_map,
                          conn->set.auth_bind ? "password" : NULL);
        module->module.cache_key =
-               auth_cache_parse_key(auth_passdb->pool,
+               auth_cache_parse_key(pool,
                                     t_strconcat(conn->set.base,
                                                 conn->set.pass_filter, NULL));
        module->module.default_pass_scheme = conn->set.default_pass_scheme;

diff --git a/src/auth/passdb-pam.c b/src/auth/passdb-pam.c
index 1d42d7f7eefbde4a80c2201ed36f6bfa6d0cda9d..0a6b1468d83436c02102e316f5c5923774b915b8 100644 (file)
--- a/src/auth/passdb-pam.c
+++ b/src/auth/passdb-pam.c
@@ -327,13 +327,13 @@ pam_verify_plain(struct auth_request *request, const char *password,
 }
 
 static struct passdb_module *
-pam_preinit(struct auth_passdb *auth_passdb, const char *args)
+pam_preinit(pool_t pool, const char *args)
 {
        struct pam_passdb_module *module;
        const char *const *t_args;
        int i;
 
-       module = p_new(auth_passdb->pool, struct pam_passdb_module, 1);
+       module = p_new(pool, struct pam_passdb_module, 1);
        module->service_name = "dovecot";
        /* we're caching the password by using directly the plaintext password
           given by the auth mechanism */
@@ -351,8 +351,7 @@ pam_preinit(struct auth_passdb *auth_passdb, const char *args)
                        module->pam_setcred = TRUE;
                else if (strncmp(t_args[i], "cache_key=", 10) == 0) {
                        module->module.cache_key =
-                               auth_cache_parse_key(auth_passdb->pool,
-                                                    t_args[i] + 10);
+                               auth_cache_parse_key(pool, t_args[i] + 10);
                } else if (strcmp(t_args[i], "blocking=yes") == 0) {
                        /* ignore, for backwards compatibility */
                } else if (strcmp(t_args[i], "failure_show_msg=yes") == 0) {
@@ -363,8 +362,7 @@ pam_preinit(struct auth_passdb *auth_passdb, const char *args)
                } else if (strncmp(t_args[i], "max_requests=", 13) == 0) {
                        module->requests_left = atoi(t_args[i] + 13);
                } else if (t_args[i+1] == NULL) {
-                       module->service_name =
-                               p_strdup(auth_passdb->pool, t_args[i]);
+                       module->service_name = p_strdup(pool, t_args[i]);
                } else {
                        i_fatal("passdb pam: Unknown setting: %s", t_args[i]);
                }

diff --git a/src/auth/passdb-passwd-file.c b/src/auth/passdb-passwd-file.c
index 42b2f718315ddf04807377fc323541ca6f81fa18..b01e1fcf9e2161d151eaaa1aee7e65ffab9b8748 100644 (file)
--- a/src/auth/passdb-passwd-file.c
+++ b/src/auth/passdb-passwd-file.c
@@ -107,7 +107,7 @@ passwd_file_lookup_credentials(struct auth_request *request,
 }
 
 static struct passdb_module *
-passwd_file_preinit(struct auth_passdb *auth_passdb, const char *args)
+passwd_file_preinit(pool_t pool, const char *args)
 {
        struct passwd_file_passdb_module *module;
        const char *scheme = PASSWD_FILE_DEFAULT_SCHEME;
@@ -135,9 +135,9 @@ passwd_file_preinit(struct auth_passdb *auth_passdb, const char *args)
                        args++;
 
                if (strcmp(key, "scheme") == 0)
-                       scheme = p_strdup(auth_passdb->pool, value);
+                       scheme = p_strdup(pool, value);
                else if (strcmp(key, "username_format") == 0)
-                       format = p_strdup(auth_passdb->pool, value);
+                       format = p_strdup(pool, value);
                else
                        i_fatal("passdb passwd-file: Unknown setting: %s", key);
        }
@@ -145,16 +145,15 @@ passwd_file_preinit(struct auth_passdb *auth_passdb, const char *args)
        if (*args == '\0')
                i_fatal("passdb passwd-file: Missing args");
 
-       module = p_new(auth_passdb->pool, struct passwd_file_passdb_module, 1);
+       module = p_new(pool, struct passwd_file_passdb_module, 1);
        module->pwf = db_passwd_file_init(args, format, FALSE,
                                          global_auth_settings->debug);
 
        if (!module->pwf->vars)
                module->module.cache_key = format;
        else {
-               module->module.cache_key =
-                       auth_cache_parse_key(auth_passdb->pool,
-                               t_strconcat(format, module->pwf->path, NULL));
+               module->module.cache_key = auth_cache_parse_key(pool,
+                       t_strconcat(format, module->pwf->path, NULL));
        }
 
        module->module.default_pass_scheme = scheme;

diff --git a/src/auth/passdb-sql.c b/src/auth/passdb-sql.c
index 2b54a0f6330a7460cf3c2af809383fa7e123aa39..153bd07d2f81729aa3adaf586b85833fb5b2fe5c 100644 (file)
--- a/src/auth/passdb-sql.c
+++ b/src/auth/passdb-sql.c
@@ -225,17 +225,16 @@ static int sql_set_credentials(struct auth_request *request,
 }
 
 static struct passdb_module *
-passdb_sql_preinit(struct auth_passdb *auth_passdb, const char *args)
+passdb_sql_preinit(pool_t pool, const char *args)
 {
        struct sql_passdb_module *module;
        struct sql_connection *conn;
 
-       module = p_new(auth_passdb->pool, struct sql_passdb_module, 1);
+       module = p_new(pool, struct sql_passdb_module, 1);
        module->conn = conn = db_sql_init(args);
 
        module->module.cache_key =
-               auth_cache_parse_key(auth_passdb->pool,
-                                    conn->set.password_query);
+               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 dc4532ff0542f86afe3eae1b5f9449f6d5c4a1e5..32ab3bc0b34f2f501b6081de310cc76c727ef1ca 100644 (file)
--- a/src/auth/passdb-vpopmail.c
+++ b/src/auth/passdb-vpopmail.c
@@ -159,20 +159,19 @@ vpopmail_verify_plain(struct auth_request *request, const char *password,
 }
 
 static struct passdb_module *
-vpopmail_preinit(struct auth_passdb *auth_passdb, const char *args)
+vpopmail_preinit(pool_t pool, const char *args)
 {
        struct vpopmail_passdb_module *module;
        const char *const *tmp;
 
-       module = p_new(auth_passdb->pool, struct vpopmail_passdb_module, 1);
+       module = p_new(pool, struct vpopmail_passdb_module, 1);
        module->module.default_pass_scheme = VPOPMAIL_DEFAULT_PASS_SCHEME;
 
        tmp = t_strsplit_spaces(args, " ");
        for (; *tmp != NULL; tmp++) {
                if (strncmp(*tmp, "cache_key=", 10) == 0) {
                        module->module.cache_key =
-                               auth_cache_parse_key(auth_passdb->pool,
-                                                    *tmp + 10);
+                               auth_cache_parse_key(pool, *tmp + 10);
                } else if (strncmp(*tmp, "webmail=", 8) == 0) {
                        if (net_addr2ip(*tmp + 8, &module->webmail_ip) < 0)
                                i_fatal("vpopmail: Invalid webmail IP address");

diff --git a/src/auth/passdb.c b/src/auth/passdb.c
index e22d33fddf9e8b1b61387cc3cced51fca56e3864..83df9bf6075d48d6f6b0b79dff1e72dbcbb73acd 100644 (file)
--- a/src/auth/passdb.c
+++ b/src/auth/passdb.c
@@ -154,8 +154,7 @@ void passdb_handle_credentials(enum passdb_result result,
        callback(result, credentials, size, auth_request);
 }
 
-struct auth_passdb *
-passdb_preinit(struct auth *auth, struct auth_passdb_settings *set)
+void passdb_preinit(struct auth *auth, const struct auth_passdb_settings *set)
 {
        static unsigned int auth_passdb_id = 0;
        struct passdb_module_interface *iface;
@@ -187,26 +186,26 @@ passdb_preinit(struct auth *auth, struct auth_passdb_settings *set)
                        p_new(auth->pool, struct passdb_module, 1);
        } else {
                auth_passdb->passdb =
-                       iface->preinit(auth_passdb, set->args);
+                       iface->preinit(auth->pool, set->args);
        }
        auth_passdb->passdb->id = ++auth_passdb_id;
        auth_passdb->passdb->iface = *iface;
-       return auth_passdb;
 }
 
-void passdb_init(struct auth_passdb *passdb)
+void passdb_init(struct passdb_module *passdb,
+                const struct auth_passdb_settings *set)
 {
-       if (passdb->passdb->iface.init != NULL)
-               passdb->passdb->iface.init(passdb->passdb, passdb->set->args);
+       if (passdb->iface.init != NULL)
+               passdb->iface.init(passdb, set->args);
 
-       i_assert(passdb->passdb->default_pass_scheme != NULL ||
-                passdb->passdb->cache_key == NULL);
+       i_assert(passdb->default_pass_scheme != NULL ||
+                passdb->cache_key == NULL);
 }
 
-void passdb_deinit(struct auth_passdb *passdb)
+void passdb_deinit(struct passdb_module *passdb)
 {
-       if (passdb->passdb->iface.deinit != NULL)
-               passdb->passdb->iface.deinit(passdb->passdb);
+       if (passdb->iface.deinit != NULL)
+               passdb->iface.deinit(passdb);
 }
 
 extern struct passdb_module_interface passdb_passwd;

diff --git a/src/auth/passdb.h b/src/auth/passdb.h
index 4b2400cc9fb0f4fc11773eb3063f204732a013c1..53400e954a5ade9d69316185db99cf6f318e70fe 100644 (file)
--- a/src/auth/passdb.h
+++ b/src/auth/passdb.h
@@ -5,7 +5,6 @@
        ((pass)[0] != '\0' && (pass)[0] != '*' && (pass)[0] != '!')
 
 struct auth_request;
-struct auth_passdb;
 struct auth_passdb_settings;
 
 enum passdb_result {
@@ -32,8 +31,7 @@ typedef void set_credentials_callback_t(bool success,
 struct passdb_module_interface {
        const char *name;
 
-       struct passdb_module *
-               (*preinit)(struct auth_passdb *auth_passdb, const char *args);
+       struct passdb_module *(*preinit)(pool_t pool, const char *args);
        void (*init)(struct passdb_module *module, const char *args);
        void (*deinit)(struct passdb_module *module);
 
@@ -84,11 +82,10 @@ void passdb_handle_credentials(enum passdb_result result,
                               lookup_credentials_callback_t *callback,
                                struct auth_request *auth_request);
 
-struct auth_passdb *
-passdb_preinit(struct auth *auth, struct auth_passdb_settings *set);
-
-void passdb_init(struct auth_passdb *passdb);
-void passdb_deinit(struct auth_passdb *passdb);
+void passdb_preinit(struct auth *auth, const struct auth_passdb_settings *set);
+void passdb_init(struct passdb_module *passdb,
+                const struct auth_passdb_settings *set);
+void passdb_deinit(struct passdb_module *passdb);
 
 void passdb_register_module(struct passdb_module_interface *iface);
 void passdb_unregister_module(struct passdb_module_interface *iface);

diff --git a/src/auth/userdb-blocking.c b/src/auth/userdb-blocking.c
index 45b7c7d1aec347f4de2db66fe18ccb72943b0cd1..6e6510c69cd1daf44ad5aba876592e7fdcc7ca1c 100644 (file)
--- a/src/auth/userdb-blocking.c
+++ b/src/auth/userdb-blocking.c
@@ -70,7 +70,7 @@ static bool iter_callback(const char *reply, void *context)
 }
 
 struct userdb_iterate_context *
-userdb_blocking_iter_init(struct auth_userdb *userdb,
+userdb_blocking_iter_init(struct userdb_module *userdb,
                          userdb_iter_callback_t *callback, void *context)
 {
        struct blocking_userdb_iterate_context *ctx;
@@ -79,11 +79,11 @@ userdb_blocking_iter_init(struct auth_userdb *userdb,
 
        reply = auth_stream_reply_init(pool_datastack_create());
        auth_stream_reply_add(reply, "LIST", NULL);
-       auth_stream_reply_add(reply, NULL, dec2str(userdb->userdb->id));
+       auth_stream_reply_add(reply, NULL, dec2str(userdb->id));
 
        pool = pool_alloconly_create("userdb iter", 512);
        ctx = p_new(pool, struct blocking_userdb_iterate_context, 1);
-       ctx->ctx.userdb = userdb->userdb;
+       ctx->ctx.userdb = userdb;
        ctx->ctx.callback = callback;
        ctx->ctx.context = context;
        ctx->pool = pool;

diff --git a/src/auth/userdb-blocking.h b/src/auth/userdb-blocking.h
index 3d45d36de27ff41c17aef069d7a0388c53fff5a2..9818762570c83f46d12fff477944bd5cc8fa66e7 100644 (file)
--- a/src/auth/userdb-blocking.h
+++ b/src/auth/userdb-blocking.h
@@ -4,7 +4,7 @@
 void userdb_blocking_lookup(struct auth_request *request);
 
 struct userdb_iterate_context *
-userdb_blocking_iter_init(struct auth_userdb *userdb,
+userdb_blocking_iter_init(struct userdb_module *userdb,
                          userdb_iter_callback_t *callback, void *context);
 void userdb_blocking_iter_next(struct userdb_iterate_context *ctx);
 int userdb_blocking_iter_deinit(struct userdb_iterate_context **ctx);

diff --git a/src/auth/userdb-checkpassword.c b/src/auth/userdb-checkpassword.c
index e6c0432672656bffb5f8c58d85a3cc9e630c0c43..a48f1ac7dc41f4e29de53fee2b654ad83b11b78e 100644 (file)
--- a/src/auth/userdb-checkpassword.c
+++ b/src/auth/userdb-checkpassword.c
@@ -218,13 +218,12 @@ checkpassword_lookup(struct auth_request *request, userdb_callback_t *callback)
 }
 
 static struct userdb_module *
-checkpassword_preinit(struct auth_userdb *auth_userdb, const char *args)
+checkpassword_preinit(pool_t pool, const char *args)
 {
        struct checkpassword_userdb_module *module;
 
-       module = p_new(auth_userdb->pool,
-                      struct checkpassword_userdb_module, 1);
-       module->checkpassword_path = p_strdup(auth_userdb->pool, args);
+       module = p_new(pool, struct checkpassword_userdb_module, 1);
+       module->checkpassword_path = p_strdup(pool, args);
        module->checkpassword_reply_path =
                PKG_LIBEXECDIR"/checkpassword-reply";
 

diff --git a/src/auth/userdb-ldap.c b/src/auth/userdb-ldap.c
index 0ef9e5003078183ce41726b7333733d2592782b3..cc3b9ee210e3faf3ccb2033ad8b7a683fffd68c1 100644 (file)
--- a/src/auth/userdb-ldap.c
+++ b/src/auth/userdb-ldap.c
@@ -175,18 +175,18 @@ static void userdb_ldap_iterate_callback(struct ldap_connection *conn,
 }
 
 static struct userdb_iterate_context *
-userdb_ldap_iterate_init(struct auth_userdb *userdb,
+userdb_ldap_iterate_init(struct userdb_module *userdb,
                         userdb_iter_callback_t *callback, void *context)
 {
        struct ldap_userdb_module *module =
-               (struct ldap_userdb_module *)userdb->userdb;
+               (struct ldap_userdb_module *)userdb;
        struct ldap_connection *conn = module->conn;
        struct ldap_userdb_iterate_context *ctx;
        struct userdb_iter_ldap_request *request;
        const char **attr_names = (const char **)conn->iterate_attr_names;
 
        ctx = i_new(struct ldap_userdb_iterate_context, 1);
-       ctx->ctx.userdb = userdb->userdb;
+       ctx->ctx.userdb = userdb;
        ctx->ctx.callback = callback;
        ctx->ctx.context = context;
        ctx->conn = conn;
@@ -232,12 +232,12 @@ static int userdb_ldap_iterate_deinit(struct userdb_iterate_context *_ctx)
 }
 
 static struct userdb_module *
-userdb_ldap_preinit(struct auth_userdb *auth_userdb, const char *args)
+userdb_ldap_preinit(pool_t pool, const char *args)
 {
        struct ldap_userdb_module *module;
        struct ldap_connection *conn;
 
-       module = p_new(auth_userdb->pool, struct ldap_userdb_module, 1);
+       module = p_new(pool, struct ldap_userdb_module, 1);
        module->conn = conn = db_ldap_init(args);
        conn->user_attr_map =
                hash_table_create(default_pool, conn->pool, 0, str_hash,
@@ -252,7 +252,7 @@ userdb_ldap_preinit(struct auth_userdb *auth_userdb, const char *args)
                          &conn->iterate_attr_names,
                          conn->iterate_attr_map, NULL);
        module->module.cache_key =
-               auth_cache_parse_key(auth_userdb->pool,
+               auth_cache_parse_key(pool,
                                     t_strconcat(conn->set.base,
                                                 conn->set.user_filter, NULL));
        return &module->module;

diff --git a/src/auth/userdb-nss.c b/src/auth/userdb-nss.c
index ad9494aa290703283b6764c135b96e3e9bfe435c..04e3fdc4c92379e53a5e03fe72e4067443eb6909 100644 (file)
--- a/src/auth/userdb-nss.c
+++ b/src/auth/userdb-nss.c
@@ -101,11 +101,10 @@ userdb_nss_load_module(struct nss_userdb_module *module, pool_t pool)
 }
 
 static struct userdb_module *
-userdb_nss_preinit(struct auth_userdb *auth_userdb, const char *args)
+userdb_nss_preinit(pool_t pool, const char *args)
 {
        struct nss_userdb_module *module;
        const char *const *tmp;
-       pool_t pool = auth_userdb->pool;
 
        module = p_new(pool, struct nss_userdb_module, 1);
        module->bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);

diff --git a/src/auth/userdb-passwd-file.c b/src/auth/userdb-passwd-file.c
index 50ef25a92df41e9c34d6a755bb299e71d9ffbc5c..194e5c23c56c6d289f2a690eeda31d3e90e634ec 100644 (file)
--- a/src/auth/userdb-passwd-file.c
+++ b/src/auth/userdb-passwd-file.c
@@ -83,16 +83,16 @@ static void passwd_file_lookup(struct auth_request *auth_request,
 }
 
 static struct userdb_iterate_context *
-passwd_file_iterate_init(struct auth_userdb *userdb,
+passwd_file_iterate_init(struct userdb_module *userdb,
                         userdb_iter_callback_t *callback, void *context)
 {
        struct passwd_file_userdb_module *module =
-               (struct passwd_file_userdb_module *)userdb->userdb;
+               (struct passwd_file_userdb_module *)userdb;
        struct passwd_file_userdb_iterate_context *ctx;
        int fd;
 
        ctx = i_new(struct passwd_file_userdb_iterate_context, 1);
-       ctx->ctx.userdb = userdb->userdb;
+       ctx->ctx.userdb = userdb;
        ctx->ctx.callback = callback;
        ctx->ctx.context = context;
        if (module->pwf->default_file == NULL) {
@@ -154,7 +154,7 @@ static int passwd_file_iterate_deinit(struct userdb_iterate_context *_ctx)
 }
 
 static struct userdb_module *
-passwd_file_preinit(struct auth_userdb *auth_userdb, const char *args)
+passwd_file_preinit(pool_t pool, const char *args)
 {
        struct passwd_file_userdb_module *module;
        const char *format = PASSWD_FILE_DEFAULT_USERNAME_FORMAT;
@@ -167,7 +167,7 @@ passwd_file_preinit(struct auth_userdb *auth_userdb, const char *args)
                        format = args;
                        args = "";
                } else {
-                       format = p_strdup_until(auth_userdb->pool, args, p);
+                       format = p_strdup_until(pool, args, p);
                        args = p + 1;
                }
        }
@@ -175,7 +175,7 @@ passwd_file_preinit(struct auth_userdb *auth_userdb, const char *args)
        if (*args == '\0')
                i_fatal("userdb passwd-file: Missing args");
 
-       module = p_new(auth_userdb->pool, struct passwd_file_userdb_module, 1);
+       module = p_new(pool, struct passwd_file_userdb_module, 1);
        module->pwf = db_passwd_file_init(args, format, TRUE,
                                          global_auth_settings->debug);
 
@@ -183,7 +183,7 @@ passwd_file_preinit(struct auth_userdb *auth_userdb, const char *args)
                module->module.cache_key = PASSWD_FILE_CACHE_KEY;
        else {
                module->module.cache_key =
-                       auth_cache_parse_key(auth_userdb->pool,
+                       auth_cache_parse_key(pool,
                                             t_strconcat(PASSWD_FILE_CACHE_KEY,
                                                         module->pwf->path,
                                                         NULL));

diff --git a/src/auth/userdb-passwd.c b/src/auth/userdb-passwd.c
index 9932d5e63c53b9aa51cb0bbd1e8c3d89797220f8..2aa62be41bb19ddd0f99afa0c2eaf13f277f94f8 100644 (file)
--- a/src/auth/userdb-passwd.c
+++ b/src/auth/userdb-passwd.c
@@ -69,13 +69,13 @@ static void passwd_lookup(struct auth_request *auth_request,
 }
 
 static struct userdb_iterate_context *
-passwd_iterate_init(struct auth_userdb *userdb,
+passwd_iterate_init(struct userdb_module *userdb,
                    userdb_iter_callback_t *callback, void *context)
 {
        struct passwd_userdb_iterate_context *ctx;
 
        ctx = i_new(struct passwd_userdb_iterate_context, 1);
-       ctx->ctx.userdb = userdb->userdb;
+       ctx->ctx.userdb = userdb;
        ctx->ctx.callback = callback;
        ctx->ctx.context = context;
        setpwent();
@@ -135,15 +135,14 @@ static int passwd_iterate_deinit(struct userdb_iterate_context *_ctx)
 }
 
 static struct userdb_module *
-passwd_passwd_preinit(struct auth_userdb *auth_userdb, const char *args)
+passwd_passwd_preinit(pool_t pool, const char *args)
 {
        struct passwd_userdb_module *module;
        const char *value;
 
-       module = p_new(auth_userdb->pool, struct passwd_userdb_module, 1);
+       module = p_new(pool, struct passwd_userdb_module, 1);
        module->module.cache_key = USER_CACHE_KEY;
-       module->tmpl = userdb_static_template_build(auth_userdb->pool,
-                                                   "passwd", args);
+       module->tmpl = userdb_static_template_build(pool, "passwd", args);
 
        if (userdb_static_template_remove(module->tmpl, "blocking",
                                          &value)) {

diff --git a/src/auth/userdb-sql.c b/src/auth/userdb-sql.c
index d3b888c70613d88351ed91e73ac3569e525c5633..2cee1c10f60e87fc17bb6f97c45a178f502297b2 100644 (file)
--- a/src/auth/userdb-sql.c
+++ b/src/auth/userdb-sql.c
@@ -129,15 +129,15 @@ static void sql_iter_query_callback(struct sql_result *sql_result,
 }
 
 static struct userdb_iterate_context *
-userdb_sql_iterate_init(struct auth_userdb *userdb,
+userdb_sql_iterate_init(struct userdb_module *userdb,
                        userdb_iter_callback_t *callback, void *context)
 {
        struct sql_userdb_module *module =
-               (struct sql_userdb_module *)userdb->userdb;
+               (struct sql_userdb_module *)userdb;
        struct sql_userdb_iterate_context *ctx;
 
        ctx = i_new(struct sql_userdb_iterate_context, 1);
-       ctx->ctx.userdb = userdb->userdb;
+       ctx->ctx.userdb = userdb;
        ctx->ctx.callback = callback;
        ctx->ctx.context = context;
 
@@ -226,16 +226,15 @@ static int userdb_sql_iterate_deinit(struct userdb_iterate_context *_ctx)
 }
 
 static struct userdb_module *
-userdb_sql_preinit(struct auth_userdb *auth_userdb, const char *args)
+userdb_sql_preinit(pool_t pool, const char *args)
 {
        struct sql_userdb_module *module;
 
-       module = p_new(auth_userdb->pool, struct sql_userdb_module, 1);
+       module = p_new(pool, struct sql_userdb_module, 1);
        module->conn = db_sql_init(args);
 
        module->module.cache_key =
-               auth_cache_parse_key(auth_userdb->pool,
-                                    module->conn->set.user_query);
+               auth_cache_parse_key(pool, module->conn->set.user_query);
        return &module->module;
 }
 

diff --git a/src/auth/userdb-static.c b/src/auth/userdb-static.c
index d6fee5d191291a1e926deb44c9c7c0beb229b749..1e63fabb47988858b3b5e48eafdb24c23e19ff10 100644 (file)
--- a/src/auth/userdb-static.c
+++ b/src/auth/userdb-static.c
@@ -212,14 +212,13 @@ static void static_lookup(struct auth_request *auth_request,
 }
 
 static struct userdb_module *
-static_preinit(struct auth_userdb *auth_userdb, const char *args)
+static_preinit(pool_t pool, const char *args)
 {
        struct static_userdb_module *module;
        const char *value;
 
-       module = p_new(auth_userdb->pool, struct static_userdb_module, 1);
-       module->tmpl = userdb_static_template_build(auth_userdb->pool,
-                                                   "static", args);
+       module = p_new(pool, struct static_userdb_module, 1);
+       module->tmpl = userdb_static_template_build(pool, "static", args);
 
        if (userdb_static_template_remove(module->tmpl, "allow_all_users",
                                          &value)) {

diff --git a/src/auth/userdb-vpopmail.c b/src/auth/userdb-vpopmail.c
index 1e146825c64632fa754011b1c6e758e7d963dbdb..9aeada287e10324b9e406c27fcae465cb4e00a5c 100644 (file)
--- a/src/auth/userdb-vpopmail.c
+++ b/src/auth/userdb-vpopmail.c
@@ -137,11 +137,10 @@ static void vpopmail_lookup(struct auth_request *auth_request,
 }
 
 static struct userdb_module *
-vpopmail_preinit(struct auth_userdb *auth_userdb, const char *args)
+vpopmail_preinit(pool_t pool, const char *args)
 {
        struct vpopmail_userdb_module *module;
        const char *const *tmp, *p;
-       pool_t pool = auth_userdb->pool;
 
        module = p_new(pool, struct vpopmail_userdb_module, 1);
 

diff --git a/src/auth/userdb.c b/src/auth/userdb.c
index 5475cf885fee4f1f20d3d48545c4b8b4a84d8d3f..215efbec5e65431c1d2df8e701b20c97b6cf0ecd 100644 (file)
--- a/src/auth/userdb.c
+++ b/src/auth/userdb.c
@@ -106,7 +106,7 @@ gid_t userdb_parse_gid(struct auth_request *request, const char *str)
        return gr->gr_gid;
 }
 
-void userdb_preinit(struct auth *auth, struct auth_userdb_settings *set)
+void userdb_preinit(struct auth *auth, const struct auth_userdb_settings *set)
 {
        static unsigned int auth_userdb_id = 0;
        struct userdb_module_interface *iface;
@@ -138,22 +138,23 @@ void userdb_preinit(struct auth *auth, struct auth_userdb_settings *set)
                        p_new(auth->pool, struct userdb_module, 1);
        } else {
                auth_userdb->userdb =
-                       iface->preinit(auth_userdb, auth_userdb->set->args);
+                       iface->preinit(auth->pool, auth_userdb->set->args);
        }
        auth_userdb->userdb->id = ++auth_userdb_id;
        auth_userdb->userdb->iface = iface;
 }
 
-void userdb_init(struct auth_userdb *userdb)
+void userdb_init(struct userdb_module *userdb,
+                const struct auth_userdb_settings *set)
 {
-       if (userdb->userdb->iface->init != NULL)
-               userdb->userdb->iface->init(userdb->userdb, userdb->set->args);
+       if (userdb->iface->init != NULL)
+               userdb->iface->init(userdb, set->args);
 }
 
-void userdb_deinit(struct auth_userdb *userdb)
+void userdb_deinit(struct userdb_module *userdb)
 {
-       if (userdb->userdb->iface->deinit != NULL)
-               userdb->userdb->iface->deinit(userdb->userdb);
+       if (userdb->iface->deinit != NULL)
+               userdb->iface->deinit(userdb);
 }
 
 extern struct userdb_module_interface userdb_prefetch;

diff --git a/src/auth/userdb.h b/src/auth/userdb.h
index 5aaf65d941883f26aa1449358f2e30e053fbe931..e42ad9e079ee825a3eb8183600515e82aec6876e 100644 (file)
--- a/src/auth/userdb.h
+++ b/src/auth/userdb.h
@@ -5,7 +5,6 @@
 
 struct auth;
 struct auth_request;
-struct auth_userdb;
 struct auth_userdb_settings;
 
 enum userdb_result {
@@ -43,8 +42,7 @@ struct userdb_iterate_context {
 struct userdb_module_interface {
        const char *name;
 
-       struct userdb_module *
-               (*preinit)(struct auth_userdb *auth_userdb, const char *args);
+       struct userdb_module *(*preinit)(pool_t pool, const char *args);
        void (*init)(struct userdb_module *module, const char *args);
        void (*deinit)(struct userdb_module *module);
 
@@ -52,7 +50,7 @@ struct userdb_module_interface {
                       userdb_callback_t *callback);
 
        struct userdb_iterate_context *
-               (*iterate_init)(struct auth_userdb *userdb,
+               (*iterate_init)(struct userdb_module *userdb,
                                userdb_iter_callback_t *callback,
                                void *context);
        void (*iterate_next)(struct userdb_iterate_context *ctx);
@@ -62,9 +60,10 @@ struct userdb_module_interface {
 uid_t userdb_parse_uid(struct auth_request *request, const char *str);
 gid_t userdb_parse_gid(struct auth_request *request, const char *str);
 
-void userdb_preinit(struct auth *auth, struct auth_userdb_settings *set);
-void userdb_init(struct auth_userdb *userdb);
-void userdb_deinit(struct auth_userdb *userdb);
+void userdb_preinit(struct auth *auth, const struct auth_userdb_settings *set);
+void userdb_init(struct userdb_module *userdb,
+                const struct auth_userdb_settings *set);
+void userdb_deinit(struct userdb_module *userdb);
 
 void userdb_register_module(struct userdb_module_interface *iface);
 void userdb_unregister_module(struct userdb_module_interface *iface);