--- a/configure.in	Wed Nov 15 21:14:08 2006 +0200
+++ b/configure.in	Thu Nov 16 02:16:31 2006 +0200
@@ -1843,11 +1843,11 @@
 src/lib-otp/Makefile
 src/lib-settings/Makefile
 src/lib-storage/Makefile
+src/lib-storage/list/Makefile
 src/lib-storage/index/Makefile
 src/lib-storage/index/maildir/Makefile
 src/lib-storage/index/mbox/Makefile
 src/lib-storage/index/dbox/Makefile
-src/lib-storage/subscription-file/Makefile
 src/lib-storage/register/Makefile
 src/auth/Makefile
 src/deliver/Makefile

--- a/src/deliver/Makefile.am	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/deliver/Makefile.am	Thu Nov 16 02:16:31 2006 +0200
@@ -23,7 +23,7 @@
 	../lib-storage/register/libstorage-register.a \
 	$(STORAGE_LIBS) \
 	../lib-storage/libstorage.a \
-	../lib-storage/subscription-file/libstorage_subscription_file.a \
+	../lib-storage/list/libstorage_list.a \
 	../lib-imap/libimap.a \
 	../lib-mail/libmail.a \
 	../lib-dict/libdict.a \

--- a/src/imap/Makefile.am	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/imap/Makefile.am	Thu Nov 16 02:16:31 2006 +0200
@@ -22,8 +22,8 @@
 libs = \
 	../lib-storage/register/libstorage-register.a \
 	$(STORAGE_LIBS) \
+	../lib-storage/list/libstorage_list.a \
 	../lib-storage/libstorage.a \
-	../lib-storage/subscription-file/libstorage_subscription_file.a \
 	../lib-imap/libimap.a \
 	../lib-mail/libmail.a \
 	../lib-dict/libdict.a \

--- a/src/imap/cmd-list.c	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/imap/cmd-list.c	Thu Nov 16 02:16:31 2006 +0200
@@ -9,8 +9,8 @@
 #include "namespace.h"
 
 enum {
-	_MAILBOX_LIST_HIDE_CHILDREN	= 0x1000000,
-	_MAILBOX_LIST_LISTEXT		= 0x0800000
+	_MAILBOX_LIST_ITER_HIDE_CHILDREN	= 0x1000000,
+	_MAILBOX_LIST_ITER_LISTEXT		= 0x0800000
 };
 
 struct cmd_list_context {
@@ -19,7 +19,7 @@
 	enum mailbox_list_flags list_flags;
 
 	struct namespace *ns;
-	struct mailbox_list_context *list_ctx;
+	struct mailbox_list_iterate_context *list_iter;
 	struct imap_match_glob *glob;
 
 	unsigned int lsub:1;
@@ -28,24 +28,25 @@
 };
 
 static const char *
-mailbox_flags2str(enum mailbox_flags flags, enum mailbox_list_flags list_flags)
+mailbox_flags2str(enum mailbox_info_flags flags,
+		  enum mailbox_list_flags list_flags)
 {
 	const char *str;
 
 	if (flags & MAILBOX_PLACEHOLDER) {
 		i_assert((flags & ~MAILBOX_CHILDREN) == MAILBOX_PLACEHOLDER);
 
-		if ((list_flags & _MAILBOX_LIST_LISTEXT) == 0)
+		if ((list_flags & _MAILBOX_LIST_ITER_LISTEXT) == 0)
 			flags = MAILBOX_NOSELECT;
 		flags |= MAILBOX_CHILDREN;
 	}
 	if ((flags & MAILBOX_NONEXISTENT) != 0 &&
-	    (list_flags & _MAILBOX_LIST_LISTEXT) == 0) {
+	    (list_flags & _MAILBOX_LIST_ITER_LISTEXT) == 0) {
 		flags |= MAILBOX_NOSELECT;
 		flags &= ~MAILBOX_NONEXISTENT;
 	}
 
-	if ((list_flags & _MAILBOX_LIST_HIDE_CHILDREN) != 0)
+	if ((list_flags & _MAILBOX_LIST_ITER_HIDE_CHILDREN) != 0)
 		flags &= ~(MAILBOX_CHILDREN|MAILBOX_NOCHILDREN);
 
 	str = t_strconcat(
@@ -78,9 +79,9 @@
 		atom = IMAP_ARG_STR(args);
 
 		if (strcasecmp(atom, "SUBSCRIBED") == 0)
-			*list_flags |= MAILBOX_LIST_SUBSCRIBED;
+			*list_flags |= MAILBOX_LIST_ITER_SUBSCRIBED;
 		else if (strcasecmp(atom, "CHILDREN") == 0)
-			*list_flags |= MAILBOX_LIST_CHILDREN;
+			*list_flags |= MAILBOX_LIST_ITER_CHILDREN;
 		else {
 			client_send_tagline(cmd, t_strconcat(
 				"BAD Invalid list option ", atom, NULL));
@@ -97,7 +98,7 @@
 	const char *str;
 
 	if (!ctx->inbox_found && ctx->ns->inbox && ctx->match_inbox &&
-	    (ctx->list_flags & MAILBOX_LIST_SUBSCRIBED) == 0) {
+	    (ctx->list_flags & MAILBOX_LIST_ITER_SUBSCRIBED) == 0) {
 		/* INBOX always exists */
 		str = t_strdup_printf("* LIST (\\Unmarked) \"%s\" \"INBOX\"",
 				      ctx->ns->sep_str);
@@ -108,12 +109,12 @@
 static int
 list_namespace_mailboxes(struct client *client, struct cmd_list_context *ctx)
 {
-	struct mailbox_list *list;
+	struct mailbox_info *info;
 	const char *name;
 	string_t *str, *name_str;
-	int ret;
+	int ret = 0;
 
-	if (ctx->list_ctx == NULL) {
+	if (ctx->list_iter == NULL) {
 		list_namespace_inbox(client, ctx);
 		return 1;
 	}
@@ -121,13 +122,13 @@
 	t_push();
 	str = t_str_new(256);
 	name_str = t_str_new(256);
-	while ((list = mail_storage_mailbox_list_next(ctx->list_ctx)) != NULL) {
+	while ((info = mailbox_list_iter_next(ctx->list_iter)) != NULL) {
 		str_truncate(name_str, 0);
 		/* when listing INBOX from inbox=yes namespace, don't insert
 		   the namespace prefix */
-		if (strcasecmp(list->name, "INBOX") != 0 || !ctx->ns->inbox)
+		if (strcasecmp(info->name, "INBOX") != 0 || !ctx->ns->inbox)
 			str_append(name_str, ctx->ns->prefix);
-		str_append(name_str, list->name);
+		str_append(name_str, info->name);
 
 		if (ctx->ns->sep != ctx->ns->real_sep) {
                         char *p = str_c_modifiable(name_str);
@@ -156,7 +157,7 @@
 		str_truncate(str, 0);
 		str_printfa(str, "* %s (%s) \"%s\" ",
 			    ctx->lsub ? "LSUB" : "LIST",
-			    mailbox_flags2str(list->flags, ctx->list_flags),
+			    mailbox_flags2str(info->flags, ctx->list_flags),
 			    ctx->ns->sep_str);
 		imap_quote_append_string(str, name, FALSE);
 		if (client_send_line(client, str_c(str)) == 0) {
@@ -166,11 +167,15 @@
 		}
 	}
 
-        list_namespace_inbox(client, ctx);
-	t_pop();
+	if (mailbox_list_iter_deinit(&ctx->list_iter) < 0) {
+		mail_storage_set_list_error(ctx->ns->storage);
+		ret = -1;
+	}
 
-	ret = mail_storage_mailbox_list_deinit(&ctx->list_ctx);
-	ctx->list_ctx = NULL;
+	if (ret == 0)
+		list_namespace_inbox(client, ctx);
+
+	t_pop();
 	return ret < 0 ? -1 : 1;
 }
 
@@ -222,8 +227,8 @@
 	struct namespace *ns = ctx->ns;
 	const char *cur_ns_prefix, *cur_ref, *cur_mask;
 	enum imap_match_result match;
-	enum mailbox_list_flags list_flags;
 	enum imap_match_result inbox_match;
+	struct mailbox_list *list;
 	struct imap_match_glob *inbox_glob;
 	unsigned int count;
 	size_t len;
@@ -306,11 +311,11 @@
 
 		len = strlen(ns->prefix);
 		if (match == IMAP_MATCH_YES &&
-		    (ctx->list_flags & MAILBOX_LIST_SUBSCRIBED) == 0 &&
+		    (ctx->list_flags & MAILBOX_LIST_ITER_SUBSCRIBED) == 0 &&
 		    (!ctx->ns->inbox ||
 		     strncmp(ns->prefix, "INBOX", len-1) != 0)) {
 			/* The prefix itself matches */
-                        enum mailbox_flags flags;
+                        enum mailbox_info_flags flags;
 			string_t *str = t_str_new(128);
 
 			flags = MAILBOX_PLACEHOLDER;
@@ -380,12 +385,9 @@
 	cur_ref = namespace_fix_sep(ns, cur_ref);
 	cur_mask = namespace_fix_sep(ns, cur_mask);
 
-	list_flags = ctx->list_flags;
-	if ((*ns->prefix == '\0' || ns->inbox) && ctx->match_inbox)
-		list_flags |= MAILBOX_LIST_INBOX;
-	ctx->list_ctx = mail_storage_mailbox_list_init(ns->storage,
-						       cur_ref, cur_mask,
-						       list_flags);
+	list = mail_storage_get_list(ns->storage);
+	ctx->list_iter = mailbox_list_iter_init(list, cur_ref, cur_mask,
+						ctx->list_flags);
 }
 
 static bool cmd_list_continue(struct client_command_context *cmd)
@@ -395,7 +397,7 @@
 	int ret;
 
 	for (; ctx->ns != NULL; ctx->ns = ctx->ns->next) {
-		if (ctx->list_ctx == NULL)
+		if (ctx->list_iter == NULL)
 			list_namespace_init(cmd, ctx);
 
 		if ((ret = list_namespace_mailboxes(client, ctx)) < 0) {
@@ -427,21 +429,22 @@
 
 	if (lsub) {
 		/* LSUB - we don't care about flags */
-		list_flags = MAILBOX_LIST_SUBSCRIBED | MAILBOX_LIST_FAST_FLAGS |
-			_MAILBOX_LIST_HIDE_CHILDREN;
+		list_flags = MAILBOX_LIST_ITER_SUBSCRIBED |
+			MAILBOX_LIST_ITER_FAST_FLAGS |
+			_MAILBOX_LIST_ITER_HIDE_CHILDREN;
 	} else if (args[0].type != IMAP_ARG_LIST) {
 		/* LIST - allow children flags, but don't require them */
 		list_flags = 0;
 	} else {
-		list_flags = _MAILBOX_LIST_LISTEXT;
+		list_flags = _MAILBOX_LIST_ITER_LISTEXT;
 		if (!parse_list_flags(cmd, IMAP_ARG_LIST(&args[0])->args,
 				      &list_flags))
 			return TRUE;
 		args++;
 
 		/* don't show children flags unless explicitly specified */
-		if ((list_flags & MAILBOX_LIST_CHILDREN) == 0)
-			list_flags |= _MAILBOX_LIST_HIDE_CHILDREN;
+		if ((list_flags & MAILBOX_LIST_ITER_CHILDREN) == 0)
+			list_flags |= _MAILBOX_LIST_ITER_HIDE_CHILDREN;
 	}
 
 	ref = imap_arg_string(&args[0]);

--- a/src/imap/cmd-subscribe.c	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/imap/cmd-subscribe.c	Thu Nov 16 02:16:31 2006 +0200
@@ -6,6 +6,7 @@
 bool _cmd_subscribe_full(struct client_command_context *cmd, bool subscribe)
 {
         struct mail_storage *storage;
+	struct mailbox_list *list;
 	const char *mailbox, *verify_name;
 
 	/* <mailbox> */
@@ -32,7 +33,8 @@
 	if (!client_verify_mailbox_name(cmd, verify_name, subscribe, FALSE))
 		return TRUE;
 
-	if (mail_storage_set_subscribed(storage, mailbox, subscribe) < 0)
+	list = mail_storage_get_list(storage);
+	if (mailbox_list_set_subscribed(list, mailbox, subscribe) < 0)
 		client_send_storage_error(cmd, storage);
 	else {
 		client_send_tagline(cmd, subscribe ?

--- a/src/imap/commands-util.c	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/imap/commands-util.c	Thu Nov 16 02:16:31 2006 +0200
@@ -36,6 +36,7 @@
 				bool should_exist, bool should_not_exist)
 {
 	struct mail_storage *storage;
+	struct mailbox_list *list;
 	enum mailbox_name_status mailbox_status;
 	const char *p;
 	char sep;
@@ -65,7 +66,8 @@
 	}
 
 	/* check what our storage thinks of it */
-	if (mail_storage_get_mailbox_name_status(storage, mailbox,
+	list = mail_storage_get_list(storage);
+	if (mailbox_list_get_mailbox_name_status(list, mailbox,
 						 &mailbox_status) < 0) {
 		client_send_storage_error(cmd, storage);
 		return FALSE;

--- a/src/imap/main.c	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/imap/main.c	Thu Nov 16 02:16:31 2006 +0200
@@ -182,6 +182,7 @@
 	dict_driver_register(&dict_driver_client);
         mail_storage_init();
 	mail_storage_register_all();
+	mailbox_list_register_all();
 	clients_init();
 	commands_init();
 	imap_thread_init();

--- a/src/lib-storage/Makefile.am	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/Makefile.am	Thu Nov 16 02:16:31 2006 +0200
@@ -1,4 +1,4 @@
-SUBDIRS = index subscription-file register
+SUBDIRS = list index register
 
 noinst_LIBRARIES = libstorage.a
 
@@ -13,6 +13,7 @@
 	mail-copy.c \
 	mail-search.c \
 	mail-storage.c \
+	mailbox-list.c \
 	mailbox-tree.c
 
 noinst_HEADERS = \
@@ -20,4 +21,6 @@
 	mail-search.h \
 	mail-storage.h \
 	mail-storage-private.h \
+	mailbox-list.h \
+	mailbox-list-private.h \
 	mailbox-tree.h

--- a/src/lib-storage/index/dbox/Makefile.am	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/dbox/Makefile.am	Thu Nov 16 02:16:31 2006 +0200
@@ -11,7 +11,6 @@
 libstorage_dbox_a_SOURCES = \
 	dbox-file.c \
 	dbox-keywords.c \
-	dbox-list.c \
 	dbox-mail.c \
 	dbox-save.c \
 	dbox-sync.c \

--- a/src/lib-storage/index/dbox/dbox-list.c	Wed Nov 15 21:14:08 2006 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,415 +0,0 @@
-/* Copyright (C) 2002-2005 Timo Sirainen */
-
-#include "lib.h"
-#include "unlink-directory.h"
-#include "imap-match.h"
-#include "subscription-file/subscription-file.h"
-#include "dbox-storage.h"
-#include "home-expand.h"
-
-#include <dirent.h>
-#include <sys/stat.h>
-
-struct list_dir_context {
-	struct list_dir_context *prev;
-
-	DIR *dirp;
-	char *real_path, *virtual_path;
-};
-
-struct dbox_list_context {
-	struct mailbox_list_context mailbox_ctx;
-	struct index_storage *istorage;
-
-	struct imap_match_glob *glob;
-	struct subsfile_list_context *subsfile_ctx;
-
-	bool inbox_found;
-
-	struct mailbox_list *(*next)(struct dbox_list_context *ctx);
-
-	pool_t list_pool;
-	struct mailbox_list list;
-        struct list_dir_context *dir;
-};
-
-static struct mailbox_list *dbox_list_subs(struct dbox_list_context *ctx);
-static struct mailbox_list *dbox_list_path(struct dbox_list_context *ctx);
-static struct mailbox_list *dbox_list_next(struct dbox_list_context *ctx);
-
-static const char *mask_get_dir(const char *mask)
-{
-	const char *p, *last_dir;
-
-	last_dir = NULL;
-	for (p = mask; *p != '\0' && *p != '%' && *p != '*'; p++) {
-		if (*p == '/')
-			last_dir = p;
-	}
-
-	return last_dir == NULL ? NULL : t_strdup_until(mask, last_dir);
-}
-
-static const char *
-dbox_get_path(struct index_storage *storage, const char *name)
-{
-	if ((storage->storage.flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) == 0 ||
-	    name == NULL || (*name != '/' && *name != '~' && *name != '\0'))
-		return t_strconcat(storage->dir, "/", name, NULL);
-	else
-		return home_expand(name);
-}
-
-static int list_opendir(struct mail_storage *storage,
-			const char *path, bool root, DIR **dirp)
-{
-	*dirp = opendir(*path == '\0' ? "/" : path);
-	if (*dirp != NULL)
-		return 1;
-
-	if (ENOTFOUND(errno)) {
-		/* root) user gave invalid hiearchy, ignore
-		   sub) probably just race condition with other client
-		   deleting the mailbox. */
-		return 0;
-	}
-
-	if (errno == EACCES) {
-		if (!root) {
-			/* subfolder, ignore */
-			return 0;
-		}
-		mail_storage_set_error(storage, "Access denied");
-		return -1;
-	}
-
-	mail_storage_set_critical(storage, "opendir(%s) failed: %m", path);
-	return -1;
-}
-
-struct mailbox_list_context *
-dbox_mailbox_list_init(struct mail_storage *storage,
-		       const char *ref, const char *mask,
-		       enum mailbox_list_flags flags)
-{
-	struct index_storage *istorage = (struct index_storage *)storage;
-	struct dbox_list_context *ctx;
-	const char *path, *virtual_path;
-	DIR *dirp;
-
-	ctx = i_new(struct dbox_list_context, 1);
-	ctx->mailbox_ctx.storage = storage;
-	ctx->istorage = istorage;
-	ctx->list_pool = pool_alloconly_create("dbox_list", 1024);
-        ctx->next = dbox_list_next;
-
-	mail_storage_clear_error(storage);
-
-	/* check that we're not trying to do any "../../" lists */
-	if (!dbox_is_valid_mask(storage, ref) ||
-	    !dbox_is_valid_mask(storage, mask)) {
-		mail_storage_set_error(storage, "Invalid mask");
-		return &ctx->mailbox_ctx;
-	}
-
-	if (*mask == '/' || *mask == '~') {
-		/* mask overrides reference */
-	} else if (*ref != '\0') {
-		/* merge reference and mask */
-		mask = t_strconcat(ref, mask, NULL);
-	}
-
-	if ((flags & MAILBOX_LIST_SUBSCRIBED) != 0) {
-		ctx->mailbox_ctx.storage = storage;
-		ctx->mailbox_ctx.flags = flags;
-		ctx->istorage = istorage;
-		ctx->next = dbox_list_subs;
-
-		path = t_strconcat(istorage->dir,
-				   "/"DBOX_SUBSCRIPTION_FILE_NAME, NULL);
-		ctx->subsfile_ctx =
-			subsfile_list_init(storage, path);
-		if (ctx->subsfile_ctx == NULL) {
-			ctx->next = dbox_list_next;
-			ctx->mailbox_ctx.failed = TRUE;
-			return &ctx->mailbox_ctx;
-		}
-		ctx->glob = imap_match_init(default_pool, mask, TRUE, '/');
-		return &ctx->mailbox_ctx;
-	}
-
-	/* if we're matching only subdirectories, don't bother scanning the
-	   parent directories */
-	virtual_path = mask_get_dir(mask);
-
-	path = dbox_get_path(istorage, virtual_path);
-	if (list_opendir(storage, path, TRUE, &dirp) < 0)
-		return &ctx->mailbox_ctx;
-	/* if user gave invalid directory, we just don't show any results. */
-
-	ctx->mailbox_ctx.flags = flags;
-	ctx->glob = imap_match_init(default_pool, mask, TRUE, '/');
-
-	if (virtual_path != NULL && dirp != NULL)
-		ctx->next = dbox_list_path;
-
-	if (dirp != NULL) {
-		ctx->dir = i_new(struct list_dir_context, 1);
-		ctx->dir->dirp = dirp;
-		ctx->dir->real_path = i_strdup(path);
-		ctx->dir->virtual_path = i_strdup(virtual_path);
-	}
-	return &ctx->mailbox_ctx;
-}
-
-static void list_dir_context_free(struct list_dir_context *dir)
-{
-	(void)closedir(dir->dirp);
-	i_free(dir->real_path);
-	i_free(dir->virtual_path);
-	i_free(dir);
-}
-
-int dbox_mailbox_list_deinit(struct mailbox_list_context *_ctx)
-{
-	struct dbox_list_context *ctx = (struct dbox_list_context *)_ctx;
-	int ret = ctx->mailbox_ctx.failed ? -1 : 0;
-
-	if (ctx->subsfile_ctx != NULL) {
-		if (subsfile_list_deinit(ctx->subsfile_ctx) < 0)
-			ret = -1;
-	}
-
-	while (ctx->dir != NULL) {
-		struct list_dir_context *dir = ctx->dir;
-
-		ctx->dir = dir->prev;
-                list_dir_context_free(dir);
-	}
-
-	if (ctx->list_pool != NULL)
-		pool_unref(ctx->list_pool);
-	if (ctx->glob != NULL)
-		imap_match_deinit(&ctx->glob);
-	i_free(ctx);
-
-	return ret;
-}
-
-struct mailbox_list *
-dbox_mailbox_list_next(struct mailbox_list_context *_ctx)
-{
-	struct dbox_list_context *ctx = (struct dbox_list_context *)_ctx;
-
-	return ctx->next(ctx);
-}
-
-static int list_file(struct dbox_list_context *ctx, const char *fname)
-{
-        struct list_dir_context *dir;
-	const char *list_path, *real_path, *path, *mail_path;
-	struct stat st;
-	DIR *dirp;
-	size_t len;
-	enum imap_match_result match, match2;
-	int ret, noselect;
-
-	/* skip all hidden files */
-	if (fname[0] == '.')
-		return 0;
-
-	/* skip all .lock files */
-	len = strlen(fname);
-	if (len > 5 && strcmp(fname+len-5, ".lock") == 0)
-		return 0;
-
-	/* skip dbox-Mails/ dir */
-	if (strcmp(fname, DBOX_MAILDIR_NAME) == 0)
-		return 0;
-
-	/* check the mask */
-	if (ctx->dir->virtual_path == NULL)
-		list_path = fname;
-	else {
-		list_path = t_strconcat(ctx->dir->virtual_path,
-					"/", fname, NULL);
-	}
-
-	if ((match = imap_match(ctx->glob, list_path)) < 0)
-		return 0;
-
-	/* first as an optimization check if it contains dbox-Mails/ directory.
-	   that means it's a directory and it contains mails. */
-	real_path = t_strconcat(ctx->dir->real_path, "/", fname, NULL);
-	mail_path = t_strconcat(real_path, "/"DBOX_MAILDIR_NAME, NULL);
-
-	if (stat(mail_path, &st) == 0)
-		noselect = FALSE;
-	else {
-		/* non-selectable, but may contain subdirs */
-		noselect = TRUE;
-		if (stat(real_path, &st) < 0) {
-			if (ENOTFOUND(errno))
-				return 0; /* just lost it */
-
-			if (errno != EACCES && errno != ELOOP) {
-				mail_storage_set_critical(
-					ctx->mailbox_ctx.storage,
-					"stat(%s) failed: %m", real_path);
-				return -1;
-			}
-		}
-	}
-
-	if (!S_ISDIR(st.st_mode)) {
-		/* not a directory - we don't care about it */
-		return 0;
-	}
-
-	/* make sure we give only one correct INBOX */
-	if (strcasecmp(list_path, "INBOX") == 0 &&
-	    (ctx->mailbox_ctx.flags & MAILBOX_LIST_INBOX) != 0) {
-		if (ctx->inbox_found)
-			return 0;
-
-		ctx->inbox_found = TRUE;
-	}
-
-	/* scan inside the directory */
-	path = t_strconcat(list_path, "/", NULL);
-	match2 = imap_match(ctx->glob, path);
-
-	ctx->list.flags = noselect ? MAILBOX_NOSELECT : 0;
-	if (match > 0)
-		ctx->list.name = p_strdup(ctx->list_pool, list_path);
-	else if (match2 > 0)
-		ctx->list.name = p_strdup(ctx->list_pool, path);
-	else
-		ctx->list.name = NULL;
-
-	ret = match2 < 0 ? 0 :
-		list_opendir(ctx->mailbox_ctx.storage,
-			     real_path, FALSE, &dirp);
-	if (ret > 0) {
-		dir = i_new(struct list_dir_context, 1);
-		dir->dirp = dirp;
-		dir->real_path = i_strdup(real_path);
-		dir->virtual_path = i_strdup(list_path);
-
-		dir->prev = ctx->dir;
-		ctx->dir = dir;
-	} else if (ret < 0)
-		return -1;
-	return match > 0 || match2 > 0;
-}
-
-static struct mailbox_list *dbox_list_subs(struct dbox_list_context *ctx)
-{
-	struct stat st;
-	const char *name, *path, *p;
-	enum imap_match_result match = IMAP_MATCH_NO;
-
-	while ((name = subsfile_list_next(ctx->subsfile_ctx)) != NULL) {
-		match = imap_match(ctx->glob, name);
-		if (match == IMAP_MATCH_YES || match == IMAP_MATCH_PARENT)
-			break;
-	}
-
-	if (name == NULL)
-		return NULL;
-
-	ctx->list.flags = 0;
-	ctx->list.name = name;
-
-	if (match == IMAP_MATCH_PARENT) {
-		/* placeholder */
-		ctx->list.flags = MAILBOX_PLACEHOLDER;
-		while ((p = strrchr(name, '/')) != NULL) {
-			name = t_strdup_until(name, p);
-			if (imap_match(ctx->glob, name) > 0) {
-				p_clear(ctx->list_pool);
-				ctx->list.name = p_strdup(ctx->list_pool, name);
-				return &ctx->list;
-			}
-		}
-		i_unreached();
-	}
-
-	if ((ctx->mailbox_ctx.flags & MAILBOX_LIST_FAST_FLAGS) != 0)
-		return &ctx->list;
-
-	t_push();
-	path = dbox_get_path(ctx->istorage, ctx->list.name);
-	if (stat(path, &st) == 0) {
-		if (S_ISDIR(st.st_mode))
-			ctx->list.flags = MAILBOX_NOSELECT | MAILBOX_CHILDREN;
-		else {
-			ctx->list.flags = MAILBOX_NOINFERIORS;
-		}
-	} else {
-		ctx->list.flags = MAILBOX_NONEXISTENT;
-	}
-	t_pop();
-	return &ctx->list;
-}
-
-static struct mailbox_list *dbox_list_path(struct dbox_list_context *ctx)
-{
-	ctx->next = dbox_list_next;
-
-	ctx->list.flags = MAILBOX_NOSELECT | MAILBOX_CHILDREN;
-	ctx->list.name =
-		p_strconcat(ctx->list_pool, ctx->dir->virtual_path, "/", NULL);
-
-	if (imap_match(ctx->glob, ctx->list.name) > 0)
-		return &ctx->list;
-	else
-		return ctx->next(ctx);
-}
-
-static struct mailbox_list *dbox_list_inbox(struct dbox_list_context *ctx)
-{
-	ctx->list.flags = MAILBOX_UNMARKED | MAILBOX_NOCHILDREN;
-	ctx->list.name = "INBOX";
-	return &ctx->list;
-}
-
-static struct mailbox_list *dbox_list_next(struct dbox_list_context *ctx)
-{
-	struct list_dir_context *dir;
-	struct dirent *d;
-	int ret;
-
-	p_clear(ctx->list_pool);
-
-	while (ctx->dir != NULL) {
-		/* NOTE: list_file() may change ctx->dir */
-		while ((d = readdir(ctx->dir->dirp)) != NULL) {
-			t_push();
-			ret = list_file(ctx, d->d_name);
-			t_pop();
-
-			if (ret > 0)
-				return &ctx->list;
-			if (ret < 0) {
-				ctx->mailbox_ctx.failed = TRUE;
-				return NULL;
-			}
-		}
-
-		dir = ctx->dir;
-		ctx->dir = dir->prev;
-		list_dir_context_free(dir);
-	}
-
-	if (!ctx->inbox_found &&
-	    (ctx->mailbox_ctx.flags & MAILBOX_LIST_INBOX) != 0 &&
-	    ctx->glob != NULL && imap_match(ctx->glob, "INBOX")  > 0) {
-		/* show inbox */
-		ctx->inbox_found = TRUE;
-		return dbox_list_inbox(ctx);
-	}
-
-	/* finished */
-	return NULL;
-}

--- a/src/lib-storage/index/dbox/dbox-storage.c	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/dbox/dbox-storage.c	Thu Nov 16 02:16:31 2006 +0200
@@ -1,12 +1,10 @@
 /* Copyright (C) 2005 Timo Sirainen */
 
 #include "lib.h"
-#include "home-expand.h"
 #include "mkdir-parents.h"
 #include "unlink-directory.h"
-#include "subscription-file/subscription-file.h"
+#include "index-mail.h"
 #include "mail-copy.h"
-#include "index-mail.h"
 #include "dbox-uidlist.h"
 #include "dbox-sync.h"
 #include "dbox-file.h"
@@ -19,17 +17,11 @@
 
 #define CREATE_MODE 0770 /* umask() should limit it more */
 
-/* Don't allow creating too long mailbox names. They could start causing
-   problems when they reach the limit. */
-#define DBOX_MAX_MAILBOX_NAME_LENGTH (PATH_MAX/2)
-
 extern struct mail_storage dbox_storage;
 extern struct mailbox dbox_mailbox;
 
-static bool dbox_handle_errors(struct index_storage *istorage)
+static bool dbox_handle_errors(struct mail_storage *storage)
 {
-	struct mail_storage *storage = &istorage->storage;
-
 	if (ENOACCESS(errno))
 		mail_storage_set_error(storage, MAIL_STORAGE_ERR_NO_PERMISSION);
 	else if (ENOSPACE(errno))
@@ -41,25 +33,22 @@
 	return TRUE;
 }
 
-static struct mail_storage *
-dbox_create(const char *data, const char *user,
-	    enum mail_storage_flags flags,
-	    enum mail_storage_lock_method lock_method)
+static int
+dbox_get_list_settings(struct mailbox_list_settings *list_set,
+		       const char *data, enum mail_storage_flags flags)
 {
 	bool debug = (flags & MAIL_STORAGE_FLAG_DEBUG) != 0;
-	struct dbox_storage *storage;
-	struct index_storage *istorage;
-	const char *root_dir, *index_dir, *p;
+	const char *p;
 	size_t len;
-	pool_t pool;
 
-	root_dir = index_dir = NULL;
+	memset(list_set, 0, sizeof(*list_set));
+	list_set->subscription_fname = DBOX_SUBSCRIPTION_FILE_NAME;
 
 	if (data == NULL || *data == '\0') {
 		/* we won't do any guessing for this format. */
 		if (debug)
 			i_info("dbox: mailbox location not given");
-		return NULL;
+		return -1;
 	}
 
 	/* <root dir> [:INDEX=<dir>] */
@@ -67,51 +56,69 @@
 		i_info("dbox: data=%s", data);
 	p = strchr(data, ':');
 	if (p == NULL)
-		root_dir = data;
+		list_set->root_dir = data;
 	else {
-		root_dir = t_strdup_until(data, p);
+		list_set->root_dir = t_strdup_until(data, p);
 
 		do {
 			p++;
 			if (strncmp(p, "INDEX=", 6) == 0)
-				index_dir = t_strcut(p+6, ':');
+				list_set->index_dir = t_strcut(p+6, ':');
 			p = strchr(p, ':');
 		} while (p != NULL);
 	}
 
 	/* strip trailing '/' */
-	len = strlen(root_dir);
-	if (root_dir[len-1] == '/')
-		root_dir = t_strndup(root_dir, len-1);
+	len = strlen(list_set->root_dir);
+	if (list_set->root_dir[len-1] == '/')
+		list_set->root_dir = t_strndup(list_set->root_dir, len-1);
 
-	if (index_dir == NULL)
-		index_dir = root_dir;
-	else if (strcmp(index_dir, "MEMORY") == 0)
-		index_dir = NULL;
+	if (list_set->index_dir != NULL &&
+	    strcmp(list_set->index_dir, "MEMORY") == 0)
+		list_set->index_dir = "";
+	return 0;
+}
 
-	if (debug) {
-		i_info("dbox: root=%s, index=%s",
-		       root_dir, index_dir == NULL ? "" : index_dir);
-	}
+static struct mail_storage *
+dbox_create(const char *data, const char *user,
+	    enum mail_storage_flags flags,
+	    enum mail_storage_lock_method lock_method)
+{
+	struct dbox_storage *storage;
+	struct index_storage *istorage;
+	struct mailbox_list_settings list_set;
+	struct mailbox_list *list;
+	const char *error;
+	pool_t pool;
 
-        root_dir = home_expand(root_dir);
-	if (mkdir_parents(root_dir, CREATE_MODE) < 0 && errno != EEXIST) {
-		i_error("mkdir_parents(%s) failed: %m", root_dir);
+	if (dbox_get_list_settings(&list_set, data, flags) < 0)
+		return NULL;
+
+	if (mkdir_parents(list_set.root_dir, CREATE_MODE) < 0 &&
+	    errno != EEXIST) {
+		i_error("mkdir_parents(%s) failed: %m", list_set.root_dir);
 		return NULL;
 	}
 
 	pool = pool_alloconly_create("storage", 512);
 	storage = p_new(pool, struct dbox_storage, 1);
 
+	if (mailbox_list_init("fs", &list_set,
+			      mail_storage_get_list_flags(flags),
+			      mailbox_storage_list_is_mailbox, storage,
+			      &list, &error) < 0) {
+		i_error("dbox fs: %s", error);
+		pool_unref(pool);
+		return NULL;
+	}
+
 	istorage = INDEX_STORAGE(storage);
 	istorage->storage = dbox_storage;
 	istorage->storage.pool = pool;
 
-	istorage->dir = p_strdup(pool, root_dir);
-	istorage->index_dir = p_strdup(pool, home_expand(index_dir));
 	istorage->user = p_strdup(pool, user);
 	istorage->callbacks = p_new(pool, struct mail_storage_callbacks, 1);
-	index_storage_init(istorage, flags, lock_method);
+	index_storage_init(istorage, list, flags, lock_method);
 
 	return STORAGE(storage);
 }
@@ -147,124 +154,33 @@
 	return TRUE;
 }
 
-bool dbox_is_valid_mask(struct mail_storage *storage, const char *mask)
+static int create_dbox(struct mail_storage *storage, const char *path)
 {
-	const char *p;
-	bool newdir;
-
-	if ((storage->flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0)
-		return TRUE;
-
-	/* make sure it's not absolute path */
-	if (*mask == '/' || *mask == '~')
-		return FALSE;
-
-	/* make sure the mailbox name doesn't contain any foolishness:
-	   "../" could give access outside the mailbox directory.
-	   "./" and "//" could fool ACL checks. */
-	newdir = TRUE;
-	for (p = mask; *p != '\0'; p++) {
-		if (newdir) {
-			if (p[0] == '/')
-				return FALSE; /* // */
-			if (p[0] == '.') {
-				if (p[1] == '/')
-					return FALSE; /* ./ */
-				if (p[1] == '.' && p[2] == '/')
-					return FALSE; /* ../ */
-			}
-			if (strncmp(p, DBOX_MAILDIR_NAME,
-				    sizeof(DBOX_MAILDIR_NAME)-1) == 0 &&
-			    (p[sizeof(DBOX_MAILDIR_NAME)-1] == '\0' ||
-			     p[sizeof(DBOX_MAILDIR_NAME)-1] == '/')) {
-				/* don't allow the dbox-Mails directory to be
-				   used as part of the mask */
-				return FALSE;
-			}
-		}
-		newdir = p[0] == '/';
-	}
-
-	if (mask[0] == '.' && (mask[1] == '\0' ||
-			       (mask[1] == '.' && mask[2] == '\0'))) {
-		/* "." and ".." aren't allowed. */
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-static bool dbox_is_valid_create_name(struct mail_storage *storage,
-				      const char *name)
-{
-	size_t len;
-
-	len = strlen(name);
-	if (name[0] == '\0' || name[len-1] == '/' ||
-	    len > DBOX_MAX_MAILBOX_NAME_LENGTH)
-		return FALSE;
-
-	if ((storage->flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) == 0) {
-		if (mailbox_name_is_too_large(name, '/'))
-		    return FALSE;
-	}
-
-	return dbox_is_valid_mask(storage, name);
-}
-
-static bool dbox_is_valid_existing_name(struct mail_storage *storage,
-					const char *name)
-{
-	size_t len;
-
-	len = strlen(name);
-	if (name[0] == '\0' || name[len-1] == '/')
-		return FALSE;
-
-	return dbox_is_valid_mask(storage, name);
-}
-
-static const char *
-dbox_get_path(struct index_storage *storage, const char *name)
-{
-	if ((storage->storage.flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0 &&
-	    (*name == '/' || *name == '~'))
-		return home_expand(name);
-
-	return t_strconcat(storage->dir, "/", name, NULL);
-}
-
-static int create_dbox(struct index_storage *storage, const char *dir)
-{
-	const char *path;
-
-	path = t_strconcat(dir, "/", DBOX_MAILDIR_NAME, NULL);
 	if (mkdir_parents(path, CREATE_MODE) < 0 && errno != EEXIST) {
 		if (dbox_handle_errors(storage))
 			return -1;
 
-		mail_storage_set_critical(&storage->storage,
-					  "mkdir(%s) failed: %m", dir);
+		mail_storage_set_critical(storage, "mkdir(%s) failed: %m",
+					  path);
 		return -1;
 	}
 	return 0;
 }
 
-static int create_index_dir(struct index_storage *storage, const char *name)
+static int create_index_dir(struct mail_storage *storage, const char *name)
 {
-	const char *dir;
+	const char *root_dir, *index_dir;
 
-	if (storage->index_dir == NULL)
+	root_dir = mailbox_list_get_path(storage->list, name,
+					 MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	index_dir = mailbox_list_get_path(storage->list, name,
+					  MAILBOX_LIST_PATH_TYPE_INDEX);
+	if (strcmp(index_dir, root_dir) == 0)
 		return 0;
 
-	if (strcmp(storage->index_dir, storage->dir) == 0)
-		return 0;
-
-	dir = t_strconcat(storage->index_dir, "/", name,
-			  "/"DBOX_MAILDIR_NAME, NULL);
-	if (mkdir_parents(dir, CREATE_MODE) < 0 && errno != EEXIST) {
-		mail_storage_set_critical(&storage->storage,
-					  "mkdir(%s) failed: %m", dir);
+	if (mkdir_parents(index_dir, CREATE_MODE) < 0 && errno != EEXIST) {
+		mail_storage_set_critical(storage, "mkdir(%s) failed: %m",
+					  index_dir);
 		return -1;
 	}
 
@@ -278,54 +194,17 @@
 }
 
 static const char *
-dbox_get_index_dir(struct index_storage *storage, const char *name)
-{
-	const char *p;
-
-	if (storage->index_dir == NULL)
-		return NULL;
-
-	if ((storage->storage.flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0 &&
-	    (*name == '/' || *name == '~')) {
-		name = home_expand(name);
-		p = strrchr(name, '/');
-		return t_strconcat(t_strdup_until(name, p),
-				   "/"DBOX_MAILDIR_NAME"/", p+1, NULL);
-	}
-
-	return t_strconcat(storage->index_dir,
-			   "/", name, "/"DBOX_MAILDIR_NAME, NULL);
-}
-
-static const char *
-dbox_get_mailbox_path(struct mail_storage *_storage,
-		      const char *name, bool *is_file_r)
-{
-	struct dbox_storage *storage = (struct dbox_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
-
-	*is_file_r = FALSE;
-	if (*name == '\0')
-		return istorage->dir;
-	return dbox_get_path(istorage, name);
-}
-
-static const char *
 dbox_get_mailbox_control_dir(struct mail_storage *_storage, const char *name)
 {
-	struct dbox_storage *storage = (struct dbox_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
-
-	return dbox_get_path(istorage, name);
+	return mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_CONTROL);
 }
 
 static const char *
 dbox_get_mailbox_index_dir(struct mail_storage *_storage, const char *name)
 {
-	struct dbox_storage *storage = (struct dbox_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
-
-	return dbox_get_index_dir(istorage, name);
+	return mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_INDEX);
 }
 
 static struct mailbox *
@@ -333,17 +212,20 @@
 	  enum mailbox_open_flags flags)
 {
 	struct index_storage *istorage = INDEX_STORAGE(storage);
+	struct mail_storage *_storage = STORAGE(storage);
 	struct dbox_mailbox *mbox;
 	struct mail_index *index;
 	const char *path, *index_dir, *value;
 	pool_t pool;
 
-	path = dbox_get_path(istorage, name);
-	index_dir = dbox_get_index_dir(istorage, name);
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	index_dir = mailbox_list_get_path(_storage->list, name,
+					  MAILBOX_LIST_PATH_TYPE_INDEX);
 
-	if (create_dbox(istorage, path) < 0)
+	if (create_dbox(_storage, path) < 0)
 		return NULL;
-	if (create_index_dir(istorage, name) < 0)
+	if (create_index_dir(_storage, name) < 0)
 		return NULL;
 
 	index = index_storage_alloc(index_dir, path, DBOX_INDEX_PREFIX);
@@ -404,7 +286,6 @@
 		  struct istream *input, enum mailbox_open_flags flags)
 {
 	struct dbox_storage *storage = (struct dbox_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
 	const char *path;
 	struct stat st;
 
@@ -419,12 +300,13 @@
 	if (strcmp(name, "INBOX") == 0)
 		return dbox_open(storage, "INBOX", flags);
 
-	if (!dbox_is_valid_existing_name(_storage, name)) {
+	if (!mailbox_list_is_valid_existing_name(_storage->list, name)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return NULL;
 	}
 
-	path = dbox_get_path(istorage, name);
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (stat(path, &st) == 0) {
 		return dbox_open(storage, name, flags);
 	} else if (errno == ENOENT) {
@@ -442,34 +324,29 @@
 			       const char *name,
 			       bool directory __attr_unused__)
 {
-	struct dbox_storage *storage = (struct dbox_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
-	const char *path, *mail_path;
+	const char *path;
 	struct stat st;
 
 	mail_storage_clear_error(_storage);
 
-	if (!dbox_is_valid_create_name(_storage, name)) {
+	if (!mailbox_list_is_valid_create_name(_storage->list, name)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return -1;
 	}
 
-	path = dbox_get_path(istorage, name);
-	mail_path = t_strconcat(path, "/", DBOX_MAILDIR_NAME, NULL);
-
-	if (stat(mail_path, &st) == 0) {
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	if (stat(path, &st) == 0) {
 		mail_storage_set_error(_storage, "Mailbox already exists");
 		return -1;
 	}
 
-	return create_dbox(istorage, path);
+	return create_dbox(_storage, path);
 }
 
 static int dbox_mailbox_delete(struct mail_storage *_storage,
 			       const char *name)
 {
-	struct dbox_storage *storage = (struct dbox_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
 	const char *path, *mail_path;
 	struct stat st;
 
@@ -480,16 +357,19 @@
 		return -1;
 	}
 
-	if (!dbox_is_valid_existing_name(_storage, name)) {
+	if (!mailbox_list_is_valid_existing_name(_storage->list, name)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return -1;
 	}
 
-	path = dbox_get_path(istorage, name);
-	mail_path = t_strconcat(path, "/", DBOX_MAILDIR_NAME, NULL);
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_DIR);
+	mail_path = mailbox_list_get_path(_storage->list, name,
+					  MAILBOX_LIST_PATH_TYPE_MAILBOX);
 
 	if (stat(mail_path, &st) < 0 && ENOTFOUND(errno)) {
 		if (stat(path, &st) < 0) {
+			/* doesn't exist at all */
 			mail_storage_set_error(_storage,
 				MAIL_STORAGE_ERR_MAILBOX_NOT_FOUND, name);
 			return -1;
@@ -515,7 +395,7 @@
 	index_storage_destroy_unrefed();
 
 	if (unlink_directory(mail_path, TRUE) < 0) {
-		if (!dbox_handle_errors(istorage)) {
+		if (!dbox_handle_errors(_storage)) {
 			mail_storage_set_critical(_storage,
 				"unlink_directory() failed for %s: %m",
 				mail_path);
@@ -524,14 +404,15 @@
 	}
 	/* try also removing the root directory. it can fail if the deleted
 	   mailbox had submailboxes. do it as long as we can. */
-	while (rmdir(path) == 0) {
+	while (rmdir(path) == 0 || errno == ENOENT) {
 		const char *p = strrchr(name, '/');
 
 		if (p == NULL)
 			break;
 
 		name = t_strdup_until(name, p);
-		path = dbox_get_path(istorage, name);
+		path = mailbox_list_get_path(_storage->list, name,
+					     MAILBOX_LIST_PATH_TYPE_DIR);
 	}
 	return 0;
 }
@@ -539,27 +420,28 @@
 static int dbox_mailbox_rename(struct mail_storage *_storage,
 			       const char *oldname, const char *newname)
 {
-	struct index_storage *storage = (struct index_storage *)_storage;
 	const char *oldpath, *newpath, *p;
 	struct stat st;
 
 	mail_storage_clear_error(_storage);
 
-	if (!dbox_is_valid_existing_name(_storage, oldname) ||
-	    !dbox_is_valid_create_name(_storage, newname)) {
+	if (!mailbox_list_is_valid_existing_name(_storage->list, oldname) ||
+	    !mailbox_list_is_valid_create_name(_storage->list, newname)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return -1;
 	}
 
-	oldpath = dbox_get_path(storage, oldname);
-	newpath = dbox_get_path(storage, newname);
+	oldpath = mailbox_list_get_path(_storage->list, oldname,
+					MAILBOX_LIST_PATH_TYPE_DIR);
+	newpath = mailbox_list_get_path(_storage->list, newname,
+					MAILBOX_LIST_PATH_TYPE_DIR);
 
 	/* create the hierarchy */
 	p = strrchr(newpath, '/');
 	if (p != NULL) {
 		p = t_strdup_until(newpath, p);
 		if (mkdir_parents(p, CREATE_MODE) < 0) {
-			if (dbox_handle_errors(storage))
+			if (dbox_handle_errors(_storage))
 				return -1;
 
 			mail_storage_set_critical(_storage,
@@ -592,7 +474,7 @@
 		if (ENOTFOUND(errno)) {
 			mail_storage_set_error(_storage,
 				MAIL_STORAGE_ERR_MAILBOX_NOT_FOUND, oldname);
-		} else if (!dbox_handle_errors(storage)) {
+		} else if (!dbox_handle_errors(_storage)) {
 			mail_storage_set_critical(_storage,
 				"rename(%s, %s) failed: %m", oldpath, newpath);
 		}
@@ -602,58 +484,6 @@
 	return 0;
 }
 
-static int dbox_set_subscribed(struct mail_storage *_storage,
-			       const char *name, bool set)
-{
-	struct dbox_storage *storage = (struct dbox_storage *)_storage;
-	const char *path;
-
-	path = t_strconcat(INDEX_STORAGE(storage)->dir,
-			   "/"DBOX_SUBSCRIPTION_FILE_NAME, NULL);
-
-	return subsfile_set_subscribed(_storage, path,
-				       INDEX_STORAGE(storage)->temp_prefix,
-				       name, set);
-}
-
-static int dbox_get_mailbox_name_status(struct mail_storage *_storage,
-					const char *name,
-					enum mailbox_name_status *status)
-{
-	struct index_storage *storage = (struct index_storage *)_storage;
-	struct stat st;
-	const char *path, *mail_path;
-
-	mail_storage_clear_error(_storage);
-
-	if (!dbox_is_valid_existing_name(_storage, name)) {
-		*status = MAILBOX_NAME_INVALID;
-		return 0;
-	}
-
-	path = dbox_get_path(storage, name);
-	mail_path = t_strconcat(path, "/", DBOX_MAILDIR_NAME, NULL);
-
-	if (strcmp(name, "INBOX") == 0 || stat(mail_path, &st) == 0) {
-		*status = MAILBOX_NAME_EXISTS;
-		return 0;
-	}
-
-	if (!dbox_is_valid_create_name(_storage, name)) {
-		*status = MAILBOX_NAME_INVALID;
-		return 0;
-	}
-
-	if (errno == ENOENT) {
-		*status = MAILBOX_NAME_VALID;
-		return 0;
-	} else {
-		mail_storage_set_critical(_storage, "stat(%s) failed: %m",
-					  path);
-		return -1;
-	}
-}
-
 static int dbox_storage_close(struct mailbox *box)
 {
 	struct dbox_mailbox *mbox = (struct dbox_mailbox *)box;
@@ -686,6 +516,69 @@
 		t_strconcat(mbox->path, "/"DBOX_MAILDIR_NAME, NULL));
 }
 
+static int dbox_is_mailbox(struct mail_storage *storage,
+			   const char *dir, const char *fname,
+			   enum mailbox_list_iter_flags iter_flags,
+			   enum mailbox_info_flags *flags,
+			   enum mailbox_list_file_type type)
+{
+	const char *path, *mail_path;
+	size_t len;
+	struct stat st;
+	int ret = 1;
+
+	if (strcmp(fname, DBOX_MAILDIR_NAME) == 0) {
+		*flags = MAILBOX_NOSELECT;
+		return 0;
+	}
+
+	/* skip all .lock files */
+	len = strlen(fname);
+	if (len > 5 && strcmp(fname+len-5, ".lock") == 0) {
+		*flags = MAILBOX_NOSELECT | MAILBOX_NOINFERIORS;
+		return 0;
+	}
+
+	/* try to avoid stat() with these checks */
+	if (type != MAILBOX_LIST_FILE_TYPE_DIR &&
+	    type != MAILBOX_LIST_FILE_TYPE_SYMLINK &&
+	    type != MAILBOX_LIST_FILE_TYPE_UNKNOWN &&
+	    (iter_flags & MAILBOX_LIST_ITER_FAST_FLAGS) != 0) {
+		/* it's a file */
+		*flags |= MAILBOX_NOSELECT | MAILBOX_NOINFERIORS;
+		return 0;
+	}
+
+	/* need to stat() then */
+	t_push();
+	path = t_strconcat(dir, "/", fname, NULL);
+	mail_path = t_strconcat(path, "/"DBOX_MAILDIR_NAME, NULL);
+
+	if (stat(mail_path, &st) == 0) {
+		if (!S_ISDIR(st.st_mode)) {
+			/* non-directory */
+			*flags |= MAILBOX_NOSELECT | MAILBOX_NOINFERIORS;
+			ret = 0;
+		}
+	} else {
+		/* non-selectable, but may contain subdirs */
+		*flags |= MAILBOX_NOSELECT;
+		if (stat(path, &st) < 0) {
+			if (ENOTFOUND(errno)) {
+				/* just lost it */
+				ret = 0;
+			} else if (errno != EACCES && errno != ELOOP) {
+				mail_storage_set_critical(storage,
+					"stat(%s) failed: %m", path);
+				ret = -1;
+			}
+		}
+	}
+	t_pop();
+
+	return ret;
+}
+
 static void dbox_class_init(void)
 {
 	dbox_transaction_class_init();
@@ -698,7 +591,7 @@
 
 struct mail_storage dbox_storage = {
 	MEMBER(name) DBOX_STORAGE_NAME,
-	MEMBER(hierarchy_sep) '/',
+	MEMBER(mailbox_is_file) FALSE,
 
 	{
 		dbox_class_init,
@@ -707,18 +600,13 @@
 		dbox_free,
 		dbox_autodetect,
 		index_storage_set_callbacks,
-		dbox_get_mailbox_path,
 		dbox_get_mailbox_control_dir,
 		dbox_get_mailbox_index_dir,
 		dbox_mailbox_open,
 		dbox_mailbox_create,
 		dbox_mailbox_delete,
 		dbox_mailbox_rename,
-		dbox_mailbox_list_init,
-		dbox_mailbox_list_next,
-		dbox_mailbox_list_deinit,
-		dbox_set_subscribed,
-		dbox_get_mailbox_name_status,
+		dbox_is_mailbox,
 		index_storage_get_last_error
 	}
 };

--- a/src/lib-storage/index/dbox/dbox-storage.h	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/dbox/dbox-storage.h	Thu Nov 16 02:16:31 2006 +0200
@@ -77,13 +77,6 @@
 
 extern struct mail_vfuncs dbox_mail_vfuncs;
 
-struct mailbox_list_context *
-dbox_mailbox_list_init(struct mail_storage *storage,
-		       const char *ref, const char *mask,
-		       enum mailbox_list_flags flags);
-int dbox_mailbox_list_deinit(struct mailbox_list_context *ctx);
-struct mailbox_list *dbox_mailbox_list_next(struct mailbox_list_context *ctx);
-
 void dbox_transaction_created(struct mail_index_transaction *t);
 void dbox_transaction_class_init(void);
 void dbox_transaction_class_deinit(void);
@@ -101,8 +94,6 @@
 void dbox_transaction_save_commit_post(struct dbox_save_context *ctx);
 void dbox_transaction_save_rollback(struct dbox_save_context *ctx);
 
-bool dbox_is_valid_mask(struct mail_storage *storage, const char *mask);
-
 int dbox_mail_lookup_offset(struct index_transaction_context *trans,
 			    uint32_t seq, uint32_t *file_seq_r,
 			    uoff_t *offset_r);

--- a/src/lib-storage/index/index-storage.c	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/index-storage.c	Thu Nov 16 02:16:31 2006 +0200
@@ -41,9 +41,11 @@
 static int index_storage_refcount = 0;
 
 void index_storage_init(struct index_storage *storage,
+			struct mailbox_list *list,
 			enum mail_storage_flags flags,
 			enum mail_storage_lock_method lock_method)
 {
+	storage->storage.list = list;
 	storage->storage.flags = flags;
 	storage->storage.lock_method = lock_method;
 
@@ -95,8 +97,11 @@
 	struct stat st, st2;
 	int destroy_count;
 
-	if (index_dir == NULL || stat(index_dir, &st) < 0)
+	if (*index_dir == '\0' || stat(index_dir, &st) < 0) {
+		if (*index_dir == '\0')
+			index_dir = NULL;
 		memset(&st, 0, sizeof(st));
+	}
 
 	/* compare index_dir inodes so we don't break even with symlinks.
 	   for in-memory indexes compare just mailbox paths */

--- a/src/lib-storage/index/index-storage.h	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/index-storage.h	Thu Nov 16 02:16:31 2006 +0200
@@ -24,11 +24,6 @@
 struct index_storage {
 	struct mail_storage storage;
 
-	const char *dir; /* root directory */
-	const char *index_dir;
-	const char *inbox_path; /* INBOX location */
-        const char *temp_prefix; /* prefix for temporary files */
-
 	const char *user; /* name of user accessing the storage */
 
 	struct mail_storage_callbacks *callbacks;
@@ -113,6 +108,7 @@
 void index_storage_destroy_unrefed(void);
 
 void index_storage_init(struct index_storage *storage,
+			struct mailbox_list *list,
 			enum mail_storage_flags flags,
 			enum mail_storage_lock_method lock_method);
 void index_storage_deinit(struct index_storage *storage);

--- a/src/lib-storage/index/maildir/Makefile.am	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/maildir/Makefile.am	Thu Nov 16 02:16:31 2006 +0200
@@ -11,7 +11,6 @@
 libstorage_maildir_a_SOURCES = \
 	maildir-copy.c \
 	maildir-keywords.c \
-	maildir-list.c \
 	maildir-mail.c \
 	maildir-save.c \
 	maildir-storage.c \

--- a/src/lib-storage/index/maildir/maildir-list.c	Wed Nov 15 21:14:08 2006 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,401 +0,0 @@
-/* Copyright (C) 2002 Timo Sirainen */
-
-#include "lib.h"
-#include "ioloop.h"
-#include "str.h"
-#include "home-expand.h"
-#include "unlink-directory.h"
-#include "imap-match.h"
-#include "subscription-file/subscription-file.h"
-#include "maildir-storage.h"
-#include "mailbox-tree.h"
-
-#include <stdlib.h>
-#include <dirent.h>
-#include <sys/stat.h>
-
-#define MAILBOX_FLAG_MATCHED 0x40000000
-
-struct maildir_list_context {
-	struct mailbox_list_context mailbox_ctx;
-	pool_t pool;
-
-	const char *dir, *prefix;
-
-        struct mailbox_tree_context *tree_ctx;
-
-	string_t *node_path;
-	size_t parent_pos;
-	struct mailbox_node *root, *next_node;
-	struct mailbox_list list;
-};
-
-static void maildir_nodes_fix(struct mailbox_node *node, bool is_subs)
-{
-	while (node != NULL) {
-		if (node->children != NULL) {
-			node->flags |= MAILBOX_CHILDREN;
-			node->flags &= ~MAILBOX_NOCHILDREN;
-			maildir_nodes_fix(node->children, is_subs);
-		} else if ((node->flags & MAILBOX_PLACEHOLDER) != 0) {
-			if (!is_subs) {
-				node->flags &= ~MAILBOX_PLACEHOLDER;
-				node->flags |= MAILBOX_NOSELECT;
-			}
-		}
-		node = node->next;
-	}
-}
-
-static bool
-maildir_fill_readdir(struct maildir_list_context *ctx,
-		     struct imap_match_glob *glob, bool update_only)
-{
-	DIR *dirp;
-	struct dirent *d;
-	struct stat st;
-	const char *path, *p, *mailbox_c;
-	string_t *mailbox;
-	enum imap_match_result match;
-	struct mailbox_node *node;
-	bool stat_dirs, created, hide;
-
-	dirp = opendir(ctx->dir);
-	if (dirp == NULL) {
-		if (errno != ENOENT) {
-			mail_storage_set_critical(ctx->mailbox_ctx.storage,
-				"opendir(%s) failed: %m", ctx->dir);
-			return FALSE;
-		}
-		return TRUE;
-	}
-
-	stat_dirs = getenv("MAILDIR_STAT_DIRS") != NULL;
-
-	t_push();
-	mailbox = t_str_new(PATH_MAX);
-	while ((d = readdir(dirp)) != NULL) {
-		const char *fname = d->d_name;
-
-		if (fname[0] != MAILDIR_FS_SEP)
-			continue;
-
-		/* skip . and .. */
-		if (fname[0] == '.' &&
-		    (fname[1] == '\0' || (fname[1] == '.' && fname[2] == '\0')))
-			continue;
-
-#ifdef HAVE_DIRENT_D_TYPE
-		/* check the type always since there's no extra cost */
-		if (d->d_type == DT_DIR)
-			;
-		else if (d->d_type != DT_UNKNOWN && d->d_type != DT_LNK)
-			continue;
-		else if (d->d_type == DT_LNK && !stat_dirs)
-			;
-		else
-#endif
-		/* Check files beginning with .nfs always because they may be
-		   temporary files created by the kernel */
-		if (stat_dirs || strncmp(fname, ".nfs", 4) == 0) {
-			t_push();
-			path = t_strdup_printf("%s/%s", ctx->dir, fname);
-			hide = stat(path, &st) < 0 || !S_ISDIR(st.st_mode);
-			t_pop();
-			if (hide)
-				continue;
-		}
-
-		if (fname[1] == MAILDIR_FS_SEP &&
-		    strcmp(fname+1, MAILDIR_UNLINK_DIRNAME) == 0) {
-			/* this directory is in the middle of being deleted,
-			   or the process trying to delete it had died.
-			   delete it ourself if it's been there longer than
-			   one hour. */
-			t_push();
-			path = t_strdup_printf("%s/%s", ctx->dir, fname);
-			if (stat(path, &st) == 0 &&
-			    st.st_mtime < ioloop_time - 3600)
-				(void)unlink_directory(path, TRUE);
-			t_pop();
-			continue;
-		}
-		fname++;
-
-		/* make sure the mask matches */
-		str_truncate(mailbox, 0);
-		str_append(mailbox, ctx->prefix);
-		str_append(mailbox, fname);
-                mailbox_c = str_c(mailbox);
-
-		match = imap_match(glob, mailbox_c);
-
-		if (match != IMAP_MATCH_YES &&
-		    match != IMAP_MATCH_PARENT)
-			continue;
-
-		if (match == IMAP_MATCH_PARENT) {
-			t_push();
-			while ((p = strrchr(mailbox_c,
-					    MAILDIR_FS_SEP)) != NULL) {
-				str_truncate(mailbox, (size_t) (p-mailbox_c));
-				mailbox_c = str_c(mailbox);
-				if (imap_match(glob, mailbox_c) > 0)
-					break;
-			}
-			i_assert(p != NULL);
-
-			created = FALSE;
-			node = update_only ?
-				mailbox_tree_update(ctx->tree_ctx, mailbox_c) :
-				mailbox_tree_get(ctx->tree_ctx,
-						 mailbox_c, &created);
-			if (node != NULL) {
-				if (created)
-					node->flags = MAILBOX_PLACEHOLDER;
-
-				node->flags |= MAILBOX_CHILDREN |
-					MAILBOX_FLAG_MATCHED;
-				node->flags &= ~MAILBOX_NOCHILDREN;
-			}
-
-			t_pop();
-		} else {
-			created = FALSE;
-			node = update_only ?
-				mailbox_tree_update(ctx->tree_ctx, mailbox_c) :
-				mailbox_tree_get(ctx->tree_ctx,
-						 mailbox_c, &created);
-
-			if (node != NULL) {
-				if (created)
-					node->flags = MAILBOX_NOCHILDREN;
-				node->flags &= ~(MAILBOX_PLACEHOLDER |
-						 MAILBOX_NONEXISTENT);
-				node->flags |= MAILBOX_FLAG_MATCHED;
-			}
-		}
-	}
-	t_pop();
-
-	if (closedir(dirp) < 0) {
-		mail_storage_set_critical(ctx->mailbox_ctx.storage,
-					  "readdir(%s) failed: %m", ctx->dir);
-		return FALSE;
-	}
-
-	if ((ctx->mailbox_ctx.flags &
-	     (MAILBOX_LIST_SUBSCRIBED |
-	      MAILBOX_LIST_INBOX)) == MAILBOX_LIST_INBOX) {
-		/* make sure INBOX is there */
-		node = mailbox_tree_get(ctx->tree_ctx, "INBOX", &created);
-		if (created)
-			node->flags = MAILBOX_NOCHILDREN;
-		else
-			node->flags &= ~MAILBOX_PLACEHOLDER;
-
-		switch (imap_match(glob, "INBOX")) {
-		case IMAP_MATCH_YES:
-		case IMAP_MATCH_PARENT:
-			node->flags |= MAILBOX_FLAG_MATCHED;
-			break;
-		default:
-			break;
-		}
-	}
-	maildir_nodes_fix(mailbox_tree_get(ctx->tree_ctx, NULL, NULL),
-			  (ctx->mailbox_ctx.flags &
-			   MAILBOX_LIST_SUBSCRIBED) != 0);
-	return TRUE;
-}
-
-static bool maildir_fill_subscribed(struct maildir_list_context *ctx,
-				    struct imap_match_glob *glob)
-{
-	struct maildir_storage *storage =
-		(struct maildir_storage *)ctx->mailbox_ctx.storage;
-	struct subsfile_list_context *subsfile_ctx;
-	const char *path, *name, *p;
-	struct mailbox_node *node;
-	bool created;
-
-	path = t_strconcat(storage->control_dir != NULL ?
-			   storage->control_dir : INDEX_STORAGE(storage)->dir,
-			   "/" SUBSCRIPTION_FILE_NAME, NULL);
-	subsfile_ctx = subsfile_list_init(ctx->mailbox_ctx.storage, path);
-	if (subsfile_ctx == NULL)
-		return FALSE;
-
-	while ((name = subsfile_list_next(subsfile_ctx)) != NULL) {
-		switch (imap_match(glob, name)) {
-		case IMAP_MATCH_YES:
-			node = mailbox_tree_get(ctx->tree_ctx, name, NULL);
-			node->flags = MAILBOX_FLAG_MATCHED;
-			if ((ctx->mailbox_ctx.flags &
-			     MAILBOX_LIST_FAST_FLAGS) == 0) {
-				node->flags |= MAILBOX_NONEXISTENT |
-					MAILBOX_NOCHILDREN;
-			}
-			break;
-		case IMAP_MATCH_PARENT:
-			/* placeholder */
-			while ((p = strrchr(name, MAILDIR_FS_SEP)) != NULL) {
-				name = t_strdup_until(name, p);
-				if (imap_match(glob, name) > 0)
-					break;
-			}
-			i_assert(p != NULL);
-
-			node = mailbox_tree_get(ctx->tree_ctx, name, &created);
-			if (created) node->flags = MAILBOX_PLACEHOLDER;
-			node->flags |= MAILBOX_FLAG_MATCHED | MAILBOX_CHILDREN;
-			node->flags &= ~MAILBOX_NOCHILDREN;
-			break;
-		default:
-			break;
-		}
-	}
-
-	return subsfile_list_deinit(subsfile_ctx) == 0;
-
-}
-
-struct mailbox_list_context *
-maildir_mailbox_list_init(struct mail_storage *storage,
-			  const char *ref, const char *mask,
-			  enum mailbox_list_flags flags)
-{
-	struct index_storage *istorage = (struct index_storage *)storage;
-        struct maildir_list_context *ctx;
-        struct imap_match_glob *glob;
-	const char *dir, *p;
-	pool_t pool;
-
-	mail_storage_clear_error(storage);
-
-	pool = pool_alloconly_create("maildir_list", 1024);
-	ctx = p_new(pool, struct maildir_list_context, 1);
-	ctx->mailbox_ctx.storage = storage;
-	ctx->mailbox_ctx.flags = flags;
-	ctx->pool = pool;
-	ctx->tree_ctx = mailbox_tree_init(MAILDIR_FS_SEP);
-
-	if (*ref != '\0') {
-		/* join reference + mask */
-		mask = t_strconcat(ref, mask, NULL);
-	}
-
-	glob = imap_match_init(pool, mask, TRUE, MAILDIR_FS_SEP);
-
-	ctx->dir = istorage->dir;
-	ctx->prefix = "";
-
-	if ((flags & MAILBOX_LIST_SUBSCRIBED) != 0) {
-		if (!maildir_fill_subscribed(ctx, glob)) {
-			ctx->mailbox_ctx.failed = TRUE;
-			return &ctx->mailbox_ctx;
-		}
-	} else if ((storage->flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0 &&
-		   (p = strrchr(mask, '/')) != NULL) {
-		dir = t_strdup_until(mask, p);
-		ctx->prefix = p_strdup_until(pool, mask, p+1);
-
-		if (*mask != '/' && *mask != '~')
-			dir = t_strconcat(istorage->dir, "/", dir, NULL);
-		ctx->dir = p_strdup(pool, home_expand(dir));
-	}
-
-	if ((flags & MAILBOX_LIST_SUBSCRIBED) == 0 ||
-	    (ctx->mailbox_ctx.flags & MAILBOX_LIST_FAST_FLAGS) == 0) {
-		bool update_only = (flags & MAILBOX_LIST_SUBSCRIBED) != 0;
-		if (!maildir_fill_readdir(ctx, glob, update_only)) {
-			ctx->mailbox_ctx.failed = TRUE;
-			return &ctx->mailbox_ctx;
-		}
-	}
-
-	ctx->node_path = str_new(pool, 256);
-	ctx->root = mailbox_tree_get(ctx->tree_ctx, NULL, NULL);
-	ctx->mailbox_ctx.storage = storage;
-	return &ctx->mailbox_ctx;
-}
-
-int maildir_mailbox_list_deinit(struct mailbox_list_context *_ctx)
-{
-	struct maildir_list_context *ctx = (struct maildir_list_context *)_ctx;
-	int ret = ctx->mailbox_ctx.failed ? -1 : 0;
-
-	mailbox_tree_deinit(ctx->tree_ctx);
-	pool_unref(ctx->pool);
-	return ret;
-}
-
-static struct mailbox_node *find_next(struct mailbox_node **node,
-				      string_t *path, char hierarchy_sep)
-{
-	struct mailbox_node *child;
-	size_t len;
-
-	while (*node != NULL) {
-		if (((*node)->flags & MAILBOX_FLAG_MATCHED) != 0)
-			return *node;
-
-		if ((*node)->children != NULL) {
-			len = str_len(path);
-			if (len != 0)
-				str_append_c(path, hierarchy_sep);
-			str_append(path, (*node)->name);
-
-			child = find_next(&(*node)->children, path,
-					  hierarchy_sep);
-			if (child != NULL)
-				return child;
-
-			str_truncate(path, len);
-		}
-
-		*node = (*node)->next;
-	}
-
-	return NULL;
-}
-
-struct mailbox_list *
-maildir_mailbox_list_next(struct mailbox_list_context *_ctx)
-{
-	struct maildir_list_context *ctx = (struct maildir_list_context *)_ctx;
-	struct mailbox_node *node;
-
-	for (node = ctx->next_node; node != NULL; node = node->next) {
-		if ((node->flags & MAILBOX_FLAG_MATCHED) != 0)
-			break;
-	}
-
-	if (node == NULL) {
-		if (ctx->root == NULL)
-			return NULL;
-
-		str_truncate(ctx->node_path, 0);
-		node = find_next(&ctx->root, ctx->node_path,
-				 ctx->mailbox_ctx.storage->hierarchy_sep);
-                ctx->parent_pos = str_len(ctx->node_path);
-
-		if (node == NULL)
-			return NULL;
-	}
-	ctx->next_node = node->next;
-
-	i_assert((node->flags & MAILBOX_FLAG_MATCHED) != 0);
-	node->flags &= ~MAILBOX_FLAG_MATCHED;
-
-	str_truncate(ctx->node_path, ctx->parent_pos);
-	if (ctx->parent_pos != 0) {
-		str_append_c(ctx->node_path,
-			     ctx->mailbox_ctx.storage->hierarchy_sep);
-	}
-	str_append(ctx->node_path, node->name);
-
-	ctx->list.name = str_c(ctx->node_path);
-	ctx->list.flags = node->flags;
-	return &ctx->list;
-}

--- a/src/lib-storage/index/maildir/maildir-storage.c	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/maildir/maildir-storage.c	Thu Nov 16 02:16:31 2006 +0200
@@ -1,12 +1,12 @@
 /* Copyright (C) 2002-2006 Timo Sirainen */
 
 #include "lib.h"
+#include "ioloop.h"
 #include "array.h"
 #include "hostpid.h"
 #include "home-expand.h"
 #include "mkdir-parents.h"
 #include "unlink-directory.h"
-#include "subscription-file/subscription-file.h"
 #include "maildir-storage.h"
 #include "maildir-uidlist.h"
 #include "maildir-keywords.h"
@@ -19,10 +19,7 @@
 
 #define CREATE_MODE 0777 /* umask() should limit it more */
 
-/* Don't allow creating too long mailbox names. They could start causing
-   problems when they reach the limit. */
-#define MAILDIR_MAX_MAILBOX_NAME_LENGTH (PATH_MAX/2)
-
+#define MAILDIR_PLUSPLUS_DRIVER_NAME "maildir++"
 #define MAILDIR_SUBFOLDER_FILENAME "maildirfolder"
 
 struct rename_context {
@@ -36,27 +33,38 @@
 
 static const char *maildirs[] = { "cur", "new", "tmp", NULL  };
 
-static int verify_inbox(struct maildir_storage *storage);
+static int verify_inbox(struct mail_storage *storage);
+
+static const char *strip_tail_slash(const char *path)
+{
+	size_t len = strlen(path);
 
-static struct mail_storage *
-maildir_create(const char *data, const char *user,
-	       enum mail_storage_flags flags,
-	       enum mail_storage_lock_method lock_method)
+	if (len > 0 && path[len-1] == '/')
+		return t_strndup(path, len-1);
+	else
+		return path;
+}
+
+static const char *strip_tail_slash_and_cut(const char *path)
+{
+	return strip_tail_slash(t_strcut(path, ':'));
+}
+
+static int
+maildir_get_list_settings(struct mailbox_list_settings *list_set,
+			  const char *data, enum mail_storage_flags flags)
 {
 	bool debug = (flags & MAIL_STORAGE_FLAG_DEBUG) != 0;
-	struct maildir_storage *storage;
-	struct index_storage *istorage;
-	const char *root_dir, *inbox_dir, *index_dir, *control_dir;
 	const char *home, *path, *p;
-	size_t len;
-	pool_t pool;
 
-	inbox_dir = root_dir = index_dir = control_dir = NULL;
+	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 ((flags & MAIL_STORAGE_FLAG_NO_AUTODETECTION) != 0) {
 			i_error("maildir: root directory not given");
-			return NULL;
+			return -1;
 		}
 
 		/* we'll need to figure out the maildir location ourself.
@@ -68,7 +76,7 @@
 					i_info("maildir: root exists (%s)",
 					       path);
 				}
-				root_dir = path;
+				list_set->root_dir = path;
 			} else {
 				if (debug) {
 					i_info("maildir: access(%s, rwx): "
@@ -83,7 +91,7 @@
 		if (access("/cur", R_OK|W_OK|X_OK) == 0) {
 			if (debug)
 				i_info("maildir: /cur exists, assuming chroot");
-			root_dir = "/";
+			list_set->root_dir = "/";
 		}
 	} else {
 		/* <Maildir> [:INBOX=<dir>] [:INDEX=<dir>] [:CONTROL=<dir>] */
@@ -91,68 +99,87 @@
 			i_info("maildir: data=%s", data);
 		p = strchr(data, ':');
 		if (p == NULL)
-			root_dir = data;
+			list_set->root_dir = data;
 		else {
-			root_dir = t_strdup_until(data, p);
+			list_set->root_dir = t_strdup_until(data, p);
 
 			do {
 				p++;
-				if (strncmp(p, "INBOX=", 6) == 0)
-					inbox_dir = t_strcut(p+6, ':');
-				else if (strncmp(p, "INDEX=", 6) == 0)
-					index_dir = t_strcut(p+6, ':');
-				else if (strncmp(p, "CONTROL=", 8) == 0)
-					control_dir = t_strcut(p+8, ':');
+				if (strncmp(p, "INBOX=", 6) == 0) {
+					list_set->inbox_path =
+						strip_tail_slash_and_cut(p+6);
+				} else if (strncmp(p, "INDEX=", 6) == 0) {
+					list_set->index_dir =
+						strip_tail_slash_and_cut(p+6);
+				} else if (strncmp(p, "CONTROL=", 8) == 0) {
+					list_set->control_dir =
+						strip_tail_slash_and_cut(p+8);
+				}
 				p = strchr(p, ':');
 			} while (p != NULL);
 		}
 	}
 
-	if (root_dir == NULL) {
+	if (list_set->root_dir == NULL) {
 		if (debug)
 			i_info("maildir: couldn't find root dir");
+		return -1;
+	}
+	list_set->root_dir = strip_tail_slash(list_set->root_dir);
+
+	if (list_set->index_dir != NULL &&
+	    strcmp(list_set->index_dir, "MEMORY") == 0)
+		list_set->index_dir = "";
+	return 0;
+}
+
+static struct mail_storage *
+maildir_create(const char *data, const char *user,
+	       enum mail_storage_flags flags,
+	       enum mail_storage_lock_method lock_method)
+{
+	struct maildir_storage *storage;
+	struct index_storage *istorage;
+	struct mailbox_list_settings list_set;
+	struct mailbox_list *list;
+	const char *error;
+	pool_t pool;
+
+	if (maildir_get_list_settings(&list_set, data, flags) < 0)
+		return NULL;
+
+	pool = pool_alloconly_create("storage", 512);
+	storage = p_new(pool, struct maildir_storage, 1);
+
+	if (mailbox_list_init("maildir++", &list_set,
+			      mail_storage_get_list_flags(flags),
+			      mailbox_storage_list_is_mailbox, storage,
+			      &list, &error) < 0) {
+		i_error("maildir++: %s", error);
+		pool_unref(pool);
 		return NULL;
 	}
 
-	/* strip trailing '/' */
-	len = strlen(root_dir);
-	if (root_dir[len-1] == '/')
-		root_dir = t_strndup(root_dir, len-1);
-
-	if (index_dir == NULL)
-		index_dir = root_dir;
-	else if (strcmp(index_dir, "MEMORY") == 0)
-		index_dir = NULL;
-
-	if (debug) {
-		i_info("maildir: root=%s, index=%s, control=%s, inbox=%s",
-		       root_dir, index_dir == NULL ? "" : index_dir,
-		       control_dir == NULL ? "" : control_dir,
-		       inbox_dir == NULL ? "" : inbox_dir);
-	}
-
-	pool = pool_alloconly_create("storage", 512);
-	storage = p_new(pool, struct maildir_storage, 1);
-	storage->control_dir = p_strdup(pool, home_expand(control_dir));
 	storage->copy_with_hardlinks =
 		getenv("MAILDIR_COPY_WITH_HARDLINKS") != NULL;
+	storage->stat_dirs = getenv("MAILDIR_STAT_DIRS") != NULL;
+
+	storage->temp_prefix = mailbox_list_get_temp_prefix(list);
+	if (list_set.control_dir == NULL) {
+		/* put the temp files into tmp/ directory preferrably */
+		storage->temp_prefix =
+			p_strconcat(pool, "tmp/", storage->temp_prefix, NULL);
+	}
 
 	istorage = INDEX_STORAGE(storage);
 	istorage->storage = maildir_storage;
 	istorage->storage.pool = pool;
 
-	/* the default ".temp.xxx" prefix would be treated as directory */
-	istorage->temp_prefix =
-		p_strconcat(pool, "temp.", my_hostname, ".", my_pid, ".", NULL);
-
-	istorage->dir = p_strdup(pool, home_expand(root_dir));
-	istorage->inbox_path = p_strdup(pool, home_expand(inbox_dir));
-	istorage->index_dir = p_strdup(pool, home_expand(index_dir));
 	istorage->user = p_strdup(pool, user);
 	istorage->callbacks = p_new(pool, struct mail_storage_callbacks, 1);
-	index_storage_init(istorage, flags, lock_method);
+	index_storage_init(istorage, list, flags, lock_method);
 
-	(void)verify_inbox(storage);
+	(void)verify_inbox(STORAGE(storage));
 	return STORAGE(storage);
 }
 
@@ -187,130 +214,28 @@
 	return TRUE;
 }
 
-static bool maildir_is_valid_create_name(struct mail_storage *storage,
-					 const char *name)
+static const char *
+maildir_get_unlink_dest(struct mail_storage *storage, const char *name)
 {
-	size_t len;
-
-	/* check that there are no adjacent hierarchy separators */
-	for (len = 0; name[len] != '\0'; len++) {
-		if (name[len] == MAILDIR_FS_SEP &&
-		    name[len+1] == MAILDIR_FS_SEP)
-			return FALSE;
-	}
-
-	if (len == 0 || len > MAILDIR_MAX_MAILBOX_NAME_LENGTH ||
-	    name[0] == MAILDIR_FS_SEP || name[len-1] == MAILDIR_FS_SEP)
-		return FALSE;
-
-	if ((storage->flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0)
-		return TRUE;
-
-	if (*name == '~' || strchr(name, '/') != NULL)
-		return FALSE;
-
-	if (name[0] == '.' && (name[1] == '\0' ||
-			       (name[1] == '.' && name[2] == '\0'))) {
-		/* "." and ".." aren't allowed. */
-		return FALSE;
-	}
-
-	if (mailbox_name_is_too_large(name, '.'))
-		return FALSE;
-
-	return TRUE;
-}
-
-static bool maildir_is_valid_existing_name(struct mail_storage *storage,
-					   const char *name)
-{
-	if (name[0] == '\0' || name[strlen(name)-1] == '/')
-		return FALSE;
-
-	if ((storage->flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0)
-		return TRUE;
+	const char *root_dir;
 
-	if (*name == '~' || strchr(name, '/') != NULL)
-		return FALSE;
-
-	if (name[0] == '.' && (name[1] == '\0' ||
-			       (name[1] == '.' && name[2] == '\0'))) {
-		/* "." and ".." aren't allowed. */
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-static const char *maildir_get_absolute_path(const char *name)
-{
-	const char *p;
-
-	name = home_expand(name);
-
-	p = strrchr(name, '/');
-	if (p == NULL)
-		return name;
-	return t_strconcat(t_strdup_until(name, p+1),
-			   MAILDIR_FS_SEP_S, p+1, NULL);
-}
-
-const char *maildir_get_path(struct index_storage *storage, const char *name)
-{
-	if ((storage->storage.flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0 &&
-	    (*name == '/' || *name == '~'))
-		return maildir_get_absolute_path(name);
-
-	if (strcmp(name, "INBOX") == 0) {
-		return storage->inbox_path != NULL ?
-			storage->inbox_path : storage->dir;
-	}
-
-	return t_strconcat(storage->dir, "/"MAILDIR_FS_SEP_S, name, NULL);
-}
-
-static const char *
-maildir_get_unlink_dest(struct index_storage *storage, const char *name)
-{
-	if ((storage->storage.flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0 &&
+	if ((storage->flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0 &&
 	    (*name == '/' || *name == '~'))
 		return NULL;
 
-	return maildir_get_path(storage, MAILDIR_UNLINK_DIRNAME);
+	if (strcmp(mailbox_list_get_driver_name(storage->list),
+		   MAILDIR_PLUSPLUS_DRIVER_NAME) != 0) {
+		/* Not maildir++ driver. Don't use this trick. */
+		return NULL;
+	}
+
+	root_dir = mailbox_list_get_path(storage->list, NULL,
+					 MAILBOX_LIST_PATH_TYPE_DIR);
+	return t_strdup_printf("%s/%c"MAILDIR_UNLINK_DIRNAME, root_dir,
+			       mailbox_list_get_hierarchy_sep(storage->list));
 }
 
-static const char *maildir_get_index_path(struct index_storage *storage,
-					  const char *name)
-{
-	if (storage->index_dir == NULL)
-		return NULL;
-
-	if (strcmp(name, "INBOX") == 0 &&
-	    strcmp(storage->index_dir, storage->dir) == 0)
-		return storage->dir;
-
-	if ((storage->storage.flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0 &&
-	    (*name == '/' || *name == '~'))
-		return maildir_get_absolute_path(name);
-
-	return t_strconcat(storage->index_dir, "/"MAILDIR_FS_SEP_S, name, NULL);
-}
-
-static const char *maildir_get_control_path(struct maildir_storage *storage,
-					    const char *name)
-{
-	if (storage->control_dir == NULL)
-		return maildir_get_path(INDEX_STORAGE(storage), name);
-
-	if ((STORAGE(storage)->flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0 &&
-	    (*name == '/' || *name == '~'))
-		return maildir_get_absolute_path(name);
-
-	return t_strconcat(storage->control_dir, "/"MAILDIR_FS_SEP_S,
-			   name, NULL);
-}
-
-static int mkdir_verify(struct index_storage *storage,
+static int mkdir_verify(struct mail_storage *storage,
 			const char *dir, bool verify)
 {
 	struct stat st;
@@ -320,7 +245,7 @@
 			return 0;
 
 		if (errno != ENOENT) {
-			mail_storage_set_critical(&storage->storage,
+			mail_storage_set_critical(storage,
 						  "lstat(%s) failed: %m", dir);
 			return -1;
 		}
@@ -329,7 +254,7 @@
 	if (mkdir_parents(dir, CREATE_MODE) < 0 &&
 	    (errno != EEXIST || !verify)) {
 		if (errno != EEXIST && (!verify || errno != ENOENT)) {
-			mail_storage_set_critical(&storage->storage,
+			mail_storage_set_critical(storage,
 						  "mkdir(%s) failed: %m", dir);
 		}
 		return -1;
@@ -339,7 +264,7 @@
 }
 
 /* create or fix maildir, ignore if it already exists */
-static int create_maildir(struct index_storage *storage,
+static int create_maildir(struct mail_storage *storage,
 			  const char *dir, bool verify)
 {
 	const char **tmp, *path;
@@ -367,21 +292,25 @@
 	return 0;
 }
 
-static int create_index_dir(struct index_storage *storage, const char *name)
+static int create_index_dir(struct mail_storage *storage, const char *name)
 {
-	const char *dir;
+	const char *index_dir, *root_dir, *dir;
 
-	if (storage->index_dir == NULL)
+	index_dir = mailbox_list_get_path(storage->list, name,
+					  MAILBOX_LIST_PATH_TYPE_INDEX);
+	if (*index_dir == '\0')
 		return 0;
 
-	if (strcmp(storage->index_dir, storage->dir) == 0 ||
-	    (strcmp(name, "INBOX") == 0 && storage->inbox_path != NULL &&
-	     strcmp(storage->index_dir, storage->inbox_path) == 0))
+	root_dir = mailbox_list_get_path(storage->list, name,
+					 MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	if (strcmp(index_dir, root_dir) == 0)
 		return 0;
 
-	dir = t_strconcat(storage->index_dir, "/"MAILDIR_FS_SEP_S, name, NULL);
+	dir = t_strdup_printf("%s/%c%s", index_dir,
+			      mailbox_list_get_hierarchy_sep(storage->list),
+			      name);
 	if (mkdir_parents(dir, CREATE_MODE) < 0 && errno != EEXIST) {
-		mail_storage_set_critical(&storage->storage,
+		mail_storage_set_critical(storage,
 					  "mkdir(%s) failed: %m", dir);
 		return -1;
 	}
@@ -389,17 +318,22 @@
 	return 0;
 }
 
-static int create_control_dir(struct maildir_storage *storage, const char *name)
+static int create_control_dir(struct mail_storage *storage, const char *name)
 {
-	const char *dir;
+	const char *control_dir, *root_dir, *dir;
 
-	if (storage->control_dir == NULL)
+	control_dir = mailbox_list_get_path(storage->list, name,
+					    MAILBOX_LIST_PATH_TYPE_CONTROL);
+	root_dir = mailbox_list_get_path(storage->list, name,
+					 MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	if (strcmp(control_dir, root_dir) == 0)
 		return 0;
 
-	dir = t_strconcat(storage->control_dir, "/"MAILDIR_FS_SEP_S,
-			  name, NULL);
+	dir = t_strdup_printf("%s/%c%s", control_dir,
+			      mailbox_list_get_hierarchy_sep(storage->list),
+			      name);
 	if (mkdir_parents(dir, CREATE_MODE) < 0 && errno != EEXIST) {
-		mail_storage_set_critical(STORAGE(storage),
+		mail_storage_set_critical(storage,
 					  "mkdir(%s) failed: %m", dir);
 		return -1;
 	}
@@ -407,19 +341,16 @@
 	return 0;
 }
 
-static int verify_inbox(struct maildir_storage *storage)
+static int verify_inbox(struct mail_storage *storage)
 {
-	struct index_storage *istorage = INDEX_STORAGE(storage);
 	const char *path;
 
-	path = istorage->inbox_path != NULL ?
-		istorage->inbox_path : istorage->dir;
-
-	if (create_maildir(istorage, path, TRUE) < 0)
+	path = mailbox_list_get_path(storage->list, "INBOX",
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	if (create_maildir(storage, path, TRUE) < 0)
 		return -1;
 
-	/* make sure the index directories exist */
-	if (create_index_dir(istorage, "INBOX") < 0)
+	if (create_index_dir(storage, "INBOX") < 0)
 		return -1;
 	if (create_control_dir(storage, "INBOX") < 0)
 		return -1;
@@ -445,12 +376,15 @@
 	int shared;
 	pool_t pool;
 
-	path = maildir_get_path(istorage, name);
-	index_dir = maildir_get_index_path(istorage, name);
-	control_dir = maildir_get_control_path(storage, name);
+	path = mailbox_list_get_path(istorage->storage.list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	index_dir = mailbox_list_get_path(istorage->storage.list, name,
+					  MAILBOX_LIST_PATH_TYPE_INDEX);
+	control_dir = mailbox_list_get_path(istorage->storage.list, name,
+					    MAILBOX_LIST_PATH_TYPE_CONTROL);
 
 	if ((flags & MAILBOX_OPEN_NO_INDEX_FILES) != 0)
-		index_dir = NULL;
+		index_dir = "";
 
 	index = index_storage_alloc(index_dir, path,
 				    MAILDIR_INDEX_PREFIX);
@@ -502,33 +436,17 @@
 }
 
 static const char *
-maildir_get_mailbox_path(struct mail_storage *_storage,
-			 const char *name, bool *is_file_r)
+maildir_get_mailbox_control_dir(struct mail_storage *storage, const char *name)
 {
-	struct maildir_storage *storage = (struct maildir_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
-
-	*is_file_r = FALSE;
-	if (*name == '\0')
-		return istorage->dir;
-	return maildir_get_path(istorage, name);
+	return mailbox_list_get_path(storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_CONTROL);
 }
 
 static const char *
-maildir_get_mailbox_control_dir(struct mail_storage *_storage, const char *name)
+maildir_get_mailbox_index_dir(struct mail_storage *storage, const char *name)
 {
-	struct maildir_storage *storage = (struct maildir_storage *)_storage;
-
-	return maildir_get_control_path(storage, name);
-}
-
-static const char *
-maildir_get_mailbox_index_dir(struct mail_storage *_storage, const char *name)
-{
-	struct maildir_storage *storage = (struct maildir_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
-
-	return maildir_get_index_path(istorage, name);
+	return mailbox_list_get_path(storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_INDEX);
 }
 
 static struct mailbox *
@@ -536,7 +454,6 @@
 		     struct istream *input, enum mailbox_open_flags flags)
 {
 	struct maildir_storage *storage = (struct maildir_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
 	const char *path;
 	struct stat st;
 
@@ -549,25 +466,26 @@
 	}
 
 	if (strcmp(name, "INBOX") == 0) {
-		if (verify_inbox(storage) < 0)
+		if (verify_inbox(_storage) < 0)
 			return NULL;
 		return maildir_open(storage, "INBOX", flags);
 	}
 
-	if (!maildir_is_valid_existing_name(_storage, name)) {
+	if (!mailbox_list_is_valid_existing_name(_storage->list, name)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return NULL;
 	}
 
-	path = maildir_get_path(istorage, name);
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (stat(path, &st) == 0) {
 		/* exists - make sure the required directories are also there */
-		if (create_maildir(istorage, path, TRUE) < 0 ||
-		    create_control_dir(storage, name) < 0)
+		if (create_maildir(_storage, path, TRUE) < 0 ||
+		    create_control_dir(_storage, name) < 0)
 			return NULL;
 
 		if ((flags & MAILBOX_OPEN_NO_INDEX_FILES) == 0) {
-			if (create_index_dir(istorage, name) < 0)
+			if (create_index_dir(_storage, name) < 0)
 				return NULL;
 		}
 
@@ -583,7 +501,7 @@
 	}
 }
 
-static int maildir_create_shared(struct index_storage *storage,
+static int maildir_create_shared(struct mail_storage *storage,
 				 const char *dir, mode_t mode, gid_t gid)
 {
 	const char *path;
@@ -598,15 +516,14 @@
 	old_mask = umask(0777 ^ mode);
 	if (create_maildir(storage, dir, FALSE) < 0) {
 		if (errno == EEXIST) {
-			mail_storage_set_error(&storage->storage,
+			mail_storage_set_error(storage,
 					       "Mailbox already exists");
 		}
 		umask(old_mask);
 		return -1;
 	}
 	if (chown(dir, (uid_t)-1, gid) < 0) {
-		mail_storage_set_critical(&storage->storage,
-					  "chown(%s) failed: %m", dir);
+		mail_storage_set_critical(storage, "chown(%s) failed: %m", dir);
 	}
 
 	path = t_strconcat(dir, "/dovecot-shared", NULL);
@@ -614,13 +531,12 @@
 	umask(old_mask);
 
 	if (fd == -1) {
-		mail_storage_set_critical(&storage->storage,
-					  "open(%s) failed: %m", path);
+		mail_storage_set_critical(storage, "open(%s) failed: %m", path);
 		return -1;
 	}
 
 	if (fchown(fd, (uid_t)-1, gid) < 0) {
-		mail_storage_set_critical(&storage->storage,
+		mail_storage_set_critical(storage,
 					  "fchown(%s) failed: %m", path);
 	}
 	(void)close(fd);
@@ -631,29 +547,31 @@
 				  const char *name,
 				  bool directory __attr_unused__)
 {
-	struct index_storage *storage = (struct index_storage *)_storage;
 	struct stat st;
-	const char *path, *shared_path;
+	const char *path, *root_dir, *shared_path;
 	int fd;
 
 	mail_storage_clear_error(_storage);
 
-	if (!maildir_is_valid_create_name(_storage, name)) {
+	if (!mailbox_list_is_valid_create_name(_storage->list, name)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return -1;
 	}
 
-	path = maildir_get_path(storage, name);
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	root_dir = mailbox_list_get_path(_storage->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(storage->dir, "/dovecot-shared", NULL);
+	shared_path = t_strconcat(root_dir, "/dovecot-shared", NULL);
 	if (stat(shared_path, &st) == 0) {
-		return maildir_create_shared(storage, path,
+		return maildir_create_shared(_storage, path,
 					     st.st_mode & 0666, st.st_gid);
 	}
 
-	if (create_maildir(storage, path, FALSE) < 0) {
+	if (create_maildir(_storage, path, FALSE) < 0) {
 		if (errno == EEXIST) {
 			mail_storage_set_error(_storage,
 					       "Mailbox already exists");
@@ -675,7 +593,6 @@
 static int maildir_mailbox_delete(struct mail_storage *_storage,
 				  const char *name)
 {
-	struct index_storage *storage = (struct index_storage *)_storage;
 	struct stat st;
 	const char *src, *dest, *index_dir;
 	int count;
@@ -687,16 +604,14 @@
 		return -1;
 	}
 
-	if (!maildir_is_valid_existing_name(_storage, name)) {
+	if (!mailbox_list_is_valid_existing_name(_storage->list, name)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return -1;
 	}
 
-	/* rename the .maildir into ..DOVECOT-TRASH which marks it as being
-	   deleted. delete indexes before the actual maildir. this way we
-	   never see partially deleted mailboxes. */
-	src = maildir_get_path(storage, name);
-	dest = maildir_get_unlink_dest(storage, name);
+	/* check if the mailbox actually exists */
+	src = mailbox_list_get_path(_storage->list, name,
+				    MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (stat(src, &st) != 0 && errno == ENOENT) {
 		mail_storage_set_error(_storage,
 			MAIL_STORAGE_ERR_MAILBOX_NOT_FOUND, name);
@@ -706,13 +621,16 @@
 	/* Make sure the indexes are closed before trying to delete the
 	   directory that contains them. It can still fail with some NFS
 	   implementations if indexes are opened by another session, but
-	   can't really help that. */
+	   that can't really be helped. */
 	index_storage_destroy_unrefed();
 
-	if (storage->index_dir != NULL && *name != '/' && *name != '~' &&
-	    strcmp(storage->index_dir, storage->dir) != 0) {
-		index_dir = t_strconcat(storage->index_dir,
-					"/"MAILDIR_FS_SEP_S, name, NULL);
+	/* if there's a separate index directory, delete it before the actual
+	   maildir. this way we never see partially deleted mailboxes. */
+	index_dir = mailbox_list_get_path(_storage->list, name,
+					  MAILBOX_LIST_PATH_TYPE_INDEX);
+	if (strcmp(index_dir, src) != 0) {
+		i_assert(*name != '/' && *name != '~');
+
 		if (unlink_directory(index_dir, TRUE) < 0 &&
 		    errno != ENOTEMPTY) {
 			mail_storage_set_critical(_storage,
@@ -721,11 +639,16 @@
 		}
 	}
 
+	dest = maildir_get_unlink_dest(_storage, name);
 	if (dest == NULL) {
 		/* absolute maildir path, delete the directory directly
 		   without any renaming */
 		dest = src;
 	} else {
+		/* rename the .maildir into ..DOVECOT-TRASH which atomically
+		   marks it as being deleted. If we die before deleting the
+		   ..DOVECOT-TRASH directory, it gets deleted the next time
+		   mailbox listing sees it. */
 		count = 0;
 		while (rename(src, dest) < 0 && count < 2) {
 			/* EBUSY is given by some NFS implementations */
@@ -752,30 +675,26 @@
 			"unlink_directory(%s) failed: %m", dest);
 
 		/* it's already renamed to ..dir, which means it's deleted
-		   as far as client is concerned. Report success. */
+		   as far as the client is concerned. Report success. */
 	}
 
 	return 0;
 }
 
-static int rename_indexes(struct index_storage *storage,
+static int rename_indexes(struct mail_storage *storage,
 			  const char *oldname, const char *newname)
 {
 	const char *oldpath, *newpath;
 
-	if (storage->index_dir == NULL ||
-	    strcmp(storage->index_dir, storage->dir) == 0)
+	oldpath = mailbox_list_get_path(storage->list, oldname,
+					MAILBOX_LIST_PATH_TYPE_INDEX);
+	newpath = mailbox_list_get_path(storage->list, newname,
+					MAILBOX_LIST_PATH_TYPE_INDEX);
+	if (strcmp(oldpath, newpath) == 0)
 		return 0;
 
-	/* Rename it's index. */
-	oldpath = t_strconcat(storage->index_dir, "/"MAILDIR_FS_SEP_S,
-			      oldname, NULL);
-	newpath = t_strconcat(storage->index_dir, "/"MAILDIR_FS_SEP_S,
-			      newname, NULL);
-
 	if (rename(oldpath, newpath) < 0 && errno != ENOENT) {
-		mail_storage_set_critical(&storage->storage,
-					  "rename(%s, %s) failed: %m",
+		mail_storage_set_critical(storage, "rename(%s, %s) failed: %m",
 					  oldpath, newpath);
 		return -1;
 	}
@@ -783,13 +702,13 @@
 	return 0;
 }
 
-static int rename_subfolders(struct index_storage *storage,
+static int rename_subfolders(struct mail_storage *storage,
 			     const char *oldname, const char *newname)
 {
-	struct mailbox_list_context *ctx;
-        struct mailbox_list *list;
+	struct mailbox_list_iterate_context *iter;
+        struct mailbox_info *info;
 	ARRAY_DEFINE(names_arr, const char *);
-	const char *oldpath, *newpath, *old_listname, *new_listname;
+	const char *mask, *oldpath, *newpath, *old_listname, *new_listname;
 	const char *const *names;
 	unsigned int i, count;
 	size_t oldnamelen;
@@ -805,18 +724,20 @@
 	   other processes though. */
 	pool = pool_alloconly_create("Maildir subfolders list", 1024);
 	i_array_init(&names_arr, 64);
-	ctx = maildir_mailbox_list_init(&storage->storage, oldname,
-					MAILDIR_FS_SEP_S"*",
-					MAILBOX_LIST_FAST_FLAGS);
-	while ((list = maildir_mailbox_list_next(ctx)) != NULL) {
+
+	mask = t_strdup_printf("%s%c*", oldname,
+			       mailbox_list_get_hierarchy_sep(storage->list));
+	iter = mailbox_list_iter_init(storage->list, "", mask,
+				      MAILBOX_LIST_ITER_FAST_FLAGS);
+	while ((info = mailbox_list_iter_next(iter)) != NULL) {
 		const char *name;
 
-		i_assert(oldnamelen <= strlen(list->name));
+		i_assert(oldnamelen <= strlen(info->name));
 
-		name = p_strdup(pool, list->name + oldnamelen);
+		name = p_strdup(pool, info->name + oldnamelen);
 		array_append(&names_arr, &name, 1);
 	}
-	if (maildir_mailbox_list_deinit(ctx) < 0) {
+	if (mailbox_list_iter_deinit(&iter) < 0) {
 		ret = -1;
 		names = NULL; count = 0;
 	} else {
@@ -828,8 +749,10 @@
 
 		old_listname = t_strconcat(oldname, names[i], NULL);
 		new_listname = t_strconcat(newname, names[i], NULL);
-		oldpath = maildir_get_path(storage, old_listname);
-		newpath = maildir_get_path(storage, new_listname);
+		oldpath = mailbox_list_get_path(storage->list, old_listname,
+						MAILBOX_LIST_PATH_TYPE_MAILBOX);
+		newpath = mailbox_list_get_path(storage->list, new_listname,
+						MAILBOX_LIST_PATH_TYPE_MAILBOX);
 
 		/* FIXME: it's possible to merge two folders if either one of
 		   them doesn't have existing root folder. We could check this
@@ -843,9 +766,8 @@
 		    errno == EEXIST || errno == ENOTEMPTY)
 			ret = 1;
 		else {
-			mail_storage_set_critical(&storage->storage,
-						  "rename(%s, %s) failed: %m",
-						  oldpath, newpath);
+			mail_storage_set_critical(storage,
+				"rename(%s, %s) failed: %m", oldpath, newpath);
 			ret = -1;
 			t_pop();
 			break;
@@ -863,15 +785,14 @@
 static int maildir_mailbox_rename(struct mail_storage *_storage,
 				  const char *oldname, const char *newname)
 {
-	struct index_storage *storage = (struct index_storage *)_storage;
 	const char *oldpath, *newpath;
 	int ret;
         bool found;
 
 	mail_storage_clear_error(_storage);
 
-	if (!maildir_is_valid_existing_name(_storage, oldname) ||
-	    !maildir_is_valid_create_name(_storage, newname)) {
+	if (!mailbox_list_is_valid_existing_name(_storage->list, oldname) ||
+	    !mailbox_list_is_valid_create_name(_storage->list, newname)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return -1;
 	}
@@ -884,15 +805,17 @@
 
 	/* NOTE: it's possible to rename a nonexisting folder which has
 	   subfolders. In that case we should ignore the rename() error. */
-	oldpath = maildir_get_path(storage, oldname);
-	newpath = maildir_get_path(storage, newname);
+	oldpath = mailbox_list_get_path(_storage->list, oldname,
+					MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	newpath = mailbox_list_get_path(_storage->list, newname,
+					MAILBOX_LIST_PATH_TYPE_MAILBOX);
 
 	ret = rename(oldpath, newpath);
 	if (ret == 0 || errno == ENOENT) {
-		(void)rename_indexes(storage, oldname, newname);
+		(void)rename_indexes(_storage, oldname, newname);
 
 		found = ret == 0;
-		ret = rename_subfolders(storage, oldname, newname);
+		ret = rename_subfolders(_storage, oldname, newname);
 		if (ret < 0)
 			return -1;
 		if (!found && ret == 0) {
@@ -915,57 +838,6 @@
 	}
 }
 
-static int maildir_set_subscribed(struct mail_storage *_storage,
-				  const char *name, bool set)
-{
-	struct maildir_storage *storage = (struct maildir_storage *)_storage;
-	const char *path;
-
-	path = t_strconcat(storage->control_dir != NULL ?
-			   storage->control_dir : INDEX_STORAGE(storage)->dir,
-			   "/" SUBSCRIPTION_FILE_NAME, NULL);
-
-	return subsfile_set_subscribed(_storage, path,
-				       INDEX_STORAGE(storage)->temp_prefix,
-				       name, set);
-}
-
-static int maildir_get_mailbox_name_status(struct mail_storage *_storage,
-					   const char *name,
-					   enum mailbox_name_status *status)
-{
-	struct index_storage *storage = (struct index_storage *)_storage;
-	struct stat st;
-	const char *path;
-
-	mail_storage_clear_error(_storage);
-
-	if (!maildir_is_valid_existing_name(_storage, name)) {
-		*status = MAILBOX_NAME_INVALID;
-		return 0;
-	}
-
-	path = maildir_get_path(storage, name);
-	if (strcmp(name, "INBOX") == 0 || stat(path, &st) == 0) {
-		*status = MAILBOX_NAME_EXISTS;
-		return 0;
-	}
-
-	if (!maildir_is_valid_create_name(_storage, name)) {
-		*status = MAILBOX_NAME_INVALID;
-		return 0;
-	}
-
-	if (errno == ENOENT) {
-		*status = MAILBOX_NAME_VALID;
-		return 0;
-	} else {
-		mail_storage_set_critical(_storage, "stat(%s) failed: %m",
-					  path);
-		return -1;
-	}
-}
-
 static int maildir_storage_close(struct mailbox *box)
 {
 	struct maildir_mailbox *mbox = (struct maildir_mailbox *)box;
@@ -1006,6 +878,75 @@
 		t_strconcat(mbox->path, "/cur", NULL));
 }
 
+static int
+maildir_storage_is_mailbox(struct mail_storage *_storage,
+			   const char *dir, const char *fname,
+			   enum mailbox_list_iter_flags iter_flags
+				__attr_unused__,
+			   enum mailbox_info_flags *flags,
+			   enum mailbox_list_file_type type)
+{
+	struct maildir_storage *storage = (struct maildir_storage *)_storage;
+	int ret;
+
+	if (fname[1] == mailbox_list_get_hierarchy_sep(_storage->list) &&
+	    strcmp(fname+2, MAILDIR_UNLINK_DIRNAME) == 0 &&
+	    strcmp(mailbox_list_get_driver_name(_storage->list),
+		   MAILDIR_PLUSPLUS_DRIVER_NAME) == 0) {
+		const char *path;
+		struct stat st;
+
+		/* this directory is in the middle of being deleted,
+		   or the process trying to delete it had died.
+		   delete it ourself if it's been there longer than
+		   one hour. */
+		t_push();
+		path = t_strdup_printf("%s/%s", dir, fname);
+		if (stat(path, &st) == 0 &&
+		    st.st_mtime < ioloop_time - 3600)
+			(void)unlink_directory(path, TRUE);
+		t_pop();
+
+		*flags = MAILBOX_NONEXISTENT;
+		return 0;
+	}
+
+	switch (type) {
+	case MAILBOX_LIST_FILE_TYPE_DIR:
+		/* all directories are valid maildirs */
+		return 1;
+
+	case MAILBOX_LIST_FILE_TYPE_FILE:
+	case MAILBOX_LIST_FILE_TYPE_OTHER:
+		/* non-directories are not */
+		*flags = MAILBOX_NOSELECT;
+		return 0;
+
+	case MAILBOX_LIST_FILE_TYPE_UNKNOWN:
+	case MAILBOX_LIST_FILE_TYPE_SYMLINK:
+		/* need to check with stat() to be sure */
+		break;
+	}
+
+	/* Check files beginning with .nfs always because they may be
+	   temporary files created by the kernel */
+	if (storage->stat_dirs || strncmp(fname, ".nfs", 4) == 0) {
+		const char *path;
+		struct stat st;
+
+		t_push();
+		path = t_strdup_printf("%s/%s", dir, fname);
+		ret = (stat(path, &st) < 0 || !S_ISDIR(st.st_mode)) ? 0 : 1;
+		t_pop();
+
+		if (ret == 0)
+			*flags = MAILBOX_NONEXISTENT;
+	} else {
+		ret = 1;
+	}
+	return ret;
+}
+
 static void maildir_class_init(void)
 {
 	maildir_transaction_class_init();
@@ -1018,7 +959,7 @@
 
 struct mail_storage maildir_storage = {
 	MEMBER(name) MAILDIR_STORAGE_NAME,
-	MEMBER(hierarchy_sep) MAILDIR_FS_SEP,
+	MEMBER(mailbox_is_file) FALSE,
 
 	{
 		maildir_class_init,
@@ -1027,18 +968,13 @@
 		maildir_free,
 		maildir_autodetect,
 		index_storage_set_callbacks,
-		maildir_get_mailbox_path,
 		maildir_get_mailbox_control_dir,
 		maildir_get_mailbox_index_dir,
 		maildir_mailbox_open,
 		maildir_mailbox_create,
 		maildir_mailbox_delete,
 		maildir_mailbox_rename,
-		maildir_mailbox_list_init,
-		maildir_mailbox_list_next,
-		maildir_mailbox_list_deinit,
-		maildir_set_subscribed,
-		maildir_get_mailbox_name_status,
+		maildir_storage_is_mailbox,
 		index_storage_get_last_error
 	}
 };

--- a/src/lib-storage/index/maildir/maildir-storage.h	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/maildir/maildir-storage.h	Thu Nov 16 02:16:31 2006 +0200
@@ -1,14 +1,10 @@
 #ifndef __MAILDIR_STORAGE_H
 #define __MAILDIR_STORAGE_H
 
-/* Hierarchy separator in Maildir++ filenames - shouldn't be changed */
-#define MAILDIR_FS_SEP '.'
-#define MAILDIR_FS_SEP_S "."
-
 #define MAILDIR_STORAGE_NAME "maildir"
-#define SUBSCRIPTION_FILE_NAME "subscriptions"
+#define MAILDIR_SUBSCRIPTION_FILE_NAME "subscriptions"
 #define MAILDIR_INDEX_PREFIX "dovecot.index"
-#define MAILDIR_UNLINK_DIRNAME MAILDIR_FS_SEP_S"DOVECOT-TRASHED"
+#define MAILDIR_UNLINK_DIRNAME "DOVECOT-TRASHED"
 
 /* "base,S=123:2," means:
    <base> [<extra sep> <extra data> [..]] <info sep> 2 <flags sep> */
@@ -52,9 +48,11 @@
 struct maildir_storage {
 	struct index_storage storage;
 
-	const char *control_dir;
+	const char *temp_prefix;
+
 	unsigned int copy_with_hardlinks:1;
 	unsigned int save_size_in_filename:1;
+	unsigned int stat_dirs:1;
 };
 
 struct maildir_mailbox {
@@ -93,14 +91,6 @@
 		       mode_t mode, const char **fname_r);
 bool maildir_filename_get_size(const char *fname, char type, uoff_t *size_r);
 
-struct mailbox_list_context *
-maildir_mailbox_list_init(struct mail_storage *storage,
-			  const char *ref, const char *mask,
-			  enum mailbox_list_flags flags);
-int maildir_mailbox_list_deinit(struct mailbox_list_context *ctx);
-struct mailbox_list *
-maildir_mailbox_list_next(struct mailbox_list_context *ctx);
-
 int maildir_sync_is_synced(struct maildir_mailbox *mbox);
 
 struct mailbox_sync_context *
@@ -146,8 +136,6 @@
 int maildir_transaction_copy_commit(struct maildir_copy_context *ctx);
 void maildir_transaction_copy_rollback(struct maildir_copy_context *ctx);
 
-const char *maildir_get_path(struct index_storage *storage, const char *name);
-
 int maildir_sync_last_commit(struct maildir_mailbox *mbox);
 
 int maildir_filename_get_flags(struct maildir_keywords_sync_ctx *ctx,

--- a/src/lib-storage/index/maildir/maildir-uidlist.c	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/maildir/maildir-uidlist.c	Thu Nov 16 02:16:31 2006 +0200
@@ -174,8 +174,7 @@
 
 	uidlist->dotlock_settings.timeout = UIDLIST_LOCK_STALE_TIMEOUT + 2;
 	uidlist->dotlock_settings.stale_timeout = UIDLIST_LOCK_STALE_TIMEOUT;
-	uidlist->dotlock_settings.temp_prefix =
-		INDEX_STORAGE(mbox->storage)->temp_prefix;
+	uidlist->dotlock_settings.temp_prefix = mbox->storage->temp_prefix;
 
 	return uidlist;
 }

--- a/src/lib-storage/index/mbox/Makefile.am	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/mbox/Makefile.am	Thu Nov 16 02:16:31 2006 +0200
@@ -12,7 +12,6 @@
 	istream-raw-mbox.c \
 	mbox-file.c \
 	mbox-from.c \
-	mbox-list.c \
 	mbox-lock.c \
 	mbox-mail.c \
 	mbox-md5.c \

--- a/src/lib-storage/index/mbox/mbox-list.c	Wed Nov 15 21:14:08 2006 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,434 +0,0 @@
-/* Copyright (C) 2002-2003 Timo Sirainen */
-
-#include "lib.h"
-#include "unlink-directory.h"
-#include "imap-match.h"
-#include "subscription-file/subscription-file.h"
-#include "mbox-storage.h"
-#include "home-expand.h"
-
-#include <dirent.h>
-#include <sys/stat.h>
-
-/* Assume that if atime < mtime, there are new mails. If it's good enough for
-   UW-IMAP, it's good enough for us. */
-#define STAT_GET_MARKED(st) \
-	((st).st_size == 0 ? MAILBOX_UNMARKED : \
-	 (st).st_atime < (st).st_mtime ? MAILBOX_MARKED : MAILBOX_UNMARKED)
-
-struct list_dir_context {
-	struct list_dir_context *prev;
-
-	DIR *dirp;
-	char *real_path, *virtual_path;
-};
-
-struct mbox_list_context {
-	struct mailbox_list_context mailbox_ctx;
-	struct index_storage *istorage;
-
-	struct imap_match_glob *glob;
-	struct subsfile_list_context *subsfile_ctx;
-
-	bool inbox_found;
-
-	struct mailbox_list *(*next)(struct mbox_list_context *ctx);
-
-	pool_t list_pool;
-	struct mailbox_list list;
-        struct list_dir_context *dir;
-};
-
-static struct mailbox_list *mbox_list_subs(struct mbox_list_context *ctx);
-static struct mailbox_list *mbox_list_path(struct mbox_list_context *ctx);
-static struct mailbox_list *mbox_list_next(struct mbox_list_context *ctx);
-
-static const char *mask_get_dir(const char *mask)
-{
-	const char *p, *last_dir;
-
-	last_dir = NULL;
-	for (p = mask; *p != '\0' && *p != '%' && *p != '*'; p++) {
-		if (*p == '/')
-			last_dir = p;
-	}
-
-	return last_dir == NULL ? NULL : t_strdup_until(mask, last_dir);
-}
-
-static const char *
-mbox_get_path(struct index_storage *storage, const char *name)
-{
-	if ((storage->storage.flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) == 0 ||
-	    name == NULL || (*name != '/' && *name != '~' && *name != '\0'))
-		return t_strconcat(storage->dir, "/", name, NULL);
-	else
-		return home_expand(name);
-}
-
-static int list_opendir(struct mail_storage *storage,
-			const char *path, bool root, DIR **dirp)
-{
-	*dirp = opendir(*path == '\0' ? "/" : path);
-	if (*dirp != NULL)
-		return 1;
-
-	if (ENOTFOUND(errno)) {
-		/* root) user gave invalid hiearchy, ignore
-		   sub) probably just race condition with other client
-		   deleting the mailbox. */
-		return 0;
-	}
-
-	if (errno == EACCES) {
-		if (!root) {
-			/* subfolder, ignore */
-			return 0;
-		}
-		mail_storage_set_error(storage, "Access denied");
-		return -1;
-	}
-
-	mail_storage_set_critical(storage, "opendir(%s) failed: %m", path);
-	return -1;
-}
-
-struct mailbox_list_context *
-mbox_mailbox_list_init(struct mail_storage *storage,
-		       const char *ref, const char *mask,
-		       enum mailbox_list_flags flags)
-{
-	struct index_storage *istorage = (struct index_storage *)storage;
-	struct mbox_list_context *ctx;
-	const char *path, *virtual_path;
-	DIR *dirp;
-
-	ctx = i_new(struct mbox_list_context, 1);
-	ctx->mailbox_ctx.storage = storage;
-	ctx->istorage = istorage;
-	ctx->list_pool = pool_alloconly_create("mbox_list", 1024);
-        ctx->next = mbox_list_next;
-
-	mail_storage_clear_error(storage);
-
-	/* check that we're not trying to do any "../../" lists */
-	if (!mbox_is_valid_mask(storage, ref) ||
-	    !mbox_is_valid_mask(storage, mask)) {
-		mail_storage_set_error(storage, "Invalid mask");
-		return &ctx->mailbox_ctx;
-	}
-
-	if (*mask == '/' || *mask == '~') {
-		/* mask overrides reference */
-	} else if (*ref != '\0') {
-		/* merge reference and mask */
-		mask = t_strconcat(ref, mask, NULL);
-	}
-
-	if ((flags & MAILBOX_LIST_SUBSCRIBED) != 0) {
-		ctx->mailbox_ctx.storage = storage;
-		ctx->mailbox_ctx.flags = flags;
-		ctx->istorage = istorage;
-		ctx->next = mbox_list_subs;
-
-		path = t_strconcat(istorage->dir,
-				   "/" SUBSCRIPTION_FILE_NAME, NULL);
-		ctx->subsfile_ctx =
-			subsfile_list_init(storage, path);
-		if (ctx->subsfile_ctx == NULL) {
-			ctx->next = mbox_list_next;
-			ctx->mailbox_ctx.failed = TRUE;
-			return &ctx->mailbox_ctx;
-		}
-		ctx->glob = imap_match_init(default_pool, mask, TRUE, '/');
-		return &ctx->mailbox_ctx;
-	}
-
-	/* if we're matching only subdirectories, don't bother scanning the
-	   parent directories */
-	virtual_path = mask_get_dir(mask);
-
-	path = mbox_get_path(istorage, virtual_path);
-	if (list_opendir(storage, path, TRUE, &dirp) < 0)
-		return &ctx->mailbox_ctx;
-	/* if user gave invalid directory, we just don't show any results. */
-
-	ctx->mailbox_ctx.flags = flags;
-	ctx->glob = imap_match_init(default_pool, mask, TRUE, '/');
-
-	if (virtual_path != NULL && dirp != NULL)
-		ctx->next = mbox_list_path;
-
-	if (dirp != NULL) {
-		ctx->dir = i_new(struct list_dir_context, 1);
-		ctx->dir->dirp = dirp;
-		ctx->dir->real_path = i_strdup(path);
-		ctx->dir->virtual_path = i_strdup(virtual_path);
-	}
-	return &ctx->mailbox_ctx;
-}
-
-static void list_dir_context_free(struct list_dir_context *dir)
-{
-	(void)closedir(dir->dirp);
-	i_free(dir->real_path);
-	i_free(dir->virtual_path);
-	i_free(dir);
-}
-
-int mbox_mailbox_list_deinit(struct mailbox_list_context *_ctx)
-{
-	struct mbox_list_context *ctx = (struct mbox_list_context *)_ctx;
-	int ret = ctx->mailbox_ctx.failed ? -1 : 0;
-
-	if (ctx->subsfile_ctx != NULL) {
-		if (subsfile_list_deinit(ctx->subsfile_ctx) < 0)
-			ret = -1;
-	}
-
-	while (ctx->dir != NULL) {
-		struct list_dir_context *dir = ctx->dir;
-
-		ctx->dir = dir->prev;
-                list_dir_context_free(dir);
-	}
-
-	if (ctx->list_pool != NULL)
-		pool_unref(ctx->list_pool);
-	if (ctx->glob != NULL)
-		imap_match_deinit(&ctx->glob);
-	i_free(ctx);
-
-	return ret;
-}
-
-struct mailbox_list *mbox_mailbox_list_next(struct mailbox_list_context *_ctx)
-{
-	struct mbox_list_context *ctx = (struct mbox_list_context *)_ctx;
-
-	return ctx->next(ctx);
-}
-
-static int list_file(struct mbox_list_context *ctx, const char *fname)
-{
-        struct list_dir_context *dir;
-	const char *list_path, *real_path, *path;
-	struct stat st;
-	DIR *dirp;
-	size_t len;
-	enum imap_match_result match, match2;
-	int ret;
-	bool noselect;
-
-	/* skip ., .., subscription file and .imap/ directory */
-	if (fname[0] == '.' &&
-	    (fname[1] == '\0' ||
-	     (fname[1] == '.' && fname[2] == '\0') ||
-	     strcmp(fname, SUBSCRIPTION_FILE_NAME) == 0 ||
-	     strcmp(fname, MBOX_INDEX_DIR_NAME) == 0))
-		return 0;
-
-	/* skip all .lock files */
-	len = strlen(fname);
-	if (len > 5 && strcmp(fname+len-5, ".lock") == 0)
-		return 0;
-
-	/* check the mask */
-	if (ctx->dir->virtual_path == NULL)
-		list_path = fname;
-	else {
-		list_path = t_strconcat(ctx->dir->virtual_path,
-					"/", fname, NULL);
-	}
-
-	if ((match = imap_match(ctx->glob, list_path)) < 0)
-		return 0;
-
-	/* see if it's a directory */
-	real_path = t_strconcat(ctx->dir->real_path, "/", fname, NULL);
-	if (stat(real_path, &st) == 0)
-		noselect = FALSE;
-	else if (errno == EACCES || errno == ELOOP)
-		noselect = TRUE;
-	else {
-		if (ENOTFOUND(errno))
-			return 0;
-		mail_storage_set_critical(ctx->mailbox_ctx.storage,
-					  "stat(%s) failed: %m", real_path);
-		return -1;
-	}
-
-	/* make sure we give only one correct INBOX */
-	if (strcasecmp(list_path, "INBOX") == 0 &&
-	    (ctx->mailbox_ctx.flags & MAILBOX_LIST_INBOX) != 0) {
-		if (ctx->inbox_found ||
-		    strcmp(real_path, ctx->istorage->inbox_path) != 0)
-			return 0;
-
-		ctx->inbox_found = TRUE;
-	}
-
-	if (!noselect && S_ISDIR(st.st_mode)) {
-		/* subdirectory. scan inside it. */
-		path = t_strconcat(list_path, "/", NULL);
-		match2 = imap_match(ctx->glob, path);
-
-		ctx->list.flags = MAILBOX_NOSELECT | MAILBOX_CHILDREN;
-		if (match > 0)
-			ctx->list.name = p_strdup(ctx->list_pool, list_path);
-		else if (match2 > 0)
-			ctx->list.name = p_strdup(ctx->list_pool, path);
-		else
-			ctx->list.name = NULL;
-
-		ret = match2 < 0 ? 0 :
-			list_opendir(ctx->mailbox_ctx.storage,
-				     real_path, FALSE, &dirp);
-		if (ret > 0) {
-			dir = i_new(struct list_dir_context, 1);
-			dir->dirp = dirp;
-			dir->real_path = i_strdup(real_path);
-			dir->virtual_path = i_strdup(list_path);
-
-			dir->prev = ctx->dir;
-			ctx->dir = dir;
-		} else if (ret < 0)
-			return -1;
-		return match > 0 || match2 > 0;
-	} else if (match > 0) {
-		ctx->list.flags = noselect ? MAILBOX_NOSELECT :
-			(MAILBOX_NOINFERIORS | STAT_GET_MARKED(st));
-		ctx->list.name = p_strdup(ctx->list_pool, list_path);
-		return 1;
-	}
-
-	return 0;
-}
-
-static struct mailbox_list *mbox_list_subs(struct mbox_list_context *ctx)
-{
-	struct stat st;
-	const char *name, *path, *p;
-	enum imap_match_result match = IMAP_MATCH_NO;
-
-	while ((name = subsfile_list_next(ctx->subsfile_ctx)) != NULL) {
-		match = imap_match(ctx->glob, name);
-		if (match == IMAP_MATCH_YES || match == IMAP_MATCH_PARENT)
-			break;
-	}
-
-	if (name == NULL)
-		return NULL;
-
-	ctx->list.flags = 0;
-	ctx->list.name = name;
-
-	if (match == IMAP_MATCH_PARENT) {
-		/* placeholder */
-		ctx->list.flags = MAILBOX_PLACEHOLDER;
-		while ((p = strrchr(name, '/')) != NULL) {
-			name = t_strdup_until(name, p);
-			if (imap_match(ctx->glob, name) > 0) {
-				p_clear(ctx->list_pool);
-				ctx->list.name = p_strdup(ctx->list_pool, name);
-				return &ctx->list;
-			}
-		}
-		i_unreached();
-	}
-
-	if ((ctx->mailbox_ctx.flags & MAILBOX_LIST_FAST_FLAGS) != 0)
-		return &ctx->list;
-
-	t_push();
-	path = mbox_get_path(ctx->istorage, ctx->list.name);
-	if (stat(path, &st) == 0) {
-		if (S_ISDIR(st.st_mode))
-			ctx->list.flags = MAILBOX_NOSELECT | MAILBOX_CHILDREN;
-		else {
-			ctx->list.flags = MAILBOX_NOINFERIORS |
-				STAT_GET_MARKED(st);
-		}
-	} else {
-		ctx->list.flags = MAILBOX_NONEXISTENT;
-	}
-	t_pop();
-	return &ctx->list;
-}
-
-static struct mailbox_list *mbox_list_path(struct mbox_list_context *ctx)
-{
-	ctx->next = mbox_list_next;
-
-	ctx->list.flags = MAILBOX_NOSELECT | MAILBOX_CHILDREN;
-	ctx->list.name =
-		p_strconcat(ctx->list_pool, ctx->dir->virtual_path, "/", NULL);
-
-	if (imap_match(ctx->glob, ctx->list.name) > 0)
-		return &ctx->list;
-	else
-		return ctx->next(ctx);
-}
-
-static struct mailbox_list *mbox_list_inbox(struct mbox_list_context *ctx)
-{
-	struct stat st;
-
-	ctx->list.flags = MAILBOX_NOINFERIORS;
-	ctx->list.name = "INBOX";
-
-	if (stat(ctx->istorage->inbox_path, &st) == 0)
-		ctx->list.flags |= STAT_GET_MARKED(st);
-	else if (errno == EACCES || errno == ELOOP)
-		ctx->list.flags = MAILBOX_NOSELECT;
-	else if (ENOTFOUND(errno))
-		ctx->list.flags |= MAILBOX_UNMARKED;
-	else {
-		mail_storage_set_critical(ctx->mailbox_ctx.storage,
-			"stat(%s) failed: %m", ctx->istorage->inbox_path);
-		ctx->mailbox_ctx.failed = TRUE;
-		return NULL;
-	}
-
-	return &ctx->list;
-}
-
-static struct mailbox_list *mbox_list_next(struct mbox_list_context *ctx)
-{
-	struct list_dir_context *dir;
-	struct dirent *d;
-	int ret;
-
-	p_clear(ctx->list_pool);
-
-	while (ctx->dir != NULL) {
-		/* NOTE: list_file() may change ctx->dir */
-		while ((d = readdir(ctx->dir->dirp)) != NULL) {
-			t_push();
-			ret = list_file(ctx, d->d_name);
-			t_pop();
-
-			if (ret > 0)
-				return &ctx->list;
-			if (ret < 0) {
-				ctx->mailbox_ctx.failed = TRUE;
-				return NULL;
-			}
-		}
-
-		dir = ctx->dir;
-		ctx->dir = dir->prev;
-		list_dir_context_free(dir);
-	}
-
-	if (!ctx->inbox_found &&
-	    (ctx->mailbox_ctx.flags & MAILBOX_LIST_INBOX) != 0 &&
-	    ctx->glob != NULL && imap_match(ctx->glob, "INBOX")  > 0) {
-		/* show inbox */
-		ctx->inbox_found = TRUE;
-		return mbox_list_inbox(ctx);
-	}
-
-	/* finished */
-	return NULL;
-}

--- a/src/lib-storage/index/mbox/mbox-storage.c	Wed Nov 15 21:14:08 2006 +0200
+++ b/src/lib-storage/index/mbox/mbox-storage.c	Thu Nov 16 02:16:31 2006 +0200
@@ -3,10 +3,8 @@
 #include "lib.h"
 #include "buffer.h"
 #include "istream.h"
-#include "home-expand.h"
 #include "mkdir-parents.h"
 #include "unlink-directory.h"
-#include "subscription-file/subscription-file.h"
 #include "mbox-storage.h"
 #include "mbox-lock.h"
 #include "mbox-file.h"
@@ -22,9 +20,11 @@
 
 #define CREATE_MODE 0770 /* umask() should limit it more */
 
-/* Don't allow creating too long mailbox names. They could start causing
-   problems when they reach the limit. */
-#define MBOX_MAX_MAILBOX_NAME_LENGTH (PATH_MAX/2)
+/* Assume that if atime < mtime, there are new mails. If it's good enough for
+   UW-IMAP, it's good enough for us. */
+#define STAT_GET_MARKED(st) \
+	((st).st_size == 0 ? MAILBOX_UNMARKED : \
+	 (st).st_atime < (st).st_mtime ? MAILBOX_MARKED : MAILBOX_UNMARKED)
 
 /* 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
@@ -251,31 +251,30 @@
 	return path;
 }
 
-static struct mail_storage *
-mbox_create(const char *data, const char *user, enum mail_storage_flags flags,
-	    enum mail_storage_lock_method lock_method)
+static int
+mbox_get_list_settings(struct mailbox_list_settings *list_set,
+		       const char *data, enum mail_storage_flags flags)
 {
 	bool debug = (flags & MAIL_STORAGE_FLAG_DEBUG) != 0;
-	struct mbox_storage *storage;
-	struct index_storage *istorage;
-	const char *root_dir, *inbox_file, *index_dir, *p;
+	const char *p;
 	struct stat st;
 	bool autodetect;
-	pool_t pool;
 
-	root_dir = inbox_file = index_dir = NULL;
+	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) {
 			i_error("mbox: root mail directory not given");
-			return NULL;
+			return -1;
 		}
 
 		/* we'll need to figure out the mail location ourself.
 		   it's root dir if we've already chroot()ed, otherwise
 		   either $HOME/mail or $HOME/Mail */
-		root_dir = get_root_dir(flags);
+		list_set->root_dir = get_root_dir(flags);
 	} else {
 		/* <root mail directory> | <INBOX path>
 		   [:INBOX=<path>] [:INDEX=<dir>] */
@@ -286,74 +285,99 @@
 			/* if the data points to a file, treat it as an INBOX */
 			if ((flags & MAIL_STORAGE_FLAG_NO_AUTODETECTION) != 0 ||
 			    stat(data, &st) < 0 || S_ISDIR(st.st_mode))
-				root_dir = data;
+				list_set->root_dir = data;
 			else {
-				root_dir = get_root_dir(flags);
-				inbox_file = data;
+				list_set->root_dir = get_root_dir(flags);
+				list_set->inbox_path = data;
 			}
 		} else {
-			root_dir = t_strdup_until(data, p);
+			list_set->root_dir = t_strdup_until(data, p);
 			do {
 				p++;
-				if (strncmp(p, "INBOX=", 6) == 0)
-					inbox_file = t_strcut(p+6, ':');
-				else if (strncmp(p, "INDEX=", 6) == 0)
-					index_dir = t_strcut(p+6, ':');
+				if (strncmp(p, "INBOX=", 6) == 0) {
+					list_set->inbox_path =
+						t_strcut(p+6, ':');
+				} else if (strncmp(p, "INDEX=", 6) == 0) {
+					list_set->index_dir =
+						t_strcut(p+6, ':');
+				}
 				p = strchr(p, ':');
 			} while (p != NULL);
 		}
 	}
 
-	if (root_dir == NULL) {
-		root_dir = create_root_dir(debug);
-		if (root_dir == NULL)
-			return NULL;
+	if (list_set->root_dir == NULL) {
+		list_set->root_dir = create_root_dir(debug);
+		if (list_set->root_dir == NULL)
+			return -1;
 	} else {
 		/* strip trailing '/' */
-		size_t len = strlen(root_dir);
-		if (root_dir[len-1] == '/')
-			root_dir = t_strndup(root_dir, len-1);
+		size_t len = strlen(list_set->root_dir);
+
+		if (list_set->root_dir[len-1] == '/') {
+			list_set->root_dir =
+				t_strndup(list_set->root_dir, len-1);
+		}
 
 		/* make sure the directory exists */
-		if (*root_dir == '\0' ||
-		    lstat(root_dir, &st) == 0) {
+		if (*list_set->root_dir == '\0' ||
+		    lstat(list_set->root_dir, &st) == 0) {
 			/* yep, go ahead */
 		} else if (errno != ENOENT && errno != ENOTDIR) {
-			i_error("lstat(%s) failed: %m", root_dir);
-			return NULL;
-		} else if (mkdir_parents(root_dir, CREATE_MODE) < 0 &&
+			i_error("lstat(%s) failed: %m", list_set->root_dir);
+			return -1;
+		} else if (mkdir_parents(list_set->root_dir, CREATE_MODE) < 0 &&
 			   errno != EEXIST) {
-			i_error("mkdir_parents(%s) failed: %m", root_dir);
-			return NULL;
+			i_error("mkdir_parents(%s) failed: %m",
+				list_set->root_dir);
+			return -1;
 		}
 	}
 
-	if (inbox_file == NULL)
-		inbox_file = get_inbox_file(root_dir, !autodetect, debug);
+	if (list_set->inbox_path == NULL) {
+		list_set->inbox_path =
+			get_inbox_file(list_set->root_dir, !autodetect, debug);
+	}
+
+	if (list_set->index_dir != NULL &&
+	    strcmp(list_set->index_dir, "MEMORY") == 0)
+		list_set->index_dir = "";
+	return 0;
+}
 
-	if (index_dir == NULL)
-		index_dir = root_dir;
-	else if (strcmp(index_dir, "MEMORY") == 0)
-		index_dir = NULL;
+static struct mail_storage *
+mbox_create(const char *data, const char *user, enum mail_storage_flags flags,
+	    enum mail_storage_lock_method lock_method)
+{
+	struct mbox_storage *storage;
+	struct index_storage *istorage;
+	struct mailbox_list_settings list_set;
+	struct mailbox_list *list;
+	const char *error;
+	pool_t pool;
 
-	if (debug) {
-		i_info("mbox: root=%s, index=%s, inbox=%s",
-		       root_dir, index_dir == NULL ? "" : index_dir,
-		       inbox_file == NULL ? "" : inbox_file);
-	}
+	if (mbox_get_list_settings(&list_set, data, flags) < 0)
+		return NULL;
 
 	pool = pool_alloconly_create("storage", 512);
 	storage = p_new(pool, struct mbox_storage, 1);
+
+	if (mailbox_list_init("maildir++", &list_set,
+			      mail_storage_get_list_flags(flags),
+			      mailbox_storage_list_is_mailbox, storage,
+			      &list, &error) < 0) {
+		i_error("mbox fs: %s", error);
+		pool_unref(pool);
+		return NULL;
+	}
+
 	istorage = INDEX_STORAGE(storage);
 	istorage->storage = mbox_storage;
 	istorage->storage.pool = pool;
 
-	istorage->dir = p_strdup(pool, home_expand(root_dir));
-	istorage->inbox_path = p_strdup(pool, home_expand(inbox_file));
-	istorage->index_dir = p_strdup(pool, home_expand(index_dir));
 	istorage->user = p_strdup(pool, user);
 	istorage->callbacks = p_new(pool, struct mail_storage_callbacks, 1);
-	index_storage_init(istorage, flags, lock_method);
+	index_storage_init(istorage, list, flags, lock_method);
 	return &storage->storage.storage;
 }
 
@@ -365,102 +389,25 @@
 	pool_unref(storage->storage.pool);
 }
 
-bool mbox_is_valid_mask(struct mail_storage *storage, const char *mask)
+static const char *
+mbox_get_index_dir(struct mail_storage *storage, const char *name)
 {
-	const char *p;
-	bool newdir;
-
-	if ((storage->flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0)
-		return TRUE;
-
-	/* make sure it's not absolute path */
-	if (*mask == '/' || *mask == '~')
-		return FALSE;
+	const char *dir, *p;
 
-	/* make sure the mailbox name doesn't contain any foolishness:
-	   "../" could give access outside the mailbox directory.
-	   "./" and "//" could fool ACL checks. */
-	newdir = TRUE;
-	for (p = mask; *p != '\0'; p++) {
-		if (newdir) {
-			if (p[0] == '/')
-				return FALSE; /* // */
-			if (p[0] == '.') {
-				if (p[1] == '/')
-					return FALSE; /* ./ */
-				if (p[1] == '.' && p[2] == '/')
-					return FALSE; /* ../ */
-			}
-		} 
-		newdir = p[0] == '/';
-	}
-	if (mask[0] == '.' && (mask[1] == '\0' ||
-			       (mask[1] == '.' && mask[2] == '\0'))) {
-		/* "." and ".." aren't allowed. */
-		return FALSE;
-	}
+	dir = mailbox_list_get_path(storage->list, name,
+				    MAILBOX_LIST_PATH_TYPE_INDEX);
+	if (*dir == '\0')
+		return NULL;
 
-	return TRUE;
+	p = strrchr(dir, '/');
+	if (p == NULL)
+		return NULL;
+
+	return t_strconcat(t_strdup_until(dir, p),
+			   "/"MBOX_INDEX_DIR_NAME"/", p+1, NULL);
 }
 
-static bool mbox_is_valid_create_name(struct mail_storage *storage,
-				      const char *name)
-{
-	size_t len;
-
-	len = strlen(name);
-	if (name[0] == '\0' || name[len-1] == '/' ||
-	    len > MBOX_MAX_MAILBOX_NAME_LENGTH)
-		return FALSE;
-
-	if ((storage->flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) == 0) {
-		if (mailbox_name_is_too_large(name, '/'))
-		    return FALSE;
-	}
-
-	return mbox_is_valid_mask(storage, name);
-}
-
-static bool mbox_is_valid_existing_name(struct mail_storage *storage,
-					const char *name)
-{
-	size_t len;
-
-	len = strlen(name);
-	if (name[0] == '\0' || name[len-1] == '/')
-		return FALSE;
-
-	return mbox_is_valid_mask(storage, name);
-}
-
-static const char *mbox_get_index_dir(struct index_storage *storage,
-				      const char *name)
-{
-	const char *p;
-
-	if (storage->index_dir == NULL)
-		return NULL;
-
-	if ((storage->storage.flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0 &&
-	    (*name == '/' || *name == '~')) {
-		name = home_expand(name);
-		p = strrchr(name, '/');
-		return t_strconcat(t_strdup_until(name, p),
-				   "/"MBOX_INDEX_DIR_NAME"/", p+1, NULL);
-	}
-
-	p = strrchr(name, '/');
-	if (p == NULL) {
-		return t_strconcat(storage->index_dir,
-				   "/"MBOX_INDEX_DIR_NAME"/", name, NULL);
-	} else {
-		return t_strconcat(storage->index_dir, "/",
-				   t_strdup_until(name, p),
-				   "/"MBOX_INDEX_DIR_NAME"/", p+1, NULL);
-	}
-}
-
-static int create_mbox_index_dirs(struct index_storage *storage,
+static int create_mbox_index_dirs(struct mail_storage *storage,
 				  const char *name)
 {
 	const char *index_dir;
@@ -470,7 +417,7 @@
 		return 0;
 
 	if (mkdir_parents(index_dir, CREATE_MODE) < 0) {
-		mail_storage_set_critical(&storage->storage,
+		mail_storage_set_critical(storage,
 			"mkdir_parents(%s) failed: %m", index_dir);
 		return -1;
 	}
@@ -478,33 +425,26 @@
 	return 0;
 }
 
-static int verify_inbox(struct index_storage *storage)
+static int verify_inbox(struct mail_storage *storage)
 {
+	const char *inbox_path;
 	int fd;
 
+	inbox_path = mailbox_list_get_path(storage->list, "INBOX",
+					   MAILBOX_LIST_PATH_TYPE_MAILBOX);
+
 	/* make sure inbox file itself exists */
-	fd = open(storage->inbox_path, O_RDWR | O_CREAT | O_EXCL, 0660);
+	fd = open(inbox_path, O_RDWR | O_CREAT | O_EXCL, 0660);
 	if (fd != -1)
 		(void)close(fd);
 	else if (errno != EEXIST) {
-		mail_storage_set_critical(&storage->storage,
-			"open(%s, O_CREAT) failed: %m", storage->inbox_path);
+		mail_storage_set_critical(storage,
+			"open(%s, O_CREAT) failed: %m", inbox_path);
 	}
 
 	return 0;
 }
 
-static const char *
-mbox_get_path(struct index_storage *storage, const char *name)
-{
-	if (strcmp(name, "INBOX") == 0)
-		return storage->inbox_path;
-	if ((storage->storage.flags & MAIL_STORAGE_FLAG_FULL_FS_ACCESS) != 0 &&
-	    (*name == '/' || *name == '~'))
-		return home_expand(name);
-	return t_strconcat(storage->dir, "/", name, NULL);
-}
-
 static bool mbox_mail_is_recent(struct index_mailbox *ibox __attr_unused__,
 				uint32_t uid __attr_unused__)
 {
@@ -578,31 +518,21 @@
 mbox_open(struct mbox_storage *storage, const char *name,
 	  enum mailbox_open_flags flags)
 {
-	struct index_storage *istorage = INDEX_STORAGE(storage);
+	struct mail_storage *_storage = STORAGE(storage);
 	struct mbox_mailbox *mbox;
 	struct mail_index *index;
 	const char *path, *index_dir;
 
-	if (strcmp(name, "INBOX") == 0) {
-		/* name = "INBOX"
-		   path = "<inbox_file>/INBOX"
-		   index_dir = "/mail/.imap/INBOX" */
-		path = istorage->inbox_path;
-		index_dir = mbox_get_index_dir(istorage, "INBOX");
-	} else {
-		/* name = "foo/bar"
-		   path = "/mail/foo/bar"
-		   index_dir = "/mail/foo/.imap/bar" */
-		path = mbox_get_path(istorage, name);
-		index_dir = mbox_get_index_dir(istorage, name);
-	}
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	index_dir = mbox_get_index_dir(_storage, name);
 
 	if ((flags & MAILBOX_OPEN_NO_INDEX_FILES) != 0)
-		index_dir = NULL;
+		index_dir = "";
 
-	if (index_dir != NULL) {
+	if (*index_dir != '\0') {
 		/* make sure the index directories exist */
-		if (create_mbox_index_dirs(istorage, name) < 0)
+		if (create_mbox_index_dirs(_storage, name) < 0)
 			return NULL;
 	}
 
@@ -638,21 +568,22 @@
 mbox_mailbox_open_stream(struct mbox_storage *storage, const char *name,
 			 struct istream *input, enum mailbox_open_flags flags)
 {
-	struct index_storage *istorage = INDEX_STORAGE(storage);
+	struct mail_storage *_storage = STORAGE(storage);
 	struct mail_index *index;
 	struct mbox_mailbox *mbox;
 	const char *path, *index_dir;
 
 	flags |= MAILBOX_OPEN_READONLY;
 
-	path = mbox_get_path(istorage, name);
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if ((flags & MAILBOX_OPEN_NO_INDEX_FILES) != 0)
 		index_dir = NULL;
 	else {
-		index_dir = mbox_get_index_dir(istorage, name);
+		index_dir = mbox_get_index_dir(_storage, name);
 
 		/* make sure the required directories are also there */
-		if (create_mbox_index_dirs(istorage, name) < 0)
+		if (create_mbox_index_dirs(_storage, name) < 0)
 			return NULL;
 	}
 
@@ -670,31 +601,6 @@
 	return &mbox->ibox.box;
 }
 
-static const char *
-mbox_get_mailbox_path(struct mail_storage *_storage,
-		      const char *name, bool *is_file_r)
-{
-	struct mbox_storage *storage = (struct mbox_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
-
-	if (*name == '\0') {
-		*is_file_r = FALSE;
-		return istorage->dir;
-	}
-
-	*is_file_r = TRUE;
-	return mbox_get_path(istorage, name);
-}
-
-static const char *
-mbox_get_mailbox_index_dir(struct mail_storage *_storage, const char *name)
-{
-	struct mbox_storage *storage = (struct mbox_storage *)_storage;
-	struct index_storage *istorage = INDEX_STORAGE(storage);
-
-	return mbox_get_index_dir(istorage, name);
-}
-
 static struct mailbox *
 mbox_mailbox_open(struct mail_storage *_storage, const char *name,
 		  struct istream *input, enum mailbox_open_flags flags)
@@ -711,17 +617,18 @@
 
 	if (strcmp(name, "INBOX") == 0) {
 		/* make sure INBOX exists */
-		if (verify_inbox(istorage) < 0)
+		if (verify_inbox(_storage) < 0)
 			return NULL;
 		return mbox_open(storage, "INBOX", flags);
 	}
 
-	if (!mbox_is_valid_existing_name(_storage, name)) {
+	if (!mailbox_list_is_valid_existing_name(_storage->list, name)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return NULL;
 	}
 
-	path = mbox_get_path(istorage, name);
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (stat(path, &st) == 0) {
 		if (S_ISDIR(st.st_mode)) {
 			mail_storage_set_error(_storage,
@@ -753,7 +660,7 @@
 
 	mail_storage_clear_error(_storage);
 
-	if (!mbox_is_valid_create_name(_storage, name)) {
+	if (!mailbox_list_is_valid_create_name(_storage->list, name)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return -1;
 	}
@@ -770,7 +677,8 @@
 	}
 
 	/* make sure it doesn't exist already */
-	path = mbox_get_path(storage, name);
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (stat(path, &st) == 0) {
 		mail_storage_set_error(_storage, "Mailbox already exists");
 		return -1;
@@ -836,12 +744,13 @@
 		return -1;
 	}
 
-	if (!mbox_is_valid_existing_name(_storage, name)) {
+	if (!mailbox_list_is_valid_existing_name(_storage->list, name)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return -1;
 	}
 
-	path = mbox_get_path(storage, name);
+	path = mailbox_list_get_path(_storage->list, name,
+				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
 	if (lstat(path, &st) < 0) {
 		if (ENOTFOUND(errno)) {
 			mail_storage_set_error(_storage,
@@ -854,12 +763,13 @@
 	}
 
 	if (S_ISDIR(st.st_mode)) {
-		/* deleting a folder, only allow it if it's empty.
-		   Delete .imap folder before to make sure it goes empty. */
-		index_dir = t_strconcat(storage->index_dir, "/", name,
-					"/"MBOX_INDEX_DIR_NAME, NULL);
+		/* deleting a directory. allow it only if it doesn't contain
+		   anything. Delete the ".imap" directory first in case there
+		   have been indexes. */
+		index_dir = mailbox_list_get_path(_storage->list, name,
+					MAILBOX_LIST_PATH_TYPE_MAILBOX);
 
-		if (index_dir != NULL && rmdir(index_dir) < 0 &&
+		if (*index_dir != '\0' && rmdir(index_dir) < 0 &&
 		    !ENOTFOUND(errno) && errno != ENOTEMPTY) {
 			if (!mbox_handle_errors(storage)) {
 				mail_storage_set_critical(_storage,
@@ -885,7 +795,19 @@
 		return -1;
 	}
 
-	/* first unlink the mbox file */
+	/* delete the index directory first, so that if we crash we don't
+	   leave indexes for deleted mailboxes lying around */
+	index_dir = mbox_get_index_dir(_storage, name);
+	if (index_dir != NULL) {
+		index_storage_destroy_unrefed();
+
+		if (unlink_directory(index_dir, TRUE) < 0 && errno != ENOENT) {
+			mail_storage_set_critical(_storage,
+				"unlink_directory(%s) failed: %m", index_dir);
+			return -1;
+		}
+	}
+
 	if (unlink(path) < 0) {
 		if (ENOTFOUND(errno)) {
 			mail_storage_set_error(_storage,
@@ -897,20 +819,6 @@
 		return -1;
 	}
 
-	/* next delete the index directory */
-	index_dir = mbox_get_index_dir(storage, name);
-	if (index_dir != NULL) {
-		index_storage_destroy_unrefed();
-
-		if (unlink_directory(index_dir, TRUE) < 0 && errno != ENOENT) {
-			mail_storage_set_critical(_storage,
-				"unlink_directory(%s) failed: %m", index_dir);
-
-			/* mailbox itself is deleted, so return success
-			   anyway */
-		}
-	}
-
 	return 0;
 }
 
@@ -923,8 +831,8 @@
 
 	mail_storage_clear_error(_storage);
 
-	if (!mbox_is_valid_existing_name(_storage, oldname) ||
-	    !mbox_is_valid_create_name(_storage, newname)) {
+	if (!mailbox_list_is_valid_existing_name(_storage->list, oldname) ||
+	    !mailbox_list_is_valid_create_name(_storage->list, newname)) {
 		mail_storage_set_error(_storage, "Invalid mailbox name");
 		return -1;
 	}
@@ -936,8 +844,10 @@
 		return -1;
 	}
 
-	oldpath = mbox_get_path(storage, oldname);
-	newpath = mbox_get_path(storage, newname);
+	oldpath = mailbox_list_get_path(_storage->list, oldname,
+					MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	newpath = mailbox_list_get_path(_storage->list, newname,
+					MAILBOX_LIST_PATH_TYPE_MAILBOX);
 
 	/* create the hierarchy */
 	p = strrchr(newpath, '/');
@@ -985,8 +895,8 @@
 	}
 
 	/* we need to rename the index directory as well */
-	old_indexdir = mbox_get_index_dir(storage, oldname);
-	new_indexdir = mbox_get_index_dir(storage, newname);
+	old_indexdir = mbox_get_index_dir(_storage, oldname);
+	new_indexdir = mbox_get_index_dir(_storage, newname);
 	if (old_indexdir != NULL) {
 		if (rename(old_indexdir, new_indexdir) < 0 &&
 		    errno != ENOENT) {
@@ -999,56 +909,6 @@
 	return 0;
 }
 
-static int mbox_set_subscribed(struct mail_storage *_storage,
-			       const char *name, bool set)
-{
-	struct index_storage *storage = (struct index_storage *)_storage;
-	const char *path;
-
-	path = t_strconcat(storage->dir, "/" SUBSCRIPTION_FILE_NAME, NULL);
-	return subsfile_set_subscribed(_storage, path, storage->temp_prefix,
-				       name, set);
-}
-
-static int mbox_get_mailbox_name_status(struct mail_storage *_storage,
-					const char *name,
-					enum mailbox_name_status *status)
-{
-	struct index_storage *storage = (struct index_storage *)_storage;
-	struct stat st;
-	const char *path;
-
-	mail_storage_clear_error(_storage);
-
-	if (!mbox_is_valid_existing_name(_storage, name)) {
-		*status = MAILBOX_NAME_INVALID;
-		return 0;
-	}
-
-	path = mbox_get_path(storage, name);
-	if (strcmp(name, "INBOX") == 0 || stat(path, &st) == 0) {
-		*status = MAILBOX_NAME_EXISTS;
-		return 0;
-	}
-
-	if (!mbox_is_valid_create_name(_storage, name)) {
-		*status = MAILBOX_NAME_INVALID;
-		return 0;
-	}
-
-	if (ENOTFOUND(errno) || errno == EACCES) {
-		*status = MAILBOX_NAME_VALID;
-		return 0;
-	} else if (errno == ENOTDIR) {
-		*status = MAILBOX_NAME_NOINFERIORS;
-		return 0;
-	} else {
-		mail_storage_set_critical(_storage, "mailbox name status: "
-					  "stat(%s) failed: %m", path);
-		return -1;
-	}
-}
-
 static int mbox_storage_close(struct mailbox *box)
 {
 	struct mbox_mailbox *mbox = (struct mbox_mailbox *)box;
@@ -1091,6 +951,70 @@
 		index_mailbox_check_add(&mbox->ibox, mbox->path);
 }
 
+static int mbox_is_mailbox(struct mail_storage *storage,
+			   const char *dir, const char *fname,
+			   enum mailbox_list_iter_flags iter_flags,
+			   enum mailbox_info_flags *flags,
+			   enum mailbox_list_file_type type)
+{
+	const char *path, *root_dir;
+	size_t len;
+	struct stat st;
+	int ret = 1;
+
+	if (strcmp(fname, MBOX_INDEX_DIR_NAME) == 0) {
+		*flags = MAILBOX_NOSELECT;
+		return 0;
+	}
+	if (strcmp(fname, MBOX_SUBSCRIPTION_FILE_NAME) == 0) {
+		root_dir = mailbox_list_get_path(storage->list, NULL,
+					MAILBOX_LIST_PATH_TYPE_MAILBOX);
+		if (strcmp(root_dir, dir) == 0) {
+			*flags = MAILBOX_NOSELECT | MAILBOX_NOINFERIORS;
+			return 0;
+		}
+	}
+
+	/* skip all .lock files */
+	len = strlen(fname);
+	if (len > 5 && strcmp(fname+len-5, ".lock") == 0) {
+		*flags = MAILBOX_NOSELECT | MAILBOX_NOINFERIORS;
+		return 0;
+	}
+
+	/* try to avoid stat() with these checks */
+	if (type == MAILBOX_LIST_FILE_TYPE_DIR) {
+		*flags |= MAILBOX_NOSELECT | MAILBOX_CHILDREN;
+		return 1;
+	}
+	if (type != MAILBOX_LIST_FILE_TYPE_SYMLINK &&
+	    type != MAILBOX_LIST_FILE_TYPE_UNKNOWN &&
+	    (iter_flags & MAILBOX_LIST_ITER_FAST_FLAGS) != 0) {
+		*flags |= MAILBOX_NOINFERIORS;
+		return 1;
+	}
+
+	/* need to stat() then */
+	t_push();
+	path = t_strconcat(dir, "/", fname, NULL);
+	if (stat(path, &st) == 0) {
+		if (S_ISDIR(st.st_mode))
+			*flags |= MAILBOX_NOSELECT | MAILBOX_CHILDREN;
+		else
+			*flags |= MAILBOX_NOINFERIORS | STAT_GET_MARKED(st);
+	} else if (errno == EACCES || errno == ELOOP)
+		*flags |= MAILBOX_NOSELECT;
+	else if (ENOTFOUND(errno))
+		ret = 0;
+	else {
+		mail_storage_set_critical(storage, "stat(%s) failed: %m", path);
+		ret = -1;
+	}
+	t_pop();
+
+	return ret;
+}
+
 static void mbox_class_init(void)
 {
 	mbox_transaction_class_init();
@@ -1103,7 +1027,7 @@
 
 struct mail_storage mbox_storage = {
 	MEMBER(name) MBOX_STORAGE_NAME,
-	MEMBER(hierarchy_sep) '/',
+	MEMBER(mailbox_is_file) TRUE,
 
 	{
 		mbox_class_init,
@@ -1112,18 +1036,13 @@
 		mbox_free,
 		mbox_autodetect,
 		index_storage_set_callbacks,
-		mbox_get_mailbox_path,
-		mbox_get_mailbox_index_dir,
-		mbox_get_mailbox_index_dir,
+		mbox_get_index_dir,
+		mbox_get_index_dir,
 		mbox_mailbox_open,
 		mbox_mailbox_create,
 		mbox_mailbox_delete,
 		mbox_mailbox_rename,
-		mbox_mailbox_list_init,
-		mbox_mailbox_list_next,
-		mbox_mailbox_list_deinit,
-		mbox_set_subscribed,
-		mbox_get_mailbox_name_status,
+		mbox_is_mailbox,
 		index_storage_get_last_error
 	}
 };