--- a/src/config/settings-get.pl	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/config/settings-get.pl	Tue Jun 02 22:30:28 2009 -0400
@@ -4,6 +4,7 @@
 print '#include "lib.h"'."\n";
 print '#include "array.h"'."\n";
 print '#include "var-expand.h"'."\n";
+print '#include "file-lock.h"'."\n";
 print '#include "settings-parser.h"'."\n";
 print '#include "all-settings.h"'."\n";
 print '#include <stddef.h>'."\n";

--- a/src/imap/cmd-append.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/cmd-append.c	Tue Jun 02 22:30:28 2009 -0400
@@ -8,7 +8,6 @@
 #include "imap-commands.h"
 #include "imap-parser.h"
 #include "imap-date.h"
-#include "mail-storage.h"
 
 #include <sys/time.h>
 
@@ -452,24 +451,24 @@
 static struct mailbox *
 get_mailbox(struct client_command_context *cmd, const char *name)
 {
-	struct mail_storage *storage;
+	struct mail_namespace *ns;
 	struct mailbox *box;
 
 	if (!client_verify_mailbox_name(cmd, name, TRUE, FALSE))
 		return NULL;
 
-	storage = client_find_storage(cmd, &name);
-	if (storage == NULL)
+	ns = client_find_namespace(cmd, &name);
+	if (ns == NULL)
 		return NULL;
 
 	if (cmd->client->mailbox != NULL &&
-	    mailbox_equals(cmd->client->mailbox, storage, name))
+	    mailbox_equals(cmd->client->mailbox, ns, name))
 		return cmd->client->mailbox;
 
-	box = mailbox_open(&storage, name, NULL, MAILBOX_OPEN_SAVEONLY |
+	box = mailbox_open(ns->list, name, NULL, MAILBOX_OPEN_SAVEONLY |
 			   MAILBOX_OPEN_KEEP_RECENT);
 	if (box == NULL) {
-		client_send_storage_error(cmd, storage);
+		client_send_list_error(cmd, ns->list);
 		return NULL;
 	}
 	if (cmd->client->enabled_features != 0)

--- a/src/imap/cmd-copy.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/cmd-copy.c	Tue Jun 02 22:30:28 2009 -0400
@@ -93,7 +93,8 @@
 bool cmd_copy(struct client_command_context *cmd)
 {
 	struct client *client = cmd->client;
-	struct mail_storage *storage;
+	struct mail_namespace *dest_ns;
+	struct mail_storage *dest_storage;
 	struct mailbox *destbox;
 	struct mailbox_transaction_context *t;
         struct mail_search_args *search_args;
@@ -119,18 +120,18 @@
 	if (ret <= 0)
 		return ret < 0;
 
-	storage = client_find_storage(cmd, &mailbox);
-	if (storage == NULL)
+	dest_ns = client_find_namespace(cmd, &mailbox);
+	if (dest_ns == NULL)
 		return TRUE;
 
-	if (mailbox_equals(client->mailbox, storage, mailbox))
+	if (mailbox_equals(client->mailbox, dest_ns, mailbox))
 		destbox = client->mailbox;
 	else {
-		destbox = mailbox_open(&storage, mailbox, NULL,
+		destbox = mailbox_open(dest_ns->list, mailbox, NULL,
 				       MAILBOX_OPEN_SAVEONLY |
 				       MAILBOX_OPEN_KEEP_RECENT);
 		if (destbox == NULL) {
-			client_send_storage_error(cmd, storage);
+			client_send_list_error(cmd, dest_ns->list);
 			return TRUE;
 		}
 		if (client->enabled_features != 0)
@@ -168,6 +169,7 @@
 		}
 	}
 
+	dest_storage = mailbox_get_storage(destbox);
 	if (destbox != client->mailbox) {
 		sync_flags |= MAILBOX_SYNC_FLAG_FAST;
 		imap_flags |= IMAP_SYNC_FLAG_SAFE;
@@ -182,7 +184,7 @@
 			"NO ["IMAP_RESP_CODE_EXPUNGEISSUED"] "
 			"Some of the requested messages no longer exist.");
 	} else {
-		client_send_storage_error(cmd, storage);
+		client_send_storage_error(cmd, dest_storage);
 		return TRUE;
 	}
 }

--- a/src/imap/cmd-create.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/cmd-create.c	Tue Jun 02 22:30:28 2009 -0400
@@ -7,6 +7,7 @@
 bool cmd_create(struct client_command_context *cmd)
 {
 	struct mail_namespace *ns;
+	struct mail_storage *storage;
 	const char *mailbox, *full_mailbox;
 	bool directory;
 	size_t len;
@@ -38,8 +39,9 @@
 	if (!client_verify_mailbox_name(cmd, full_mailbox, FALSE, TRUE))
 		return TRUE;
 
-	if (mail_storage_mailbox_create(ns->storage, mailbox, directory) < 0)
-		client_send_storage_error(cmd, ns->storage);
+	storage = mail_namespace_get_default_storage(ns);
+	if (mail_storage_mailbox_create(storage, ns, mailbox, directory) < 0)
+		client_send_storage_error(cmd, storage);
 	else
 		client_send_tagline(cmd, "OK Create completed.");
 	return TRUE;

--- a/src/imap/cmd-delete.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/cmd-delete.c	Tue Jun 02 22:30:28 2009 -0400
@@ -6,8 +6,8 @@
 bool cmd_delete(struct client_command_context *cmd)
 {
 	struct client *client = cmd->client;
+	struct mail_namespace *ns;
 	struct mail_storage *storage;
-	struct mailbox_list *list;
 	struct mailbox *mailbox;
 	const char *name;
 
@@ -21,8 +21,13 @@
 		return TRUE;
 	}
 
+	ns = client_find_namespace(cmd, &name);
+	if (ns == NULL)
+		return TRUE;
+
 	mailbox = client->mailbox;
-	if (mailbox != NULL && strcmp(mailbox_get_name(mailbox), name) == 0) {
+	if (mailbox != NULL && mailbox_get_namespace(mailbox) == ns &&
+	    strcmp(mailbox_get_name(mailbox), name) == 0) {
 		/* deleting selected mailbox. close it first */
 		client_search_updates_free(client);
 		storage = mailbox_get_storage(mailbox);
@@ -30,22 +35,17 @@
 
 		if (mailbox_close(&mailbox) < 0)
 			client_send_untagged_storage_error(client, storage);
-	} else {
-		storage = client_find_storage(cmd, &name);
-		if (storage == NULL)
-			return TRUE;
 	}
 
 	if ((client->workarounds & WORKAROUND_TB_EXTRA_MAILBOX_SEP) != 0 &&
 	    *name != '\0' &&
-	    name[strlen(name)-1] == mail_storage_get_hierarchy_sep(storage)) {
+	    name[strlen(name)-1] == mailbox_list_get_hierarchy_sep(ns->list)) {
 		/* drop the extra trailing hierarchy separator */
 		name = t_strndup(name, strlen(name)-1);
 	}
 
-	list = mail_storage_get_list(storage);
-	if (mailbox_list_delete_mailbox(list, name) < 0)
-		client_send_list_error(cmd, list);
+	if (mailbox_list_delete_mailbox(ns->list, name) < 0)
+		client_send_list_error(cmd, ns->list);
 	else {
 		client_send_tagline(cmd, "OK Delete completed.");
 	}

--- a/src/imap/cmd-list.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/cmd-list.c	Tue Jun 02 22:30:28 2009 -0400
@@ -310,16 +310,16 @@
 static void list_send_status(struct cmd_list_context *ctx, const char *name)
 {
 	struct mailbox_status status;
-	const char *storage_name;
+	const char *storage_name, *error;
 	size_t prefix_len = strlen(ctx->ns->prefix);
 
 	storage_name = strncmp(name, ctx->ns->prefix, prefix_len) == 0 ?
 		name + prefix_len : name;
 
-	if (!imap_status_get(ctx->cmd->client, ctx->ns->storage, storage_name,
-			     ctx->status_items, &status)) {
-		client_send_untagged_storage_error(ctx->cmd->client,
-						   ctx->ns->storage);
+	if (imap_status_get(ctx->cmd->client, ctx->ns, storage_name,
+			    ctx->status_items, &status, &error) < 0) {
+		client_send_line(ctx->cmd->client,
+				 t_strconcat("* NO ", error, NULL));
 		return;
 	}
 
@@ -775,7 +775,7 @@
 		ns_sep = ns->sep;
 	} else {
 		ns_prefix = "";
-		ns_sep = mail_namespace_get_root_sep(client->user->namespaces);
+		ns_sep = mail_namespaces_get_root_sep(client->user->namespaces);
 	}
 
 	str = t_str_new(64);

--- a/src/imap/cmd-rename.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/cmd-rename.c	Tue Jun 02 22:30:28 2009 -0400
@@ -6,9 +6,7 @@
 
 bool cmd_rename(struct client_command_context *cmd)
 {
-	struct mail_storage *old_storage, *new_storage;
-	struct mailbox_list *old_list, *new_list;
-	struct mail_namespace *old_ns;
+	struct mail_namespace *old_ns, *new_ns;
 	const char *oldname, *newname;
 	unsigned int oldlen;
 
@@ -19,20 +17,18 @@
 	if (!client_verify_mailbox_name(cmd, newname, FALSE, TRUE))
 		return TRUE;
 
-	old_storage = client_find_storage(cmd, &oldname);
-	if (old_storage == NULL)
+	old_ns = client_find_namespace(cmd, &oldname);
+	if (old_ns == NULL)
 		return TRUE;
-	old_list = mail_storage_get_list(old_storage);
 
-	new_storage = client_find_storage(cmd, &newname);
-	if (new_storage == NULL)
+	new_ns = client_find_namespace(cmd, &newname);
+	if (new_ns == NULL)
 		return TRUE;
-	new_list = mail_storage_get_list(new_storage);
 
-	if (old_storage == new_storage) {
+	if (old_ns == new_ns) {
 		/* disallow box -> box/child, because it may break clients and
 		   there's really no point in doing it anyway. */
-		old_ns = mailbox_list_get_namespace(old_list);
+		old_ns = mailbox_list_get_namespace(old_ns->list);
 		oldlen = strlen(oldname);
 		if (strncmp(oldname, newname, oldlen) == 0 &&
 		    newname[oldlen] == old_ns->real_sep) {
@@ -42,9 +38,9 @@
 		}
 	}
 
-	if (mailbox_list_rename_mailbox(old_list, oldname,
-					new_list, newname, TRUE) < 0)
-		client_send_list_error(cmd, old_list);
+	if (mailbox_list_rename_mailbox(old_ns->list, oldname,
+					new_ns->list, newname, TRUE) < 0)
+		client_send_list_error(cmd, old_ns->list);
 	else
 		client_send_tagline(cmd, "OK Rename completed.");
 	return TRUE;

--- a/src/imap/cmd-select.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/cmd-select.c	Tue Jun 02 22:30:28 2009 -0400
@@ -12,7 +12,7 @@
 
 struct imap_select_context {
 	struct client_command_context *cmd;
-	struct mail_storage *storage;
+	struct mail_namespace *ns;
 	struct mailbox *box;
 
 	struct imap_fetch_context *fetch_ctx;
@@ -188,7 +188,6 @@
 	if (ret < 0) {
 		if (ctx->box != NULL)
 			mailbox_close(&ctx->box);
-		client_send_storage_error(ctx->cmd, ctx->storage);
 		ctx->cmd->client->mailbox = NULL;
 	} else {
 		client_send_tagline(ctx->cmd, mailbox_is_readonly(ctx->box) ?
@@ -209,6 +208,10 @@
 	}
 
 	ret = imap_fetch_deinit(ctx->fetch_ctx);
+	if (ret < 0) {
+		client_send_storage_error(ctx->cmd,
+					  mailbox_get_storage(ctx->box));
+	}
 	cmd_select_finish(ctx, ret);
 	return TRUE;
 }
@@ -264,9 +267,11 @@
 
 	if (readonly)
 		open_flags |= MAILBOX_OPEN_READONLY | MAILBOX_OPEN_KEEP_RECENT;
-	ctx->box = mailbox_open(&ctx->storage, mailbox, NULL, open_flags);
-	if (ctx->box == NULL)
+	ctx->box = mailbox_open(ctx->ns->list, mailbox, NULL, open_flags);
+	if (ctx->box == NULL) {
+		client_send_list_error(ctx->cmd, ctx->ns->list);
 		return -1;
+	}
 
 	if (client->enabled_features != 0)
 		mailbox_enable(ctx->box, client->enabled_features);
@@ -274,8 +279,11 @@
 			 STATUS_MESSAGES | STATUS_RECENT |
 			 STATUS_FIRST_UNSEEN_SEQ | STATUS_UIDVALIDITY |
 			 STATUS_UIDNEXT | STATUS_KEYWORDS |
-			 STATUS_HIGHESTMODSEQ, &status) < 0)
+			 STATUS_HIGHESTMODSEQ, &status) < 0) {
+		client_send_storage_error(ctx->cmd,
+					  mailbox_get_storage(ctx->box));
 		return -1;
+	}
 
 	client->mailbox = ctx->box;
 	client->select_counter++;
@@ -317,8 +325,11 @@
 	}
 
 	if (ctx->qresync_uid_validity == status.uidvalidity) {
-		if (select_qresync(ctx) < 0)
+		if (select_qresync(ctx) < 0) {
+			client_send_storage_error(ctx->cmd,
+				mailbox_get_storage(ctx->box));
 			return -1;
+		}
 	}
 	return 0;
 }
@@ -344,8 +355,8 @@
 
 	ctx = p_new(cmd->pool, struct imap_select_context, 1);
 	ctx->cmd = cmd;
-	ctx->storage = client_find_storage(cmd, &mailbox);
-	if (ctx->storage == NULL)
+	ctx->ns = client_find_namespace(cmd, &mailbox);
+	if (ctx->ns == NULL)
 		return TRUE;
 
 	if (args[1].type == IMAP_ARG_LIST) {

--- a/src/imap/cmd-status.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/cmd-status.c	Tue Jun 02 22:30:28 2009 -0400
@@ -12,8 +12,8 @@
 	const struct imap_arg *args;
 	struct mailbox_status status;
 	enum mailbox_status_items items;
-	struct mail_storage *storage;
-	const char *mailbox, *real_mailbox;
+	struct mail_namespace *ns;
+	const char *mailbox, *real_mailbox, *error;
 	bool selected_mailbox;
 
 	/* <mailbox> <status items> */
@@ -31,14 +31,15 @@
 				    &items) < 0)
 		return TRUE;
 
-	storage = client_find_storage(cmd, &real_mailbox);
-	if (storage == NULL)
+	ns = client_find_namespace(cmd, &real_mailbox);
+	if (ns == NULL)
 		return TRUE;
 
 	selected_mailbox = client->mailbox != NULL &&
-		mailbox_equals(client->mailbox, storage, real_mailbox);
-	if (!imap_status_get(client, storage, real_mailbox, items, &status)) {
-		client_send_storage_error(cmd, storage);
+		mailbox_equals(client->mailbox, ns, real_mailbox);
+	if (imap_status_get(client, ns, real_mailbox, items,
+			    &status, &error) < 0) {
+		client_send_tagline(cmd, error);
 		return TRUE;
 	}
 

--- a/src/imap/cmd-subscribe.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/cmd-subscribe.c	Tue Jun 02 22:30:28 2009 -0400
@@ -29,7 +29,6 @@
 bool cmd_subscribe_full(struct client_command_context *cmd, bool subscribe)
 {
 	struct mail_namespace *ns, *real_ns;
-	struct mail_storage *storage;
 	const char *mailbox, *verify_name, *real_name;
 
 	/* <mailbox> */
@@ -38,8 +37,8 @@
 	verify_name = mailbox;
 
 	real_name = mailbox;
-	storage = client_find_storage(cmd, &real_name);
-	if (storage == NULL)
+	real_ns = client_find_namespace(cmd, &real_name);
+	if (real_ns == NULL)
 		return TRUE;
 
 	/* now find a namespace where the subscription can be added to */
@@ -50,7 +49,6 @@
 		return TRUE;
 	}
 
-	real_ns = mail_storage_get_namespace(storage);
 	if (ns != real_ns) {
 		/* subscription is being written to a different namespace
 		   than where the mailbox exists. */
@@ -62,7 +60,7 @@
 
 	if ((cmd->client->workarounds & WORKAROUND_TB_EXTRA_MAILBOX_SEP) != 0 &&
 	    *mailbox != '\0' && mailbox[strlen(mailbox)-1] ==
-	    mail_storage_get_hierarchy_sep(ns->storage)) {
+	    mailbox_list_get_hierarchy_sep(ns->list)) {
 		/* verify the validity without the trailing '/' */
 		verify_name = t_strndup(verify_name, strlen(verify_name)-1);
 	}

--- a/src/imap/imap-client.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/imap-client.c	Tue Jun 02 22:30:28 2009 -0400
@@ -34,7 +34,6 @@
 			     const struct imap_settings *set)
 {
 	struct client *client;
-	struct mail_namespace *ns;
 	const char *ident;
 
 	/* always use nonblocking I/O */
@@ -60,10 +59,8 @@
 		pool_alloconly_create(MEMPOOL_GROWING"client command", 1024*12);
 	client->user = user;
 
-	for (ns = user->namespaces; ns != NULL; ns = ns->next) {
-		mail_storage_set_callbacks(ns->storage,
-					   &mail_storage_callbacks, client);
-	}
+	mail_namespaces_set_storage_callbacks(user->namespaces,
+					      &mail_storage_callbacks, client);
 
 	client->capability_string =
 		str_new(default_pool, sizeof(CAPABILITY_STRING)+32);

--- a/src/imap/imap-commands-util.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/imap-commands-util.c	Tue Jun 02 22:30:28 2009 -0400
@@ -32,21 +32,11 @@
 	return NULL;
 }
 
-struct mail_storage *
-client_find_storage(struct client_command_context *cmd, const char **mailbox)
-{
-	struct mail_namespace *ns;
-
-	ns = client_find_namespace(cmd, mailbox);
-	return ns == NULL ? NULL : ns->storage;
-}
-
 bool client_verify_mailbox_name(struct client_command_context *cmd,
 				const char *mailbox,
 				bool should_exist, bool should_not_exist)
 {
 	struct mail_namespace *ns;
-	struct mailbox_list *list;
 	enum mailbox_name_status mailbox_status;
 	const char *orig_mailbox, *p;
 
@@ -90,10 +80,9 @@
 	}
 
 	/* check what our storage thinks of it */
-	list = mail_storage_get_list(ns->storage);
-	if (mailbox_list_get_mailbox_name_status(list, mailbox,
+	if (mailbox_list_get_mailbox_name_status(ns->list, mailbox,
 						 &mailbox_status) < 0) {
-		client_send_list_error(cmd, list);
+		client_send_list_error(cmd, ns->list);
 		return FALSE;
 	}
 
@@ -144,8 +133,8 @@
 	}
 }
 
-static const char *
-get_error_string(const char *error_string, enum mail_error error)
+const char *
+imap_get_error_string(const char *error_string, enum mail_error error)
 {
 	const char *resp_code = NULL;
 
@@ -191,7 +180,7 @@
 	enum mail_error error;
 
 	error_string = mailbox_list_get_last_error(list, &error);
-	client_send_tagline(cmd, get_error_string(error_string, error));
+	client_send_tagline(cmd, imap_get_error_string(error_string, error));
 }
 
 void client_send_storage_error(struct client_command_context *cmd,
@@ -209,7 +198,7 @@
 	}
 
 	error_string = mail_storage_get_last_error(storage, &error);
-	client_send_tagline(cmd, get_error_string(error_string, error));
+	client_send_tagline(cmd, imap_get_error_string(error_string, error));
 }
 
 void client_send_untagged_storage_error(struct client *client,
@@ -363,12 +352,12 @@
 }
 
 bool mailbox_equals(const struct mailbox *box1,
-		    const struct mail_storage *storage2, const char *name2)
+		    const struct mail_namespace *ns2, const char *name2)
 {
-	struct mail_storage *storage1 = mailbox_get_storage(box1);
+	struct mail_namespace *ns1 = mailbox_get_namespace(box1);
 	const char *name1;
 
-	if (storage1 != storage2)
+	if (ns1 != ns2)
 		return FALSE;
 
         name1 = mailbox_get_name(box1);

--- a/src/imap/imap-commands-util.h	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/imap-commands-util.h	Tue Jun 02 22:30:28 2009 -0400
@@ -13,10 +13,6 @@
    sends "Unknown namespace" error message to client. */
 struct mail_namespace *
 client_find_namespace(struct client_command_context *cmd, const char **mailbox);
-/* Finds mail storage for given mailbox from namespaces. If not found,
-   sends "Unknown namespace" error message to client. */
-struct mail_storage *
-client_find_storage(struct client_command_context *cmd, const char **mailbox);
 
 /* If should_exist is TRUE, this function returns TRUE if the mailbox
    exists. If it doesn't exist but would be a valid mailbox name, the
@@ -32,6 +28,9 @@
    error message to client. */
 bool client_verify_open_mailbox(struct client_command_context *cmd);
 
+const char *
+imap_get_error_string(const char *error_string, enum mail_error error);
+
 /* Send last mailbox list error message to client. */
 void client_send_list_error(struct client_command_context *cmd,
 			    struct mailbox_list *list);
@@ -62,7 +61,7 @@
 			 const ARRAY_TYPE(keyword_indexes) *src);
 
 bool mailbox_equals(const struct mailbox *box1,
-		    const struct mail_storage *storage2,
+		    const struct mail_namespace *ns2,
 		    const char *name2) ATTR_PURE;
 
 void msgset_generator_init(struct msgset_generator_context *ctx, string_t *str);

--- a/src/imap/imap-commands.h	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/imap-commands.h	Tue Jun 02 22:30:28 2009 -0400
@@ -4,6 +4,7 @@
 struct client_command_context;
 
 #include "mail-storage.h"
+#include "mail-namespace.h"
 #include "imap-parser.h"
 #include "imap-sync.h"
 #include "imap-commands-util.h"

--- a/src/imap/imap-status.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/imap-status.c	Tue Jun 02 22:30:28 2009 -0400
@@ -46,25 +46,29 @@
 	return 0;
 }
 
-bool imap_status_get(struct client *client, struct mail_storage *storage,
-		     const char *mailbox, enum mailbox_status_items items,
-		     struct mailbox_status *status_r)
+int imap_status_get(struct client *client, struct mail_namespace *ns,
+		    const char *mailbox, enum mailbox_status_items items,
+		    struct mailbox_status *status_r, const char **error_r)
 {
 	struct mailbox *box;
+	enum mail_error error;
 	int ret;
 
 	if (client->mailbox != NULL &&
-	    mailbox_equals(client->mailbox, storage, mailbox)) {
+	    mailbox_equals(client->mailbox, ns, mailbox)) {
 		/* this mailbox is selected */
 		mailbox_get_status(client->mailbox, items, status_r);
 		return TRUE;
 	}
 
 	/* open the mailbox */
-	box = mailbox_open(&storage, mailbox, NULL, MAILBOX_OPEN_FAST |
+	box = mailbox_open(ns->list, mailbox, NULL, MAILBOX_OPEN_FAST |
 			   MAILBOX_OPEN_READONLY | MAILBOX_OPEN_KEEP_RECENT);
-	if (box == NULL)
-		return FALSE;
+	if (box == NULL) {
+		*error_r = mailbox_list_get_last_error(ns->list, &error);
+		*error_r = imap_get_error_string(*error_r, error);
+		return -1;
+	}
 
 	if ((items & STATUS_HIGHESTMODSEQ) != 0)
 		client_enable(client, MAILBOX_FEATURE_CONDSTORE);
@@ -72,8 +76,13 @@
 		mailbox_enable(box, client->enabled_features);
 
 	ret = mailbox_sync(box, 0, items, status_r);
+	if (ret < 0) {
+		struct mail_storage *storage = mailbox_get_storage(box);
+		*error_r = mail_storage_get_last_error(storage, &error);
+		*error_r = imap_get_error_string(*error_r, error);
+	}
 	mailbox_close(&box);
-	return ret == 0;
+	return ret;
 }
 
 void imap_status_send(struct client *client, const char *mailbox,

--- a/src/imap/imap-status.h	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/imap/imap-status.h	Tue Jun 02 22:30:28 2009 -0400
@@ -4,9 +4,9 @@
 int imap_status_parse_items(struct client_command_context *cmd,
 			    const struct imap_arg *args,
 			    enum mailbox_status_items *items_r);
-bool imap_status_get(struct client *client, struct mail_storage *storage,
-		     const char *mailbox, enum mailbox_status_items items,
-		     struct mailbox_status *status_r);
+int imap_status_get(struct client *client, struct mail_namespace *ns,
+		    const char *mailbox, enum mailbox_status_items items,
+		    struct mailbox_status *status_r, const char **error_r);
 void imap_status_send(struct client *client, const char *mailbox,
 		      enum mailbox_status_items items,
 		      const struct mailbox_status *status);

--- a/src/lda/main.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lda/main.c	Tue Jun 02 22:30:28 2009 -0400
@@ -416,21 +416,21 @@
 		i_fatal("Couldn't create internal raw storage: %s", errstr);
 	if (path == NULL) {
 		input = create_raw_stream(&ctx, 0, &mtime);
-		box = mailbox_open(&raw_ns->storage, "Dovecot Delivery Mail",
+		box = mailbox_open(raw_ns->list, "Dovecot Delivery Mail",
 				   input, MAILBOX_OPEN_NO_INDEX_FILES);
 		i_stream_unref(&input);
 	} else {
 		mtime = (time_t)-1;
-		box = mailbox_open(&raw_ns->storage, path, NULL,
+		box = mailbox_open(raw_ns->list, path, NULL,
 				   MAILBOX_OPEN_NO_INDEX_FILES);
 	}
 	if (box == NULL) {
 		i_fatal("Can't open delivery mail as raw: %s",
-			mail_storage_get_last_error(raw_ns->storage, &error));
+			mailbox_list_get_last_error(raw_ns->list, &error));
 	}
 	if (mailbox_sync(box, 0, 0, NULL) < 0) {
 		i_fatal("Can't sync delivery mail: %s",
-			mail_storage_get_last_error(raw_ns->storage, &error));
+			mail_storage_get_last_error(box->storage, &error));
 	}
 	raw_box = (struct raw_mailbox *)box;
 	raw_box->envelope_sender = ctx.src_envelope_sender != NULL ?

--- a/src/lib-lda/mail-deliver.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-lda/mail-deliver.c	Tue Jun 02 22:30:28 2009 -0400
@@ -72,28 +72,28 @@
 
 static struct mailbox *
 mailbox_open_or_create_synced(struct mail_deliver_context *ctx, 
-			      struct mail_storage **storage_r,
-			      const char *name)
+			      const char *name, struct mail_namespace **ns_r,
+			      const char **error_r)
 {
 	struct mail_namespace *ns;
+	struct mail_storage *storage;
 	struct mailbox *box;
 	enum mail_error error;
 	enum mailbox_open_flags open_flags =
 		MAILBOX_OPEN_KEEP_RECENT | MAILBOX_OPEN_SAVEONLY |
 		MAILBOX_OPEN_POST_SESSION;
 
+	*error_r = NULL;
+
 	if (strcasecmp(name, "INBOX") == 0) {
 		/* deliveries to INBOX must always succeed,
 		   regardless of ACLs */
 		open_flags |= MAILBOX_OPEN_IGNORE_ACLS;
 	}
 
-	ns = mail_namespace_find(ctx->dest_user->namespaces, &name);
-	if (ns == NULL) {
-		*storage_r = NULL;
+	*ns_r = ns = mail_namespace_find(ctx->dest_user->namespaces, &name);
+	if (*ns_r == NULL)
 		return NULL;
-	}
-	*storage_r = ns->storage;
 
 	if (*name == '\0') {
 		/* delivering to a namespace prefix means we actually want to
@@ -101,29 +101,36 @@
 		return NULL;
 	}
 
-	box = mailbox_open(storage_r, name, NULL, open_flags);
-	if (box != NULL || !ctx->set->lda_mailbox_autocreate)
+	box = mailbox_open(ns->list, name, NULL, open_flags);
+	if (box != NULL)
 		return box;
 
-	(void)mail_storage_get_last_error(*storage_r, &error);
-	if (error != MAIL_ERROR_NOTFOUND)
+	*error_r = mailbox_list_get_last_error(ns->list, &error);
+	if (!ctx->set->lda_mailbox_autocreate || error != MAIL_ERROR_NOTFOUND)
 		return NULL;
 
 	/* try creating it. */
-	if (mail_storage_mailbox_create(*storage_r, name, FALSE) < 0)
+	storage = mail_namespace_get_default_storage(ns);
+	if (mail_storage_mailbox_create(storage, ns, name, FALSE) < 0) {
+		*error_r = mail_storage_get_last_error(storage, &error);
 		return NULL;
+	}
 	if (ctx->set->lda_mailbox_autosubscribe) {
 		/* (try to) subscribe to it */
 		(void)mailbox_list_set_subscribed(ns->list, name, TRUE);
 	}
 
 	/* and try opening again */
-	box = mailbox_open(storage_r, name, NULL, open_flags);
-	if (box == NULL)
+	box = mailbox_open(ns->list, name, NULL, open_flags);
+	if (box == NULL) {
+		*error_r = mailbox_list_get_last_error(ns->list, &error);
 		return NULL;
+	}
 
 	if (mailbox_sync(box, 0, 0, NULL) < 0) {
 		mailbox_close(&box);
+		*error_r = mail_storage_get_last_error(mailbox_get_storage(box),
+						       &error);
 		return NULL;
 	}
 	return box;
@@ -140,7 +147,7 @@
 	struct mail_save_context *save_ctx;
 	struct mail_keywords *kw;
 	enum mail_error error;
-	const char *mailbox_name;
+	const char *mailbox_name, *errstr;
 	uint32_t uid_validity, uid1 = 0, uid2 = 0;
 	bool default_save;
 	int ret = 0;
@@ -150,23 +157,23 @@
 		ctx->tried_default_save = TRUE;
 
 	mailbox_name = str_sanitize(mailbox, 80);
-	box = mailbox_open_or_create_synced(ctx, storage_r, mailbox);
+	box = mailbox_open_or_create_synced(ctx, mailbox, &ns, &errstr);
 	if (box == NULL) {
-		if (*storage_r == NULL) {
+		if (ns == NULL) {
 			mail_deliver_log(ctx,
 					 "save failed to %s: Unknown namespace",
 					 mailbox_name);
 			return -1;
 		}
-		ns = mail_storage_get_namespace(*storage_r);
 		if (default_save && strcmp(ns->prefix, mailbox) == 0) {
 			/* silently store to the INBOX instead */
 			return -1;
 		}
-		mail_deliver_log(ctx, "save failed to %s: %s", mailbox_name,
-				 mail_storage_get_last_error(*storage_r, &error));
+		mail_deliver_log(ctx, "save failed to %s: %s",
+				 mailbox_name, errstr);
 		return -1;
 	}
+	*storage_r = mailbox_get_storage(box);
 
 	trans_flags = MAILBOX_TRANSACTION_FLAG_EXTERNAL;
 	if (ctx->save_dest_mail)
@@ -205,7 +212,7 @@
 		}
 	} else {
 		mail_deliver_log(ctx, "save failed to %s: %s", mailbox_name,
-				 mail_storage_get_last_error(*storage_r, &error));
+			mail_storage_get_last_error(*storage_r, &error));
 	}
 
 	if (ctx->dest_mail == NULL)

--- a/src/lib-storage/index/cydir/cydir-mail.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/cydir/cydir-mail.c	Tue Jun 02 22:30:28 2009 -0400
@@ -13,7 +13,7 @@
 {
 	const char *dir;
 
-	dir = mailbox_list_get_path(mail->box->storage->list, mail->box->name,
+	dir = mailbox_list_get_path(mail->box->list, mail->box->name,
 				    MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	return t_strdup_printf("%s/%u.", dir, mail->uid);
 }

--- a/src/lib-storage/index/cydir/cydir-save.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/cydir/cydir-save.c	Tue Jun 02 22:30:28 2009 -0400
@@ -49,7 +49,7 @@
 {
 	const char *dir;
 
-	dir = mailbox_list_get_path(ctx->mbox->storage->storage.list,
+	dir = mailbox_list_get_path(ctx->mbox->ibox.box.list,
 				    ctx->mbox->ibox.box.name,
 				    MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	return t_strdup_printf("%s/%s.%u", dir, ctx->tmp_basename, num);
@@ -253,7 +253,7 @@
 	*t->ictx.first_saved_uid = uid;
 	*t->ictx.last_saved_uid = next_uid - 1;
 
-	dir = mailbox_list_get_path(ctx->mbox->storage->storage.list,
+	dir = mailbox_list_get_path(ctx->mbox->ibox.box.list,
 				    ctx->mbox->ibox.box.name,
 				    MAILBOX_LIST_PATH_TYPE_MAILBOX);
 

--- a/src/lib-storage/index/cydir/cydir-storage.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/cydir/cydir-storage.c	Tue Jun 02 22:30:28 2009 -0400
@@ -13,51 +13,22 @@
 #include <dirent.h>
 #include <sys/stat.h>
 
-#define CREATE_MODE 0770 /* umask() should limit it more */
-
 #define CYDIR_LIST_CONTEXT(obj) \
 	MODULE_CONTEXT(obj, cydir_mailbox_list_module)
 
+struct cydir_mailbox_list {
+	union mailbox_list_module_context module_ctx;
+};
+
 extern struct mail_storage cydir_storage;
 extern struct mailbox cydir_mailbox;
 
 static MODULE_CONTEXT_DEFINE_INIT(cydir_mailbox_list_module,
 				  &mailbox_list_module_register);
 
-static int
-cydir_list_delete_mailbox(struct mailbox_list *list, const char *name);
-static int cydir_list_iter_is_mailbox(struct mailbox_list_iterate_context *ctx,
-				      const char *dir, const char *fname,
-				      const char *mailbox_name,
-				      enum mailbox_list_file_type type,
-				      enum mailbox_info_flags *flags);
-
-static int
-cydir_get_list_settings(struct mailbox_list_settings *list_set,
-			const char *data, struct mail_storage *storage,
-			const char **layout_r, const char **error_r)
-{
-	*layout_r = "fs";
+static void cydir_list_init(struct mailbox_list *list);
 
-	memset(list_set, 0, sizeof(*list_set));
-	list_set->subscription_fname = CYDIR_SUBSCRIPTION_FILE_NAME;
-	list_set->maildir_name = "";
-
-	if (data == NULL || *data == '\0' || *data == ':') {
-		/* we won't do any guessing for this format. */
-		if (storage->set->mail_debug)
-			i_info("cydir: mailbox location not given");
-		*error_r = "Root mail directory not given";
-		return -1;
-	}
-
-	if (storage->set->mail_debug)
-		i_info("cydir: data=%s", data);
-	return mailbox_list_settings_parse(data, list_set, storage->ns,
-					   layout_r, NULL, error_r);
-}
-
-static struct mail_storage *cydir_alloc(void)
+static struct mail_storage *cydir_storage_alloc(void)
 {
 	struct cydir_storage *storage;
 	pool_t pool;
@@ -66,73 +37,35 @@
 	storage = p_new(pool, struct cydir_storage, 1);
 	storage->storage = cydir_storage;
 	storage->storage.pool = pool;
-	storage->storage.storage_class = &cydir_storage;
-
 	return &storage->storage;
 }
 
-static int cydir_create(struct mail_storage *_storage, const char *data,
-			const char **error_r)
+static int
+cydir_storage_create(struct mail_storage *_storage ATTR_UNUSED,
+		     struct mail_namespace *ns,
+		     const char **error_r ATTR_UNUSED)
 {
-	struct cydir_storage *storage = (struct cydir_storage *)_storage;
-	struct mailbox_list_settings list_set;
-	struct stat st;
-	const char *layout;
-
-	if (cydir_get_list_settings(&list_set, data, _storage,
-				    &layout, error_r) < 0)
-		return -1;
-	list_set.mail_storage_flags = &_storage->flags;
-	list_set.lock_method = &_storage->lock_method;
-
-	if ((_storage->flags & MAIL_STORAGE_FLAG_NO_AUTOCREATE) != 0) {
-		if (stat(list_set.root_dir, &st) < 0) {
-			if (errno == ENOENT) {
-				*error_r = t_strdup_printf(
-					"Root mail directory doesn't exist: %s",
-					list_set.root_dir);
-			} else if (errno == EACCES) {
-				*error_r = mail_error_eacces_msg("stat",
-							list_set.root_dir);
-			} else {
-				*error_r = t_strdup_printf(
-							"stat(%s) failed: %m",
-							list_set.root_dir);
-			}
-			return -1;
-		}
-	} else if (mkdir_parents(list_set.root_dir,
-				 CREATE_MODE) == 0 || errno == EEXIST) {
-	} else if (errno == EACCES) {
-		*error_r = mail_error_create_eacces_msg("mkdir",
-							list_set.root_dir);
-		return -1;
-	} else {
-		*error_r = t_strdup_printf("mkdir(%s) failed: %m",
-					   list_set.root_dir);
-		return -1;
-	}
-
-	if (mailbox_list_alloc(layout, &_storage->list, error_r) < 0)
-		return -1;
-	storage->list_module_ctx.super = _storage->list->v;
-	_storage->list->v.iter_is_mailbox = cydir_list_iter_is_mailbox;
-	_storage->list->v.delete_mailbox = cydir_list_delete_mailbox;
-
-	MODULE_CONTEXT_SET_FULL(_storage->list, cydir_mailbox_list_module,
-				storage, &storage->list_module_ctx);
-
-	/* finish list init after we've overridden vfuncs */
-	mailbox_list_init(_storage->list, _storage->ns, &list_set, 0);
+	cydir_list_init(ns->list);
 	return 0;
 }
 
-static int create_cydir(struct mail_storage *storage, const char *path)
+static void
+cydir_storage_get_list_settings(const struct mail_namespace *ns ATTR_UNUSED,
+				struct mailbox_list_settings *set)
+{
+	if (set->layout == NULL)
+		set->layout = MAILBOX_LIST_NAME_FS;
+	if (set->subscription_fname == NULL)
+		set->subscription_fname = CYDIR_SUBSCRIPTION_FILE_NAME;
+}
+
+static int create_cydir(struct mail_storage *storage, struct mail_namespace *ns,
+			const char *path)
 {
 	mode_t mode;
 	gid_t gid;
 
-	mailbox_list_get_dir_permissions(storage->list, NULL, &mode, &gid);
+	mailbox_list_get_dir_permissions(ns->list, NULL, &mode, &gid);
 	if (mkdir_parents_chown(path, mode, (uid_t)-1, gid) < 0 &&
 	    errno != EEXIST) {
 		if (!mail_storage_set_error_from_errno(storage)) {
@@ -145,18 +78,17 @@
 }
 
 static struct mailbox *
-cydir_open(struct cydir_storage *storage, const char *name,
-	   enum mailbox_open_flags flags)
+cydir_open(struct mail_storage *storage, struct mailbox_list *list,
+	   const char *name, enum mailbox_open_flags flags)
 {
-	struct mail_storage *_storage = &storage->storage;
 	struct cydir_mailbox *mbox;
 	struct mail_index *index;
 	const char *path;
 	pool_t pool;
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
-	index = index_storage_alloc(_storage, name, flags, CYDIR_INDEX_PREFIX);
+	index = index_storage_alloc(list, name, flags, CYDIR_INDEX_PREFIX);
 	mail_index_set_fsync_types(index, MAIL_INDEX_SYNC_TYPE_APPEND |
 				   MAIL_INDEX_SYNC_TYPE_EXPUNGE);
 
@@ -164,11 +96,11 @@
 	mbox = p_new(pool, struct cydir_mailbox, 1);
 	mbox->ibox.box = cydir_mailbox;
 	mbox->ibox.box.pool = pool;
-	mbox->ibox.storage = &storage->storage;
+	mbox->ibox.box.storage = storage;
 	mbox->ibox.mail_vfuncs = &cydir_mail_vfuncs;
 	mbox->ibox.index = index;
 
-	mbox->storage = storage;
+	mbox->storage = (struct cydir_storage *)storage;
 	mbox->path = p_strdup(pool, path);
 
 	index_storage_mailbox_init(&mbox->ibox, name, flags, FALSE);
@@ -176,58 +108,61 @@
 }
 
 static struct mailbox *
-cydir_mailbox_open(struct mail_storage *_storage, const char *name,
-		   struct istream *input, enum mailbox_open_flags flags)
+cydir_mailbox_open(struct mail_storage *storage, struct mailbox_list *list,
+		   const char *name, struct istream *input,
+		   enum mailbox_open_flags flags)
 {
-	struct cydir_storage *storage = (struct cydir_storage *)_storage;
 	const char *path;
 	struct stat st;
 
 	if (input != NULL) {
-		mail_storage_set_critical(_storage,
+		mailbox_list_set_critical(list,
 			"cydir doesn't support streamed mailboxes");
 		return NULL;
 	}
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (stat(path, &st) == 0)
-		return cydir_open(storage, name, flags);
+		return cydir_open(storage, list, name, flags);
 	else if (errno == ENOENT) {
 		if (strcmp(name, "INBOX") == 0) {
 			/* INBOX always exists, create it */
-			if (create_cydir(_storage, path) < 0)
+			if (create_cydir(storage, list->ns, path) < 0) {
+				mailbox_list_set_error_from_storage(list,
+								    storage);
 				return NULL;
-			return cydir_open(storage, "INBOX", flags);
+			}
+			return cydir_open(storage, list, "INBOX", flags);
 		}
-		mail_storage_set_error(_storage, MAIL_ERROR_NOTFOUND,
+		mail_storage_set_error(storage, MAIL_ERROR_NOTFOUND,
 			T_MAIL_ERR_MAILBOX_NOT_FOUND(name));
 	} else if (errno == EACCES) {
-		mail_storage_set_critical(_storage, "%s",
+		mail_storage_set_critical(storage, "%s",
 			mail_error_eacces_msg("stat", path));
 	} else {
-		mail_storage_set_critical(_storage, "stat(%s) failed: %m",
+		mail_storage_set_critical(storage, "stat(%s) failed: %m",
 					  path);
 	}
 	return NULL;
 }
 
-static int cydir_mailbox_create(struct mail_storage *_storage,
-				const char *name,
-				bool directory ATTR_UNUSED)
+static int
+cydir_mailbox_create(struct mail_storage *storage, struct mailbox_list *list,
+		     const char *name, bool directory ATTR_UNUSED)
 {
 	const char *path;
 	struct stat st;
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (stat(path, &st) == 0) {
-		mail_storage_set_error(_storage, MAIL_ERROR_EXISTS,
+		mail_storage_set_error(storage, MAIL_ERROR_EXISTS,
 				       "Mailbox already exists");
 		return -1;
 	}
 
-	return create_cydir(_storage, path);
+	return create_cydir(storage, list->ns, path);
 }
 
 static int
@@ -302,7 +237,7 @@
 static int
 cydir_list_delete_mailbox(struct mailbox_list *list, const char *name)
 {
-	struct cydir_storage *storage = CYDIR_LIST_CONTEXT(list);
+	struct cydir_mailbox_list *mlist = CYDIR_LIST_CONTEXT(list);
 	struct stat st;
 	const char *src;
 
@@ -313,7 +248,7 @@
 	index_storage_destroy_unrefed();
 
 	/* delete the index and control directories */
-	if (storage->list_module_ctx.super.delete_mailbox(list, name) < 0)
+	if (mlist->module_ctx.super.delete_mailbox(list, name) < 0)
 		return -1;
 
 	/* check if the mailbox actually exists */
@@ -401,6 +336,19 @@
 	cydir_transaction_class_deinit();
 }
 
+static void cydir_list_init(struct mailbox_list *list)
+{
+	struct cydir_mailbox_list *mlist;
+
+	mlist = p_new(list->pool, struct cydir_mailbox_list, 1);
+	mlist->module_ctx.super = list->v;
+
+	list->v.iter_is_mailbox = cydir_list_iter_is_mailbox;
+	list->v.delete_mailbox = cydir_list_delete_mailbox;
+
+	MODULE_CONTEXT_SET(list, cydir_mailbox_list_module, mlist);
+}
+
 struct mail_storage cydir_storage = {
 	MEMBER(name) CYDIR_STORAGE_NAME,
 	MEMBER(mailbox_is_file) FALSE,
@@ -409,9 +357,10 @@
 		NULL,
 		cydir_class_init,
 		cydir_class_deinit,
-		cydir_alloc,
-		cydir_create,
+		cydir_storage_alloc,
+		cydir_storage_create,
 		index_storage_destroy,
+		cydir_storage_get_list_settings,
 		NULL,
 		cydir_mailbox_open,
 		cydir_mailbox_create,
@@ -422,6 +371,7 @@
 struct mailbox cydir_mailbox = {
 	MEMBER(name) NULL, 
 	MEMBER(storage) NULL, 
+	MEMBER(list) NULL,
 
 	{
 		index_storage_is_readonly,

--- a/src/lib-storage/index/cydir/cydir-sync.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/cydir/cydir-sync.c	Tue Jun 02 22:30:28 2009 -0400
@@ -21,8 +21,7 @@
 	string_t *path = str_new(default_pool, 256);
 	const char *dir;
 
-	dir = mailbox_list_get_path(mbox->storage->storage.list,
-				    mbox->ibox.box.name,
+	dir = mailbox_list_get_path(mbox->ibox.box.list, mbox->ibox.box.name,
 				    MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	str_append(path, dir);
 	str_append_c(path, '/');

--- a/src/lib-storage/index/dbox/dbox-map.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/dbox/dbox-map.c	Tue Jun 02 22:30:28 2009 -0400
@@ -69,13 +69,9 @@
 
 static int dbox_map_mkdir_storage(struct dbox_storage *storage)
 {
-	mode_t mode;
-	gid_t gid;
-
-	mailbox_list_get_dir_permissions(storage->storage.list, NULL,
-					 &mode, &gid);
-	if (mkdir_parents_chown(storage->storage_dir, mode,
-				(uid_t)-1, gid) < 0 && errno != EEXIST) {
+	if (mkdir_parents_chown(storage->storage_dir, storage->create_mode,
+				(uid_t)-1, storage->create_gid) < 0 &&
+	    errno != EEXIST) {
 		mail_storage_set_critical(&storage->storage,
 			"mkdir(%s) failed: %m", storage->storage_dir);
 		return -1;
@@ -101,7 +97,8 @@
 		if (dbox_map_mkdir_storage(map->storage) < 0)
 			return -1;
 	}
-	ret = mail_index_open(map->index, open_flags, storage->lock_method);
+	ret = mail_index_open(map->index, open_flags,
+			      storage->set->parsed_lock_method);
 	if (ret < 0) {
 		mail_storage_set_internal_error(storage);
 		mail_index_reset_error(map->index);

--- a/src/lib-storage/index/dbox/dbox-settings.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/dbox/dbox-settings.c	Tue Jun 02 22:30:28 2009 -0400
@@ -11,6 +11,9 @@
 #define DEF(type, name) \
 	{ type, #name, offsetof(struct dbox_settings, name), NULL }
 
+static bool dbox_settings_verify(void *_set, pool_t pool ATTR_UNUSED,
+				 const char **error_r);
+
 static struct setting_define dbox_setting_defines[] = {
 	DEF(SET_UINT, dbox_rotate_size),
 	DEF(SET_UINT, dbox_rotate_min_size),
@@ -38,9 +41,24 @@
 
 	MEMBER(parent_offset) (size_t)-1,
 	MEMBER(type_offset) (size_t)-1,
-	MEMBER(struct_size) sizeof(struct dbox_settings)
+	MEMBER(struct_size) sizeof(struct dbox_settings),
+	MEMBER(check_func) dbox_settings_verify
 };
 
+/* <settings checks> */
+static bool dbox_settings_verify(void *_set, pool_t pool ATTR_UNUSED,
+				 const char **error_r)
+{
+	const struct dbox_settings *set = _set;
+
+	if (set->dbox_max_open_files < 2) {
+		*error_r = "dbox_max_open_files must be at least 2";
+		return FALSE;
+	}
+	return TRUE;
+}
+/* </settings checks> */
+
 const struct setting_parser_info *dbox_get_setting_parser_info(void)
 {
 	return &dbox_setting_parser_info;

--- a/src/lib-storage/index/dbox/dbox-storage-rebuild.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/dbox/dbox-storage-rebuild.c	Tue Jun 02 22:30:28 2009 -0400
@@ -46,6 +46,7 @@
 	uint32_t prev_file_id;
 	uint32_t highest_seen_map_uid;
 
+	struct mailbox_list *default_list;
 	struct mail_index_sync_ctx *sync_ctx;
 	struct mail_index_view *sync_view;
 	struct mail_index_transaction *trans;
@@ -385,7 +386,8 @@
 }
 
 static int
-rebuild_mailbox(struct dbox_storage_rebuild_context *ctx, const char *name)
+rebuild_mailbox(struct dbox_storage_rebuild_context *ctx,
+		struct mail_namespace *ns, const char *name)
 {
 	struct mailbox *box;
 	struct dbox_mailbox *mbox;
@@ -396,12 +398,12 @@
 	enum mail_error error;
 	int ret;
 
-	box = dbox_mailbox_open(&ctx->storage->storage, name, NULL,
+	box = dbox_mailbox_open(&ctx->storage->storage, ns->list, name, NULL,
 				MAILBOX_OPEN_READONLY |
 				MAILBOX_OPEN_KEEP_RECENT |
 				MAILBOX_OPEN_IGNORE_ACLS);
 	if (box == NULL) {
-		mail_storage_get_last_error(&ctx->storage->storage, &error);
+		mailbox_list_get_last_error(ns->list, &error);
 		if (error == MAIL_ERROR_TEMP)
 			return -1;
 		/* non-temporary error, ignore */
@@ -433,19 +435,24 @@
 	return ret < 0 ? -1 : 0;
 }
 
-static int rebuild_mailboxes(struct dbox_storage_rebuild_context *ctx)
+static int rebuild_namespace_mailboxes(struct dbox_storage_rebuild_context *ctx,
+				       struct mail_namespace *ns)
 {
 	struct mailbox_list_iterate_context *iter;
 	const struct mailbox_info *info;
 	int ret = 0;
 
-	iter = mailbox_list_iter_init(ctx->storage->storage.list, "*",
+	if (ctx->default_list == NULL ||
+	    (ns->flags & NAMESPACE_FLAG_INBOX) != 0)
+		ctx->default_list = ns->list;
+
+	iter = mailbox_list_iter_init(ns->list, "*",
 				      MAILBOX_LIST_ITER_RETURN_NO_FLAGS);
 	while ((info = mailbox_list_iter_next(iter)) != NULL) {
 		if ((info->flags & (MAILBOX_NONEXISTENT |
 				    MAILBOX_NOSELECT)) == 0) {
 			T_BEGIN {
-				ret = rebuild_mailbox(ctx, info->name);
+				ret = rebuild_mailbox(ctx, ns, info->name);
 			} T_END;
 			if (ret < 0) {
 				ret = -1;
@@ -458,6 +465,28 @@
 	return ret;
 }
 
+static int rebuild_mailboxes(struct dbox_storage_rebuild_context *ctx)
+{
+	struct mail_user *user = ctx->storage->storage.user;
+	struct mail_namespace *ns;
+	const char *rebuild_dir, *ns_dir;
+
+	rebuild_dir = ctx->storage->storage_dir;
+	for (ns = user->namespaces; ns != NULL; ns = ns->next) {
+		if (strcmp(ns->storage->name, "dbox") != 0)
+			continue;
+
+		ns_dir = mailbox_list_get_path(ns->list, NULL,
+					       MAILBOX_LIST_PATH_TYPE_DIR);
+		if (strcmp(ns_dir, rebuild_dir) != 0)
+			continue;
+
+		if (rebuild_namespace_mailboxes(ctx, ns) < 0)
+			return -1;
+	}
+	return 0;
+}
+
 static int rebuild_msg_mailbox_commit(struct rebuild_msg_mailbox *msg)
 {
 	if (mail_index_sync_commit(&msg->sync_ctx) < 0)
@@ -511,7 +540,8 @@
 		strcmp(mailbox, ctx->prev_msg.box->name) == 0 ?
 		ctx->prev_msg.box : NULL;
 	while (box == NULL) {
-		box = dbox_mailbox_open(storage, mailbox, NULL,
+		box = dbox_mailbox_open(storage, ctx->default_list,
+					mailbox, NULL,
 					MAILBOX_OPEN_READONLY |
 					MAILBOX_OPEN_KEEP_RECENT |
 					MAILBOX_OPEN_IGNORE_ACLS);
@@ -526,8 +556,8 @@
 			/* mailbox doesn't exist currently? see if creating
 			   it helps. */
 			created = TRUE;
-			(void)mail_storage_mailbox_create(storage, mailbox,
-							  FALSE);
+			(void)mail_storage_mailbox_create(storage,
+				ctx->default_list->ns, mailbox, FALSE);
 		} else if (strcmp(mailbox, "INBOX") != 0) {
 			/* see if we can save to INBOX instead. */
 			mailbox = "INBOX";

--- a/src/lib-storage/index/dbox/dbox-storage.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/dbox/dbox-storage.c	Tue Jun 02 22:30:28 2009 -0400
@@ -25,69 +25,24 @@
 #include <dirent.h>
 #include <sys/stat.h>
 
-#define CREATE_MODE 0770 /* umask() should limit it more */
-
 #define DBOX_LIST_CONTEXT(obj) \
 	MODULE_CONTEXT(obj, dbox_mailbox_list_module)
 
+struct dbox_mailbox_list {
+	union mailbox_list_module_context module_ctx;
+	const struct dbox_settings *set;
+};
+
 extern struct mail_storage dbox_storage;
 extern struct mailbox dbox_mailbox;
 
 static MODULE_CONTEXT_DEFINE_INIT(dbox_mailbox_list_module,
 				  &mailbox_list_module_register);
 
-static int
-dbox_list_delete_mailbox(struct mailbox_list *list, const char *name);
-static int
-dbox_list_rename_mailbox(struct mailbox_list *oldlist, const char *oldname,
-			 struct mailbox_list *newlist, const char *newname,
-			 bool rename_children);
-static int
-dbox_list_rename_mailbox_pre(struct mailbox_list *oldlist,
-			     const char *oldname,
-			     struct mailbox_list *newlist,
-			     const char *newname);
-static int dbox_list_iter_is_mailbox(struct mailbox_list_iterate_context *ctx,
-				     const char *dir, const char *fname,
-				     const char *mailbox_name,
-				     enum mailbox_list_file_type type,
-				     enum mailbox_info_flags *flags);
-
-static int
-dbox_get_list_settings(struct mailbox_list_settings *list_set,
-		       const char *data, struct mail_storage *storage,
-		       const char **layout_r, const char **alt_dir_r,
-		       const char **error_r)
-{
-	*layout_r = "fs";
+static void dbox_list_init(struct mailbox_list *list,
+			   const struct dbox_settings *set);
 
-	memset(list_set, 0, sizeof(*list_set));
-	list_set->subscription_fname = DBOX_SUBSCRIPTION_FILE_NAME;
-	list_set->maildir_name = DBOX_MAILDIR_NAME;
-	list_set->mailbox_dir_name = DBOX_MAILBOX_DIR_NAME;
-
-	if (data == NULL || *data == '\0' || *data == ':') {
-		/* we won't do any guessing for this format. */
-		if (storage->set->mail_debug)
-			i_info("dbox: mailbox location not given");
-		*error_r = "Root mail directory not given";
-		return -1;
-	}
-
-	if (storage->set->mail_debug)
-		i_info("dbox: data=%s", data);
-	if (mailbox_list_settings_parse(data, list_set, storage->ns,
-					layout_r, alt_dir_r, error_r) < 0)
-		return -1;
-
-	if (*list_set->mailbox_dir_name == '\0') {
-		*error_r = "dbox: MAILBOXDIR must not be empty";
-		return -1;
-	}
-	return 0;
-}
-
-static struct mail_storage *dbox_alloc(void)
+static struct mail_storage *dbox_storage_alloc(void)
 {
 	struct dbox_storage *storage;
 	pool_t pool;
@@ -96,96 +51,42 @@
 	storage = p_new(pool, struct dbox_storage, 1);
 	storage->storage = dbox_storage;
 	storage->storage.pool = pool;
-	storage->storage.storage_class = &dbox_storage;
-
 	return &storage->storage;
 }
 
-static int dbox_create(struct mail_storage *_storage, const char *data,
-		       const char **error_r)
+static int
+dbox_storage_create(struct mail_storage *_storage, struct mail_namespace *ns,
+		    const char **error_r)
 {
 	struct dbox_storage *storage = (struct dbox_storage *)_storage;
-	struct mailbox_list_settings list_set;
-	struct stat st;
-	const char *layout, *alt_dir, *dir;
-
-	if (dbox_get_list_settings(&list_set, data, _storage,
-				   &layout, &alt_dir, error_r) < 0)
-		return -1;
-	list_set.mail_storage_flags = &_storage->flags;
-	list_set.lock_method = &_storage->lock_method;
+	const char *dir;
 
-	if ((_storage->flags & MAIL_STORAGE_FLAG_NO_AUTOCREATE) != 0) {
-		if (stat(list_set.root_dir, &st) < 0) {
-			if (errno == ENOENT) {
-				*error_r = t_strdup_printf(
-					"Root mail directory doesn't exist: %s",
-					list_set.root_dir);
-			} else if (errno == EACCES) {
-				*error_r = mail_error_eacces_msg("stat",
-							list_set.root_dir);
-			} else {
-				*error_r = t_strdup_printf(
-							"stat(%s) failed: %m",
-							list_set.root_dir);
-			}
-			return -1;
-		}
-	} else if (mkdir_parents(list_set.root_dir,
-				 CREATE_MODE) == 0 || errno == EEXIST) {
-	} else if (errno == EACCES) {
-		if (_storage->ns->type != NAMESPACE_SHARED) {
-			*error_r = mail_error_create_eacces_msg("mkdir",
-							list_set.root_dir);
-			return -1;
-		}
-		/* can't create a new user, but we don't want to fail
-		   the storage creation. */
-	} else {
-		*error_r = t_strdup_printf("mkdir(%s) failed: %m",
-					   list_set.root_dir);
+	storage->set = mail_storage_get_driver_settings(_storage);
+	i_assert(storage->set->dbox_max_open_files >= 2);
+
+	if (*ns->list->set.mailbox_dir_name == '\0') {
+		*error_r = "dbox: MAILBOXDIR must not be empty";
 		return -1;
 	}
 
-	storage->set = mail_storage_get_driver_settings(_storage);
-	if (storage->set->dbox_max_open_files <= 1) {
-		/* we store file offsets in a 32bit integer. */
-		*error_r = "dbox_max_open_files must be at least 2";
-		return -1;
-	}
+	dbox_list_init(ns->list, storage->set);
 
-	if (mailbox_list_alloc(layout, &_storage->list, error_r) < 0)
-		return -1;
-	storage->list_module_ctx.super = _storage->list->v;
-	storage->alt_dir = p_strdup(_storage->pool, alt_dir);
-	_storage->list->v.iter_is_mailbox = dbox_list_iter_is_mailbox;
-	_storage->list->v.delete_mailbox = dbox_list_delete_mailbox;
-	_storage->list->v.rename_mailbox = dbox_list_rename_mailbox;
-	_storage->list->v.rename_mailbox_pre = dbox_list_rename_mailbox_pre;
-
-	MODULE_CONTEXT_SET_FULL(_storage->list, dbox_mailbox_list_module,
-				storage, &storage->list_module_ctx);
-
-	/* finish list init after we've overridden vfuncs */
-	mailbox_list_init(_storage->list, _storage->ns, &list_set, 0);
-
-	dir = mailbox_list_get_path(storage->storage.list, NULL,
-				    MAILBOX_LIST_PATH_TYPE_DIR);
+	dir = mailbox_list_get_path(ns->list, NULL, MAILBOX_LIST_PATH_TYPE_DIR);
 	storage->storage_dir = p_strconcat(_storage->pool, dir,
 					   "/"DBOX_GLOBAL_DIR_NAME, NULL);
-	storage->alt_storage_dir = p_strconcat(_storage->pool, alt_dir,
+	storage->alt_storage_dir = p_strconcat(_storage->pool,
+					       ns->list->set.alt_dir,
 					       "/"DBOX_GLOBAL_DIR_NAME, NULL);
 	i_array_init(&storage->open_files,
 		     I_MIN(storage->set->dbox_max_open_files, 128));
 
 	storage->map = dbox_map_init(storage);
-	mailbox_list_get_permissions(storage->storage.list, NULL,
-				     &storage->create_mode,
+	mailbox_list_get_permissions(ns->list, NULL, &storage->create_mode,
 				     &storage->create_gid);
 	return 0;
 }
 
-static void dbox_destroy(struct mail_storage *_storage)
+static void dbox_storage_destroy(struct mail_storage *_storage)
 {
 	struct dbox_storage *storage = (struct dbox_storage *)_storage;
 
@@ -200,9 +101,24 @@
 	index_storage_destroy(_storage);
 }
 
+static void
+dbox_storage_get_list_settings(const struct mail_namespace *ns ATTR_UNUSED,
+			       struct mailbox_list_settings *set)
+{
+	if (set->layout == NULL)
+		set->layout = MAILBOX_LIST_NAME_FS;
+	if (set->subscription_fname == NULL)
+		set->subscription_fname = DBOX_SUBSCRIPTION_FILE_NAME;
+	if (set->maildir_name == NULL)
+		set->maildir_name = DBOX_MAILDIR_NAME;
+	if (set->mailbox_dir_name == NULL)
+		set->mailbox_dir_name = DBOX_MAILBOX_DIR_NAME;
+}
+
 static const char *
-dbox_get_alt_path(struct dbox_storage *storage, const char *path)
+dbox_get_alt_path(struct mailbox_list *list, const char *path)
 {
+#if 0 // FIXME
 	const char *root;
 	unsigned int len;
 
@@ -218,11 +134,13 @@
 		return NULL;
 	}
 	return t_strconcat(storage->alt_dir, path + len, NULL);
+#endif
+	return NULL;
 }
 
 static struct mailbox *
-dbox_open(struct dbox_storage *storage, const char *name,
-	  enum mailbox_open_flags flags)
+dbox_open(struct dbox_storage *storage, struct mailbox_list *list,
+	  const char *name, enum mailbox_open_flags flags)
 {
 	struct mail_storage *_storage = &storage->storage;
 	struct dbox_mailbox *mbox;
@@ -232,10 +150,10 @@
 	pool_t pool;
 	int ret;
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 
-	index = index_storage_alloc(_storage, name, flags, DBOX_INDEX_PREFIX);
+	index = index_storage_alloc(list, name, flags, DBOX_INDEX_PREFIX);
 	mail_index_set_fsync_types(index, MAIL_INDEX_SYNC_TYPE_APPEND |
 				   MAIL_INDEX_SYNC_TYPE_EXPUNGE);
 
@@ -243,13 +161,13 @@
 	mbox = p_new(pool, struct dbox_mailbox, 1);
 	mbox->ibox.box = dbox_mailbox;
 	mbox->ibox.box.pool = pool;
-	mbox->ibox.storage = &storage->storage;
+	mbox->ibox.box.storage = _storage;
 	mbox->ibox.mail_vfuncs = &dbox_mail_vfuncs;
 	mbox->ibox.index = index;
 	mbox->ibox.keep_index_backups = TRUE;
 	mbox->ibox.index_never_in_memory = TRUE;
 	mbox->path = p_strdup(pool, path);
-	mbox->alt_path = p_strdup(pool, dbox_get_alt_path(storage, path));
+	mbox->alt_path = p_strdup(pool, dbox_get_alt_path(list, path));
 	mbox->storage = storage;
 
 	mbox->dbox_ext_id =
@@ -271,11 +189,11 @@
 	return box;
 }
 
-uint32_t dbox_get_uidvalidity_next(struct mail_storage *storage)
+uint32_t dbox_get_uidvalidity_next(struct mailbox_list *list)
 {
 	const char *path;
 
-	path = mailbox_list_get_path(storage->list, NULL,
+	path = mailbox_list_get_path(list, NULL,
 				     MAILBOX_LIST_PATH_TYPE_CONTROL);
 	path = t_strconcat(path, "/"DBOX_UIDVALIDITY_FILE_NAME, NULL);
 	return mailbox_uidvalidity_next(path);
@@ -296,7 +214,7 @@
 				     &hdr, sizeof(hdr));
 
 	/* set uidvalidity */
-	uid_validity = dbox_get_uidvalidity_next(&mbox->storage->storage);
+	uid_validity = dbox_get_uidvalidity_next(box->list);
 	mail_index_update_header(trans,
 		offsetof(struct mail_index_header, uid_validity),
 		&uid_validity, sizeof(uid_validity), TRUE);
@@ -304,19 +222,19 @@
 	(void)mail_index_transaction_commit(&trans);
 }
 
-static int create_dbox(struct mail_storage *_storage, const char *path,
-		       const char *name, bool directory)
+static int create_dbox(struct mail_storage *_storage, struct mailbox_list *list,
+		       const char *path, const char *name, bool directory)
 {
 	struct dbox_storage *storage = (struct dbox_storage *)_storage;
 	struct mailbox *box;
 	mode_t mode;
 	gid_t gid;
 
-	mailbox_list_get_dir_permissions(_storage->list, NULL, &mode, &gid);
+	mailbox_list_get_dir_permissions(list, NULL, &mode, &gid);
 	if (mkdir_parents_chown(path, mode, (uid_t)-1, gid) == 0) {
 		if (!directory) {
 			/* create indexes immediately with the dbox header */
-			box = dbox_open(storage, name,
+			box = dbox_open(storage, list, name,
 					MAILBOX_OPEN_KEEP_RECENT);
 			if (box == NULL)
 				return -1;
@@ -335,7 +253,7 @@
 }
 
 static bool
-dbox_cleanup_if_exists(struct mail_storage *storage, const char *path)
+dbox_cleanup_if_exists(struct mailbox_list *list, const char *path)
 {
 	struct stat st;
 
@@ -349,7 +267,7 @@
 	} else if (st.st_atime < ioloop_time - DBOX_TMP_SCAN_SECS) {
 		/* time to scan */
 		const char *prefix =
-			mailbox_list_get_global_temp_prefix(storage->list);
+			mailbox_list_get_global_temp_prefix(list);
 
 		(void)unlink_old_files(path, prefix,
 				       ioloop_time - DBOX_TMP_DELETE_SECS);
@@ -358,39 +276,42 @@
 }
 
 struct mailbox *
-dbox_mailbox_open(struct mail_storage *_storage, const char *name,
-		  struct istream *input, enum mailbox_open_flags flags)
+dbox_mailbox_open(struct mail_storage *_storage, struct mailbox_list *list,
+		  const char *name, struct istream *input,
+		  enum mailbox_open_flags flags)
 {
 	struct dbox_storage *storage = (struct dbox_storage *)_storage;
 	const char *path;
 
 	if (input != NULL) {
-		mail_storage_set_critical(_storage,
+		mailbox_list_set_critical(list,
 			"dbox doesn't support streamed mailboxes");
 		return NULL;
 	}
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
-	if (dbox_cleanup_if_exists(_storage, path)) {
-		return dbox_open(storage, name, flags);
+	if (dbox_cleanup_if_exists(list, path)) {
+		return dbox_open(storage, list, name, flags);
 	} else if (errno == ENOENT) {
 		if (strcmp(name, "INBOX") == 0 &&
-		    (_storage->ns->flags & NAMESPACE_FLAG_INBOX) != 0) {
+		    (list->ns->flags & NAMESPACE_FLAG_INBOX) != 0) {
 			/* INBOX always exists, create it */
-			if (create_dbox(_storage, path, "INBOX", FALSE) < 0)
+			if (create_dbox(_storage, list, path, name, FALSE) < 0) {
+				mailbox_list_set_error_from_storage(list,
+								    _storage);
 				return NULL;
-			return dbox_open(storage, name, flags);
+			}
+			return dbox_open(storage, list, name, flags);
 		}
 
-		mail_storage_set_error(_storage, MAIL_ERROR_NOTFOUND,
+		mailbox_list_set_error(list, MAIL_ERROR_NOTFOUND,
 			T_MAIL_ERR_MAILBOX_NOT_FOUND(name));
 	} else if (errno == EACCES) {
-		mail_storage_set_critical(_storage, "%s",
+		mailbox_list_set_critical(list, "%s",
 			mail_error_eacces_msg("stat", path));
 	} else {
-		mail_storage_set_critical(_storage, "stat(%s) failed: %m",
-					  path);
+		mailbox_list_set_critical(list, "stat(%s) failed: %m", path);
 	}
 	return NULL;
 }
@@ -403,18 +324,18 @@
 	return index_storage_mailbox_close(box);
 }
 
-static int dbox_mailbox_create(struct mail_storage *_storage,
-			       const char *name, bool directory)
+static int
+dbox_mailbox_create(struct mail_storage *storage, struct mailbox_list *list,
+		    const char *name, bool directory)
 {
-	struct dbox_storage *storage = (struct dbox_storage *)_storage;
 	const char *path, *alt_path;
 	struct stat st;
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     directory ? MAILBOX_LIST_PATH_TYPE_DIR :
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (stat(path, &st) == 0) {
-		mail_storage_set_error(_storage, MAIL_ERROR_EXISTS,
+		mail_storage_set_error(storage, MAIL_ERROR_EXISTS,
 				       "Mailbox already exists");
 		return -1;
 	}
@@ -423,20 +344,20 @@
 	   race conditions with RENAME/DELETE), but if something crashed and
 	   left it lying around we don't want to start overwriting files in
 	   it. */
-	alt_path = directory ? NULL : dbox_get_alt_path(storage, path);
+	alt_path = directory ? NULL : dbox_get_alt_path(list, path);
 	if (alt_path != NULL && stat(alt_path, &st) == 0) {
-		mail_storage_set_error(_storage, MAIL_ERROR_EXISTS,
+		mail_storage_set_error(storage, MAIL_ERROR_EXISTS,
 				       "Mailbox already exists");
 		return -1;
 	}
 
-	return create_dbox(_storage, path, name, directory);
+	return create_dbox(storage, list, path, name, directory);
 }
 
 static int
-dbox_mailbox_unref_mails(struct dbox_storage *storage, const char *path)
+dbox_mailbox_unref_mails(struct mailbox_list *list, const char *path)
 {
-	struct mailbox_list *list = storage->storage.list;
+	struct dbox_storage *storage = (struct dbox_storage *)list->ns->storage;
 	const struct mail_storage_settings *old_set;
 	struct mail_storage_settings tmp_set;
 	struct mailbox *box;
@@ -454,7 +375,7 @@
 	tmp_set = *list->mail_set;
 	tmp_set.mail_full_filesystem_access = TRUE;
 	list->mail_set = &tmp_set;
-	box = dbox_open(storage, path, MAILBOX_OPEN_IGNORE_ACLS |
+	box = dbox_open(storage, list, path, MAILBOX_OPEN_IGNORE_ACLS |
 			MAILBOX_OPEN_KEEP_RECENT);
 	list->mail_set = old_set;
 	if (box == NULL)
@@ -504,7 +425,7 @@
 static int
 dbox_list_delete_mailbox(struct mailbox_list *list, const char *name)
 {
-	struct dbox_storage *storage = DBOX_LIST_CONTEXT(list);
+	struct dbox_mailbox_list *mlist = DBOX_LIST_CONTEXT(list);
 	struct stat st;
 	const char *path, *alt_path, *trash_dir, *trash_dest;
 	bool deleted = FALSE;
@@ -517,7 +438,7 @@
 	index_storage_destroy_unrefed();
 
 	/* delete the index and control directories */
-	if (storage->list_module_ctx.super.delete_mailbox(list, name) < 0)
+	if (mlist->module_ctx.super.delete_mailbox(list, name) < 0)
 		return -1;
 
 	path = mailbox_list_get_path(list, name,
@@ -545,7 +466,7 @@
 		ret = rename(path, trash_dest);
 	}
 	if (ret == 0) {
-		if (dbox_mailbox_unref_mails(storage, trash_dest) < 0) {
+		if (dbox_mailbox_unref_mails(list, trash_dest) < 0) {
 			/* we've already renamed it. there's no going back. */
 			mailbox_list_set_internal_error(list);
 			ret = -1;
@@ -556,7 +477,7 @@
 			ret = -1;
 		}
 		/* if there's an alt path, delete it too */
-		alt_path = dbox_get_alt_path(storage, path);
+		alt_path = dbox_get_alt_path(list, path);
 		if (alt_path != NULL) {
 			if (unlink_directory(alt_path, TRUE) < 0) {
 				mailbox_list_set_critical(list,
@@ -589,7 +510,7 @@
 		ret = 0;
 	}
 
-	alt_path = dbox_get_alt_path(storage, path);
+	alt_path = dbox_get_alt_path(list, path);
 	if (alt_path != NULL)
 		(void)rmdir(alt_path);
 
@@ -616,17 +537,15 @@
 			       enum mailbox_list_path_type path_type,
 			       const char **oldpath_r, const char **newpath_r)
 {
-	struct dbox_storage *oldstorage = DBOX_LIST_CONTEXT(oldlist);
-	struct dbox_storage *newstorage = DBOX_LIST_CONTEXT(newlist);
 	const char *path;
 
 	path = mailbox_list_get_path(oldlist, oldname, path_type);
-	*oldpath_r = dbox_get_alt_path(oldstorage, path);
+	*oldpath_r = dbox_get_alt_path(oldlist, path);
 	if (*oldpath_r == NULL)
 		return 0;
 
 	path = mailbox_list_get_path(newlist, newname, path_type);
-	*newpath_r = dbox_get_alt_path(newstorage, path);
+	*newpath_r = dbox_get_alt_path(newlist, path);
 	if (*newpath_r == NULL) {
 		/* destination dbox storage doesn't have alt-path defined.
 		   we can't do the rename easily. */
@@ -672,14 +591,15 @@
 			 struct mailbox_list *newlist, const char *newname,
 			 bool rename_children)
 {
-	struct dbox_storage *oldstorage = DBOX_LIST_CONTEXT(oldlist);
+	struct dbox_mailbox_list *oldmlist = DBOX_LIST_CONTEXT(oldlist);
 	enum mailbox_list_path_type path_type;
 	const char *alt_oldpath, *alt_newpath, *path;
 	int ret;
 
-	if (oldstorage->list_module_ctx.super.
-	    		rename_mailbox(oldlist, oldname, newlist, newname,
-				       rename_children) < 0)
+	ret = oldmlist->module_ctx.super.
+		rename_mailbox(oldlist, oldname, newlist, newname,
+			       rename_children);
+	if (ret < 0)
 		return -1;
 
 	path_type = rename_children ? MAILBOX_LIST_PATH_TYPE_DIR :
@@ -800,6 +720,23 @@
 	dbox_transaction_class_deinit();
 }
 
+static void dbox_list_init(struct mailbox_list *list,
+			   const struct dbox_settings *set)
+{
+	struct dbox_mailbox_list *mlist;
+
+	mlist = p_new(list->pool, struct dbox_mailbox_list, 1);
+	mlist->module_ctx.super = list->v;
+	mlist->set = set;
+
+	list->v.iter_is_mailbox = dbox_list_iter_is_mailbox;
+	list->v.delete_mailbox = dbox_list_delete_mailbox;
+	list->v.rename_mailbox = dbox_list_rename_mailbox;
+	list->v.rename_mailbox_pre = dbox_list_rename_mailbox_pre;
+
+	MODULE_CONTEXT_SET(list, dbox_mailbox_list_module, mlist);
+}
+
 struct mail_storage dbox_storage = {
 	MEMBER(name) DBOX_STORAGE_NAME,
 	MEMBER(mailbox_is_file) FALSE,
@@ -808,9 +745,10 @@
                 dbox_get_setting_parser_info,
 		dbox_class_init,
 		dbox_class_deinit,
-		dbox_alloc,
-		dbox_create,
-		dbox_destroy,
+		dbox_storage_alloc,
+		dbox_storage_create,
+		dbox_storage_destroy,
+		dbox_storage_get_list_settings,
 		NULL,
 		dbox_mailbox_open,
 		dbox_mailbox_create,
@@ -821,6 +759,7 @@
 struct mailbox dbox_mailbox = {
 	MEMBER(name) NULL, 
 	MEMBER(storage) NULL, 
+	MEMBER(list) NULL,
 
 	{
 		index_storage_is_readonly,

--- a/src/lib-storage/index/dbox/dbox-storage.h	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/dbox/dbox-storage.h	Tue Jun 02 22:30:28 2009 -0400
@@ -90,8 +90,9 @@
 void dbox_transaction_class_deinit(void);
 
 struct mailbox *
-dbox_mailbox_open(struct mail_storage *storage, const char *name,
-		  struct istream *input, enum mailbox_open_flags flags);
+dbox_mailbox_open(struct mail_storage *_storage, struct mailbox_list *list,
+		  const char *name, struct istream *input,
+		  enum mailbox_open_flags flags);
 
 struct mail *
 dbox_mail_alloc(struct mailbox_transaction_context *t,
@@ -101,7 +102,7 @@
 /* Get map_uid for wanted message. */
 int dbox_mail_lookup(struct dbox_mailbox *mbox, struct mail_index_view *view,
 		     uint32_t seq, uint32_t *map_uid_r);
-uint32_t dbox_get_uidvalidity_next(struct mail_storage *storage);
+uint32_t dbox_get_uidvalidity_next(struct mailbox_list *list);
 
 struct mail_save_context *
 dbox_save_alloc(struct mailbox_transaction_context *_t);

--- a/src/lib-storage/index/dbox/dbox-sync-rebuild.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/dbox/dbox-sync-rebuild.c	Tue Jun 02 22:30:28 2009 -0400
@@ -36,13 +36,13 @@
 
 static void dbox_sync_set_uidvalidity(struct dbox_sync_rebuild_context *ctx)
 {
-	struct mail_storage *storage = &ctx->mbox->storage->storage;
+	struct mailbox *box = &ctx->mbox->ibox.box;
 	uint32_t uid_validity;
 
 	/* if uidvalidity is set in the old index, use it */
 	uid_validity = mail_index_get_header(ctx->view)->uid_validity;
 	if (uid_validity == 0)
-		uid_validity = dbox_get_uidvalidity_next(storage);
+		uid_validity = dbox_get_uidvalidity_next(box->list);
 
 	mail_index_update_header(ctx->trans,
 		offsetof(struct mail_index_header, uid_validity),
@@ -389,7 +389,7 @@
 	mail_index_ext_lookup(mbox->ibox.index, "cache", &ctx->cache_ext_id);
 
 	/* if backup index file exists, try to use it */
-	index_dir = mailbox_list_get_path(box->storage->list, box->name,
+	index_dir = mailbox_list_get_path(box->list, box->name,
 					  MAILBOX_LIST_PATH_TYPE_INDEX);
 	ctx->backup_index =
 		mail_index_alloc(index_dir, DBOX_INDEX_PREFIX".backup");
@@ -399,7 +399,7 @@
 #endif
 		open_flags |= MAIL_INDEX_OPEN_FLAG_MMAP_DISABLE;
 	if (mail_index_open(ctx->backup_index, open_flags,
-			    box->storage->lock_method) <= 0)
+			    box->storage->set->parsed_lock_method) <= 0)
 		mail_index_free(&ctx->backup_index);
 	else
 		ctx->backup_view = mail_index_view_open(ctx->backup_index);

--- a/src/lib-storage/index/index-storage.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/index-storage.c	Tue Jun 02 22:30:28 2009 -0400
@@ -8,6 +8,7 @@
 #include "mkdir-parents.h"
 #include "mail-index-private.h"
 #include "mail-index-modseq.h"
+#include "mailbox-list-private.h"
 #include "index-storage.h"
 #include "index-mail.h"
 #include "index-thread-private.h"
@@ -64,39 +65,39 @@
 	i_free(list);
 }
 
-static int create_index_dir(struct mail_storage *storage, const char *name)
+static int create_index_dir(struct mailbox_list *list, const char *name)
 {
 	const char *root_dir, *index_dir, *p, *parent_dir;
 	mode_t mode, parent_mode;
 	gid_t gid, parent_gid;
 	int n = 0;
 
-	root_dir = mailbox_list_get_path(storage->list, name,
+	root_dir = mailbox_list_get_path(list, name,
 					 MAILBOX_LIST_PATH_TYPE_MAILBOX);
-	index_dir = mailbox_list_get_path(storage->list, name,
+	index_dir = mailbox_list_get_path(list, name,
 					  MAILBOX_LIST_PATH_TYPE_INDEX);
 	if (strcmp(index_dir, root_dir) == 0 || *index_dir == '\0')
 		return 0;
 
-	mailbox_list_get_dir_permissions(storage->list, name, &mode, &gid);
+	mailbox_list_get_dir_permissions(list, name, &mode, &gid);
 	while (mkdir_chown(index_dir, mode, (uid_t)-1, gid) < 0) {
 		if (errno == EEXIST)
 			break;
 
 		p = strrchr(index_dir, '/');
 		if (errno != ENOENT || p == NULL || ++n == 2) {
-			mail_storage_set_critical(storage,
+			mailbox_list_set_critical(list,
 				"mkdir(%s) failed: %m", index_dir);
 			return -1;
 		}
 		/* create the parent directory first */
-		mailbox_list_get_dir_permissions(storage->list, NULL,
+		mailbox_list_get_dir_permissions(list, NULL,
 						 &parent_mode, &parent_gid);
 		parent_dir = t_strdup_until(index_dir, p);
 		if (mkdir_parents_chown(parent_dir, parent_mode,
 					(uid_t)-1, parent_gid) < 0 &&
 		    errno != EEXIST) {
-			mail_storage_set_critical(storage,
+			mailbox_list_set_critical(list,
 				"mkdir(%s) failed: %m", parent_dir);
 			return -1;
 		}
@@ -105,14 +106,13 @@
 }
 
 static const char *
-get_index_dir(struct mail_storage *storage, const char *name,
+get_index_dir(struct mailbox_list *list, const char *name,
 	      enum mailbox_open_flags flags, struct stat *st_r)
 {
 	const char *index_dir;
 
 	index_dir = (flags & MAILBOX_OPEN_NO_INDEX_FILES) != 0 ? "" :
-		mailbox_list_get_path(storage->list, name,
-				      MAILBOX_LIST_PATH_TYPE_INDEX);
+		mailbox_list_get_path(list, name, MAILBOX_LIST_PATH_TYPE_INDEX);
 	if (*index_dir == '\0') {
 		/* disabled */
 		return NULL;
@@ -121,18 +121,18 @@
 	if (stat(index_dir, st_r) < 0) {
 		if (errno == ENOENT) {
 			/* try to create it */
-			if (create_index_dir(storage, name) < 0)
+			if (create_index_dir(list, name) < 0)
 				return NULL;
 			if (stat(index_dir, st_r) == 0)
 				return index_dir;
 		}
 		if (errno == EACCES) {
-			mail_storage_set_critical(storage, "%s",
+			mailbox_list_set_critical(list, "%s",
 				mail_error_eacces_msg("stat", index_dir));
 			return NULL;
 		}
 
-		mail_storage_set_critical(storage, "stat(%s) failed: %m",
+		mailbox_list_set_critical(list, "stat(%s) failed: %m",
 					  index_dir);
 		return NULL;
 	}
@@ -140,18 +140,18 @@
 }
 
 struct mail_index *
-index_storage_alloc(struct mail_storage *storage, const char *name,
+index_storage_alloc(struct mailbox_list *list, const char *name,
 		    enum mailbox_open_flags flags, const char *prefix)
 {
-	struct index_list **list, *rec;
+	struct index_list **indexp, *rec;
 	struct mail_index *index;
 	struct stat st, st2;
 	const char *index_dir, *mailbox_path;
 	int destroy_count;
 
-	mailbox_path = mailbox_list_get_path(storage->list, name,
+	mailbox_path = mailbox_list_get_path(list, name,
 					     MAILBOX_LIST_PATH_TYPE_MAILBOX);
-	index_dir = get_index_dir(storage, name, flags, &st);
+	index_dir = get_index_dir(list, name, flags, &st);
 
 	if (index_dir == NULL)
 		memset(&st, 0, sizeof(st));
@@ -159,8 +159,8 @@
 	/* compare index_dir inodes so we don't break even with symlinks.
 	   for in-memory indexes compare just mailbox paths */
 	destroy_count = 0; index = NULL;
-	for (list = &indexes; *list != NULL;) {
-		rec = *list;
+	for (indexp = &indexes; *indexp != NULL;) {
+		rec = *indexp;
 
 		if (index_dir != NULL) {
 			if (index == NULL && st.st_ino == rec->index_dir_ino &&
@@ -188,7 +188,7 @@
 		if (rec->refcount == 0) {
 			if (rec->destroy_time <= ioloop_time ||
 			    destroy_count >= INDEX_CACHE_MAX) {
-				*list = rec->next;
+				*indexp = rec->next;
 				index_list_free(rec);
 				continue;
 			} else {
@@ -196,7 +196,7 @@
 			}
 		}
 
-                list = &(*list)->next;
+                indexp = &(*indexp)->next;
 	}
 
 	if (index == NULL) {
@@ -367,7 +367,8 @@
 
 int index_storage_mailbox_open(struct index_mailbox *ibox)
 {
-	struct mail_storage *storage = ibox->storage;
+	struct mail_storage *storage = ibox->box.storage;
+	enum file_lock_method lock_method = storage->set->parsed_lock_method;
 	enum mail_index_open_flags index_flags;
 	int ret;
 
@@ -381,7 +382,7 @@
 	if (ibox->index_never_in_memory)
 		index_flags |= MAIL_INDEX_OPEN_FLAG_NEVER_IN_MEMORY;
 
-	ret = mail_index_open(ibox->index, index_flags, storage->lock_method);
+	ret = mail_index_open(ibox->index, index_flags, lock_method);
 	if (ret <= 0 || ibox->move_to_memory) {
 		if (ibox->index_never_in_memory) {
 			mail_storage_set_index_error(ibox);
@@ -393,7 +394,7 @@
 			   directly into memory now. */
 			if (mail_index_open_or_create(ibox->index,
 						      index_flags,
-						      storage->lock_method) < 0)
+						      lock_method) < 0)
 				i_panic("in-memory index creation failed");
 		}
 	}
@@ -418,7 +419,7 @@
 			       enum mailbox_open_flags flags,
 			       bool move_to_memory)
 {
-	struct mail_storage *storage = ibox->storage;
+	struct mail_storage *storage = ibox->box.storage;
 	struct mailbox *box = &ibox->box;
 	gid_t dir_gid;
 
@@ -428,10 +429,10 @@
 	box->name = p_strdup(box->pool, name);
 	box->open_flags = flags;
 	if (box->file_create_mode == 0) {
-		mailbox_list_get_permissions(box->storage->list, name,
+		mailbox_list_get_permissions(box->list, name,
 					     &box->file_create_mode,
 					     &box->file_create_gid);
-		mailbox_list_get_dir_permissions(box->storage->list, name,
+		mailbox_list_get_dir_permissions(box->list, name,
 						 &box->dir_create_mode,
 						 &dir_gid);
 		mail_index_set_permissions(ibox->index, box->file_create_mode,

--- a/src/lib-storage/index/index-storage.h	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/index-storage.h	Tue Jun 02 22:30:28 2009 -0400
@@ -20,8 +20,6 @@
 	struct mailbox box;
 	union mail_index_view_module_context view_module_ctx;
 
-	struct mail_storage *storage;
-
 	struct mail_index *index;
 	struct mail_index_view *view;
 	struct mail_cache *cache;
@@ -88,7 +86,7 @@
 void index_storage_lock_notify_reset(struct index_mailbox *ibox);
 
 struct mail_index *
-index_storage_alloc(struct mail_storage *storage, const char *name,
+index_storage_alloc(struct mailbox_list *list, const char *name,
 		    enum mailbox_open_flags flags, const char *prefix);
 void index_storage_unref(struct mail_index *index);
 void index_storage_destroy_unrefed(void);

--- a/src/lib-storage/index/maildir/maildir-keywords.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/maildir/maildir-keywords.c	Tue Jun 02 22:30:28 2009 -0400
@@ -65,7 +65,8 @@
 	struct maildir_keywords *mk;
 	const char *dir;
 
-	dir = mail_storage_get_mailbox_control_dir(box->storage, box->name);
+	dir = mailbox_list_get_path(box->list, box->name,
+				    MAILBOX_LIST_PATH_TYPE_CONTROL);
 
 	mk = i_new(struct maildir_keywords, 1);
 	mk->storage = box->storage;
@@ -82,7 +83,7 @@
 	mk->dotlock_settings.timeout = KEYWORDS_LOCK_STALE_TIMEOUT + 2;
 	mk->dotlock_settings.stale_timeout = KEYWORDS_LOCK_STALE_TIMEOUT;
 	mk->dotlock_settings.temp_prefix =
-		mailbox_list_get_temp_prefix(box->storage->list);
+		mailbox_list_get_temp_prefix(box->list);
 	return mk;
 }
 

--- a/src/lib-storage/index/maildir/maildir-storage.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/maildir/maildir-storage.c	Tue Jun 02 22:30:28 2009 -0400
@@ -21,12 +21,16 @@
 #include <unistd.h>
 #include <sys/stat.h>
 
-#define MAILDIR_PLUSPLUS_DRIVER_NAME "maildir++"
 #define MAILDIR_SUBFOLDER_FILENAME "maildirfolder"
 
 #define MAILDIR_LIST_CONTEXT(obj) \
 	MODULE_CONTEXT(obj, maildir_mailbox_list_module)
 
+struct maildir_mailbox_list {
+	union mailbox_list_module_context module_ctx;
+	const struct maildir_settings *set;
+};
+
 struct rename_context {
 	bool found;
 	size_t oldnamelen;
@@ -40,89 +44,8 @@
 				  &mailbox_list_module_register);
 static const char *maildir_subdirs[] = { "cur", "new", "tmp" };
 
-static int
-maildir_list_delete_mailbox(struct mailbox_list *list, const char *name);
-static int
-maildir_list_rename_mailbox(struct mailbox_list *oldlist, const char *oldname,
-			    struct mailbox_list *newlist, const char *newname,
-			    bool rename_children);
-static int
-maildir_list_iter_is_mailbox(struct mailbox_list_iterate_context *ctx,
-			     const char *dir, const char *fname,
-			     const char *mailbox_name,
-			     enum mailbox_list_file_type type,
-			     enum mailbox_info_flags *flags_r);
-static int
-maildirplusplus_iter_is_mailbox(struct mailbox_list_iterate_context *ctx,
-				const char *dir, const char *fname,
-				const char *mailbox_name,
-				enum mailbox_list_file_type type,
-				enum mailbox_info_flags *flags_r);
-
-static int
-maildir_get_list_settings(struct mailbox_list_settings *list_set,
-			  const char *data, struct mail_storage *storage,
-			  const char **layout_r, const char **error_r)
-{
-	struct mail_user *user = storage->ns->user;
-	bool debug = storage->set->mail_debug;
-	const char *path, *home;
-
-	*layout_r = MAILDIR_PLUSPLUS_DRIVER_NAME;
-
-	memset(list_set, 0, sizeof(*list_set));
-	list_set->subscription_fname = MAILDIR_SUBSCRIPTION_FILE_NAME;
-	list_set->maildir_name = "";
-
-	if (data == NULL || *data == '\0') {
-		if ((storage->flags &
-		     MAIL_STORAGE_FLAG_NO_AUTODETECTION) != 0) {
-			*error_r = "Root mail directory not given";
-			return -1;
-		}
-
-		/* we'll need to figure out the maildir location ourself.
-		   It's ~/Maildir unless we are chrooted. */
-		if (mail_user_get_home(user, &home) > 0) {
-			path = t_strconcat(home, "/Maildir", NULL);
-			if (access(path, R_OK|W_OK|X_OK) == 0) {
-				if (debug) {
-					i_info("maildir: root exists (%s)",
-					       path);
-				}
-				list_set->root_dir = path;
-			} else {
-				if (debug) {
-					i_info("maildir: access(%s, rwx): "
-					       "failed: %m", path);
-				}
-			}
-		} else {
-			if (debug)
-				i_info("maildir: Home directory not set");
-		}
-
-		if (access("/cur", R_OK|W_OK|X_OK) == 0) {
-			if (debug)
-				i_info("maildir: /cur exists, assuming chroot");
-			list_set->root_dir = "/";
-		}
-	} else {
-		if (debug)
-			i_info("maildir: data=%s", data);
-		if (mailbox_list_settings_parse(data, list_set, storage->ns,
-						layout_r, NULL, error_r) < 0)
-			return -1;
-	}
-
-	if (list_set->root_dir == NULL || *list_set->root_dir == '\0') {
-		if (debug)
-			i_info("maildir: couldn't find root dir");
-		*error_r = "Root mail directory not given";
-		return -1;
-	}
-	return 0;
-}
+static void maildir_list_init(struct mailbox_list *list,
+			      const struct maildir_settings *set);
 
 static bool maildir_is_internal_name(const char *name)
 {
@@ -134,10 +57,10 @@
 static bool maildir_storage_is_valid_existing_name(struct mailbox_list *list,
 						   const char *name)
 {
-	struct maildir_storage *storage = MAILDIR_LIST_CONTEXT(list);
+	struct maildir_mailbox_list *mlist = MAILDIR_LIST_CONTEXT(list);
 	const char *p;
 
-	if (!storage->list_module_ctx.super.is_valid_existing_name(list, name))
+	if (!mlist->module_ctx.super.is_valid_existing_name(list, name))
 		return FALSE;
 
 	/* Don't allow the mailbox name to end in cur/new/tmp */
@@ -150,10 +73,10 @@
 static bool maildir_storage_is_valid_create_name(struct mailbox_list *list,
 						 const char *name)
 {
-	struct maildir_storage *storage = MAILDIR_LIST_CONTEXT(list);
+	struct maildir_mailbox_list *mlist = MAILDIR_LIST_CONTEXT(list);
 	bool ret = TRUE;
 
-	if (!storage->list_module_ctx.super.is_valid_create_name(list, name))
+	if (!mlist->module_ctx.super.is_valid_create_name(list, name))
 		return FALSE;
 
 	/* Don't allow creating mailboxes under cur/new/tmp */
@@ -170,7 +93,7 @@
 	return ret;
 }
 
-static struct mail_storage *maildir_alloc(void)
+static struct mail_storage *maildir_storage_alloc(void)
 {
 	struct maildir_storage *storage;
 	pool_t pool;
@@ -179,83 +102,25 @@
 	storage = p_new(pool, struct maildir_storage, 1);
 	storage->storage = maildir_storage;
 	storage->storage.pool = pool;
-	storage->storage.storage_class = &maildir_storage;
-
 	return &storage->storage;
 }
 
 static int
-maildir_create(struct mail_storage *_storage, const char *data,
-	       const char **error_r)
+maildir_storage_create(struct mail_storage *_storage, struct mail_namespace *ns,
+		       const char **error_r ATTR_UNUSED)
 {
 	struct maildir_storage *storage = (struct maildir_storage *)_storage;
-	enum mail_storage_flags flags = _storage->flags;
-	struct mailbox_list_settings list_set;
-	struct mailbox_list *list;
-	const char *layout, *dir;
-	struct stat st;
-
-	if (maildir_get_list_settings(&list_set, data, _storage, &layout,
-				      error_r) < 0)
-		return -1;
-	list_set.mail_storage_flags = &_storage->flags;
-	list_set.lock_method = &_storage->lock_method;
-
-	if (list_set.inbox_path == NULL &&
-	    strcmp(layout, MAILDIR_PLUSPLUS_DRIVER_NAME) == 0 &&
-	    (_storage->ns->flags & NAMESPACE_FLAG_INBOX) != 0) {
-		/* Maildir++ INBOX is the Maildir base itself */
-		list_set.inbox_path = list_set.root_dir;
-	}
-
-	if ((flags & MAIL_STORAGE_FLAG_NO_AUTOCREATE) != 0) {
-		if (stat(list_set.root_dir, &st) == 0) {
-			/* ok */
-		} else if (errno == EACCES) {
-			*error_r = mail_error_eacces_msg("stat",
-							 list_set.root_dir);
-			return -1;
-		} else if (errno == ENOENT) {
-			*error_r = t_strdup_printf(
-					"Root mail directory doesn't exist: %s",
-					list_set.root_dir);
-			return -1;
-		} else {
-			*error_r = t_strdup_printf("stat(%s) failed: %m",
-						   list_set.root_dir);
-			return -1;
-		}
-	}
-
-	if (mailbox_list_alloc(layout, &list, error_r) < 0)
-		return -1;
+	struct mailbox_list *list = ns->list;
+	const char *dir;
 
 	storage->set = mail_storage_get_driver_settings(_storage);
+	maildir_list_init(list, storage->set);
 
-	_storage->list = list;
-	storage->list_module_ctx.super = list->v;
-	if (strcmp(layout, MAILDIR_PLUSPLUS_DRIVER_NAME) == 0) {
-		list->v.iter_is_mailbox = maildirplusplus_iter_is_mailbox;
-	} else {
-		list->v.is_valid_existing_name =
-			maildir_storage_is_valid_existing_name;
-		list->v.is_valid_create_name =
-			maildir_storage_is_valid_create_name;
-		list->v.iter_is_mailbox = maildir_list_iter_is_mailbox;
-	}
-	list->v.delete_mailbox = maildir_list_delete_mailbox;
-	list->v.rename_mailbox = maildir_list_rename_mailbox;
 	storage->maildir_list_ext_id = (uint32_t)-1;
-
-	MODULE_CONTEXT_SET_FULL(list, maildir_mailbox_list_module,
-				storage, &storage->list_module_ctx);
+	storage->temp_prefix = mailbox_list_get_temp_prefix(list);
 
-	/* finish list init after we've overridden vfuncs */
-	mailbox_list_init(list, _storage->ns, &list_set, 0);
-
-	storage->temp_prefix = mailbox_list_get_temp_prefix(list);
-	if (list_set.control_dir == NULL && list_set.inbox_path == NULL &&
-	    (_storage->ns->flags & NAMESPACE_FLAG_INBOX) != 0) {
+	if (list->set.control_dir == NULL && list->set.inbox_path == NULL &&
+	    (ns->flags & NAMESPACE_FLAG_INBOX) != 0) {
 		/* put the temp files into tmp/ directory preferrably */
 		storage->temp_prefix = p_strconcat(_storage->pool, "tmp/",
 						   storage->temp_prefix, NULL);
@@ -271,13 +136,70 @@
 	return 0;
 }
 
-static bool maildir_autodetect(const struct mail_namespace *ns)
+static void maildir_storage_get_list_settings(const struct mail_namespace *ns,
+					      struct mailbox_list_settings *set)
+{
+	if (set->layout == NULL)
+		set->layout = MAILBOX_LIST_NAME_MAILDIRPLUSPLUS;
+	if (set->subscription_fname == NULL)
+		set->subscription_fname = MAILDIR_SUBSCRIPTION_FILE_NAME;
+
+	if (set->inbox_path == NULL &&
+	    strcmp(set->layout, MAILBOX_LIST_NAME_MAILDIRPLUSPLUS) == 0 &&
+	    (ns->flags & NAMESPACE_FLAG_INBOX) != 0) {
+		/* Maildir++ INBOX is the Maildir base itself */
+		set->inbox_path = set->root_dir;
+	}
+}
+
+static const char *
+maildir_storage_find_root_dir(const struct mail_namespace *ns)
+{
+	bool debug = ns->mail_set->mail_debug;
+	const char *home, *path;
+
+	/* we'll need to figure out the maildir location ourself.
+	   It's ~/Maildir unless we are chrooted. */
+	if (mail_user_get_home(ns->user, &home) > 0) {
+		path = t_strconcat(home, "/Maildir", NULL);
+		if (access(path, R_OK|W_OK|X_OK) == 0) {
+			if (debug)
+				i_info("maildir: root exists (%s)", path);
+			return path;
+		} 
+		if (debug)
+			i_info("maildir: access(%s, rwx): failed: %m", path);
+	} else {
+		if (debug)
+			i_info("maildir: Home directory not set");
+		if (access("/cur", R_OK|W_OK|X_OK) == 0) {
+			if (debug)
+				i_info("maildir: /cur exists, assuming chroot");
+			return "/";
+		}
+	}
+	return NULL;
+}
+
+static bool maildir_storage_autodetect(const struct mail_namespace *ns,
+				       struct mailbox_list_settings *set)
 {
 	bool debug = ns->mail_set->mail_debug;
 	struct stat st;
-	const char *path;
+	const char *path, *root_dir;
 
-	path = t_strconcat(t_strcut(ns->set->location, ':'), "/cur", NULL);
+	if (set->root_dir != NULL)
+		root_dir = set->root_dir;
+	else {
+		root_dir = maildir_storage_find_root_dir(ns);
+		if (root_dir == NULL) {
+			if (debug)
+				i_info("maildir: couldn't find root dir");
+			return FALSE;
+		}
+	}
+
+	path = t_strconcat(root_dir, "/cur", NULL);
 	if (stat(path, &st) < 0) {
 		if (debug)
 			i_info("maildir autodetect: stat(%s) failed: %m", path);
@@ -289,10 +211,13 @@
 			i_info("maildir autodetect: %s not a directory", path);
 		return FALSE;
 	}
+
+	set->root_dir = root_dir;
+	maildir_storage_get_list_settings(ns, set);
 	return TRUE;
 }
 
-static int mkdir_verify(struct mail_storage *storage,
+static int mkdir_verify(struct mail_storage *storage, struct mail_namespace *ns,
 			const char *dir, mode_t mode, gid_t gid, bool verify)
 {
 	struct stat st;
@@ -320,7 +245,7 @@
 		mail_storage_set_error(storage, MAIL_ERROR_NOTFOUND,
 			"Mailbox was deleted while it was being created");
 	} else if (errno == EACCES) {
-		if (storage->ns->type == NAMESPACE_SHARED) {
+		if (ns->type == NAMESPACE_SHARED) {
 			/* shared namespace, don't log permission errors */
 			mail_storage_set_error(storage, MAIL_ERROR_PERM,
 					       MAIL_ERRSTR_NO_PERMISSION);
@@ -366,8 +291,9 @@
 }
 
 /* create or fix maildir, ignore if it already exists */
-static int create_maildir(struct mail_storage *storage,
-			  const char *dir, mode_t mode, gid_t gid, bool verify)
+static int
+create_maildir(struct mail_storage *storage, struct mail_namespace *ns,
+	       const char *dir, mode_t mode, gid_t gid, bool verify)
 {
 	const char *path;
 	unsigned int i;
@@ -376,8 +302,8 @@
 	ret = maildir_check_tmp(storage, dir);
 	if (ret > 0) {
 		if (!verify) {
-			mail_storage_set_error(storage, MAIL_ERROR_EXISTS,
-					       "Mailbox already exists");
+			mail_storage_set_error(storage,
+				MAIL_ERROR_EXISTS, "Mailbox already exists");
 			return -1;
 		}
 		return 1;
@@ -388,7 +314,7 @@
 	/* doesn't exist, create */
 	for (i = 0; i < N_ELEMENTS(maildir_subdirs); i++) {
 		path = t_strconcat(dir, "/", maildir_subdirs[i], NULL);
-		if (mkdir_verify(storage, path, mode, gid, verify) < 0)
+		if (mkdir_verify(storage, ns, path, mode, gid, verify) < 0)
 			return -1;
 	}
 	return 0;
@@ -409,8 +335,8 @@
 }
 
 static struct mailbox *
-maildir_open(struct maildir_storage *storage, const char *name,
-	     enum mailbox_open_flags flags)
+maildir_open(struct mail_storage *storage, struct mail_namespace *ns,
+	     const char *name, enum mailbox_open_flags flags)
 {
 	struct maildir_mailbox *mbox;
 	struct mail_index *index;
@@ -418,22 +344,23 @@
 	struct stat st;
 	pool_t pool;
 
-	path = mailbox_list_get_path(storage->storage.list, name,
+	path = mailbox_list_get_path(ns->list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
-	control_dir = mailbox_list_get_path(storage->storage.list, name,
+	control_dir = mailbox_list_get_path(ns->list, name,
 					    MAILBOX_LIST_PATH_TYPE_CONTROL);
 
 	pool = pool_alloconly_create("maildir mailbox", 1024+512);
 	mbox = p_new(pool, struct maildir_mailbox, 1);
 	mbox->ibox.box = maildir_mailbox;
 	mbox->ibox.box.pool = pool;
-	mbox->ibox.storage = &storage->storage;
+	mbox->ibox.box.storage = storage;
+	mbox->ibox.box.list = ns->list;
 	mbox->ibox.mail_vfuncs = &maildir_mail_vfuncs;
 
-	mbox->storage = storage;
+	mbox->storage = (struct maildir_storage *)storage;
 	mbox->path = p_strdup(pool, path);
 
-	index = index_storage_alloc(&storage->storage, name, flags,
+	index = index_storage_alloc(ns->list, name, flags,
 				    MAILDIR_INDEX_PREFIX);
 	mbox->ibox.index = index;
 
@@ -465,6 +392,7 @@
 			struct mailbox *box = &mbox->ibox.box;
 
 			mailbox_close(&box);
+			mailbox_list_set_error_from_storage(ns->list, storage);
 			return NULL;
 		}
 		mbox->keep_lock_to = timeout_add(MAILDIR_LOCK_TOUCH_SECS * 1000,
@@ -481,10 +409,10 @@
 }
 
 static struct mailbox *
-maildir_mailbox_open(struct mail_storage *_storage, const char *name,
-		     struct istream *input, enum mailbox_open_flags flags)
+maildir_mailbox_open(struct mail_storage *storage, struct mailbox_list *list,
+		     const char *name, struct istream *input,
+		     enum mailbox_open_flags flags)
 {
-	struct maildir_storage *storage = (struct maildir_storage *)_storage;
 	const char *path;
 	struct stat st;
 	mode_t mode;
@@ -492,56 +420,61 @@
 	int ret;
 
 	if (input != NULL) {
-		mail_storage_set_critical(_storage,
+		mailbox_list_set_critical(list,
 			"Maildir doesn't support streamed mailboxes");
 		return NULL;
 	}
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
-
 	if (strcmp(name, "INBOX") == 0 &&
-	    (_storage->ns->flags & NAMESPACE_FLAG_INBOX) != 0) {
+	    (list->ns->flags & NAMESPACE_FLAG_INBOX) != 0) {
 		/* INBOX always exists */
-		mailbox_list_get_dir_permissions(_storage->list, NULL,
-						 &mode, &gid);
-		if (create_maildir(_storage, path, mode, gid, TRUE) < 0)
+		mailbox_list_get_dir_permissions(list, NULL, &mode, &gid);
+		if (create_maildir(storage, list->ns, path,
+				   mode, gid, TRUE) < 0) {
+			mailbox_list_set_error_from_storage(list, storage);
 			return NULL;
-		return maildir_open(storage, "INBOX", flags);
+		}
+		return maildir_open(storage, list->ns, "INBOX", flags);
 	}
 
 	/* begin by checking if tmp/ directory exists and if it should be
 	   cleaned up. */
-	ret = maildir_check_tmp(_storage, path);
+	ret = maildir_check_tmp(storage, path);
 	if (ret > 0) {
 		/* exists */
-		return maildir_open(storage, name, flags);
+		return maildir_open(storage, list->ns, name, flags);
 	}
-	if (ret < 0)
+	if (ret < 0) {
+		mailbox_list_set_error_from_storage(list, storage);
 		return NULL;
+	}
 
 	/* tmp/ directory doesn't exist. does the maildir? */
 	if (stat(path, &st) == 0) {
 		/* yes, we'll need to create the missing dirs */
-		mailbox_list_get_dir_permissions(_storage->list, name,
-						 &mode, &gid);
-		if (create_maildir(_storage, path, mode, gid, TRUE) < 0)
+		mailbox_list_get_dir_permissions(list, name, &mode, &gid);
+		if (create_maildir(storage, list->ns, path,
+				   mode, gid, TRUE) < 0) {
+			mailbox_list_set_error_from_storage(list, storage);
 			return NULL;
+		}
 
-		return maildir_open(storage, name, flags);
+		return maildir_open(storage, list->ns, name, flags);
 	} else if (errno == ENOENT) {
-		mail_storage_set_error(_storage, MAIL_ERROR_NOTFOUND,
+		mailbox_list_set_error(list, MAIL_ERROR_NOTFOUND,
 			T_MAIL_ERR_MAILBOX_NOT_FOUND(name));
 		return NULL;
 	} else {
-		mail_storage_set_critical(_storage, "stat(%s) failed: %m",
-					  path);
+		mailbox_list_set_critical(list, "stat(%s) failed: %m", path);
 		return NULL;
 	}
 }
 
-static int maildir_create_shared(struct mail_storage *storage,
-				 const char *dir, mode_t mode, gid_t gid)
+static int
+maildir_create_shared(struct mail_storage *storage, struct mail_namespace *ns,
+		      const char *dir, mode_t mode, gid_t gid)
 {
 	const char *path;
 	mode_t old_mask;
@@ -552,7 +485,7 @@
 	if ((mode & 0060) != 0) mode |= 0010;
 	if ((mode & 0006) != 0) mode |= 0001;
 
-	if (create_maildir(storage, dir, mode, gid, FALSE) < 0)
+	if (create_maildir(storage, ns, dir, mode, gid, FALSE) < 0)
 		return -1;
 
 	old_mask = umask(0777 ^ mode);
@@ -566,43 +499,43 @@
 	}
 
 	if (fchown(fd, (uid_t)-1, gid) < 0) {
-		mail_storage_set_critical(storage,
-					  "fchown(%s) failed: %m", path);
+		mail_storage_set_critical(storage, "fchown(%s) failed: %m",
+					  path);
 	}
 	(void)close(fd);
 	return 0;
 }
 
-static int maildir_mailbox_create(struct mail_storage *_storage,
-				  const char *name,
-				  bool directory ATTR_UNUSED)
+static int
+maildir_mailbox_create(struct mail_storage *storage, struct mailbox_list *list,
+		       const char *name, bool directory ATTR_UNUSED)
 {
 	struct stat st;
 	const char *path, *root_dir, *shared_path;
 	mode_t old_mask;
 	int fd;
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
-	root_dir = mailbox_list_get_path(_storage->list, NULL,
+	root_dir = mailbox_list_get_path(list, NULL,
 					 MAILBOX_LIST_PATH_TYPE_MAILBOX);
 
 	/* if dovecot-shared exists in the root dir, create the mailbox using
 	   its permissions and gid, and copy the dovecot-shared inside it. */
 	shared_path = t_strconcat(root_dir, "/dovecot-shared", NULL);
 	if (stat(shared_path, &st) == 0) {
-		if (maildir_create_shared(_storage, path,
+		if (maildir_create_shared(storage, list->ns, path,
 					  st.st_mode & 0666, st.st_gid) < 0)
 			return -1;
 	} else {
-		mailbox_list_get_dir_permissions(_storage->list, NULL,
+		mailbox_list_get_dir_permissions(list, NULL,
 						 &st.st_mode, &st.st_gid);
-		if (create_maildir(_storage, path, st.st_mode, st.st_gid,
-				   FALSE) < 0)
+		if (create_maildir(storage, list->ns, path,
+				   st.st_mode, st.st_gid, FALSE) < 0)
 			return -1;
 	}
 
-	/* Maildir++ spec want that maildirfolder named file is created for
+	/* Maildir++ spec wants that maildirfolder named file is created for
 	   all subfolders. */
 	path = t_strconcat(path, "/" MAILDIR_SUBFOLDER_FILENAME, NULL);
 	old_mask = umask(0777 ^ (st.st_mode & 0666));
@@ -612,16 +545,16 @@
 		/* if dovecot-shared exists, use the same group */
 		if (st.st_gid != (gid_t)-1 &&
 		    fchown(fd, (uid_t)-1, st.st_gid) < 0) {
-			mail_storage_set_critical(_storage,
+			mail_storage_set_critical(storage,
 				"fchown(%s) failed: %m", path);
 		}
 		(void)close(fd);
 	} else if (errno == ENOENT) {
-		mail_storage_set_error(_storage, MAIL_ERROR_NOTFOUND,
+		mail_storage_set_error(storage, MAIL_ERROR_NOTFOUND,
 			"Mailbox was deleted while it was being created");
 		return -1;
 	} else {
-		mail_storage_set_critical(_storage,
+		mail_storage_set_critical(storage,
 			"open(%s, O_CREAT) failed: %m", path);
 	}
 	return 0;
@@ -638,7 +571,7 @@
 		return NULL;
 
 	if (strcmp(mailbox_list_get_driver_name(list),
-		   MAILDIR_PLUSPLUS_DRIVER_NAME) != 0) {
+		   MAILBOX_LIST_NAME_MAILDIRPLUSPLUS) != 0) {
 		/* Not maildir++ driver. Don't use this trick. */
 		return NULL;
 	}
@@ -737,7 +670,7 @@
 static int
 maildir_list_delete_mailbox(struct mailbox_list *list, const char *name)
 {
-	struct maildir_storage *storage = MAILDIR_LIST_CONTEXT(list);
+	union mailbox_list_module_context *mlist = MAILDIR_LIST_CONTEXT(list);
 	struct stat st;
 	const char *src, *dest, *base;
 	int count;
@@ -749,7 +682,7 @@
 	index_storage_destroy_unrefed();
 
 	/* delete the index and control directories */
-	if (storage->list_module_ctx.super.delete_mailbox(list, name) < 0)
+	if (mlist->super.delete_mailbox(list, name) < 0)
 		return -1;
 
 	/* check if the mailbox actually exists */
@@ -835,7 +768,7 @@
 			    struct mailbox_list *newlist, const char *newname,
 			    bool rename_children)
 {
-	struct maildir_storage *oldstorage = MAILDIR_LIST_CONTEXT(oldlist);
+	struct maildir_mailbox_list *oldmlist = MAILDIR_LIST_CONTEXT(oldlist);
 	const char *path1, *path2;
 
 	if (strcmp(oldname, "INBOX") == 0) {
@@ -852,7 +785,7 @@
 		}
 	}
 
-	return oldstorage->list_module_ctx.super.
+	return oldmlist->module_ctx.super.
 		rename_mailbox(oldlist, oldname, newlist, newname,
 			       rename_children);
 }
@@ -982,11 +915,10 @@
 				enum mailbox_list_file_type type,
 				enum mailbox_info_flags *flags)
 {
-	struct maildir_storage *storage = MAILDIR_LIST_CONTEXT(ctx->list);
-	struct mail_storage *_storage = &storage->storage;
+	struct maildir_mailbox_list *mlist = MAILDIR_LIST_CONTEXT(ctx->list);
 	int ret;
 
-	if (fname[1] == mailbox_list_get_hierarchy_sep(_storage->list) &&
+	if (fname[1] == mailbox_list_get_hierarchy_sep(ctx->list) &&
 	    strcmp(fname+2, MAILDIR_UNLINK_DIRNAME) == 0) {
 		const char *path;
 		struct stat st;
@@ -1023,7 +955,7 @@
 
 	/* Check files beginning with .nfs always because they may be
 	   temporary files created by the kernel */
-	if (storage->set->maildir_stat_dirs || *fname == '\0' ||
+	if (mlist->set->maildir_stat_dirs || *fname == '\0' ||
 	    strncmp(fname, ".nfs", 4) == 0) {
 		const char *path;
 		struct stat st;
@@ -1055,11 +987,11 @@
 	return ret;
 }
 
-uint32_t maildir_get_uidvalidity_next(struct mail_storage *storage)
+uint32_t maildir_get_uidvalidity_next(struct mailbox_list *list)
 {
 	const char *path;
 
-	path = mailbox_list_get_path(storage->list, NULL,
+	path = mailbox_list_get_path(list, NULL,
 				     MAILBOX_LIST_PATH_TYPE_CONTROL);
 	path = t_strconcat(path, "/"MAILDIR_UIDVALIDITY_FNAME, NULL);
 	return mailbox_uidvalidity_next(path);
@@ -1075,6 +1007,29 @@
 	maildir_transaction_class_deinit();
 }
 
+static void maildir_list_init(struct mailbox_list *list,
+			      const struct maildir_settings *set)
+{
+	struct maildir_mailbox_list *mlist;
+
+	mlist = p_new(list->pool, struct maildir_mailbox_list, 1);
+	mlist->module_ctx.super = list->v;
+	mlist->set = set;
+
+	if (strcmp(list->name, MAILBOX_LIST_NAME_MAILDIRPLUSPLUS) == 0) {
+		list->v.iter_is_mailbox = maildirplusplus_iter_is_mailbox;
+	} else {
+		list->v.is_valid_existing_name =
+			maildir_storage_is_valid_existing_name;
+		list->v.is_valid_create_name =
+			maildir_storage_is_valid_create_name;
+		list->v.iter_is_mailbox = maildir_list_iter_is_mailbox;
+	}
+	list->v.delete_mailbox = maildir_list_delete_mailbox;
+	list->v.rename_mailbox = maildir_list_rename_mailbox;
+	MODULE_CONTEXT_SET(list, maildir_mailbox_list_module, mlist);
+}
+
 struct mail_storage maildir_storage = {
 	MEMBER(name) MAILDIR_STORAGE_NAME,
 	MEMBER(mailbox_is_file) FALSE,
@@ -1083,10 +1038,11 @@
                 maildir_get_setting_parser_info,
 		maildir_class_init,
 		maildir_class_deinit,
-		maildir_alloc,
-		maildir_create,
+		maildir_storage_alloc,
+		maildir_storage_create,
 		index_storage_destroy,
-		maildir_autodetect,
+		maildir_storage_get_list_settings,
+		maildir_storage_autodetect,
 		maildir_mailbox_open,
 		maildir_mailbox_create,
 		NULL
@@ -1096,6 +1052,7 @@
 struct mailbox maildir_mailbox = {
 	MEMBER(name) NULL, 
 	MEMBER(storage) NULL, 
+	MEMBER(list) NULL,
 
 	{
 		index_storage_is_readonly,

--- a/src/lib-storage/index/maildir/maildir-storage.h	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/maildir/maildir-storage.h	Tue Jun 02 22:30:28 2009 -0400
@@ -70,7 +70,6 @@
 struct maildir_storage {
 	struct mail_storage storage;
 
-	union mailbox_list_module_context list_module_ctx;
 	const struct maildir_settings *set;
 	const char *temp_prefix;
 
@@ -124,7 +123,7 @@
 #endif
 
 bool maildir_set_deleted(struct maildir_mailbox *mbox);
-uint32_t maildir_get_uidvalidity_next(struct mail_storage *storage);
+uint32_t maildir_get_uidvalidity_next(struct mailbox_list *list);
 
 void maildir_transaction_class_init(void);
 void maildir_transaction_class_deinit(void);

--- a/src/lib-storage/index/maildir/maildir-sync-index.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/maildir/maildir-sync-index.c	Tue Jun 02 22:30:28 2009 -0400
@@ -573,7 +573,7 @@
 
 	if (uid_validity == 0) {
 		uid_validity = hdr->uid_validity != 0 ? hdr->uid_validity :
-			maildir_get_uidvalidity_next(mbox->ibox.box.storage);
+			maildir_get_uidvalidity_next(mbox->ibox.box.list);
 		maildir_uidlist_set_uid_validity(mbox->uidlist, uid_validity);
 	}
 	maildir_uidlist_set_next_uid(mbox->uidlist, hdr_next_uid, FALSE);
@@ -635,8 +635,7 @@
 		return 1;
 	}
 
-	root_dir = mailbox_list_get_path(mail_storage_get_list(box->storage),
-					 box->name,
+	root_dir = mailbox_list_get_path(box->list, box->name,
 					 MAILBOX_LIST_PATH_TYPE_MAILBOX);
 
 	/* check if new/ changed */

--- a/src/lib-storage/index/maildir/maildir-uidlist.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/maildir/maildir-uidlist.c	Tue Jun 02 22:30:28 2009 -0400
@@ -148,7 +148,7 @@
 
         index_storage_lock_notify_reset(&uidlist->mbox->ibox);
 
-	control_dir = mailbox_list_get_path(box->storage->list, box->name,
+	control_dir = mailbox_list_get_path(box->list, box->name,
 					    MAILBOX_LIST_PATH_TYPE_CONTROL);
 	path = t_strconcat(control_dir, "/" MAILDIR_UIDLIST_NAME, NULL);
 
@@ -243,7 +243,7 @@
 	struct maildir_uidlist *uidlist;
 	const char *control_dir;
 
-	control_dir = mailbox_list_get_path(box->storage->list, box->name,
+	control_dir = mailbox_list_get_path(box->list, box->name,
 					    MAILBOX_LIST_PATH_TYPE_CONTROL);
 
 	uidlist = i_new(struct maildir_uidlist, 1);
@@ -1201,7 +1201,7 @@
 
 	i_assert(uidlist->initial_read);
 
-	control_dir = mailbox_list_get_path(box->storage->list, box->name,
+	control_dir = mailbox_list_get_path(box->list, box->name,
 					    MAILBOX_LIST_PATH_TYPE_CONTROL);
 	temp_path = t_strconcat(control_dir,
 				"/" MAILDIR_UIDLIST_NAME ".tmp", NULL);
@@ -1330,7 +1330,7 @@
 		hdr = mail_index_get_header(uidlist->ibox->view);
 		uidlist->uid_validity = hdr->uid_validity != 0 ?
 			hdr->uid_validity :
-			maildir_get_uidvalidity_next(storage);
+			maildir_get_uidvalidity_next(uidlist->ibox->box.list);
 	}
 
 
@@ -1548,8 +1548,7 @@
 		if (*p == 13 || *p == 10) {
 			struct mailbox *box = &uidlist->ibox->box;
 
-			dir = mailbox_list_get_path(box->storage->list,
-						box->name,
+			dir = mailbox_list_get_path(box->list, box->name,
 						MAILBOX_LIST_PATH_TYPE_MAILBOX);
 			i_warning("Maildir %s: Ignoring a file with #0x%x: %s",
 				  dir, *p, filename);

--- a/src/lib-storage/index/maildir/maildir-util.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/maildir/maildir-util.c	Tue Jun 02 22:30:28 2009 -0400
@@ -153,7 +153,7 @@
 		}
 		/* create index/control root directory */
 		parent = t_strdup_until(path, p);
-		mailbox_list_get_dir_permissions(box->storage->list, NULL,
+		mailbox_list_get_dir_permissions(box->list, NULL,
 						 &parent_mode, &parent_gid);
 		if (mkdir_parents_chown(parent, parent_mode, (uid_t)-1,
 					parent_gid) == 0 || errno == EEXIST) {
@@ -182,10 +182,10 @@
 	/* @UNSAFE: get a list of directories we want to create */
 	for (i = 0; i < N_ELEMENTS(subdirs); i++)
 		dirs[i] = t_strconcat(mbox->path, "/", subdirs[i], NULL);
-	dirs[i++] = mail_storage_get_mailbox_control_dir(box->storage,
-							 box->name);
-	dirs[i++] = mail_storage_get_mailbox_index_dir(box->storage,
-						       box->name);
+	dirs[i++] = mailbox_list_get_path(box->list, box->name,
+					  MAILBOX_LIST_PATH_TYPE_CONTROL);
+	dirs[i++] = mailbox_list_get_path(box->list, box->name,
+					  MAILBOX_LIST_PATH_TYPE_INDEX);
 	i_assert(i == N_ELEMENTS(dirs));
 
 	for (i = 0; i < N_ELEMENTS(dirs); i++) {

--- a/src/lib-storage/index/mbox/mbox-lock.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/mbox/mbox-lock.c	Tue Jun 02 22:30:28 2009 -0400
@@ -352,7 +352,7 @@
 		mail_storage_set_critical(&mbox->storage->storage,
 			"%s (not INBOX -> no privileged locking)", errmsg);
 	} else if (!mbox->mbox_privileged_locking) {
-		dir = mailbox_list_get_path(mbox->storage->storage.list, NULL,
+		dir = mailbox_list_get_path(mbox->ibox.box.list, NULL,
 					    MAILBOX_LIST_PATH_TYPE_DIR);
 		mail_storage_set_critical(&mbox->storage->storage,
 			"%s (under root dir %s -> no privileged locking)",

--- a/src/lib-storage/index/mbox/mbox-save.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/mbox/mbox-save.c	Tue Jun 02 22:30:28 2009 -0400
@@ -120,7 +120,7 @@
 			struct mail_storage *storage =
 				&ctx->mbox->storage->storage;
 
-			from_envelope = t_strconcat(storage->ns->user->username,
+			from_envelope = t_strconcat(storage->user->username,
 						    "@", my_hostdomain(), NULL);
 		}
 

--- a/src/lib-storage/index/mbox/mbox-storage.c	Tue Jun 02 17:42:40 2009 -0400
+++ b/src/lib-storage/index/mbox/mbox-storage.c	Tue Jun 02 22:30:28 2009 -0400
@@ -21,8 +21,6 @@
 #include <fcntl.h>
 #include <sys/stat.h>
 
-#define CREATE_MODE 0770 /* umask() should limit it more */
-
 /* How often to touch the dotlock file when using KEEP_LOCKED flag */
 #define MBOX_LOCK_TOUCH_MSECS (10*1000)
 
@@ -35,6 +33,11 @@
 #define MBOX_LIST_CONTEXT(obj) \
 	MODULE_CONTEXT(obj, mbox_mailbox_list_module)
 
+struct mbox_mailbox_list {
+	union mailbox_list_module_context module_ctx;
+	const struct mbox_settings *set;
+};
+
 /* NOTE: must be sorted for istream-header-filter. Note that it's not such
    a good idea to change this list, as the messages will then change from
    client's point of view. So if you do it, change all mailboxes' UIDVALIDITY
@@ -70,13 +73,8 @@
 static MODULE_CONTEXT_DEFINE_INIT(mbox_mailbox_list_module,
 				  &mailbox_list_module_register);
 
-static int mbox_list_iter_is_mailbox(struct mailbox_list_iterate_context *ctx,
-				     const char *dir, const char *fname,
-				     const char *mailbox_name,
-				     enum mailbox_list_file_type type,
-				     enum mailbox_info_flags *flags);
-static int mbox_list_delete_mailbox(struct mailbox_list *list,
-				    const char *name);
+static void mbox_list_init(struct mailbox_list *list,
+			   const struct mbox_settings *set);
 
 int mbox_set_syscall_error(struct mbox_mailbox *mbox, const char *function)
 {
@@ -93,6 +91,75 @@
 	return -1;
 }
 
+static const char *
+mbox_list_get_path(struct mailbox_list *list, const char *name,
+		   enum mailbox_list_path_type type)
+{
+	struct mbox_mailbox_list *mlist = MBOX_LIST_CONTEXT(list);
+	const char *path, *p;
+
+	path = mlist->module_ctx.super.get_path(list, name, type);
+	if (type == MAILBOX_LIST_PATH_TYPE_CONTROL ||
+	    type == MAILBOX_LIST_PATH_TYPE_INDEX) {
+		if (name == NULL)
+			return t_strconcat(path, "/"MBOX_INDEX_DIR_NAME, NULL);
+
+		p = strrchr(path, '/');
+		if (p == NULL)
+			return "";
+
+		return t_strconcat(t_strdup_until(path, p),
+				   "/"MBOX_INDEX_DIR_NAME"/", p+1, NULL);
+	}
+	return path;
+}
+
+static struct mail_storage *mbox_storage_alloc(void)
+{
+	struct mbox_storage *storage;
+	pool_t pool;
+
+	pool = pool_alloconly_create("mbox storage", 512+256);
+	storage = p_new(pool, struct mbox_storage, 1);
+	storage->storage = mbox_storage;
+	storage->storage.pool = pool;
+	return &storage->storage;
+}
+
+static int
+mbox_storage_create(struct mail_storage *_storage, struct mail_namespace *ns,
+		    const char **error_r ATTR_UNUSED)
+{
+	struct mbox_storage *storage = (struct mbox_storage *)_storage;
+	const char *dir;
+
+	storage->set = mail_storage_get_driver_settings(_storage);
+	mbox_list_init(ns->list, storage->set);
+
+	dir = mailbox_list_get_path(ns->list, NULL,
+				    MAILBOX_LIST_PATH_TYPE_INDEX);
+	if (*dir != '\0') {
+		_storage->temp_path_prefix = p_strconcat(_storage->pool, dir,
+			"/", mailbox_list_get_temp_prefix(ns->list), NULL);
+	}
+	return 0;
+}
+
+static void mbox_storage_get_list_settings(const struct mail_namespace *ns,
+					   struct mailbox_list_settings *set)
+{
+	if (set->layout == NULL)
+		set->layout = MAILBOX_LIST_NAME_FS;
+	if (set->subscription_fname == NULL)
+		set->subscription_fname = MBOX_SUBSCRIPTION_FILE_NAME;
+
+	if (set->inbox_path == NULL) {
+		set->inbox_path = t_strconcat(set->root_dir, "/inbox", NULL);
+		if (ns->mail_set->mail_debug)
+			i_info("mbox: INBOX defaulted to %s", set->inbox_path);
+	}
+}
+
 static bool mbox_is_file(const char *path, const char *name, bool debug)
 {
 	struct stat st;
@@ -155,357 +222,109 @@
 	return TRUE;
 }
 
-static bool mbox_autodetect(const struct mail_namespace *ns)
+static bool mbox_storage_is_root_dir(const char *dir, bool debug)
 {
-	bool debug = ns->mail_set->mail_debug;
-	const char *data = ns->set->location;
-	const char *path;
-
-	path = t_strcut(data, ':');
-	if (debug) {
-		if (strchr(data, ':') != NULL) {
-			i_info("mbox autodetect: data=%s, splitting ':' -> %s",
-			       data, path);
-		} else {
-			i_info("mbox autodetect: data=%s", data);
-		}
-	}
-
-	if (*path != '\0' && mbox_is_file(path, "INBOX file", debug))
-		return TRUE;
-
-	if (mbox_is_dir(t_strconcat(path, "/"MBOX_INDEX_DIR_NAME, NULL),
+	if (mbox_is_dir(t_strconcat(dir, "/"MBOX_INDEX_DIR_NAME, NULL),
 			"has "MBOX_INDEX_DIR_NAME"/", debug))
 		return TRUE;
-	if (mbox_is_file(t_strconcat(path, "/inbox", NULL), "has inbox", debug))
+	if (mbox_is_file(t_strconcat(dir, "/inbox", NULL), "has inbox", debug))
 		return TRUE;
-	if (mbox_is_file(t_strconcat(path, "/mbox", NULL), "has mbox", debug))
+	if (mbox_is_file(t_strconcat(dir, "/mbox", NULL), "has mbox", debug))
 		return TRUE;
-
 	return FALSE;
 }
 
-static const char *get_root_dir(struct mail_storage *storage)
+static const char *mbox_storage_find_root_dir(const struct mail_namespace *ns)
 {
-	struct mail_namespace auto_ns;
-	struct mail_namespace_settings ns_set;
+	bool debug = ns->mail_set->mail_debug;
 	const char *home, *path;
-	bool debug = storage->set->mail_debug;
 
-	if (mail_user_get_home(storage->ns->user, &home) > 0) {
-		path = t_strconcat(home, "/mail", NULL);
-		if (access(path, R_OK|W_OK|X_OK) == 0) {
-			if (debug)
-				i_info("mbox: root exists (%s)", path);
-			return path;
-		}
+	if (mail_user_get_home(ns->user, &home) <= 0) {
 		if (debug)
-			i_info("mbox: root: access(%s, rwx) failed: %m", path);
-
-		path = t_strconcat(home, "/Mail", NULL);
-		if (access(path, R_OK|W_OK|X_OK) == 0) {
-			if (debug)
-				i_info("mbox: root exists (%s)", path);
-			return path;
-		}
-		if (debug)
-			i_info("mbox: root: access(%s, rwx) failed: %m", path);
+			i_info("maildir: Home directory not set");
+		home = "";
 	}
 
-	if (debug)
-		i_info("mbox: checking if we are chrooted:");
+	path = t_strconcat(home, "/mail", NULL);
+	if (mbox_storage_is_root_dir(path, debug))
+		return path;
 
-	memset(&ns_set, 0, sizeof(ns_set));
-	ns_set.location = "";
-	memset(&auto_ns, 0, sizeof(auto_ns));
-	auto_ns.set = &ns_set;
-	auto_ns.mail_set = storage->set;
-	if (mbox_autodetect(&auto_ns))
-		return "/";
-
-	if (debug)
-		i_info("mbox: root mail directory not found");
+	path = t_strconcat(home, "/Mail", NULL);
+	if (mbox_storage_is_root_dir(path, debug))
+		return path;
 	return NULL;
 }
 
 static const char *
-get_inbox_file(const char *user, const char *root_dir,
-	       bool only_root, bool debug)
+mbox_storage_find_inbox_file(const char *user, bool debug)
 {
 	const char *path;
 
-	if (!only_root) {
-		path = t_strconcat("/var/mail/", user, NULL);
-		if (access(path, R_OK|W_OK) == 0) {
-			if (debug)
-				i_info("mbox: INBOX exists (%s)", path);
-			return path;
-		}
+	path = t_strconcat("/var/mail/", user, NULL);
+	if (access(path, R_OK|W_OK) == 0) {
 		if (debug)
-			i_info("mbox: INBOX: access(%s, rw) failed: %m", path);
-
-		path = t_strconcat("/var/spool/mail/", user, NULL);
-		if (access(path, R_OK|W_OK) == 0) {
-			if (debug)
-				i_info("mbox: INBOX exists (%s)", path);
-			return path;
-		}
-		if (debug)
-			i_info("mbox: INBOX: access(%s, rw) failed: %m", path);
+			i_info("mbox: INBOX exists (%s)", path);
+		return path;
 	}
-
-	path = t_strconcat(root_dir, "/inbox", NULL);
 	if (debug)
-		i_info("mbox: INBOX defaulted to %s", path);
-	return path;
-}
-
-static const char *create_root_dir(struct mail_storage *storage,
-				   const char **error_r)
-{
-	const char *home, *path;
+		i_info("mbox: INBOX: access(%s, rw) failed: %m", path);
 
-	if (mail_user_get_home(storage->ns->user, &home) <= 0) {
-		*error_r = "Root mail directory not set and "
-			"home directory is missing";
-		return NULL;
+	path = t_strconcat("/var/spool/mail/", user, NULL);
+	if (access(path, R_OK|W_OK) == 0) {
+		if (debug)
+			i_info("mbox: INBOX exists (%s)", path);
+		return path;
 	}
-
-	path = t_strconcat(home, "/mail", NULL);
-	if (mkdir_parents(path, CREATE_MODE) < 0 && errno != EEXIST) {
-		*error_r = mail_error_create_eacces_msg("mkdir", path);
-		return NULL;
-	}
-
-	if (storage->set->mail_debug)
-		i_info("mbox: root directory created: %s", path);
-	return path;
+	if (debug)
+		i_info("mbox: INBOX: access(%s, rw) failed: %m", path);
+	return NULL;
 }
 
-static int
-mbox_get_list_settings(struct mailbox_list_settings *list_set,
-		       const char *data, struct mail_storage *storage,
-		       const char **layout_r, const char **error_r)
+static bool mbox_storage_autodetect(const struct mail_namespace *ns,
+				    struct mailbox_list_settings *set)
 {
-	enum mail_storage_flags flags = storage->flags;
-	bool debug = storage->set->mail_debug;
-	const char *p;
-	struct stat st;
-	bool autodetect;
+	bool debug = ns->mail_set->mail_debug;
+	const char *root_dir, *inbox_path;
 
-	*layout_r = "fs";
-
-	memset(list_set, 0, sizeof(*list_set));
-	list_set->subscription_fname = MBOX_SUBSCRIPTION_FILE_NAME;
-	list_set->maildir_name = "";
-
-	autodetect = data == NULL || *data == '\0';
-	if (autodetect) {
-		if ((flags & MAIL_STORAGE_FLAG_NO_AUTODETECTION) != 0) {
-			*error_r = "Root mail directory not given";
-			return -1;
-		}
+	root_dir = set->root_dir;
+	inbox_path = set->inbox_path;
 
-		/* we'll need to figure out the mail location ourself.
-		   it's root dir if we've already chroot()ed, otherwise
-		   either ~/mail or ~/Mail */
-		list_set->root_dir = get_root_dir(storage);
-		if (list_set->root_dir == NULL) {
-			*error_r = "Autodetection failed";
-			return -1;
-		}
-	} else {
-		if (debug)
-			i_info("mbox: data=%s", data);
-		p = strchr(data, ':');
-		if ((flags & MAIL_STORAGE_FLAG_NO_AUTODETECTION) == 0 &&
-		    p == NULL && data[strlen(data)-1] != '/') {
-			/* if the data points to a file, treat it as an INBOX */
-			data = mail_user_home_expand(storage->ns->user, data);
-			if (stat(data, &st) < 0 || S_ISDIR(st.st_mode))
-				list_set->root_dir = data;
-			else {
-				list_set->root_dir = get_root_dir(storage);
-				list_set->inbox_path = data;
-			}
-		} else if (strncmp(data, "INBOX=", 6) == 0) {
-			/* the most common misconfiguration */
-			*error_r = "Root mail directory not given";
-			return -1;
-		} else {
-			if (mailbox_list_settings_parse(data, list_set,
-							storage->ns,
-							layout_r, NULL,
-							error_r) < 0)
-				return -1;
+	if (root_dir != NULL) {
+		if (inbox_path == NULL &&
+		    mbox_is_file(root_dir, "INBOX file", debug)) {
+			/* using location=<INBOX> */
+			inbox_path = root_dir;
+			root_dir = NULL;
+		} else if (!mbox_storage_is_root_dir(root_dir, debug))
+			return FALSE;
+	}
+	if (root_dir == NULL) {
+		root_dir = mbox_storage_find_root_dir(ns);
+		if (root_dir == NULL) {
+			if (debug)
+				i_info("mbox: couldn't find root dir");
+			return FALSE;
 		}
 	}
-
-	if (list_set->root_dir == NULL || *list_set->root_dir == '\0') {
-		if ((flags & MAIL_STORAGE_FLAG_NO_AUTOCREATE) != 0) {
-			*error_r = "Root mail directory not given";
-			return -1;
-		}
+	if (inbox_path == NULL) {
+		inbox_path = mbox_storage_find_inbox_file(ns->user->username,
+							  debug);
+	}
+	set->root_dir = root_dir;
+	set->inbox_path = inbox_path;
 
-		list_set->root_dir = create_root_dir(storage, error_r);
-		if (list_set->root_dir == NULL)
-			return -1;
-	} else {
-		/* make sure the directory exists */
-		if (lstat(list_set->root_dir, &st) == 0) {
-			/* yep, go ahead */
-		} else if (errno == EACCES) {
-			*error_r = mail_error_eacces_msg("lstat",
-							 list_set->root_dir);
-			return -1;
-		} else if (errno != ENOENT && errno != ENOTDIR) {
-			*error_r = t_strdup_printf("lstat(%s) failed: %m",
-						   list_set->root_dir);
-			return -1;
-		} else if (errno == ENOENT &&
-			   storage->ns->type == NAMESPACE_SHARED) {
-			/* can't create a new user, but we don't want to fail
-			   the storage creation. */
-		} else if ((flags & MAIL_STORAGE_FLAG_NO_AUTOCREATE) != 0) {
-			*error_r = t_strdup_printf(
-					"Root mail directory doesn't exist: %s",
-					list_set->root_dir);
-			return -1;
-		} else if (mkdir_parents(list_set->root_dir, CREATE_MODE) < 0 &&
-			   errno != EEXIST) {
-			*error_r = mail_error_create_eacces_msg("mkdir",
-							list_set->root_dir);
-			return -1;
-		}
-	}
-
-	if (list_set->inbox_path == NULL) {
-		list_set->inbox_path =
-			get_inbox_file(storage->ns->user->username,
-				       list_set->root_dir, !autodetect, debug);
-	}
-	return 0;
-}
-
-static const char *
-mbox_list_get_path(struct mailbox_list *list, const char *name,
-		   enum mailbox_list_path_type type)
-{
-	struct mbox_storage *storage = MBOX_LIST_CONTEXT(list);
-	const char *path, *p;
-
-	path = storage->list_module_ctx.super.get_path(list, name, type);
-	if (type == MAILBOX_LIST_PATH_TYPE_CONTROL ||
-	    type == MAILBOX_LIST_PATH_TYPE_INDEX) {
-		if (name == NULL)
-			return t_strconcat(path, "/"MBOX_INDEX_DIR_NAME, NULL);
-
-		p = strrchr(path, '/');
-		if (p == NULL)
-			return "";
-
-		return t_strconcat(t_strdup_until(path, p),
-				   "/"MBOX_INDEX_DIR_NAME"/", p+1, NULL);
-	}
-	return path;
+	mbox_storage_get_list_settings(ns, set);
+	return TRUE;
 }
 
-static struct mail_storage *mbox_alloc(void)
-{
-	struct mbox_storage *storage;
-	pool_t pool;
-
-	pool = pool_alloconly_create("mbox storage", 512+256);
-	storage = p_new(pool, struct mbox_storage, 1);
-	storage->storage = mbox_storage;
-	storage->storage.pool = pool;
-	storage->storage.storage_class = &mbox_storage;
-
-	return &storage->storage;
-}
-
-static bool mbox_name_is_dotlock(const char *name)
-{
-	unsigned int len = strlen(name);
-
-	return len >= 5 && strcmp(name + len - 5, ".lock") == 0;
-}
-
-static bool
-mbox_is_valid_existing_name(struct mailbox_list *list, const char *name)
-{
-	struct mbox_storage *storage = MBOX_LIST_CONTEXT(list);
-
-	return storage->list_module_ctx.super.
-		is_valid_existing_name(list, name) &&
-		!mbox_name_is_dotlock(name);
-}
-
-static bool
-mbox_is_valid_create_name(struct mailbox_list *list, const char *name)
-{
-	struct mbox_storage *storage = MBOX_LIST_CONTEXT(list);
-
-	return storage->list_module_ctx.super.
-		is_valid_create_name(list, name) &&
-		!mbox_name_is_dotlock(name);
-}
-
-static int mbox_create(struct mail_storage *_storage, const char *data,
-		       const char **error_r)
-{
-	struct mbox_storage *storage = (struct mbox_storage *)_storage;
-	struct mailbox_list_settings list_set;
-	const char *layout, *dir;
-
-	if (mbox_get_list_settings(&list_set, data, _storage,
-				   &layout, error_r) < 0)
-		return -1;
-	list_set.mail_storage_flags = &_storage->flags;
-	list_set.lock_method = &_storage->lock_method;
-
-	if (mailbox_list_alloc(layout, &_storage->list, error_r) < 0)
-		return -1;
-
-	storage->set = mail_storage_get_driver_settings(_storage);
-
-	storage->list_module_ctx.super = _storage->list->v;
-	if (strcmp(layout, "fs") == 0 && *list_set.maildir_name == '\0') {
-		/* have to use .imap/ directories */
-		_storage->list->v.get_path = mbox_list_get_path;
-	}
-	_storage->list->v.iter_is_mailbox = mbox_list_iter_is_mailbox;
-	_storage->list->v.delete_mailbox = mbox_list_delete_mailbox;
-	_storage->list->v.is_valid_existing_name = mbox_is_valid_existing_name;
-	_storage->list->v.is_valid_create_name = mbox_is_valid_create_name;
-
-	MODULE_CONTEXT_SET_FULL(_storage->list, mbox_mailbox_list_module,
-				storage, &storage->list_module_ctx);
-
-	/* finish list init after we've overridden vfuncs */
-	mailbox_list_init(_storage->list, _storage->ns, &list_set,
-			  MAILBOX_LIST_FLAG_MAILBOX_FILES);
-
-	dir = mailbox_list_get_path(_storage->list, NULL,
-				    MAILBOX_LIST_PATH_TYPE_INDEX);
-	if (*dir == '\0') {
-		/* no index directory. just fallback to writing to root. */
-		dir = mailbox_list_get_path(_storage->list, NULL,
-					    MAILBOX_LIST_PATH_TYPE_DIR);
-	}
-	_storage->temp_path_prefix = p_strconcat(_storage->pool, dir, "/",
-		mailbox_list_get_temp_prefix(_storage->list), NULL);
-	return 0;
-}
-
-static int verify_inbox(struct mail_storage *storage)
+static int verify_inbox(struct mailbox_list *list)
 {
 	const char *inbox_path, *rootdir;
 	int fd;
 
-	inbox_path = mailbox_list_get_path(storage->list, "INBOX",
+	inbox_path = mailbox_list_get_path(list, "INBOX",
 					   MAILBOX_LIST_PATH_TYPE_MAILBOX);
-	rootdir = mailbox_list_get_path(storage->list, "",
+	rootdir = mailbox_list_get_path(list, NULL,
 					MAILBOX_LIST_PATH_TYPE_DIR);
 
 	/* make sure inbox file itself exists */
@@ -520,17 +339,17 @@
 		(void)close(fd);
 	else if (errno == ENOTDIR &&
 		 strncmp(inbox_path, rootdir, strlen(rootdir)) == 0) {
-		mail_storage_set_critical(storage,
+		mailbox_list_set_critical(list,
 			"mbox root directory can't be a file: %s "
 			"(http://wiki.dovecot.org/MailLocation/Mbox)",
 			rootdir);
 		return -1;
 	} else if (errno == EACCES) {
-		mail_storage_set_critical(storage, "%s",
+		mailbox_list_set_critical(list, "%s",
 			mail_error_create_eacces_msg("open", inbox_path));
 		return -1;
 	} else if (errno != EEXIST) {
-		mail_storage_set_critical(storage,
+		mailbox_list_set_critical(list,
 			"open(%s, O_CREAT) failed: %m", inbox_path);
 		return -1;
 	}
@@ -574,7 +393,7 @@
 	mbox = p_new(pool, struct mbox_mailbox, 1);
 	mbox->ibox.box = mbox_mailbox;
 	mbox->ibox.box.pool = pool;
-	mbox->ibox.storage = &storage->storage;
+	mbox->ibox.box.storage = &storage->storage;
 	mbox->ibox.mail_vfuncs = &mbox_mail_vfuncs;
 	mbox->ibox.index = index;
 
@@ -596,18 +415,17 @@
 }
 
 static struct mailbox *
-mbox_open(struct mbox_storage *storage, const char *name,
-	  enum mailbox_open_flags flags)
+mbox_open(struct mbox_storage *storage, struct mailbox_list *list,
+	  const char *name, enum mailbox_open_flags flags)
 {
-	struct mail_storage *_storage = &storage->storage;
 	struct mbox_mailbox *mbox;
 	struct mail_index *index;
 	const char *path, *rootdir;
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 
-	index = index_storage_alloc(_storage, name, flags, MBOX_INDEX_PREFIX);
+	index = index_storage_alloc(list, name, flags, MBOX_INDEX_PREFIX);
 	mbox = mbox_alloc_mailbox(storage, index, name, path, flags);
 
 	if (access(path, R_OK|W_OK) < 0) {
@@ -620,7 +438,7 @@
 	if (strcmp(name, "INBOX") == 0) {
 		/* if INBOX isn't under the root directory, it's probably in
 		   /var/mail and we want to allow privileged dotlocking */
-		rootdir = mailbox_list_get_path(_storage->list, NULL,
+		rootdir = mailbox_list_get_path(list, NULL,
 						MAILBOX_LIST_PATH_TYPE_DIR);
 		if (strncmp(path, rootdir, strlen(rootdir)) != 0)
 			mbox->mbox_privileged_locking = TRUE;
@@ -630,6 +448,8 @@
 			struct mailbox *box = &mbox->ibox.box;
 
 			mailbox_close(&box);
+			mailbox_list_set_error_from_storage(list,
+							    &storage->storage);
 			return NULL;
 		}
 
@@ -643,22 +463,20 @@
 }
 
 static struct mailbox *
-mbox_mailbox_open_stream(struct mbox_storage *storage, const char *name,
+mbox_mailbox_open_stream(struct mbox_storage *storage,
+			 struct mailbox_list *list, const char *name,
 			 struct istream *input, enum mailbox_open_flags flags)
 {
-	struct mail_storage *_storage = &storage->storage;
 	struct mail_index *index;
 	struct mbox_mailbox *mbox;
 	const char *path;
 
 	flags |= MAILBOX_OPEN_READONLY;
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
-	index = index_storage_alloc(_storage, name, flags, MBOX_INDEX_PREFIX);
+	index = index_storage_alloc(list, name, flags, MBOX_INDEX_PREFIX);
 	mbox = mbox_alloc_mailbox(storage, index, name, path, flags);
-	if (mbox == NULL)
-		return NULL;
 
 	i_stream_ref(input);
 	mbox->mbox_file_stream = input;
@@ -670,50 +488,53 @@
 }
 
 static struct mailbox *
-mbox_mailbox_open(struct mail_storage *_storage, const char *name,
-		  struct istream *input, enum mailbox_open_flags flags)
+mbox_mailbox_open(struct mail_storage *_storage, struct mailbox_list *list,
+		  const char *name, struct istream *input,
+		  enum mailbox_open_flags flags)
 {
 	struct mbox_storage *storage = (struct mbox_storage *)_storage;
 	const char *path;
 	struct stat st;
 
-	if (input != NULL)
-		return mbox_mailbox_open_stream(storage, name, input, flags);
+	if (input != NULL) {
+		return mbox_mailbox_open_stream(storage, list, name,
+						input, flags);
+	}
 
 	if (strcmp(name, "INBOX") == 0 &&
-	    (_storage->ns->flags & NAMESPACE_FLAG_INBOX) != 0) {
+	    (list->ns->flags & NAMESPACE_FLAG_INBOX) != 0) {
 		/* make sure INBOX exists */
-		if (verify_inbox(_storage) < 0)
+		if (verify_inbox(list) < 0)
 			return NULL;
-		return mbox_open(storage, "INBOX", flags);
+		return mbox_open(storage, list, "INBOX", flags);
 	}
 
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (stat(path, &st) == 0) {
 		if (S_ISDIR(st.st_mode)) {
-			mail_storage_set_error(_storage, MAIL_ERROR_NOTPOSSIBLE,
+			mailbox_list_set_error(list, MAIL_ERROR_NOTPOSSIBLE,
 				t_strdup_printf("Mailbox isn't selectable: %s",
 						name));
 			return NULL;
 		}
 
-		return mbox_open(storage, name, flags);
+		return mbox_open(storage, list, name, flags);
 	}
 
 	if (ENOTFOUND(errno)) {
-		mail_storage_set_error(_storage, MAIL_ERROR_NOTFOUND,
+		mailbox_list_set_error(list, MAIL_ERROR_NOTFOUND,
 			T_MAIL_ERR_MAILBOX_NOT_FOUND(name));
-	} else if (!mail_storage_set_error_from_errno(_storage)) {
-		mail_storage_set_critical(_storage, "stat(%s) failed: %m",
-					  path);
+	} else if (!mailbox_list_set_error_from_errno(list)) {
+		mailbox_list_set_critical(list, "stat(%s) failed: %m", path);
 	}
 
 	return NULL;
 }
 
-static int mbox_mailbox_create(struct mail_storage *_storage, const char *name,
-			       bool directory)
+static int
+mbox_mailbox_create(struct mail_storage *_storage, struct mailbox_list *list,
+		    const char *name, bool directory)
 {
 	const char *path, *p;
 	struct stat st;
@@ -722,7 +543,7 @@
 	int fd;
 
 	/* make sure it doesn't exist already */
-	path = mailbox_list_get_path(_storage->list, name,
+	path = mailbox_list_get_path(list, name,
 				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (stat(path, &st) == 0) {
 		mail_storage_set_error(_storage, MAIL_ERROR_EXISTS,
@@ -745,8 +566,7 @@
 	p = directory ? path + strlen(path) : strrchr(path, '/');
 	if (p != NULL) {
 		p = t_strdup_until(path, p);
-		mailbox_list_get_dir_permissions(_storage->list, NULL,
-						 &mode, &gid);
+		mailbox_list_get_dir_permissions(list, NULL, &mode, &gid);
 		if (mkdir_parents_chown(p, mode, (uid_t)-1, gid) < 0 &&
 		    errno != EEXIST) {
 			if (!mail_storage_set_error_from_errno(_storage)) {
@@ -842,13 +662,37 @@
 	return strcmp(inbox_path, path) == 0;
 }
 
+static bool mbox_name_is_dotlock(const char *name)
+{
+	unsigned int len = strlen(name);
+
+	return len >= 5 && strcmp(name + len - 5, ".lock") == 0;
+}
+
+static bool
+mbox_is_valid_existing_name(struct mailbox_list *list, const char *name)
+{
+	struct mbox_mailbox_list *mlist = MBOX_LIST_CONTEXT(list);
+
+	return mlist->module_ctx.super.is_valid_existing_name(list, name) &&
+		!mbox_name_is_dotlock(name);
+}
+
+static bool
+mbox_is_valid_create_name(struct mailbox_list *list, const char *name)
+{
+	struct mbox_mailbox_list *mlist = MBOX_LIST_CONTEXT(list);
+
+	return mlist->module_ctx.super.is_valid_create_name(list, name) &&
+		!mbox_name_is_dotlock(name);
+}
+
 static int mbox_list_iter_is_mailbox(struct mailbox_list_iterate_context *ctx,
 				     const char *dir, const char *fname,
 				     const char *mailbox_name ATTR_UNUSED,
 				     enum mailbox_list_file_type type,
 				     enum mailbox_info_flags *flags)
 {
-	struct mail_storage *storage = MBOX_LIST_CONTEXT(ctx->list);
 	const char *path, *root_dir;
 	size_t len;
 	struct stat st;
@@ -858,7 +702,7 @@
 		return 0;
 	}
 	if (strcmp(fname, ctx->list->set.subscription_fname) == 0) {
-		root_dir = mailbox_list_get_path(storage->list, NULL,
+		root_dir = mailbox_list_get_path(ctx->list, NULL,
 						 MAILBOX_LIST_PATH_TYPE_DIR);
 		if (strcmp(root_dir, dir) == 0) {
 			*flags |= MAILBOX_NOSELECT | MAILBOX_NOINFERIORS;
@@ -916,7 +760,7 @@
 static int mbox_list_delete_mailbox(struct mailbox_list *list,
 				    const char *name)
 {
-	struct mbox_storage *storage = MBOX_LIST_CONTEXT(list);
+	struct mbox_mailbox_list *mlist = MBOX_LIST_CONTEXT(list);
 	struct stat st;
 	const char *path, *index_dir;
 
@@ -970,7 +814,7 @@
 
 	/* delete index / control files first */
 	index_storage_destroy_unrefed();
-	if (storage->list_module_ctx.super.delete_mailbox(list, name) < 0)
+	if (mlist->module_ctx.super.delete_mailbox(list, name) < 0)
 		return -1;
 
 	if (unlink(path) < 0) {
@@ -997,6 +841,28 @@
 	mbox_transaction_class_deinit();
 }
 
+static void mbox_list_init(struct mailbox_list *list,
+			   const struct mbox_settings *set)
+{
+	struct mbox_mailbox_list *mlist;
+
+	mlist = p_new(list->pool, struct mbox_mailbox_list, 1);
+	mlist->module_ctx.super = list->v;
+	mlist->set = set;
+
+	if (strcmp(list->name, MAILBOX_LIST_NAME_FS) == 0 &&
+	    *list->set.maildir_name == '\0') {
+		/* have to use .imap/ directories */
+		list->v.get_path = mbox_list_get_path;
+	}
+	list->v.iter_is_mailbox = mbox_list_iter_is_mailbox;
+	list->v.delete_mailbox = mbox_list_delete_mailbox;
+	list->v.is_valid_existing_name = mbox_is_valid_existing_name;
+	list->v.is_valid_create_name = mbox_is_valid_create_name;
+
+	MODULE_CONTEXT_SET(list, mbox_mailbox_list_module, mlist);
+}
+
 struct mail_storage mbox_storage = {
 	MEMBER(name) MBOX_STORAGE_NAME,
 	MEMBER(mailbox_is_file) TRUE,
@@ -1005,10 +871,11 @@
                 mbox_get_setting_parser_info,
 		mbox_class_init,
 		mbox_class_deinit,
-		mbox_alloc,
-		mbox_create,
+		mbox_storage_alloc,
+		mbox_storage_create,
 		index_storage_destroy,
-		mbox_autodetect,
+		mbox_storage_get_list_settings,
+		mbox_storage_autodetect,
 		mbox_mailbox_open,
 		mbox_mailbox_create,
 		NULL
@@ -1018,6 +885,7 @@
 struct mailbox mbox_mailbox = {
 	MEMBER(name) NULL, 
 	MEMBER(storage) NULL, 
+	MEMBER(list) NULL,
 
 	{
 		index_storage_is_readonly,