--- a/TODO	Sat Jan 01 14:34:14 2011 +0200
+++ b/TODO	Sat Jan 01 15:59:02 2011 +0200
@@ -1,3 +1,23 @@
+ - notify_sync() could have "what changed" struct with old/new flags
+ - mailbox deletion could really be "rmdir", which fails if everything isn't
+   already expunged. IMAP DELETE could fail with "mailbox changed during
+   deletion, aborting" if new messages arrive
+     - if doing any changes, figure out how to handle symlinked mailboxes
+ - maildir: copy dovecot-shared file from parent mailbox, not root.
+ - is mail_index_sync_have_any() really necessary? especially that it returns
+   TRUE for ext rec changes ... why?...
+ - mailbox listing to use UTF8 everywhere
+    - move namespace sep vs. real_sep check from imap client_find_namespace()
+      to lib-storage mailbox name validity check
+ - rewrite autocreate plugin by making it list virtual mailbox names and only
+   lazily autocreate create them when mailbox is opened
+ - login-common API change to fix compiling with
+   LDFLAGS="-Wl,--as-needed -Wl,--no-undefined"
+ - if global ACL path points to a file instead of a directory, read all of
+   them from there. support wildcards in names.
+ - remove 3 unnecessary stat() calls when opening mailbox. they all come from
+   mailbox_list_get_permissions_full()
+
  - master passdb preserves userdb_* extra fields. should it preserve
    non-userdb_* extra fields too?
  - imap, pop3: if client init fails, wait a second or two before disconnecting

--- a/src/doveadm/doveadm-mail-fetch.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/doveadm/doveadm-mail-fetch.c	Sat Jan 01 15:59:02 2011 +0200
@@ -63,11 +63,12 @@
 
 static int fetch_mailbox_guid(struct fetch_cmd_context *ctx)
 {
-	uint8_t guid[MAIL_GUID_128_SIZE];
+	struct mailbox_metadata metadata;
 
-	if (mailbox_get_guid(ctx->mail->box, guid) < 0)
+	if (mailbox_get_metadata(ctx->mail->box, MAILBOX_METADATA_GUID,
+				 &metadata) < 0)
 		return -1;
-	doveadm_print(mail_guid_128_to_string(guid));
+	doveadm_print(mail_guid_128_to_string(metadata.guid));
 	return 0;
 }
 

--- a/src/doveadm/doveadm-mail-mailbox-status.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/doveadm/doveadm-mail-mailbox-status.c	Sat Jan 01 15:59:02 2011 +0200
@@ -12,18 +12,24 @@
 #define ALL_STATUS_ITEMS \
 	(STATUS_MESSAGES | STATUS_RECENT | \
 	 STATUS_UIDNEXT | STATUS_UIDVALIDITY | \
-	 STATUS_UNSEEN | STATUS_HIGHESTMODSEQ | STATUS_VIRTUAL_SIZE)
+	 STATUS_UNSEEN | STATUS_HIGHESTMODSEQ)
+#define ALL_METADATA_ITEMS \
+	(MAILBOX_METADATA_VIRTUAL_SIZE | MAILBOX_METADATA_GUID)
 
 #define TOTAL_STATUS_ITEMS \
-	(STATUS_MESSAGES | STATUS_RECENT | STATUS_UNSEEN | STATUS_VIRTUAL_SIZE)
+	(STATUS_MESSAGES | STATUS_RECENT | STATUS_UNSEEN)
+#define TOTAL_METADATA_ITEMS \
+	(MAILBOX_METADATA_VIRTUAL_SIZE)
 
 struct status_cmd_context {
 	struct doveadm_mail_cmd_context ctx;
 	struct mail_search_args *search_args;
-	enum mailbox_status_items items;
+
+	enum mailbox_status_items status_items;
+	enum mailbox_metadata_items metadata_items;
 	struct mailbox_status total_status;
+	struct mailbox_metadata total_metadata;
 
-	unsigned int guid:1;
 	unsigned int total_sum:1;
 };
 
@@ -37,40 +43,42 @@
 		const char *field = *fields;
 
 		if (strcmp(field, "all") == 0) {
-			if (ctx->total_sum)
-				ctx->items |= TOTAL_STATUS_ITEMS;
-			else {
-				ctx->items |= ALL_STATUS_ITEMS;
-				ctx->guid = TRUE;
+			if (ctx->total_sum) {
+				ctx->status_items |= TOTAL_STATUS_ITEMS;
+				ctx->metadata_items |= TOTAL_METADATA_ITEMS;
+			} else {
+				ctx->status_items |= ALL_STATUS_ITEMS;
+				ctx->metadata_items |= ALL_METADATA_ITEMS;
 			}
 		} else if (strcmp(field, "messages") == 0)
-			ctx->items |= STATUS_MESSAGES;
+			ctx->status_items |= STATUS_MESSAGES;
 		else if (strcmp(field, "recent") == 0)
-			ctx->items |= STATUS_RECENT;
+			ctx->status_items |= STATUS_RECENT;
 		else if (strcmp(field, "uidnext") == 0)
-			ctx->items |= STATUS_UIDNEXT;
+			ctx->status_items |= STATUS_UIDNEXT;
 		else if (strcmp(field, "uidvalidity") == 0)
-			ctx->items |= STATUS_UIDVALIDITY;
+			ctx->status_items |= STATUS_UIDVALIDITY;
 		else if (strcmp(field, "unseen") == 0)
-			ctx->items |= STATUS_UNSEEN;
+			ctx->status_items |= STATUS_UNSEEN;
 		else if (strcmp(field, "highestmodseq") == 0)
-			ctx->items |= STATUS_HIGHESTMODSEQ;
+			ctx->status_items |= STATUS_HIGHESTMODSEQ;
 		else if (strcmp(field, "vsize") == 0)
-			ctx->items |= STATUS_VIRTUAL_SIZE;
+			ctx->metadata_items |= MAILBOX_METADATA_VIRTUAL_SIZE;
 		else if (strcmp(field, "guid") == 0)
-			ctx->guid = TRUE;
+			ctx->metadata_items |= MAILBOX_METADATA_GUID;
 		else
 			i_fatal("Unknown status field: %s", field);
 
 		if (ctx->total_sum &&
-		    ((ctx->items & ~TOTAL_STATUS_ITEMS) != 0 || ctx->guid))
+		    ((ctx->status_items & ~TOTAL_STATUS_ITEMS) != 0 ||
+		     (ctx->metadata_items & ~TOTAL_METADATA_ITEMS) != 0))
 			i_fatal("Status field %s can't be used with -t", field);
 	}
 }
 
 static void status_output(struct status_cmd_context *ctx, struct mailbox *box,
 			  const struct mailbox_status *status,
-			  uint8_t mailbox_guid[MAIL_GUID_128_SIZE])
+			  const struct mailbox_metadata *metadata)
 {
 	string_t *name;
 
@@ -83,34 +91,35 @@
 		doveadm_print(str_c(name));
 	}
 
-	if ((ctx->items & STATUS_MESSAGES) != 0)
+	if ((ctx->status_items & STATUS_MESSAGES) != 0)
 		doveadm_print_num(status->messages);
-	if ((ctx->items & STATUS_RECENT) != 0)
+	if ((ctx->status_items & STATUS_RECENT) != 0)
 		doveadm_print_num(status->recent);
-	if ((ctx->items & STATUS_UIDNEXT) != 0)
+	if ((ctx->status_items & STATUS_UIDNEXT) != 0)
 		doveadm_print_num(status->uidnext);
-	if ((ctx->items & STATUS_UIDVALIDITY) != 0)
+	if ((ctx->status_items & STATUS_UIDVALIDITY) != 0)
 		doveadm_print_num(status->uidvalidity);
-	if ((ctx->items & STATUS_UNSEEN) != 0)
+	if ((ctx->status_items & STATUS_UNSEEN) != 0)
 		doveadm_print_num(status->unseen);
-	if ((ctx->items & STATUS_HIGHESTMODSEQ) != 0)
+	if ((ctx->status_items & STATUS_HIGHESTMODSEQ) != 0)
 		doveadm_print_num(status->highest_modseq);
-	if ((ctx->items & STATUS_VIRTUAL_SIZE) != 0)
-		doveadm_print_num(status->virtual_size);
-	if (ctx->guid)
-		doveadm_print(mail_guid_128_to_string(mailbox_guid));
+	if ((ctx->metadata_items & MAILBOX_METADATA_VIRTUAL_SIZE) != 0)
+		doveadm_print_num(metadata->virtual_size);
+	if ((ctx->metadata_items & MAILBOX_METADATA_GUID) != 0)
+		doveadm_print(mail_guid_128_to_string(metadata->guid));
 }
 
 static void
 status_sum(struct status_cmd_context *ctx,
-	   const struct mailbox_status *status)
+	   const struct mailbox_status *status,
+	   const struct mailbox_metadata *metadata)
 {
 	struct mailbox_status *dest = &ctx->total_status;
 
 	dest->messages += status->messages;
 	dest->recent += status->recent;
 	dest->unseen += status->unseen;
-	dest->virtual_size += status->virtual_size;
+	ctx->total_metadata.virtual_size += metadata->virtual_size;
 }
 
 static void
@@ -118,7 +127,7 @@
 {
 	struct mailbox *box;
 	struct mailbox_status status;
-	uint8_t mailbox_guid[MAIL_GUID_128_SIZE];
+	struct mailbox_metadata metadata;
 	string_t *mailbox_name = t_str_new(128);
 
 	if (imap_utf7_to_utf8(info->name, mailbox_name) < 0) {
@@ -126,20 +135,17 @@
 		str_append(mailbox_name, info->name);
 	}
 
-	if (doveadm_mailbox_find_and_sync(ctx->ctx.cur_mail_user,
-					  str_c(mailbox_name), &box) < 0) {
+	box = doveadm_mailbox_find(ctx->ctx.cur_mail_user, str_c(mailbox_name));
+	if (mailbox_get_status(box, ctx->status_items, &status) < 0 ||
+	    mailbox_get_metadata(box, ctx->metadata_items, &metadata) < 0) {
 		ctx->ctx.failed = TRUE;
+		mailbox_free(&box);
 		return;
 	}
-	mailbox_get_status(box, ctx->items, &status);
-	if (ctx->guid) {
-		if (mailbox_get_guid(box, mailbox_guid) < 0)
-			memset(mailbox_guid, 0, sizeof(mailbox_guid));
-	}
 	if (!ctx->total_sum)
-		status_output(ctx, box, &status, mailbox_guid);
+		status_output(ctx, box, &status, &metadata);
 	else
-		status_sum(ctx, &status);
+		status_sum(ctx, &status, &metadata);
 	mailbox_free(&box);
 }
 
@@ -165,8 +171,10 @@
 	}
 	doveadm_mail_list_iter_deinit(&iter);
 
-	if (ctx->total_sum)
-		status_output(ctx, NULL, &ctx->total_status, NULL);
+	if (ctx->total_sum) {
+		status_output(ctx, NULL, &ctx->total_status,
+			      &ctx->total_metadata);
+	}
 }
 
 static void cmd_mailbox_status_init(struct doveadm_mail_cmd_context *_ctx,
@@ -185,21 +193,21 @@
 		doveadm_print_header("mailbox", "mailbox",
 				     DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
 	}
-	if ((ctx->items & STATUS_MESSAGES) != 0)
+	if ((ctx->status_items & STATUS_MESSAGES) != 0)
 		doveadm_print_header_simple("messages");
-	if ((ctx->items & STATUS_RECENT) != 0)
+	if ((ctx->status_items & STATUS_RECENT) != 0)
 		doveadm_print_header_simple("recent");
-	if ((ctx->items & STATUS_UIDNEXT) != 0)
+	if ((ctx->status_items & STATUS_UIDNEXT) != 0)
 		doveadm_print_header_simple("uidnext");
-	if ((ctx->items & STATUS_UIDVALIDITY) != 0)
+	if ((ctx->status_items & STATUS_UIDVALIDITY) != 0)
 		doveadm_print_header_simple("uidvalidity");
-	if ((ctx->items & STATUS_UNSEEN) != 0)
+	if ((ctx->status_items & STATUS_UNSEEN) != 0)
 		doveadm_print_header_simple("unseen");
-	if ((ctx->items & STATUS_HIGHESTMODSEQ) != 0)
+	if ((ctx->status_items & STATUS_HIGHESTMODSEQ) != 0)
 		doveadm_print_header_simple("highestmodseq");
-	if ((ctx->items & STATUS_VIRTUAL_SIZE) != 0)
+	if ((ctx->metadata_items & MAILBOX_METADATA_VIRTUAL_SIZE) != 0)
 		doveadm_print_header_simple("vsize");
-	if (ctx->guid)
+	if ((ctx->metadata_items & MAILBOX_METADATA_GUID) != 0)
 		doveadm_print_header_simple("guid");
 }
 

--- a/src/doveadm/doveadm-mail-search.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/doveadm/doveadm-mail-search.c	Sat Jan 01 15:59:02 2011 +0200
@@ -16,7 +16,7 @@
 	struct doveadm_mail_iter *iter;
 	struct mailbox_transaction_context *trans;
 	struct mail *mail;
-	uint8_t guid[MAIL_GUID_128_SIZE];
+	struct mailbox_metadata metadata;
 	const char *guid_str;
 	int ret = 0;
 
@@ -24,10 +24,12 @@
 		return -1;
 
 	mail = mail_alloc(trans, 0, NULL);
-	if (mailbox_get_guid(mail->box, guid) < 0)
+
+	if (mailbox_get_metadata(mail->box, MAILBOX_METADATA_GUID,
+				 &metadata) < 0)
 		ret = -1;
 	else {
-		guid_str = mail_guid_128_to_string(guid);
+		guid_str = mail_guid_128_to_string(metadata.guid);
 		while (doveadm_mail_iter_next(iter, mail)) {
 			doveadm_print(guid_str);
 			T_BEGIN {

--- a/src/doveadm/doveadm-mail.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/doveadm/doveadm-mail.c	Sat Jan 01 15:59:02 2011 +0200
@@ -71,13 +71,11 @@
 	return ctx;
 }
 
-static int mailbox_find_and_open(struct mail_user *user, const char *mailbox,
-				 struct mailbox **box_r)
+struct mailbox *
+doveadm_mailbox_find(struct mail_user *user, const char *mailbox)
 {
 	struct mail_namespace *ns;
-	struct mailbox *box;
 	string_t *str;
-	const char *orig_mailbox = mailbox;
 
 	str = t_str_new(128);
 	if (imap_utf8_to_utf7(mailbox, str) < 0)
@@ -88,10 +86,19 @@
 	if (ns == NULL)
 		i_fatal("Can't find namespace for mailbox %s", mailbox);
 
-	box = mailbox_alloc(ns->list, mailbox, MAILBOX_FLAG_KEEP_RECENT |
-			    MAILBOX_FLAG_IGNORE_ACLS);
+	return mailbox_alloc(ns->list, mailbox, MAILBOX_FLAG_KEEP_RECENT |
+			     MAILBOX_FLAG_IGNORE_ACLS);
+}
+
+static int
+doveadm_mailbox_find_and_open(struct mail_user *user, const char *mailbox,
+			      struct mailbox **box_r)
+{
+	struct mailbox *box;
+
+	box = doveadm_mailbox_find(user, mailbox);
 	if (mailbox_open(box) < 0) {
-		i_error("Opening mailbox %s failed: %s", orig_mailbox,
+		i_error("Opening mailbox %s failed: %s", mailbox,
 			mail_storage_get_last_error(mailbox_get_storage(box),
 						    NULL));
 		mailbox_free(&box);
@@ -104,12 +111,13 @@
 int doveadm_mailbox_find_and_sync(struct mail_user *user, const char *mailbox,
 				  struct mailbox **box_r)
 {
-	if (mailbox_find_and_open(user, mailbox, box_r) < 0)
+	if (doveadm_mailbox_find_and_open(user, mailbox, box_r) < 0)
 		return -1;
 	if (mailbox_sync(*box_r, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
 		i_error("Syncing mailbox %s failed: %s", mailbox,
 			mail_storage_get_last_error(mailbox_get_storage(*box_r),
 						    NULL));
+		mailbox_free(box_r);
 		return -1;
 	}
 	return 0;
@@ -143,7 +151,7 @@
 	struct mail_storage *storage;
 	struct mailbox *box;
 
-	if (mailbox_find_and_open(user, ctx->mailbox, &box) < 0) {
+	if (doveadm_mailbox_find_and_open(user, ctx->mailbox, &box) < 0) {
 		_ctx->failed = TRUE;
 		return;
 	}

--- a/src/doveadm/doveadm-mail.h	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/doveadm/doveadm-mail.h	Sat Jan 01 15:59:02 2011 +0200
@@ -89,6 +89,8 @@
 			     const char **error_r);
 void doveadm_mail_server_flush(void);
 
+struct mailbox *
+doveadm_mailbox_find(struct mail_user *user, const char *mailbox);
 int doveadm_mailbox_find_and_sync(struct mail_user *user, const char *mailbox,
 				  struct mailbox **box_r);
 struct mail_search_args *

--- a/src/dsync/dsync-worker-local.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/dsync/dsync-worker-local.c	Sat Jan 01 15:59:02 2011 +0200
@@ -510,13 +510,18 @@
 		(struct local_dsync_worker_mailbox_iter *)_iter;
 	struct local_dsync_worker *worker =
 		(struct local_dsync_worker *)_iter->worker;
-	enum mailbox_flags flags =
+	const enum mailbox_flags flags =
 		MAILBOX_FLAG_READONLY | MAILBOX_FLAG_KEEP_RECENT;
+	const enum mailbox_status_items status_items =
+		STATUS_UIDNEXT | STATUS_UIDVALIDITY |
+		STATUS_HIGHESTMODSEQ;
+	const enum mailbox_metadata_items metadata_items =
+		MAILBOX_METADATA_CACHE_FIELDS | MAILBOX_METADATA_GUID;
 	const struct mailbox_info *info;
 	const char *storage_name;
 	struct mailbox *box;
 	struct mailbox_status status;
-	uint8_t mailbox_guid[MAIL_GUID_128_SIZE];
+	struct mailbox_metadata metadata;
 	struct local_dsync_mailbox_change *change;
 	struct local_dsync_dir_change *dir_change, change_lookup;
 	struct local_dsync_mailbox *old_lbox;
@@ -554,8 +559,8 @@
 	}
 
 	box = mailbox_alloc(info->ns->list, storage_name, flags);
-	if (mailbox_sync(box, 0) < 0 ||
-	    mailbox_get_guid(box, mailbox_guid) < 0) {
+	if (mailbox_get_status(box, status_items, &status) < 0 ||
+	    mailbox_get_metadata(box, metadata_items, &metadata) < 0) {
 		struct mail_storage *storage = mailbox_get_storage(box);
 
 		i_error("Failed to sync mailbox %s: %s", info->name,
@@ -565,16 +570,13 @@
 		return -1;
 	}
 
-	mailbox_get_status(box, STATUS_UIDNEXT | STATUS_UIDVALIDITY |
-			   STATUS_HIGHESTMODSEQ | STATUS_CACHE_FIELDS, &status);
-
-	change = hash_table_lookup(worker->mailbox_changes_hash, mailbox_guid);
+	change = hash_table_lookup(worker->mailbox_changes_hash, metadata.guid);
 	if (change != NULL) {
 		/* it shouldn't be marked as deleted, but drop it to be sure */
 		change->deleted_mailbox = FALSE;
 	}
 
-	memcpy(dsync_box_r->mailbox_guid.guid, mailbox_guid,
+	memcpy(dsync_box_r->mailbox_guid.guid, metadata.guid,
 	       sizeof(dsync_box_r->mailbox_guid.guid));
 	dsync_box_r->uid_validity = status.uidvalidity;
 	dsync_box_r->uid_next = status.uidnext;
@@ -582,7 +584,7 @@
 	dsync_box_r->highest_modseq = status.highest_modseq;
 
 	p_clear(iter->ret_pool);
-	fields = array_get(status.cache_fields, &field_count);
+	fields = array_get(metadata.cache_fields, &field_count);
 	p_array_init(&dsync_box_r->cache_fields, iter->ret_pool, field_count);
 	for (i = 0; i < field_count; i++) {
 		const char *field_name = p_strdup(iter->ret_pool, fields[i]);
@@ -787,7 +789,7 @@
 	enum mailbox_flags flags = MAILBOX_FLAG_KEEP_RECENT;
 	struct local_dsync_mailbox *lbox;
 	struct mailbox *box;
-	uint8_t mailbox_guid[MAIL_GUID_128_SIZE];
+	struct mailbox_metadata metadata;
 
 	lbox = hash_table_lookup(worker->mailbox_hash, guid);
 	if (lbox == NULL) {
@@ -798,7 +800,7 @@
 
 	box = mailbox_alloc(lbox->ns->list, lbox->storage_name, flags);
 	if (mailbox_sync(box, 0) < 0 ||
-	    mailbox_get_guid(box, mailbox_guid) < 0) {
+	    mailbox_get_metadata(box, MAILBOX_METADATA_GUID, &metadata) < 0) {
 		struct mail_storage *storage = mailbox_get_storage(box);
 
 		i_error("Failed to sync mailbox %s: %s", lbox->storage_name,
@@ -807,10 +809,10 @@
 		return -1;
 	}
 
-	if (memcmp(mailbox_guid, guid->guid, sizeof(guid->guid)) != 0) {
+	if (memcmp(metadata.guid, guid->guid, sizeof(guid->guid)) != 0) {
 		i_error("Mailbox %s changed its GUID (%s -> %s)",
 			lbox->storage_name, dsync_guid_to_str(guid),
-			mail_guid_128_to_string(mailbox_guid));
+			mail_guid_128_to_string(metadata.guid));
 		mailbox_free(&box);
 		return -1;
 	}
@@ -935,7 +937,7 @@
 	array_clear(&iter->expunges);
 	iter->expunges_set = TRUE;
 
-	mailbox_get_status(box, STATUS_UIDNEXT, &status);
+	mailbox_get_open_status(box, STATUS_UIDNEXT, &status);
 	if (prev_uid + 1 >= status.uidnext) {
 		/* no expunged messages at the end of mailbox */
 		return FALSE;
@@ -1523,7 +1525,7 @@
 		keywords = mailbox_keywords_create_valid(worker->mail->box,
 							 msg->keywords);
 		mail_update_keywords(worker->mail, MODIFY_REPLACE, keywords);
-		mailbox_keywords_unref(worker->mail->box, &keywords);
+		mailbox_keywords_unref(&keywords);
 		mail_update_modseq(worker->mail, msg->modseq);
 	}
 }
@@ -1574,7 +1576,7 @@
 		mailbox_keywords_create_valid(box, msg->keywords);
 	mailbox_save_set_flags(save_ctx, msg->flags, keywords);
 	if (keywords != NULL)
-		mailbox_keywords_unref(box, &keywords);
+		mailbox_keywords_unref(&keywords);
 	mailbox_save_set_uid(save_ctx, msg->uid);
 	mailbox_save_set_save_date(save_ctx, msg->save_date);
 	mailbox_save_set_min_modseq(save_ctx, msg->modseq);

--- a/src/imap/cmd-append.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/cmd-append.c	Sat Jan 01 15:59:02 2011 +0200
@@ -351,7 +351,7 @@
 	ret = mailbox_save_begin(&ctx->save_ctx, ctx->input);
 
 	if (keywords != NULL)
-		mailbox_keywords_unref(ctx->box, &keywords);
+		mailbox_keywords_unref(&keywords);
 
 	if (ret < 0) {
 		/* save initialization failed */
@@ -445,47 +445,6 @@
 	return FALSE;
 }
 
-static struct mailbox *
-get_mailbox(struct client_command_context *cmd, const char *name)
-{
-	struct mail_namespace *ns;
-	struct mailbox *box;
-	enum mailbox_name_status status;
-	const char *storage_name;
-
-	ns = client_find_namespace(cmd, name, &storage_name, &status);
-	if (ns == NULL)
-		return NULL;
-
-	switch (status) {
-	case MAILBOX_NAME_EXISTS_MAILBOX:
-		break;
-	case MAILBOX_NAME_EXISTS_DIR:
-		status = MAILBOX_NAME_VALID;
-		/* fall through */
-	case MAILBOX_NAME_VALID:
-	case MAILBOX_NAME_INVALID:
-	case MAILBOX_NAME_NOINFERIORS:
-		client_fail_mailbox_name_status(cmd, name, "TRYCREATE", status);
-		return NULL;
-	}
-
-	if (cmd->client->mailbox != NULL &&
-	    mailbox_equals(cmd->client->mailbox, ns, storage_name))
-		return cmd->client->mailbox;
-
-	box = mailbox_alloc(ns->list, storage_name, MAILBOX_FLAG_SAVEONLY |
-			    MAILBOX_FLAG_KEEP_RECENT);
-	if (mailbox_open(box) < 0) {
-		client_send_storage_error(cmd, mailbox_get_storage(box));
-		mailbox_free(&box);
-		return NULL;
-	}
-	if (cmd->client->enabled_features != 0)
-		mailbox_enable(box, cmd->client->enabled_features);
-	return box;
-}
-
 bool cmd_append(struct client_command_context *cmd)
 {
 	struct client *client = cmd->client;
@@ -509,8 +468,7 @@
 	ctx = p_new(cmd->pool, struct cmd_append_context, 1);
 	ctx->cmd = cmd;
 	ctx->client = client;
-	ctx->box = get_mailbox(cmd, mailbox);
-	if (ctx->box == NULL)
+	if (client_open_save_dest_box(cmd, mailbox, &ctx->box) < 0)
 		ctx->failed = TRUE;
 	else {
 		ctx->storage = mailbox_get_storage(ctx->box);

--- a/src/imap/cmd-copy.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/cmd-copy.c	Sat Jan 01 15:59:02 2011 +0200
@@ -85,13 +85,11 @@
 bool cmd_copy(struct client_command_context *cmd)
 {
 	struct client *client = cmd->client;
-	struct mail_namespace *dest_ns;
 	struct mail_storage *dest_storage;
 	struct mailbox *destbox;
 	struct mailbox_transaction_context *t;
         struct mail_search_args *search_args;
-	const char *messageset, *mailbox, *storage_name, *src_uidset;
-	enum mailbox_name_status status;
+	const char *messageset, *mailbox, *src_uidset;
 	enum mailbox_sync_flags sync_flags = 0;
 	enum imap_sync_flags imap_flags = 0;
 	struct mail_transaction_commit_changes changes;
@@ -110,41 +108,9 @@
 	if (ret <= 0)
 		return ret < 0;
 
-	/* open the destination mailbox */
-	dest_ns = client_find_namespace(cmd, mailbox, &storage_name, &status);
-	if (dest_ns == NULL)
+	if (client_open_save_dest_box(cmd, mailbox, &destbox) < 0)
 		return TRUE;
 
-	switch (status) {
-	case MAILBOX_NAME_EXISTS_MAILBOX:
-		break;
-	case MAILBOX_NAME_EXISTS_DIR:
-		status = MAILBOX_NAME_VALID;
-		/* fall through */
-	case MAILBOX_NAME_VALID:
-	case MAILBOX_NAME_INVALID:
-	case MAILBOX_NAME_NOINFERIORS:
-		client_fail_mailbox_name_status(cmd, mailbox,
-						"TRYCREATE", status);
-		return NULL;
-	}
-
-	if (mailbox_equals(client->mailbox, dest_ns, storage_name))
-		destbox = client->mailbox;
-	else {
-		destbox = mailbox_alloc(dest_ns->list, storage_name,
-					MAILBOX_FLAG_SAVEONLY |
-					MAILBOX_FLAG_KEEP_RECENT);
-		if (mailbox_open(destbox) < 0) {
-			client_send_storage_error(cmd,
-				mailbox_get_storage(destbox));
-			mailbox_free(&destbox);
-			return TRUE;
-		}
-		if (client->enabled_features != 0)
-			mailbox_enable(destbox, client->enabled_features);
-	}
-
 	t = mailbox_transaction_begin(destbox,
 				      MAILBOX_TRANSACTION_FLAG_EXTERNAL |
 				      MAILBOX_TRANSACTION_FLAG_ASSIGN_UIDS);

--- a/src/imap/cmd-create.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/cmd-create.c	Sat Jan 01 15:59:02 2011 +0200
@@ -7,7 +7,6 @@
 
 bool cmd_create(struct client_command_context *cmd)
 {
-	enum mailbox_name_status status;
 	struct mail_namespace *ns;
 	const char *mailbox, *storage_name;
 	struct mailbox *box;
@@ -18,7 +17,7 @@
 	if (!client_read_string_args(cmd, 1, &mailbox))
 		return FALSE;
 
-	ns = client_find_namespace(cmd, mailbox, &storage_name, NULL);
+	ns = client_find_namespace(cmd, mailbox, &storage_name);
 	if (ns == NULL)
 		return TRUE;
 
@@ -34,26 +33,18 @@
 		   informing us that it wants to create children under this
 		   mailbox. */
                 directory = TRUE;
-		storage_name = t_strndup(storage_name, strlen(storage_name)-1);
 		mailbox = t_strndup(mailbox, len-1);
+
+		/* drop also from storage_name. it's already dropped when
+		   WORKAROUND_TB_EXTRA_MAILBOX_SEP is enabled */
+		len = strlen(storage_name);
+		if (storage_name[len-1] == ns->real_sep)
+			storage_name = t_strndup(storage_name, len-1);
 	}
 
-	ns = client_find_namespace(cmd, mailbox, &storage_name, &status);
+	ns = client_find_namespace(cmd, mailbox, &storage_name);
 	if (ns == NULL)
 		return TRUE;
-	switch (status) {
-	case MAILBOX_NAME_VALID:
-		break;
-	case MAILBOX_NAME_EXISTS_DIR:
-		if (!directory)
-			break;
-		/* fall through */
-	case MAILBOX_NAME_EXISTS_MAILBOX:
-	case MAILBOX_NAME_INVALID:
-	case MAILBOX_NAME_NOINFERIORS:
-		client_fail_mailbox_name_status(cmd, mailbox, NULL, status);
-		return TRUE;
-	}
 
 	box = mailbox_alloc(ns->list, storage_name, 0);
 	if (mailbox_create(box, NULL, directory) < 0)

--- a/src/imap/cmd-delete.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/cmd-delete.c	Sat Jan 01 15:59:02 2011 +0200
@@ -6,7 +6,6 @@
 bool cmd_delete(struct client_command_context *cmd)
 {
 	struct client *client = cmd->client;
-	enum mailbox_name_status status;
 	struct mail_namespace *ns;
 	struct mailbox *box;
 	const char *name, *storage_name;
@@ -21,19 +20,9 @@
 		return TRUE;
 	}
 
-	ns = client_find_namespace(cmd, name, &storage_name, &status);
+	ns = client_find_namespace(cmd, name, &storage_name);
 	if (ns == NULL)
 		return TRUE;
-	switch (status) {
-	case MAILBOX_NAME_EXISTS_MAILBOX:
-	case MAILBOX_NAME_EXISTS_DIR:
-		break;
-	case MAILBOX_NAME_VALID:
-	case MAILBOX_NAME_INVALID:
-	case MAILBOX_NAME_NOINFERIORS:
-		client_fail_mailbox_name_status(cmd, name, NULL, status);
-		return TRUE;
-	}
 
 	box = mailbox_alloc(ns->list, storage_name, 0);
 	if (client->mailbox != NULL &&

--- a/src/imap/cmd-enable.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/cmd-enable.c	Sat Jan 01 15:59:02 2011 +0200
@@ -21,13 +21,13 @@
 		}
 		str = t_str_ucase(str);
 		if (strcmp(str, "CONDSTORE") == 0) {
-			client_enable(cmd->client, MAILBOX_FEATURE_CONDSTORE);
-			str_append(reply, " CONDSTORE");
-		}
-		else if (strcmp(str, "QRESYNC") == 0) {
-			client_enable(cmd->client, MAILBOX_FEATURE_QRESYNC |
-				      MAILBOX_FEATURE_CONDSTORE);
-			str_append(reply, " QRESYNC");
+			if (client_enable(cmd->client,
+					  MAILBOX_FEATURE_CONDSTORE) == 0)
+				str_append(reply, " CONDSTORE");
+		} else if (strcmp(str, "QRESYNC") == 0) {
+			if (client_enable(cmd->client, MAILBOX_FEATURE_QRESYNC |
+					  MAILBOX_FEATURE_CONDSTORE) == 0)
+				str_append(reply, " QRESYNC");
 		}
 	}
 	if (str_len(reply) > 9)

--- a/src/imap/cmd-rename.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/cmd-rename.c	Sat Jan 01 15:59:02 2011 +0200
@@ -6,7 +6,6 @@
 
 bool cmd_rename(struct client_command_context *cmd)
 {
-	enum mailbox_name_status status;
 	struct mail_namespace *old_ns, *new_ns;
 	struct mailbox *old_box, *new_box;
 	const char *oldname, *newname, *storage_oldname, *storage_newname;
@@ -16,33 +15,12 @@
 	if (!client_read_string_args(cmd, 2, &oldname, &newname))
 		return FALSE;
 
-	old_ns = client_find_namespace(cmd, oldname, &storage_oldname, &status);
+	old_ns = client_find_namespace(cmd, oldname, &storage_oldname);
 	if (old_ns == NULL)
 		return TRUE;
-	switch (status) {
-	case MAILBOX_NAME_EXISTS_MAILBOX:
-	case MAILBOX_NAME_EXISTS_DIR:
-		break;
-	case MAILBOX_NAME_VALID:
-	case MAILBOX_NAME_INVALID:
-	case MAILBOX_NAME_NOINFERIORS:
-		client_fail_mailbox_name_status(cmd, oldname, NULL, status);
-		return TRUE;
-	}
-
-	new_ns = client_find_namespace(cmd, newname, &storage_newname, &status);
+	new_ns = client_find_namespace(cmd, newname, &storage_newname);
 	if (new_ns == NULL)
 		return TRUE;
-	switch (status) {
-	case MAILBOX_NAME_VALID:
-		break;
-	case MAILBOX_NAME_EXISTS_MAILBOX:
-	case MAILBOX_NAME_EXISTS_DIR:
-	case MAILBOX_NAME_INVALID:
-	case MAILBOX_NAME_NOINFERIORS:
-		client_fail_mailbox_name_status(cmd, newname, NULL, status);
-		return TRUE;
-	}
 
 	if (old_ns == new_ns) {
 		/* disallow box -> box/child, because it may break clients and

--- a/src/imap/cmd-select.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/cmd-select.c	Sat Jan 01 15:59:02 2011 +0200
@@ -276,7 +276,7 @@
 	struct client *client = ctx->cmd->client;
 	struct mailbox_status status;
 	enum mailbox_flags flags = 0;
-	int ret;
+	int ret = 0;
 
 	if (readonly)
 		flags |= MAILBOX_FLAG_READONLY | MAILBOX_FLAG_KEEP_RECENT;
@@ -289,16 +289,17 @@
 	}
 
 	if (client->enabled_features != 0)
-		mailbox_enable(ctx->box, client->enabled_features);
-	if (mailbox_sync(ctx->box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
+		ret = mailbox_enable(ctx->box, client->enabled_features);
+	if (ret < 0 ||
+	    mailbox_sync(ctx->box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
 		client_send_storage_error(ctx->cmd,
 					  mailbox_get_storage(ctx->box));
 		return -1;
 	}
-	mailbox_get_status(ctx->box, STATUS_MESSAGES | STATUS_RECENT |
-			   STATUS_FIRST_UNSEEN_SEQ | STATUS_UIDVALIDITY |
-			   STATUS_UIDNEXT | STATUS_KEYWORDS |
-			   STATUS_HIGHESTMODSEQ, &status);
+	mailbox_get_open_status(ctx->box, STATUS_MESSAGES | STATUS_RECENT |
+				STATUS_FIRST_UNSEEN_SEQ | STATUS_UIDVALIDITY |
+				STATUS_UIDNEXT | STATUS_KEYWORDS |
+				STATUS_HIGHESTMODSEQ, &status);
 
 	client->mailbox = ctx->box;
 	client->select_counter++;
@@ -372,7 +373,6 @@
 	struct client *client = cmd->client;
 	struct imap_select_context *ctx;
 	const struct imap_arg *args, *list_args;
-	enum mailbox_name_status status;
 	const char *mailbox, *storage_name;
 	int ret;
 
@@ -388,24 +388,11 @@
 
 	ctx = p_new(cmd->pool, struct imap_select_context, 1);
 	ctx->cmd = cmd;
-	ctx->ns = client_find_namespace(cmd, mailbox, &storage_name, &status);
+	ctx->ns = client_find_namespace(cmd, mailbox, &storage_name);
 	if (ctx->ns == NULL) {
 		close_selected_mailbox(client);
 		return TRUE;
 	}
-	switch (status) {
-	case MAILBOX_NAME_EXISTS_MAILBOX:
-		break;
-	case MAILBOX_NAME_EXISTS_DIR:
-		status = MAILBOX_NAME_VALID;
-		/* fall through */
-	case MAILBOX_NAME_VALID:
-	case MAILBOX_NAME_INVALID:
-	case MAILBOX_NAME_NOINFERIORS:
-		client_fail_mailbox_name_status(cmd, mailbox, NULL, status);
-		close_selected_mailbox(client);
-		return TRUE;
-	}
 
 	if (imap_arg_get_list(&args[1], &list_args)) {
 		if (!select_parse_options(ctx, list_args)) {
@@ -423,7 +410,7 @@
 	if (ctx->condstore) {
 		/* Enable while no mailbox is opened to avoid sending
 		   HIGHESTMODSEQ for previously opened mailbox */
-		client_enable(client, MAILBOX_FEATURE_CONDSTORE);
+		(void)client_enable(client, MAILBOX_FEATURE_CONDSTORE);
 	}
 
 	ret = select_open(ctx, storage_name, readonly);

--- a/src/imap/cmd-status.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/cmd-status.c	Sat Jan 01 15:59:02 2011 +0200
@@ -9,7 +9,6 @@
 bool cmd_status(struct client_command_context *cmd)
 {
 	struct client *client = cmd->client;
-	enum mailbox_name_status status;
 	const struct imap_arg *args, *list_args;
 	struct imap_status_items items;
 	struct imap_status_result result;
@@ -31,21 +30,9 @@
 	if (imap_status_parse_items(cmd, list_args, &items) < 0)
 		return TRUE;
 
-	ns = client_find_namespace(cmd, mailbox, &storage_name, &status);
+	ns = client_find_namespace(cmd, mailbox, &storage_name);
 	if (ns == NULL)
 		return TRUE;
-	switch (status) {
-	case MAILBOX_NAME_EXISTS_MAILBOX:
-		break;
-	case MAILBOX_NAME_EXISTS_DIR:
-		status = MAILBOX_NAME_VALID;
-		/* fall through */
-	case MAILBOX_NAME_VALID:
-	case MAILBOX_NAME_INVALID:
-	case MAILBOX_NAME_NOINFERIORS:
-		client_fail_mailbox_name_status(cmd, mailbox, NULL, status);
-		return TRUE;
-	}
 
 	selected_mailbox = client->mailbox != NULL &&
 		mailbox_equals(client->mailbox, ns, storage_name);

--- a/src/imap/cmd-store.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/cmd-store.c	Sat Jan 01 15:59:02 2011 +0200
@@ -62,8 +62,8 @@
 							  "Invalid modseq");
 				return FALSE;
 			}
-			client_enable(ctx->cmd->client,
-				      MAILBOX_FEATURE_CONDSTORE);
+			(void)client_enable(ctx->cmd->client,
+					    MAILBOX_FEATURE_CONDSTORE);
 		} else {
 			client_send_command_error(ctx->cmd,
 						  "Unknown STORE modifier");
@@ -201,7 +201,7 @@
 	mail_free(&mail);
 
 	if (ctx.keywords != NULL)
-		mailbox_keywords_unref(client->mailbox, &ctx.keywords);
+		mailbox_keywords_unref(&ctx.keywords);
 
 	ret = mailbox_search_deinit(&search_ctx);
 	if (ret < 0)

--- a/src/imap/cmd-subscribe.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/cmd-subscribe.c	Sat Jan 01 15:59:02 2011 +0200
@@ -26,9 +26,39 @@
 	return FALSE;
 }
 
+static bool
+subscribe_is_valid_name(struct client_command_context *cmd, const char *mailbox)
+{
+	enum mailbox_name_status name_status;
+	struct mail_namespace *ns;
+	const char *storage_name;
+
+	if (have_listable_namespace_prefix(cmd->client->user->namespaces,
+					   mailbox)) {
+		/* subscribing to a listable namespace prefix, allow it. */
+		return TRUE;
+	}
+
+	/* see if the mailbox exists */
+	ns = client_find_namespace(cmd, mailbox, &storage_name);
+	if (ns == NULL)
+		return FALSE;
+
+	if (mailbox_list_get_mailbox_name_status(ns->list, storage_name,
+						 &name_status) < 0) {
+		client_send_list_error(cmd, ns->list);
+		return FALSE;
+	}
+	if (name_status == MAILBOX_NAME_NONEXISTENT) {
+		client_send_tagline(cmd, t_strdup_printf(
+			"NO "MAIL_ERRSTR_MAILBOX_NOT_FOUND, mailbox));
+		return FALSE;
+	}
+	return TRUE;
+}
+
 bool cmd_subscribe_full(struct client_command_context *cmd, bool subscribe)
 {
-	enum mailbox_name_status status;
 	struct mail_namespace *ns, *box_ns;
 	const char *mailbox, *storage_name, *subs_name, *subs_name2 = NULL;
 	bool unsubscribed_mailbox2;
@@ -37,9 +67,13 @@
 	if (!client_read_string_args(cmd, 1, &mailbox))
 		return FALSE;
 
-	box_ns = client_find_namespace(cmd, mailbox, &storage_name, NULL);
+	box_ns = client_find_namespace(cmd, mailbox, &storage_name);
 	if (box_ns == NULL)
 		return TRUE;
+	if (!mailbox_list_is_valid_existing_name(box_ns->list, storage_name)) {
+		client_send_tagline(cmd, "NO [CANNOT] Invalid mailbox name");
+		return TRUE;
+	}
 
 	/* now find a namespace where the subscription can be added to */
 	subs_name = mailbox;
@@ -69,39 +103,9 @@
 		subs_name = t_strndup(subs_name, strlen(subs_name)-1);
 	}
 
-	if (have_listable_namespace_prefix(cmd->client->user->namespaces,
-					   mailbox)) {
-		/* subscribing to a listable namespace prefix, allow it. */
-	} else if (subscribe) {
-		if (client_find_namespace(cmd, mailbox,
-					  &storage_name, &status) == NULL)
-			return TRUE;
-		switch (status) {
-		case MAILBOX_NAME_EXISTS_MAILBOX:
-		case MAILBOX_NAME_EXISTS_DIR:
-			break;
-		case MAILBOX_NAME_VALID:
-		case MAILBOX_NAME_INVALID:
-		case MAILBOX_NAME_NOINFERIORS:
-			client_fail_mailbox_name_status(cmd, mailbox,
-							NULL, status);
+	if (subscribe) {
+		if (!subscribe_is_valid_name(cmd, mailbox))
 			return TRUE;
-		}
-	} else {
-		if (client_find_namespace(cmd, mailbox,
-					  &storage_name, &status) == NULL)
-			return TRUE;
-		switch (status) {
-		case MAILBOX_NAME_EXISTS_MAILBOX:
-		case MAILBOX_NAME_EXISTS_DIR:
-		case MAILBOX_NAME_VALID:
-			break;
-		case MAILBOX_NAME_INVALID:
-		case MAILBOX_NAME_NOINFERIORS:
-			client_fail_mailbox_name_status(cmd, mailbox,
-							NULL, status);
-			return TRUE;
-		}
 	}
 
 	unsubscribed_mailbox2 = FALSE;

--- a/src/imap/imap-client.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/imap-client.c	Sat Jan 01 15:59:02 2011 +0200
@@ -911,27 +911,35 @@
 	return TRUE;
 }
 
-void client_enable(struct client *client, enum mailbox_feature features)
+int client_enable(struct client *client, enum mailbox_feature features)
 {
 	struct mailbox_status status;
+	int ret;
 
 	if ((client->enabled_features & features) == features)
-		return;
+		return 0;
 
 	client->enabled_features |= features;
 	if (client->mailbox == NULL)
-		return;
+		return 0;
 
-	mailbox_enable(client->mailbox, features);
-	if ((features & MAILBOX_FEATURE_CONDSTORE) != 0) {
+	ret = mailbox_enable(client->mailbox, features);
+	if ((features & MAILBOX_FEATURE_CONDSTORE) != 0 && ret == 0) {
 		/* CONDSTORE being enabled while mailbox is selected.
 		   Notify client of the latest HIGHESTMODSEQ. */
-		mailbox_get_status(client->mailbox,
-				   STATUS_HIGHESTMODSEQ, &status);
-		client_send_line(client, t_strdup_printf(
-			"* OK [HIGHESTMODSEQ %llu] Highest",
-			(unsigned long long)status.highest_modseq));
+		ret = mailbox_get_status(client->mailbox,
+					 STATUS_HIGHESTMODSEQ, &status);
+		if (ret == 0) {
+			client_send_line(client, t_strdup_printf(
+				"* OK [HIGHESTMODSEQ %llu] Highest",
+				(unsigned long long)status.highest_modseq));
+		}
 	}
+	if (ret < 0) {
+		client_send_untagged_storage_error(client,
+			mailbox_get_storage(client->mailbox));
+	}
+	return ret;
 }
 
 struct imap_search_update *

--- a/src/imap/imap-client.h	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/imap-client.h	Sat Jan 01 15:59:02 2011 +0200
@@ -192,7 +192,7 @@
    have to wait for an existing SEARCH SAVE to finish. */
 bool client_handle_search_save_ambiguity(struct client_command_context *cmd);
 
-void client_enable(struct client *client, enum mailbox_feature features);
+int client_enable(struct client *client, enum mailbox_feature features);
 
 struct imap_search_update *
 client_search_update_lookup(struct client *client, const char *tag,

--- a/src/imap/imap-commands-util.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/imap-commands-util.c	Sat Jan 01 15:59:02 2011 +0200
@@ -13,16 +13,9 @@
 #include "mail-namespace.h"
 #include "imap-commands-util.h"
 
-/* Maximum length for mailbox name, including it's path. This isn't fully
-   exact since the user can create folder hierarchy with small names, then
-   rename them to larger names. Mail storages should set more strict limits
-   to them, mbox/maildir currently allow paths only up to PATH_MAX. */
-#define MAILBOX_MAX_NAME_LEN 512
-
 struct mail_namespace *
 client_find_namespace(struct client_command_context *cmd, const char *mailbox,
-		      const char **storage_name_r,
-		      enum mailbox_name_status *mailbox_status_r)
+		      const char **storage_name_r)
 {
 	struct mail_namespace *namespaces = cmd->client->user->namespaces;
 	struct mail_namespace *ns;
@@ -39,17 +32,6 @@
 		return NULL;
 	}
 
-	if (mailbox_status_r == NULL) {
-		*storage_name_r = storage_name;
-		return ns;
-	}
-
-	/* make sure it even looks valid */
-	if (*storage_name == '\0' && !(*mailbox != '\0' && ns->list)) {
-		client_send_tagline(cmd, "NO Empty mailbox name.");
-		return NULL;
-	}
-
 	storage_name_len = strlen(storage_name);
 	if ((cmd->client->set->parsed_workarounds &
 	     		WORKAROUND_TB_EXTRA_MAILBOX_SEP) != 0 &&
@@ -74,66 +56,10 @@
 		}
 	}
 
-	/* make sure two hierarchy separators aren't next to each others */
-	for (p = storage_name+1; *p != '\0'; p++) {
-		if (p[0] == ns->real_sep && p[-1] == ns->real_sep) {
-			client_send_tagline(cmd, "NO Invalid mailbox name.");
-			return NULL;
-		}
-	}
-
-	if (storage_name_len > MAILBOX_MAX_NAME_LEN) {
-		client_send_tagline(cmd, "NO Mailbox name too long.");
-		return NULL;
-	}
-
-	/* check what our storage thinks of it */
-	if (mailbox_list_get_mailbox_name_status(ns->list, storage_name,
-						 mailbox_status_r) < 0) {
-		client_send_list_error(cmd, ns->list);
-		return NULL;
-	}
 	*storage_name_r = storage_name;
 	return ns;
 }
 
-void client_fail_mailbox_name_status(struct client_command_context *cmd,
-				     const char *mailbox_name,
-				     const char *resp_code,
-				     enum mailbox_name_status status)
-{
-	switch (status) {
-	case MAILBOX_NAME_EXISTS_MAILBOX:
-	case MAILBOX_NAME_EXISTS_DIR:
-		client_send_tagline(cmd, t_strconcat(
-			"NO [", IMAP_RESP_CODE_ALREADYEXISTS,
-			"] Mailbox already exists: ",
-			str_sanitize(mailbox_name, MAILBOX_MAX_NAME_LEN),
-			NULL));
-		break;
-	case MAILBOX_NAME_VALID:
-		if (resp_code == NULL)
-			resp_code = "";
-		else
-			resp_code = t_strconcat("[", resp_code, "] ", NULL);
-		client_send_tagline(cmd, t_strconcat(
-			"NO ", resp_code, "Mailbox doesn't exist: ",
-			str_sanitize(mailbox_name, MAILBOX_MAX_NAME_LEN),
-			NULL));
-		break;
-	case MAILBOX_NAME_INVALID:
-		client_send_tagline(cmd, t_strconcat(
-			"NO Invalid mailbox name: ",
-			str_sanitize(mailbox_name, MAILBOX_MAX_NAME_LEN),
-			NULL));
-		break;
-	case MAILBOX_NAME_NOINFERIORS:
-		client_send_tagline(cmd,
-			"NO Parent mailbox doesn't allow child mailboxes.");
-		break;
-	}
-}
-
 bool client_verify_open_mailbox(struct client_command_context *cmd)
 {
 	if (cmd->client->mailbox != NULL)
@@ -144,6 +70,49 @@
 	}
 }
 
+int client_open_save_dest_box(struct client_command_context *cmd,
+			      const char *name, struct mailbox **destbox_r)
+{
+	struct mail_namespace *ns;
+	struct mailbox *box;
+	const char *storage_name, *error_string;
+	enum mail_error error;
+
+	ns = client_find_namespace(cmd, name, &storage_name);
+	if (ns == NULL)
+		return -1;
+
+	if (cmd->client->mailbox != NULL &&
+	    mailbox_equals(cmd->client->mailbox, ns, storage_name)) {
+		*destbox_r = cmd->client->mailbox;
+		return 0;
+	}
+	box = mailbox_alloc(ns->list, storage_name,
+			    MAILBOX_FLAG_SAVEONLY | MAILBOX_FLAG_KEEP_RECENT);
+	if (mailbox_open(box) < 0) {
+		struct mail_storage *storage = mailbox_get_storage(box);
+
+		error_string = mail_storage_get_last_error(storage, &error);
+		if (error == MAIL_ERROR_NOTFOUND) {
+			client_send_tagline(cmd,  t_strdup_printf(
+				"NO [TRYCREATE] %s", error_string));
+		} else {
+			client_send_storage_error(cmd, storage);
+		}
+		mailbox_free(&box);
+		return -1;
+	}
+	if (cmd->client->enabled_features != 0) {
+		if (mailbox_enable(box, cmd->client->enabled_features) < 0) {
+			client_send_storage_error(cmd, mailbox_get_storage(box));
+			mailbox_free(&box);
+			return -1;
+		}
+	}
+	*destbox_r = box;
+	return 0;
+}
+
 const char *
 imap_get_error_string(struct client_command_context *cmd,
 		      const char *error_string, enum mail_error error)

--- a/src/imap/imap-commands-util.h	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/imap-commands-util.h	Sat Jan 01 15:59:02 2011 +0200
@@ -13,19 +13,16 @@
    or mailbox name is invalid, sends a tagged NO reply to client. */
 struct mail_namespace *
 client_find_namespace(struct client_command_context *cmd, const char *mailbox,
-		      const char **storage_name_r,
-		      enum mailbox_name_status *mailbox_status_r);
-
-/* Send tagged NO reply based on mailbox name status. */
-void client_fail_mailbox_name_status(struct client_command_context *cmd,
-				     const char *mailbox_name,
-				     const char *resp_code,
-				     enum mailbox_name_status status);
+		      const char **storage_name_r);
 
 /* Returns TRUE if mailbox is selected. If not, sends "No mailbox selected"
    error message to client. */
 bool client_verify_open_mailbox(struct client_command_context *cmd);
 
+/* Open APPEND/COPY destination mailbox. */
+int client_open_save_dest_box(struct client_command_context *cmd,
+			      const char *name, struct mailbox **destbox_r);
+
 const char *
 imap_get_error_string(struct client_command_context *cmd,
 		      const char *error_string, enum mail_error error);

--- a/src/imap/imap-fetch.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/imap-fetch.c	Sat Jan 01 15:59:02 2011 +0200
@@ -159,7 +159,7 @@
 	i_assert(array_count(ctx->qresync_sample_uidset) == count);
 	i_assert(count > 0);
 
-	mailbox_get_status(ctx->box, STATUS_MESSAGES, &status);
+	mailbox_get_open_status(ctx->box, STATUS_MESSAGES, &status);
 
 	/* FIXME: we could do removals from the middle as well */
 	for (i = 0; i < count && seqs[i] <= status.messages; i++) {
@@ -245,7 +245,7 @@
 					  uid_filter[i].seq2);
 	}
 
-	mailbox_get_status(ctx->box, STATUS_UIDNEXT, &status);
+	mailbox_get_open_status(ctx->box, STATUS_UIDNEXT, &status);
 	seq_range_array_remove_range(expunged_uids, status.uidnext,
 				     (uint32_t)-1);
 
@@ -751,7 +751,7 @@
 fetch_modseq_init(struct imap_fetch_context *ctx, const char *name,
 		  const struct imap_arg **args ATTR_UNUSED)
 {
-	client_enable(ctx->client, MAILBOX_FEATURE_CONDSTORE);
+	(void)client_enable(ctx->client, MAILBOX_FEATURE_CONDSTORE);
 	imap_fetch_add_handler(ctx, TRUE, FALSE, name, NULL,
 			       fetch_modseq, NULL);
 	return TRUE;

--- a/src/imap/imap-search.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/imap-search.c	Sat Jan 01 15:59:02 2011 +0200
@@ -528,7 +528,7 @@
 
 	if (ctx->have_modseqs) {
 		ctx->return_options |= SEARCH_RETURN_MODSEQ;
-		client_enable(cmd->client, MAILBOX_FEATURE_CONDSTORE);
+		(void)client_enable(cmd->client, MAILBOX_FEATURE_CONDSTORE);
 	}
 
 	ctx->box = cmd->client->mailbox;

--- a/src/imap/imap-status.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/imap-status.c	Sat Jan 01 15:59:02 2011 +0200
@@ -11,7 +11,8 @@
 			    struct imap_status_items *items_r)
 {
 	const char *item;
-	enum mailbox_status_items items;
+	enum mailbox_status_items status = 0;
+	enum mailbox_metadata_items metadata = 0;
 
 	if (IMAP_ARG_IS_EOL(args)) {
 		client_send_command_error(cmd, "Empty status list.");
@@ -19,7 +20,6 @@
 	}
 
 	memset(items_r, 0, sizeof(*items_r));
-	items = 0;
 	for (; !IMAP_ARG_IS_EOL(args); args++) {
 		if (!imap_arg_get_atom(args, &item)) {
 			/* list may contain only atoms */
@@ -30,21 +30,21 @@
 
 		item = t_str_ucase(item);
 		if (strcmp(item, "MESSAGES") == 0)
-			items |= STATUS_MESSAGES;
+			status |= STATUS_MESSAGES;
 		else if (strcmp(item, "RECENT") == 0)
-			items |= STATUS_RECENT;
+			status |= STATUS_RECENT;
 		else if (strcmp(item, "UIDNEXT") == 0)
-			items |= STATUS_UIDNEXT;
+			status |= STATUS_UIDNEXT;
 		else if (strcmp(item, "UIDVALIDITY") == 0)
-			items |= STATUS_UIDVALIDITY;
+			status |= STATUS_UIDVALIDITY;
 		else if (strcmp(item, "UNSEEN") == 0)
-			items |= STATUS_UNSEEN;
+			status |= STATUS_UNSEEN;
 		else if (strcmp(item, "HIGHESTMODSEQ") == 0)
-			items |= STATUS_HIGHESTMODSEQ;
+			status |= STATUS_HIGHESTMODSEQ;
 		else if (strcmp(item, "X-SIZE") == 0)
-			items |= STATUS_VIRTUAL_SIZE;
+			metadata |= MAILBOX_METADATA_VIRTUAL_SIZE;
 		else if (strcmp(item, "X-GUID") == 0)
-			items_r->guid = TRUE;
+			metadata |= MAILBOX_METADATA_GUID;
 		else {
 			client_send_tagline(cmd, t_strconcat(
 				"BAD Invalid status item ", item, NULL));
@@ -52,7 +52,8 @@
 		}
 	}
 
-	items_r->mailbox_items = items;
+	items_r->status = status;
+	items_r->metadata = metadata;
 	return 0;
 }
 
@@ -75,19 +76,19 @@
 		box = mailbox_alloc(ns->list, mailbox,
 				    MAILBOX_FLAG_READONLY |
 				    MAILBOX_FLAG_KEEP_RECENT);
-		if (client->enabled_features != 0)
-			mailbox_enable(box, client->enabled_features);
+		if (client->enabled_features != 0) {
+			if (mailbox_enable(box, client->enabled_features) < 0)
+				ret = -1;
+		}
 	}
 
-	if ((items->mailbox_items & STATUS_HIGHESTMODSEQ) != 0)
-		client_enable(client, MAILBOX_FEATURE_CONDSTORE);
+	if ((items->status & STATUS_HIGHESTMODSEQ) != 0)
+		(void)client_enable(client, MAILBOX_FEATURE_CONDSTORE);
 
-	ret = box == client->mailbox ? 0 : mailbox_sync(box, 0);
-	if (ret == 0) {
-		mailbox_get_status(box, items->mailbox_items,
-				   &result_r->status);
-		if (items->guid)
-			ret = mailbox_get_guid(box, result_r->mailbox_guid);
+	ret = mailbox_get_status(box, items->status, &result_r->status);
+	if (items->metadata != 0 && ret == 0) {
+		ret = mailbox_get_metadata(box, items->metadata,
+					   &result_r->metadata);
 	}
 
 	if (ret < 0) {
@@ -115,27 +116,27 @@
 	str_append(str, " (");
 
 	prefix_len = str_len(str);
-	if ((items->mailbox_items & STATUS_MESSAGES) != 0)
+	if ((items->status & STATUS_MESSAGES) != 0)
 		str_printfa(str, "MESSAGES %u ", status->messages);
-	if ((items->mailbox_items & STATUS_RECENT) != 0)
+	if ((items->status & STATUS_RECENT) != 0)
 		str_printfa(str, "RECENT %u ", status->recent);
-	if ((items->mailbox_items & STATUS_UIDNEXT) != 0)
+	if ((items->status & STATUS_UIDNEXT) != 0)
 		str_printfa(str, "UIDNEXT %u ", status->uidnext);
-	if ((items->mailbox_items & STATUS_UIDVALIDITY) != 0)
+	if ((items->status & STATUS_UIDVALIDITY) != 0)
 		str_printfa(str, "UIDVALIDITY %u ", status->uidvalidity);
-	if ((items->mailbox_items & STATUS_UNSEEN) != 0)
+	if ((items->status & STATUS_UNSEEN) != 0)
 		str_printfa(str, "UNSEEN %u ", status->unseen);
-	if ((items->mailbox_items & STATUS_HIGHESTMODSEQ) != 0) {
+	if ((items->status & STATUS_HIGHESTMODSEQ) != 0) {
 		str_printfa(str, "HIGHESTMODSEQ %llu ",
 			    (unsigned long long)status->highest_modseq);
 	}
-	if ((items->mailbox_items & STATUS_VIRTUAL_SIZE) != 0) {
+	if ((items->metadata & MAILBOX_METADATA_VIRTUAL_SIZE) != 0) {
 		str_printfa(str, "X-SIZE %llu ",
-			    (unsigned long long)status->virtual_size);
+			    (unsigned long long)result->metadata.virtual_size);
 	}
-	if (items->guid) {
+	if ((items->metadata & MAILBOX_METADATA_GUID) != 0) {
 		str_printfa(str, "X-GUID %s ",
-			    mail_guid_128_to_string(result->mailbox_guid));
+			    mail_guid_128_to_string(result->metadata.guid));
 	}
 
 	if (str_len(str) != prefix_len)

--- a/src/imap/imap-status.h	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/imap-status.h	Sat Jan 01 15:59:02 2011 +0200
@@ -2,14 +2,13 @@
 #define IMAP_STATUS_H
 
 struct imap_status_items {
-	enum mailbox_status_items mailbox_items;
-
-	unsigned int guid:1;
+	enum mailbox_status_items status;
+	enum mailbox_metadata_items metadata;
 };
 
 struct imap_status_result {
 	struct mailbox_status status;
-	uint8_t mailbox_guid[MAIL_GUID_128_SIZE];
+	struct mailbox_metadata metadata;
 };
 
 int imap_status_parse_items(struct client_command_context *cmd,

--- a/src/imap/imap-sync.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/imap/imap-sync.c	Sat Jan 01 15:59:02 2011 +0200
@@ -226,9 +226,9 @@
 		i_free(ctx);
 		return -1;
 	}
-	mailbox_get_status(ctx->box, STATUS_UIDVALIDITY |
-			   STATUS_MESSAGES | STATUS_RECENT |
-			   STATUS_HIGHESTMODSEQ, &status);
+	mailbox_get_open_status(ctx->box, STATUS_UIDVALIDITY |
+				STATUS_MESSAGES | STATUS_RECENT |
+				STATUS_HIGHESTMODSEQ, &status);
 
 	ret = mailbox_transaction_commit(&ctx->t);
 

--- a/src/lib-imap/imap-bodystructure.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-imap/imap-bodystructure.c	Sat Jan 01 15:59:02 2011 +0200
@@ -360,6 +360,7 @@
 static void part_write_body(const struct message_part *part,
 			    string_t *str, bool extended)
 {
+#define NVL(str, nullstr) ((str) != NULL ? (str) : (nullstr))
 	struct message_part_body_data *data = part->context;
 	bool text;
 

--- a/src/lib-imap/imap-envelope.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-imap/imap-envelope.c	Sat Jan 01 15:59:02 2011 +0200
@@ -182,6 +182,7 @@
 void imap_envelope_write_part_data(struct message_part_envelope_data *data,
 				   string_t *str)
 {
+#define NVL(str, nullstr) ((str) != NULL ? (str) : (nullstr))
 	static const char *empty_envelope =
 		"NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL";
 

--- a/src/lib-lda/duplicate.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-lda/duplicate.c	Sat Jan 01 15:59:02 2011 +0200
@@ -232,15 +232,15 @@
 	pool_unref(&file->pool);
 }
 
-int duplicate_check(struct duplicate_context *ctx,
-		    const void *id, size_t id_size, const char *user)
+bool duplicate_check(struct duplicate_context *ctx,
+		     const void *id, size_t id_size, const char *user)
 {
 	struct duplicate d;
 
 	if (ctx->file == NULL) {
 		if (ctx->path == NULL) {
 			/* duplicate database disabled */
-			return 0;
+			return FALSE;
 		}
 		ctx->file = duplicate_file_new(ctx);
 	}

--- a/src/lib-lda/duplicate.h	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-lda/duplicate.h	Sat Jan 01 15:59:02 2011 +0200
@@ -6,8 +6,8 @@
 
 #define DUPLICATE_DEFAULT_KEEP (3600 * 24)
 
-int duplicate_check(struct duplicate_context *ctx,
-		    const void *id, size_t id_size, const char *user);
+bool duplicate_check(struct duplicate_context *ctx,
+		     const void *id, size_t id_size, const char *user);
 void duplicate_mark(struct duplicate_context *ctx,
 		    const void *id, size_t id_size,
                     const char *user, time_t timestamp);

--- a/src/lib-lda/mail-deliver.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-lda/mail-deliver.c	Sat Jan 01 15:59:02 2011 +0200
@@ -253,7 +253,7 @@
 	else
 		mail_deliver_log_cache_var_expand_table(ctx);
 	if (kw != NULL)
-		mailbox_keywords_unref(box, &kw);
+		mailbox_keywords_unref(&kw);
 	mail_free(&ctx->dest_mail);
 
 	if (ret < 0)

--- a/src/lib-storage/Makefile.am	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/Makefile.am	Sat Jan 01 15:59:02 2011 +0200
@@ -5,6 +5,7 @@
 
 AM_CPPFLAGS = \
 	-I$(top_srcdir)/src/lib \
+	-I$(top_srcdir)/src/lib-test \
 	-I$(top_srcdir)/src/lib-auth \
 	-I$(top_srcdir)/src/lib-dict \
 	-I$(top_srcdir)/src/lib-master \
@@ -33,6 +34,9 @@
 	mail-storage-settings.c \
 	mail-thread.c \
 	mail-user.c \
+	mailbox-get.c \
+	mailbox-header.c \
+	mailbox-keywords.c \
 	mailbox-list.c \
 	mailbox-search-result.c \
 	mailbox-tree.c \
@@ -86,6 +90,25 @@
 test_headers = \
 	test-mail-storage.h
 
+test_programs = \
+	test-mailbox-get
+
+noinst_PROGRAMS = $(test_programs)
+
+test_libs = \
+	$(top_builddir)/src/lib-test/libtest.la \
+	$(top_builddir)/src/lib/liblib.la
+
+test_mailbox_get_SOURCES = test-mailbox-get.c
+test_mailbox_get_LDADD = mailbox-get.lo $(test_libs)
+test_mailbox_get_DEPENDENCIES = mailbox-get.lo $(test_libs)
+
+check: check-am check-test
+check-test: all-am
+	for bin in $(test_programs); do \
+	  if ! $(RUN_TEST) ./$$bin; then exit 1; fi; \
+	done
+
 pkginc_libdir=$(pkgincludedir)
 pkginc_lib_HEADERS = $(headers)
 noinst_HEADERS = $(test_headers)

--- a/src/lib-storage/index/Makefile.am	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/Makefile.am	Sat Jan 01 15:59:02 2011 +0200
@@ -15,7 +15,6 @@
 	istream-attachment.c \
 	istream-mail-stats.c \
 	index-attachment.c \
-	index-fetch.c \
 	index-mail.c \
 	index-mail-headers.c \
 	index-mailbox-check.c \
@@ -49,24 +48,5 @@
 	index-sync-private.h \
 	index-thread-private.h
 
-test_programs = \
-	test-index-fetch
-
-noinst_PROGRAMS = $(test_programs)
-
-test_libs = \
-	$(top_builddir)/src/lib-test/libtest.la \
-	$(top_builddir)/src/lib/liblib.la
-
-test_index_fetch_SOURCES = test-index-fetch.c
-test_index_fetch_LDADD = index-fetch.lo $(test_libs)
-test_index_fetch_DEPENDENCIES = index-fetch.lo $(test_libs)
-
-check: check-am check-test
-check-test: all-am
-	for bin in $(test_programs); do \
-	  if ! $(RUN_TEST) ./$$bin; then exit 1; fi; \
-	done
-
 pkginc_libdir=$(pkgincludedir)
 pkginc_lib_HEADERS = $(headers)

--- a/src/lib-storage/index/cydir/cydir-storage.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/cydir/cydir-storage.c	Sat Jan 01 15:59:02 2011 +0200
@@ -55,10 +55,6 @@
 
 	index_storage_mailbox_alloc(&mbox->box, name, flags,
 				    CYDIR_INDEX_PREFIX);
-	mail_index_set_fsync_mode(mbox->box.index,
-				  storage->set->parsed_fsync_mode,
-				  MAIL_INDEX_SYNC_TYPE_APPEND |
-				  MAIL_INDEX_SYNC_TYPE_EXPUNGE);
 
 	ibox = INDEX_STORAGE_CONTEXT(&mbox->box);
 	ibox->save_commit_pre = cydir_transaction_save_commit_pre;
@@ -71,9 +67,10 @@
 
 static int cydir_mailbox_open(struct mailbox *box)
 {
+	const char *box_path = mailbox_get_path(box);
 	struct stat st;
 
-	if (stat(box->path, &st) == 0) {
+	if (stat(box_path, &st) == 0) {
 		/* exists, open it */
 	} else if (errno == ENOENT) {
 		mail_storage_set_error(box->storage, MAIL_ERROR_NOTFOUND,
@@ -81,14 +78,20 @@
 		return -1;
 	} else if (errno == EACCES) {
 		mail_storage_set_critical(box->storage, "%s",
-			mail_error_eacces_msg("stat", box->path));
+			mail_error_eacces_msg("stat", box_path));
 		return -1;
 	} else {
 		mail_storage_set_critical(box->storage, "stat(%s) failed: %m",
-					  box->path);
+					  box_path);
 		return -1;
 	}
-	return index_storage_mailbox_open(box, FALSE);
+	if (index_storage_mailbox_open(box, FALSE) < 0)
+		return -1;
+	mail_index_set_fsync_mode(box->index,
+				  box->storage->set->parsed_fsync_mode,
+				  MAIL_INDEX_SYNC_TYPE_APPEND |
+				  MAIL_INDEX_SYNC_TYPE_EXPUNGE);
+	return 0;
 }
 
 static int
@@ -105,12 +108,10 @@
 
 static void cydir_notify_changes(struct mailbox *box)
 {
-	struct cydir_mailbox *mbox = (struct cydir_mailbox *)box;
-
 	if (box->notify_callback == NULL)
-		index_mailbox_check_remove_all(&mbox->box);
+		index_mailbox_check_remove_all(box);
 	else
-		index_mailbox_check_add(&mbox->box, mbox->box.path);
+		index_mailbox_check_add(box, mailbox_get_path(box));
 }
 
 struct mail_storage cydir_storage = {
@@ -154,21 +155,8 @@
 		index_transaction_begin,
 		index_transaction_commit,
 		index_transaction_rollback,
-		index_transaction_set_max_modseq,
-		index_keywords_create,
-		index_keywords_create_from_indexes,
-		index_keywords_ref,
-		index_keywords_unref,
-		index_keyword_is_valid,
-		index_storage_get_seq_range,
-		index_storage_get_uid_range,
-		index_storage_get_expunges,
-		NULL,
-		NULL,
 		NULL,
 		index_mail_alloc,
-		index_header_lookup_init,
-		index_header_lookup_deinit,
 		index_storage_search_init,
 		index_storage_search_deinit,
 		index_storage_search_next_nonblock,
@@ -179,7 +167,6 @@
 		cydir_save_finish,
 		cydir_save_cancel,
 		mail_storage_copy,
-		NULL,
 		index_storage_is_inconsistent
 	}
 };

--- a/src/lib-storage/index/dbox-common/dbox-mail.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-common/dbox-mail.c	Sat Jan 01 15:59:02 2011 +0200
@@ -167,8 +167,8 @@
 	string_t *str;
 
 	str = str_new(imail->data_pool, 64);
-	if (mail_cache_lookup_field(imail->trans->cache_view, str,
-				    imail->mail.mail.seq,
+	if (mail_cache_lookup_field(imail->mail.mail.transaction->cache_view,
+				    str, imail->mail.mail.seq,
 				    ibox->cache_fields[cache_field].idx) > 0) {
 		*value_r = str_c(str);
 		return 0;

--- a/src/lib-storage/index/dbox-common/dbox-storage.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-common/dbox-storage.c	Sat Jan 01 15:59:02 2011 +0200
@@ -113,21 +113,31 @@
 
 int dbox_mailbox_open(struct mailbox *box)
 {
-	if (dbox_cleanup_if_exists(box->list, box->path)) {
-		return index_storage_mailbox_open(box, FALSE);
-	} else if (errno == ENOENT) {
+	const char *box_path = mailbox_get_path(box);
+
+	if (dbox_cleanup_if_exists(box->list, box_path))
+		;
+	else if (errno == ENOENT) {
 		mail_storage_set_error(box->storage, MAIL_ERROR_NOTFOUND,
 			T_MAIL_ERR_MAILBOX_NOT_FOUND(box->name));
 		return -1;
 	} else if (errno == EACCES) {
 		mail_storage_set_critical(box->storage, "%s",
-			mail_error_eacces_msg("stat", box->path));
+			mail_error_eacces_msg("stat", box_path));
 		return -1;
 	} else {
 		mail_storage_set_critical(box->storage,
-					  "stat(%s) failed: %m", box->path);
+					  "stat(%s) failed: %m", box_path);
 		return -1;
 	}
+
+	if (index_storage_mailbox_open(box, FALSE) < 0)
+		return -1;
+	mail_index_set_fsync_mode(box->index,
+				  box->storage->set->parsed_fsync_mode,
+				  MAIL_INDEX_SYNC_TYPE_APPEND |
+				  MAIL_INDEX_SYNC_TYPE_EXPUNGE);
+	return 0;
 }
 
 static int dir_is_empty(struct mail_storage *storage, const char *path)

--- a/src/lib-storage/index/dbox-multi/mdbox-mail.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-multi/mdbox-mail.c	Sat Jan 01 15:59:02 2011 +0200
@@ -29,7 +29,7 @@
 		mail_index_lookup_uid(view, seq, &uid);
 		mail_storage_set_critical(&mbox->storage->storage.storage,
 			"mdbox %s: map uid lost for uid %u",
-			mbox->box.path, uid);
+			mailbox_get_path(&mbox->box), uid);
 		mdbox_storage_set_corrupted(mbox->storage);
 		return -1;
 	}
@@ -48,7 +48,7 @@
 	if (cur_map_uid_validity != mbox->map_uid_validity) {
 		mail_storage_set_critical(&mbox->storage->storage.storage,
 			"mdbox %s: map uidvalidity mismatch (%u vs %u)",
-			mbox->box.path, mbox->map_uid_validity,
+			mailbox_get_path(&mbox->box), mbox->map_uid_validity,
 			cur_map_uid_validity);
 		mdbox_storage_set_corrupted(mbox->storage);
 		return -1;

--- a/src/lib-storage/index/dbox-multi/mdbox-map.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-multi/mdbox-map.c	Sat Jan 01 15:59:02 2011 +0200
@@ -77,8 +77,9 @@
 	map->ref_ext_id = mail_index_ext_register(map->index, "ref", 0,
 				sizeof(uint16_t), sizeof(uint16_t));
 
-	mailbox_list_get_permissions(root_list, NULL, &map->create_mode,
-				     &map->create_gid, &map->create_gid_origin);
+	mailbox_list_get_root_permissions(root_list, &map->create_mode,
+					  &map->create_gid,
+					  &map->create_gid_origin);
 	mail_index_set_permissions(map->index, map->create_mode,
 				   map->create_gid, map->create_gid_origin);
 	return map;

--- a/src/lib-storage/index/dbox-multi/mdbox-save.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-multi/mdbox-save.c	Sat Jan 01 15:59:02 2011 +0200
@@ -364,10 +364,11 @@
 	(void)mdbox_map_atomic_finish(&ctx->atomic);
 
 	if (storage->set->parsed_fsync_mode != FSYNC_MODE_NEVER) {
-		if (fdatasync_path(ctx->mbox->box.path) < 0) {
+		const char *box_path = mailbox_get_path(&ctx->mbox->box);
+
+		if (fdatasync_path(box_path) < 0) {
 			mail_storage_set_critical(storage,
-				"fdatasync_path(%s) failed: %m",
-				ctx->mbox->box.path);
+				"fdatasync_path(%s) failed: %m", box_path);
 		}
 	}
 	mdbox_transaction_save_rollback(_ctx);

--- a/src/lib-storage/index/dbox-multi/mdbox-storage.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-multi/mdbox-storage.c	Sat Jan 01 15:59:02 2011 +0200
@@ -101,10 +101,6 @@
 	mbox->box.mail_vfuncs = &mdbox_mail_vfuncs;
 
 	index_storage_mailbox_alloc(&mbox->box, name, flags, DBOX_INDEX_PREFIX);
-	mail_index_set_fsync_mode(mbox->box.index,
-				  storage->set->parsed_fsync_mode,
-				  MAIL_INDEX_SYNC_TYPE_APPEND |
-				  MAIL_INDEX_SYNC_TYPE_EXPUNGE);
 
 	ibox = INDEX_STORAGE_CONTEXT(&mbox->box);
 	ibox->save_commit_pre = mdbox_transaction_save_commit_pre;
@@ -114,6 +110,16 @@
 		MAIL_INDEX_OPEN_FLAG_NEVER_IN_MEMORY;
 
 	mbox->storage = (struct mdbox_storage *)storage;
+	return &mbox->box;
+}
+
+static int mdbox_mailbox_open(struct mailbox *box)
+{
+	struct mdbox_mailbox *mbox = (struct mdbox_mailbox *)box;
+
+	if (dbox_mailbox_open(box) < 0)
+		return -1;
+
 	mbox->ext_id =
 		mail_index_ext_register(mbox->box.index, "mdbox", 0,
 					sizeof(struct mdbox_mail_index_record),
@@ -124,7 +130,7 @@
 	mbox->guid_ext_id =
 		mail_index_ext_register(mbox->box.index, "guid",
 					0, MAIL_GUID_128_SIZE, 1);
-	return &mbox->box;
+	return 0;
 }
 
 static void mdbox_mailbox_close(struct mailbox *box)
@@ -149,7 +155,7 @@
 	    (!mbox->creating || data_size != 0)) {
 		mail_storage_set_critical(&mbox->storage->storage.storage,
 			"mdbox %s: Invalid dbox header size: %"PRIuSIZE_T,
-			mbox->box.path, data_size);
+			mailbox_get_path(&mbox->box), data_size);
 		mdbox_storage_set_corrupted(mbox->storage);
 		return -1;
 	}
@@ -294,9 +300,9 @@
 }
 
 static int
-mdbox_mailbox_get_guid(struct mailbox *box, uint8_t guid[MAIL_GUID_128_SIZE])
+mdbox_mailbox_get_guid(struct mdbox_mailbox *mbox,
+		       uint8_t guid[MAIL_GUID_128_SIZE])
 {
-	struct mdbox_mailbox *mbox = (struct mdbox_mailbox *)box;
 	struct mdbox_index_header hdr;
 
 	if (mdbox_read_header(mbox, &hdr) < 0)
@@ -304,7 +310,7 @@
 
 	if (mail_guid_128_is_empty(hdr.mailbox_guid)) {
 		/* regenerate it */
-		if (mdbox_write_index_header(box, NULL, NULL) < 0 ||
+		if (mdbox_write_index_header(&mbox->box, NULL, NULL) < 0 ||
 		    mdbox_read_header(mbox, &hdr) < 0)
 			return -1;
 	}
@@ -313,6 +319,20 @@
 }
 
 static int
+mdbox_mailbox_get_metadata(struct mailbox *box,
+			   enum mailbox_metadata_items items,
+			   struct mailbox_metadata *metadata_r)
+{
+	struct mdbox_mailbox *mbox = (struct mdbox_mailbox *)box;
+
+	if ((items & MAILBOX_METADATA_GUID) != 0) {
+		if (mdbox_mailbox_get_guid(mbox, metadata_r->guid) < 0)
+			return -1;
+	}
+	return index_mailbox_get_metadata(box, items, metadata_r);
+}
+
+static int
 mdbox_mailbox_update(struct mailbox *box, const struct mailbox_update *update)
 {
 	if (!box->opened) {
@@ -389,7 +409,7 @@
 		index_storage_is_readonly,
 		index_storage_allow_new_keywords,
 		index_storage_mailbox_enable,
-		dbox_mailbox_open,
+		mdbox_mailbox_open,
 		mdbox_mailbox_close,
 		index_storage_mailbox_free,
 		dbox_mailbox_create,
@@ -397,7 +417,7 @@
 		mdbox_mailbox_delete,
 		index_storage_mailbox_rename,
 		index_storage_get_status,
-		mdbox_mailbox_get_guid,
+		mdbox_mailbox_get_metadata,
 		NULL,
 		NULL,
 		mdbox_storage_sync_init,
@@ -408,21 +428,8 @@
 		index_transaction_begin,
 		index_transaction_commit,
 		index_transaction_rollback,
-		index_transaction_set_max_modseq,
-		index_keywords_create,
-		index_keywords_create_from_indexes,
-		index_keywords_ref,
-		index_keywords_unref,
-		index_keyword_is_valid,
-		index_storage_get_seq_range,
-		index_storage_get_uid_range,
-		index_storage_get_expunges,
-		NULL,
-		NULL,
 		NULL,
 		dbox_mail_alloc,
-		index_header_lookup_init,
-		index_header_lookup_deinit,
 		index_storage_search_init,
 		index_storage_search_deinit,
 		index_storage_search_next_nonblock,
@@ -433,7 +440,6 @@
 		mdbox_save_finish,
 		mdbox_save_cancel,
 		mdbox_copy,
-		NULL,
 		index_storage_is_inconsistent
 	}
 };

--- a/src/lib-storage/index/dbox-multi/mdbox-sync.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-multi/mdbox-sync.c	Sat Jan 01 15:59:02 2011 +0200
@@ -264,7 +264,7 @@
 		if (storage_rebuilt) {
 			mail_storage_set_critical(storage,
 				"mdbox %s: Storage keeps breaking",
-				mbox->box.path);
+				mailbox_get_path(&mbox->box));
 			return -1;
 		}
 

--- a/src/lib-storage/index/dbox-single/sdbox-file.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-single/sdbox-file.c	Sat Jan 01 15:59:02 2011 +0200
@@ -22,7 +22,7 @@
 	i_free(file->file.primary_path);
 	i_free(file->file.alt_path);
 	file->file.primary_path =
-		i_strdup_printf("%s/%s", box->path, fname);
+		i_strdup_printf("%s/%s", mailbox_get_path(box), fname);
 
 	alt_path = mailbox_list_get_path(box->list, box->name,
 					 MAILBOX_LIST_PATH_TYPE_ALT_MAILBOX);
@@ -46,7 +46,7 @@
 		} else {
 			file->file.primary_path =
 				i_strdup_printf("%s/%s",
-						file->mbox->box.path,
+						mailbox_get_path(&mbox->box),
 						dbox_generate_tmp_filename());
 		}
 	} T_END;
@@ -151,7 +151,7 @@
 
 	old_path = file->file.cur_path;
 	new_fname = t_strdup_printf(SDBOX_MAIL_FILE_FORMAT, uid);
-	new_path = t_strdup_printf("%s/%s", file->mbox->box.path,
+	new_path = t_strdup_printf("%s/%s", mailbox_get_path(&file->mbox->box),
 				   new_fname);
 	if (rename(old_path, new_path) < 0) {
 		mail_storage_set_critical(&file->file.storage->storage,
@@ -221,43 +221,44 @@
 {
 	struct sdbox_file *sfile = (struct sdbox_file *)file;
 	struct mailbox *box = &sfile->mbox->box;
+	const struct mailbox_permissions *perm = mailbox_get_permissions(box);
 	const char *p, *dir;
 	mode_t old_mask;
 	int fd;
 
-	old_mask = umask(0666 & ~box->file_create_mode);
+	old_mask = umask(0666 & ~perm->file_create_mode);
 	fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0666);
 	umask(old_mask);
 	if (fd == -1 && errno == ENOENT && parents &&
 	    (p = strrchr(path, '/')) != NULL) {
 		dir = t_strdup_until(path, p);
-		if (mkdir_parents_chgrp(dir, box->dir_create_mode,
-					box->file_create_gid,
-					box->file_create_gid_origin) < 0) {
+		if (mkdir_parents_chgrp(dir, perm->dir_create_mode,
+					perm->file_create_gid,
+					perm->file_create_gid_origin) < 0) {
 			mail_storage_set_critical(box->storage,
 				"mkdir_parents(%s) failed: %m", dir);
 			return -1;
 		}
 		/* try again */
-		old_mask = umask(0666 & ~box->file_create_mode);
+		old_mask = umask(0666 & ~perm->file_create_mode);
 		fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0666);
 		umask(old_mask);
 	}
 	if (fd == -1) {
 		mail_storage_set_critical(box->storage,
 			"open(%s, O_CREAT) failed: %m", path);
-	} else if (box->file_create_gid == (gid_t)-1) {
+	} else if (perm->file_create_gid == (gid_t)-1) {
 		/* no group change */
-	} else if (fchown(fd, (uid_t)-1, box->file_create_gid) < 0) {
+	} else if (fchown(fd, (uid_t)-1, perm->file_create_gid) < 0) {
 		if (errno == EPERM) {
 			mail_storage_set_critical(box->storage, "%s",
 				eperm_error_get_chgrp("fchown", path,
-					box->file_create_gid,
-					box->file_create_gid_origin));
+					perm->file_create_gid,
+					perm->file_create_gid_origin));
 		} else {
 			mail_storage_set_critical(box->storage,
 				"fchown(%s, -1, %ld) failed: %m",
-				path, (long)box->file_create_gid);
+				path, (long)perm->file_create_gid);
 		}
 		/* continue anyway */
 	}

--- a/src/lib-storage/index/dbox-single/sdbox-save.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-single/sdbox-save.c	Sat Jan 01 15:59:02 2011 +0200
@@ -307,10 +307,11 @@
 		ctx->ctx.failed = TRUE;
 
 	if (storage->set->parsed_fsync_mode != FSYNC_MODE_NEVER) {
-		if (fdatasync_path(ctx->mbox->box.path) < 0) {
+		const char *box_path = mailbox_get_path(&ctx->mbox->box);
+
+		if (fdatasync_path(box_path) < 0) {
 			mail_storage_set_critical(storage,
-				"fdatasync_path(%s) failed: %m",
-				ctx->mbox->box.path);
+				"fdatasync_path(%s) failed: %m", box_path);
 		}
 	}
 	sdbox_transaction_save_rollback(_ctx);

--- a/src/lib-storage/index/dbox-single/sdbox-storage.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-single/sdbox-storage.c	Sat Jan 01 15:59:02 2011 +0200
@@ -48,10 +48,6 @@
 	mbox->box.mail_vfuncs = &sdbox_mail_vfuncs;
 
 	index_storage_mailbox_alloc(&mbox->box, name, flags, DBOX_INDEX_PREFIX);
-	mail_index_set_fsync_mode(mbox->box.index,
-				  storage->set->parsed_fsync_mode,
-				  MAIL_INDEX_SYNC_TYPE_APPEND |
-				  MAIL_INDEX_SYNC_TYPE_EXPUNGE);
 
 	ibox = INDEX_STORAGE_CONTEXT(&mbox->box);
 	ibox->save_commit_pre = sdbox_transaction_save_commit_pre;
@@ -61,9 +57,6 @@
 		MAIL_INDEX_OPEN_FLAG_NEVER_IN_MEMORY;
 
 	mbox->storage = (struct sdbox_storage *)storage;
-	mbox->hdr_ext_id =
-		mail_index_ext_register(mbox->box.index, "dbox-hdr",
-					sizeof(struct sdbox_index_header), 0, 0);
 	return &mbox->box;
 }
 
@@ -84,7 +77,7 @@
 			mail_storage_set_critical(
 				&mbox->storage->storage.storage,
 				"sdbox %s: Invalid dbox header size",
-				mbox->box.path);
+				mailbox_get_path(&mbox->box));
 		}
 		ret = -1;
 	} else {
@@ -226,6 +219,9 @@
 
 	if (dbox_mailbox_open(box) < 0)
 		return -1;
+	mbox->hdr_ext_id =
+		mail_index_ext_register(box->index, "dbox-hdr",
+					sizeof(struct sdbox_index_header), 0, 0);
 
 	/* get/generate mailbox guid */
 	if (sdbox_read_header(mbox, &hdr, FALSE) < 0) {
@@ -307,12 +303,17 @@
 }
 
 static int
-sdbox_mailbox_get_guid(struct mailbox *box, uint8_t guid[MAIL_GUID_128_SIZE])
+sdbox_mailbox_get_metadata(struct mailbox *box,
+			   enum mailbox_metadata_items items,
+			   struct mailbox_metadata *metadata_r)
 {
 	struct sdbox_mailbox *mbox = (struct sdbox_mailbox *)box;
 
-	memcpy(guid, mbox->mailbox_guid, MAIL_GUID_128_SIZE);
-	return 0;
+	if ((items & MAILBOX_METADATA_GUID) != 0) {
+		memcpy(metadata_r->guid, mbox->mailbox_guid,
+		       MAIL_GUID_128_SIZE);
+	}
+	return index_mailbox_get_metadata(box, items, metadata_r);
 }
 
 static int
@@ -374,7 +375,7 @@
 		sdbox_mailbox_delete,
 		index_storage_mailbox_rename,
 		index_storage_get_status,
-		sdbox_mailbox_get_guid,
+		sdbox_mailbox_get_metadata,
 		NULL,
 		NULL,
 		sdbox_storage_sync_init,
@@ -385,21 +386,8 @@
 		index_transaction_begin,
 		index_transaction_commit,
 		index_transaction_rollback,
-		index_transaction_set_max_modseq,
-		index_keywords_create,
-		index_keywords_create_from_indexes,
-		index_keywords_ref,
-		index_keywords_unref,
-		index_keyword_is_valid,
-		index_storage_get_seq_range,
-		index_storage_get_uid_range,
-		index_storage_get_expunges,
-		NULL,
-		NULL,
 		NULL,
 		dbox_mail_alloc,
-		index_header_lookup_init,
-		index_header_lookup_deinit,
 		index_storage_search_init,
 		index_storage_search_deinit,
 		index_storage_search_next_nonblock,
@@ -410,7 +398,6 @@
 		sdbox_save_finish,
 		sdbox_save_cancel,
 		sdbox_copy,
-		NULL,
 		index_storage_is_inconsistent
 	}
 };

--- a/src/lib-storage/index/dbox-single/sdbox-sync-rebuild.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-single/sdbox-sync-rebuild.c	Sat Jan 01 15:59:02 2011 +0200
@@ -73,7 +73,7 @@
 
 	if (str_to_uint32(fname, &uid) < 0 || uid == 0) {
 		i_warning("sdbox %s: Ignoring invalid filename %s",
-			  ctx->box->path, fname);
+			  mailbox_get_path(ctx->box), fname);
 		return 0;
 	}
 
@@ -146,14 +146,15 @@
 static int
 sdbox_sync_index_rebuild_singles(struct dbox_sync_rebuild_context *ctx)
 {
-	const char *alt_path;
+	const char *path, *alt_path;
 	int ret = 0;
 
+	path = mailbox_get_path(ctx->box);
 	alt_path = mailbox_list_get_path(ctx->box->list, ctx->box->name,
 					 MAILBOX_LIST_PATH_TYPE_ALT_MAILBOX);
 
 	sdbox_sync_set_uidvalidity(ctx);
-	if (sdbox_sync_index_rebuild_dir(ctx, ctx->box->path, TRUE) < 0)
+	if (sdbox_sync_index_rebuild_dir(ctx, path, TRUE) < 0)
 		ret = -1;
 	else if (alt_path != NULL)
 		ret = sdbox_sync_index_rebuild_dir(ctx, alt_path, FALSE);

--- a/src/lib-storage/index/dbox-single/sdbox-sync.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/dbox-single/sdbox-sync.c	Sat Jan 01 15:59:02 2011 +0200
@@ -202,12 +202,12 @@
 			if (i >= SDBOX_REBUILD_COUNT) {
 				mail_storage_set_critical(storage,
 					"sdbox %s: Index keeps breaking",
-					ctx->mbox->box.path);
+					mailbox_get_path(&ctx->mbox->box));
 				ret = -1;
 			} else {
 				/* do a full resync and try again. */
 				i_warning("sdbox %s: Rebuilding index",
-					  ctx->mbox->box.path);
+					  mailbox_get_path(&ctx->mbox->box));
 				rebuild = FALSE;
 				ret = sdbox_sync_index_rebuild(mbox,
 							       force_rebuild);

--- a/src/lib-storage/index/index-attachment.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/index-attachment.c	Sat Jan 01 15:59:02 2011 +0200
@@ -147,7 +147,6 @@
 static bool save_is_attachment(struct mail_save_context *ctx,
 			       struct message_part *part)
 {
-	struct mailbox *box = ctx->transaction->box;
 	struct mail_attachment_part apart;
 
 	if ((part->flags & MESSAGE_PART_FLAG_MULTIPART) != 0) {
@@ -155,14 +154,14 @@
 		   but they're never themselves */
 		return FALSE;
 	}
-	if (box->v.save_is_attachment == NULL)
+	if (ctx->part_is_attachment == NULL)
 		return TRUE;
 
 	memset(&apart, 0, sizeof(apart));
 	apart.part = part;
 	apart.content_type = ctx->attach->part.content_type;
 	apart.content_disposition = ctx->attach->part.content_disposition;
-	return box->v.save_is_attachment(ctx, &apart);
+	return ctx->part_is_attachment(ctx, &apart);
 }
 
 static int index_attachment_save_temp_open_fd(struct mail_storage *storage)

--- a/src/lib-storage/index/index-fetch.c	Sat Jan 01 14:34:14 2011 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,140 +0,0 @@
-/* Copyright (c) 2002-2010 Dovecot authors, see the included COPYING file */
-
-#include "lib.h"
-#include "array.h"
-#include "mail-index-modseq.h"
-#include "index-storage.h"
-#include "index-mail.h"
-
-void index_storage_get_seq_range(struct mailbox *box,
-				 uint32_t uid1, uint32_t uid2,
-				 uint32_t *seq1_r, uint32_t *seq2_r)
-{
-	mail_index_lookup_seq_range(box->view, uid1, uid2, seq1_r, seq2_r);
-}
-
-void index_storage_get_uid_range(struct mailbox *box,
-				 const ARRAY_TYPE(seq_range) *seqs,
-				 ARRAY_TYPE(seq_range) *uids)
-{
-	const struct seq_range *range;
-	unsigned int i, count;
-	uint32_t seq, uid;
-
-	range = array_get(seqs, &count);
-	for (i = 0; i < count; i++) {
-		if (range[i].seq2 == (uint32_t)-1) {
-			i_assert(count == i-1);
-			mail_index_lookup_uid(box->view, range[i].seq1, &uid);
-			seq_range_array_add_range(uids, uid, (uint32_t)-1);
-			break;
-		}
-		for (seq = range[i].seq1; seq <= range[i].seq2; seq++) {
-			mail_index_lookup_uid(box->view, seq, &uid);
-			seq_range_array_add(uids, 0, uid);
-		}
-	}
-}
-
-static void
-add_expunges(ARRAY_TYPE(mailbox_expunge_rec) *expunges,
-	     const struct mail_transaction_expunge *src, size_t src_size,
-	     const ARRAY_TYPE(seq_range) *uids_filter)
-{
-	const struct mail_transaction_expunge *end;
-	struct mailbox_expunge_rec *expunge;
-	uint32_t uid;
-
-	end = src + src_size / sizeof(*src);
-	for (; src != end; src++) {
-		for (uid = src->uid1; uid <= src->uid2; uid++) {
-			if (seq_range_exists(uids_filter, uid)) {
-				expunge = array_append_space(expunges);
-				expunge->uid = uid;
-			}
-		}
-	}
-}
-
-static void
-add_guid_expunges(ARRAY_TYPE(mailbox_expunge_rec) *expunges,
-		  const struct mail_transaction_expunge_guid *src,
-		  size_t src_size, const ARRAY_TYPE(seq_range) *uids_filter)
-{
-	const struct mail_transaction_expunge_guid *end;
-	struct mailbox_expunge_rec *expunge;
-
-	end = src + src_size / sizeof(*src);
-	for (; src != end; src++) {
-		if (seq_range_exists(uids_filter, src->uid)) {
-			expunge = array_append_space(expunges);
-			expunge->uid = src->uid;
-			memcpy(expunge->guid_128, src->guid_128,
-			       sizeof(expunge->guid_128));
-		}
-	}
-}
-
-bool index_storage_get_expunges(struct mailbox *box, uint64_t prev_modseq,
-				const ARRAY_TYPE(seq_range) *uids_filter,
-				ARRAY_TYPE(mailbox_expunge_rec) *expunges)
-{
-	struct mail_transaction_log_view *log_view;
-	const struct mail_transaction_header *thdr;
-	const void *tdata;
-	uint32_t log_seq, tail_seq = 0;
-	uoff_t log_offset;
-	bool reset;
-	int ret;
-
-	if (!mail_index_modseq_get_next_log_offset(box->view, prev_modseq,
-						   &log_seq, &log_offset)) {
-		log_seq = 1;
-		log_offset = 0;
-	}
-	if (log_seq > box->view->log_file_head_seq ||
-	    (log_seq == box->view->log_file_head_seq &&
-	     log_offset >= box->view->log_file_head_offset)) {
-		/* we haven't seen this high expunges at all */
-		return TRUE;
-	}
-
-	log_view = mail_transaction_log_view_open(box->index->log);
-	ret = mail_transaction_log_view_set(log_view, log_seq, log_offset,
-					    box->view->log_file_head_seq,
-					    box->view->log_file_head_offset,
-					    &reset);
-	if (ret == 0) {
-		mail_transaction_log_get_tail(box->index->log, &tail_seq);
-		i_assert(tail_seq > log_seq);
-		ret = mail_transaction_log_view_set(log_view, tail_seq, 0,
-					box->view->log_file_head_seq,
-					box->view->log_file_head_offset,
-					&reset);
-		i_assert(ret != 0);
-	}
-	if (ret <= 0) {
-		mail_transaction_log_view_close(&log_view);
-		return FALSE;
-	}
-
-	while ((ret = mail_transaction_log_view_next(log_view,
-						     &thdr, &tdata)) > 0) {
-		if ((thdr->type & MAIL_TRANSACTION_EXTERNAL) == 0) {
-			/* skip expunge requests */
-			continue;
-		}
-		switch (thdr->type & MAIL_TRANSACTION_TYPE_MASK) {
-		case MAIL_TRANSACTION_EXPUNGE:
-			add_expunges(expunges, tdata, thdr->size, uids_filter);
-			break;
-		case MAIL_TRANSACTION_EXPUNGE_GUID:
-			add_guid_expunges(expunges, tdata, thdr->size,
-					  uids_filter);
-			break;
-		}
-	}
-
-	mail_transaction_log_view_close(&log_view);
-	return ret < 0 || tail_seq != 0 ? FALSE : TRUE;
-}

--- a/src/lib-storage/index/index-mail-headers.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/index-mail-headers.c	Sat Jan 01 15:59:02 2011 +0200
@@ -15,17 +15,6 @@
 #include "index-storage.h"
 #include "index-mail.h"
 
-#include <stdlib.h>
-
-struct index_header_lookup_ctx {
-	struct mailbox_header_lookup_ctx ctx;
-	pool_t pool;
-
-	unsigned int count;
-	unsigned int *idx;
-	const char **name;
-};
-
 static const enum message_header_parser_flags hdr_parser_flags =
 	MESSAGE_HEADER_PARSER_FLAG_SKIP_INITIAL_LWSP |
 	MESSAGE_HEADER_PARSER_FLAG_DROP_CR;
@@ -44,6 +33,7 @@
 
 static void index_mail_parse_header_finish(struct index_mail *mail)
 {
+	struct mail *_mail = &mail->mail.mail;
 	const struct index_mail_line *lines;
 	const unsigned char *header, *data;
 	const uint8_t *match;
@@ -68,9 +58,8 @@
 		while (match_idx < lines[i].field_idx &&
 		       match_idx < match_count) {
 			if (HEADER_MATCH_USABLE(mail, match[match_idx]) &&
-			    mail_cache_field_can_add(mail->trans->cache_trans,
-						     mail->data.seq,
-						     match_idx)) {
+			    mail_cache_field_can_add(_mail->transaction->cache_trans,
+						     _mail->seq, match_idx)) {
 				/* this header doesn't exist. remember that. */
 				i_assert((match[match_idx] &
 					  HEADER_MATCH_FLAG_FOUND) == 0);
@@ -87,9 +76,8 @@
 			match_idx++;
 		}
 
-		if (!mail_cache_field_can_add(mail->trans->cache_trans,
-					      mail->data.seq,
-					      lines[i].field_idx)) {
+		if (!mail_cache_field_can_add(_mail->transaction->cache_trans,
+					      _mail->seq, lines[i].field_idx)) {
 			/* header is already cached */
 			j = i + 1;
 			continue;
@@ -132,9 +120,8 @@
 
 	for (; match_idx < match_count; match_idx++) {
 		if (HEADER_MATCH_USABLE(mail, match[match_idx]) &&
-		    mail_cache_field_can_add(mail->trans->cache_trans,
-					     mail->data.seq,
-					     match_idx)) {
+		    mail_cache_field_can_add(_mail->transaction->cache_trans,
+					     _mail->seq, match_idx)) {
 			/* this header doesn't exist. remember that. */
 			i_assert((match[match_idx] &
 				  HEADER_MATCH_FLAG_FOUND) == 0);
@@ -176,17 +163,18 @@
 
 static void index_mail_parse_header_register_all_wanted(struct index_mail *mail)
 {
+	struct mail *_mail = &mail->mail.mail;
 	const struct mail_cache_field *all_cache_fields;
 	unsigned int i, count;
 
 	all_cache_fields =
-		mail_cache_register_get_list(mail->mail.mail.box->cache,
+		mail_cache_register_get_list(_mail->box->cache,
 					     pool_datastack_create(), &count);
 	for (i = 0; i < count; i++) {
 		if (strncasecmp(all_cache_fields[i].name, "hdr.", 4) != 0)
 			continue;
-		if (!mail_cache_field_want_add(mail->trans->cache_trans,
-					       mail->data.seq, i))
+		if (!mail_cache_field_want_add(_mail->transaction->cache_trans,
+					       _mail->seq, i))
 			continue;
 
 		array_idx_set(&mail->header_match, all_cache_fields[i].idx,
@@ -195,10 +183,8 @@
 }
 
 void index_mail_parse_header_init(struct index_mail *mail,
-				  struct mailbox_header_lookup_ctx *_headers)
+				  struct mailbox_header_lookup_ctx *headers)
 {
-	struct index_header_lookup_ctx *headers =
-		(struct index_header_lookup_ctx *)_headers;
 	const uint8_t *match;
 	unsigned int i, field_idx, match_count;
 
@@ -265,6 +251,7 @@
 
 static void index_mail_parse_finish_imap_envelope(struct index_mail *mail)
 {
+	struct mail *_mail = &mail->mail.mail;
 	const unsigned int cache_field_envelope =
 		mail->ibox->cache_fields[MAIL_CACHE_IMAP_ENVELOPE].idx;
 	string_t *str;
@@ -273,8 +260,8 @@
 	imap_envelope_write_part_data(mail->data.envelope_data, str);
 	mail->data.envelope = str_c(str);
 
-	if (mail_cache_field_can_add(mail->trans->cache_trans,
-				     mail->data.seq, cache_field_envelope)) {
+	if (mail_cache_field_can_add(_mail->transaction->cache_trans,
+				     _mail->seq, cache_field_envelope)) {
 		index_mail_cache_add_idx(mail, cache_field_envelope,
 					 str_data(str), str_len(str));
 	}
@@ -596,6 +583,7 @@
 index_mail_get_raw_headers(struct index_mail *mail, const char *field,
 			   const char *const **value_r)
 {
+	struct mail *_mail = &mail->mail.mail;
 	const char *headers[2], *value;
 	struct mailbox_header_lookup_ctx *headers_ctx;
 	unsigned char *data;
@@ -607,12 +595,12 @@
 
 	i_assert(field != NULL);
 
-	field_idx = get_header_field_idx(mail->mail.mail.box, field,
+	field_idx = get_header_field_idx(_mail->box, field,
 					 MAIL_CACHE_DECISION_TEMP);
 
 	dest = str_new(mail->data_pool, 128);
-	if (mail_cache_lookup_headers(mail->trans->cache_view, dest,
-				      mail->data.seq, &field_idx, 1) <= 0) {
+	if (mail_cache_lookup_headers(_mail->transaction->cache_view, dest,
+				      _mail->seq, &field_idx, 1) <= 0) {
 		/* not in cache / error - first see if it's already parsed */
 		p_free(mail->data_pool, dest);
 
@@ -620,8 +608,8 @@
 		    index_mail_header_is_parsed(mail, field_idx) < 0) {
 			/* parse */
 			headers[0] = field; headers[1] = NULL;
-			headers_ctx = mailbox_header_lookup_init(
-						mail->mail.mail.box, headers);
+			headers_ctx = mailbox_header_lookup_init(_mail->box,
+								 headers);
 			ret = index_mail_parse_headers(mail, headers_ctx);
 			mailbox_header_lookup_unref(&headers_ctx);
 			if (ret < 0)
@@ -800,26 +788,24 @@
 }
 
 int index_mail_get_header_stream(struct mail *_mail,
-				 struct mailbox_header_lookup_ctx *_headers,
+				 struct mailbox_header_lookup_ctx *headers,
 				 struct istream **stream_r)
 {
 	struct index_mail *mail = (struct index_mail *)_mail;
-	struct index_header_lookup_ctx *headers =
-		(struct index_header_lookup_ctx *)_headers;
 	struct istream *input;
 	string_t *dest;
 
-	i_assert(_headers->box == _mail->box);
+	i_assert(headers->box == _mail->box);
 
 	if (mail->data.save_bodystructure_header) {
 		/* we have to parse the header. */
-		if (index_mail_parse_headers(mail, _headers) < 0)
+		if (index_mail_parse_headers(mail, headers) < 0)
 			return -1;
 	}
 
 	dest = str_new(mail->data_pool, 256);
-	if (mail_cache_lookup_headers(mail->trans->cache_view, dest,
-				      mail->data.seq, headers->idx,
+	if (mail_cache_lookup_headers(_mail->transaction->cache_view, dest,
+				      _mail->seq, headers->idx,
 				      headers->count) > 0) {
 		mail->mail.stats_cache_hit_count++;
 		if (mail->data.filter_stream != NULL)
@@ -833,13 +819,13 @@
 	/* not in cache / error */
 	p_free(mail->data_pool, dest);
 
-	if (mail_get_stream(&mail->mail.mail, NULL, NULL, &input) < 0)
+	if (mail_get_stream(_mail, NULL, NULL, &input) < 0)
 		return -1;
 
 	if (mail->data.filter_stream != NULL)
 		i_stream_destroy(&mail->data.filter_stream);
 
-	index_mail_parse_header_init(mail, _headers);
+	index_mail_parse_header_init(mail, headers);
 	mail->data.filter_stream =
 		i_stream_create_header_filter(mail->data.stream,
 					      HEADER_FILTER_INCLUDE |
@@ -849,73 +835,3 @@
 	*stream_r = mail->data.filter_stream;
 	return 0;
 }
-
-static struct mailbox_header_lookup_ctx *
-index_header_lookup_init_real(struct mailbox *box, const char *const headers[])
-{
-	struct mail_cache_field *fields, header_field = {
-		NULL, 0, MAIL_CACHE_FIELD_HEADER, 0,
-		MAIL_CACHE_DECISION_TEMP
-	};
-	struct index_header_lookup_ctx *ctx;
-	const char *const *name;
-	const char **sorted_headers;
-	pool_t pool;
-	unsigned int i, count;
-
-	i_assert(*headers != NULL);
-
-	for (count = 0, name = headers; *name != NULL; name++)
-		count++;
-
-	/* @UNSAFE: headers need to be sorted for filter stream. */
-	sorted_headers = t_new(const char *, count);
-	memcpy(sorted_headers, headers, count * sizeof(*sorted_headers));
-	qsort(sorted_headers, count, sizeof(*sorted_headers), i_strcasecmp_p);
-	headers = sorted_headers;
-
-	/* @UNSAFE */
-	fields = t_new(struct mail_cache_field, count);
-	for (i = 0; i < count; i++) {
-		header_field.name = t_strconcat("hdr.", headers[i], NULL);
-		fields[i] = header_field;
-	}
-	mail_cache_register_fields(box->cache, fields, count);
-
-	pool = pool_alloconly_create("index_header_lookup_ctx", 1024);
-	ctx = p_new(pool, struct index_header_lookup_ctx, 1);
-	ctx->ctx.box = box;
-	ctx->ctx.refcount = 1;
-	ctx->pool = pool;
-	ctx->count = count;
-
-	ctx->idx = p_new(pool, unsigned int, count);
-	ctx->name = p_new(pool, const char *, count + 1);
-
-	/* @UNSAFE */
-	for (i = 0; i < count; i++) {
-		ctx->idx[i] = fields[i].idx;
-		ctx->name[i] = p_strdup(pool, headers[i]);
-	}
-	ctx->ctx.headers = ctx->name;
-	return &ctx->ctx;
-}
-
-struct mailbox_header_lookup_ctx *
-index_header_lookup_init(struct mailbox *box, const char *const headers[])
-{
-	struct mailbox_header_lookup_ctx *ctx;
-
-	T_BEGIN {
-		ctx = index_header_lookup_init_real(box, headers);
-	} T_END;
-	return ctx;
-}
-
-void index_header_lookup_deinit(struct mailbox_header_lookup_ctx *_ctx)
-{
-	struct index_header_lookup_ctx *ctx =
-		(struct index_header_lookup_ctx *)_ctx;
-
-	pool_unref(&ctx->pool);
-}

--- a/src/lib-storage/index/index-mail.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/index-mail.c	Sat Jan 01 15:59:02 2011 +0200
@@ -45,8 +45,8 @@
 {
 	int ret;
 
-	ret = mail_cache_lookup_field(mail->trans->cache_view, buf,
-				      mail->data.seq, field_idx);
+	ret = mail_cache_lookup_field(mail->mail.mail.transaction->cache_view,
+				      buf, mail->data.seq, field_idx);
 	if (ret > 0)
 		mail->mail.stats_cache_hit_count++;
 	return ret;
@@ -54,7 +54,7 @@
 
 static struct message_part *get_unserialized_parts(struct index_mail *mail)
 {
-	unsigned int field_idx =
+	const unsigned int field_idx =
 		mail->ibox->cache_fields[MAIL_CACHE_MESSAGE_PARTS].idx;
 	struct message_part *parts;
 	buffer_t *part_buf;
@@ -102,7 +102,7 @@
 				       enum index_cache_field field,
 				       void *data, size_t data_size)
 {
-	unsigned int field_idx = mail->ibox->cache_fields[field].idx;
+	const unsigned int field_idx = mail->ibox->cache_fields[field].idx;
 	buffer_t buf;
 	int ret;
 
@@ -421,21 +421,21 @@
 void index_mail_cache_add_idx(struct index_mail *mail, unsigned int field_idx,
 			      const void *data, size_t data_size)
 {
-	const struct mail_storage_settings *set =
-		mail->mail.mail.box->storage->set;
+	struct mail *_mail = &mail->mail.mail;
+	const struct mail_storage_settings *set = _mail->box->storage->set;
 	const struct mail_index_header *hdr;
 
 	if (set->mail_cache_min_mail_count > 0) {
 		/* First check if we've configured caching not to be used with
 		   low enough message count. */
-		hdr = mail_index_get_header(mail->mail.mail.box->view);
+		hdr = mail_index_get_header(_mail->box->view);
 		if (hdr->messages_count < set->mail_cache_min_mail_count)
 			return;
 	}
 
 	if (!mail->data.no_caching &&
 	    mail->data.dont_cache_field_idx != field_idx) {
-		mail_cache_add(mail->trans->cache_trans, mail->data.seq,
+		mail_cache_add(_mail->transaction->cache_trans, _mail->seq,
 			       field_idx, data, data_size);
 	}
 }
@@ -449,29 +449,36 @@
 
 static bool want_plain_bodystructure_cached(struct index_mail *mail)
 {
+	const unsigned int cache_field_body =
+		mail->ibox->cache_fields[MAIL_CACHE_IMAP_BODY].idx;
+	const unsigned int cache_field_bodystructure =
+		mail->ibox->cache_fields[MAIL_CACHE_IMAP_BODYSTRUCTURE].idx;
+	struct mail *_mail = &mail->mail.mail;
+
 	if ((mail->wanted_fields & (MAIL_FETCH_IMAP_BODY |
 				    MAIL_FETCH_IMAP_BODYSTRUCTURE)) != 0)
 		return TRUE;
 
-	if (mail_cache_field_want_add(mail->trans->cache_trans, mail->data.seq,
-		mail->ibox->cache_fields[MAIL_CACHE_IMAP_BODY].idx))
+	if (mail_cache_field_want_add(_mail->transaction->cache_trans,
+				      _mail->seq, cache_field_body))
 		return TRUE;
-	if (mail_cache_field_want_add(mail->trans->cache_trans, mail->data.seq,
-		mail->ibox->cache_fields[MAIL_CACHE_IMAP_BODYSTRUCTURE].idx))
+	if (mail_cache_field_want_add(_mail->transaction->cache_trans,
+				      _mail->seq, cache_field_bodystructure))
 		return TRUE;
 	return FALSE;
 }
 
 static void index_mail_body_parsed_cache_flags(struct index_mail *mail)
 {
+	struct mail *_mail = &mail->mail.mail;
 	struct index_mail_data *data = &mail->data;
 	unsigned int cache_flags_idx;
 	uint32_t cache_flags = data->cache_flags;
 	bool want_cached;
 
 	cache_flags_idx = mail->ibox->cache_fields[MAIL_CACHE_FLAGS].idx;
-	want_cached = mail_cache_field_want_add(mail->trans->cache_trans,
-						data->seq, cache_flags_idx);
+	want_cached = mail_cache_field_want_add(_mail->transaction->cache_trans,
+						_mail->seq, cache_flags_idx);
 
 	if (data->parsed_bodystructure &&
 	    imap_bodystructure_is_plain_7bit(data->parts) &&
@@ -490,12 +497,12 @@
 			 MAIL_CACHE_FLAG_HAS_NULS |
 			 MAIL_CACHE_FLAG_HAS_NO_NULS);
 	if ((data->parts->flags & MESSAGE_PART_FLAG_HAS_NULS) != 0) {
-		mail->mail.mail.has_nuls = TRUE;
-		mail->mail.mail.has_no_nuls = FALSE;
+		_mail->has_nuls = TRUE;
+		_mail->has_no_nuls = FALSE;
 		cache_flags |= MAIL_CACHE_FLAG_HAS_NULS;
 	} else {
-		mail->mail.mail.has_nuls = FALSE;
-		mail->mail.mail.has_no_nuls = TRUE;
+		_mail->has_nuls = FALSE;
+		_mail->has_no_nuls = TRUE;
 		cache_flags |= MAIL_CACHE_FLAG_HAS_NO_NULS;
 	}
 
@@ -513,20 +520,21 @@
 
 static void index_mail_body_parsed_cache_message_parts(struct index_mail *mail)
 {
+	struct mail *_mail = &mail->mail.mail;
 	struct index_mail_data *data = &mail->data;
-	unsigned int cache_field =
+	const unsigned int cache_field =
 		mail->ibox->cache_fields[MAIL_CACHE_MESSAGE_PARTS].idx;
 	enum mail_cache_decision_type decision;
 	buffer_t *buffer;
 
 	if (data->messageparts_saved_to_cache ||
-	    mail_cache_field_exists(mail->trans->cache_view, mail->data.seq,
+	    mail_cache_field_exists(_mail->transaction->cache_view, _mail->seq,
 				    cache_field) != 0) {
 		/* already cached */
 		return;
 	}
 
-	decision = mail_cache_field_get_decision(mail->mail.mail.box->cache,
+	decision = mail_cache_field_get_decision(_mail->box->cache,
 						 cache_field);
 	if (decision == (MAIL_CACHE_DECISION_NO | MAIL_CACHE_DECISION_FORCED)) {
 		/* we never want it cached */
@@ -554,12 +562,13 @@
 index_mail_body_parsed_cache_bodystructure(struct index_mail *mail,
 					   enum index_cache_field field)
 {
+	struct mail *_mail = &mail->mail.mail;
 	struct index_mail_data *data = &mail->data;
-	unsigned int cache_field_parts =
+	const unsigned int cache_field_parts =
 		mail->ibox->cache_fields[MAIL_CACHE_MESSAGE_PARTS].idx;
-	unsigned int cache_field_body =
+	const unsigned int cache_field_body =
 		mail->ibox->cache_fields[MAIL_CACHE_IMAP_BODY].idx;
-	unsigned int cache_field_bodystructure =
+	const unsigned int cache_field_bodystructure =
 		mail->ibox->cache_fields[MAIL_CACHE_IMAP_BODYSTRUCTURE].idx;
 	enum mail_cache_decision_type dec;
 	string_t *str;
@@ -569,8 +578,8 @@
 
 	if ((data->cache_flags & MAIL_CACHE_FLAG_TEXT_PLAIN_7BIT_ASCII) != 0) {
 		if (data->messageparts_saved_to_cache ||
-		    mail_cache_field_exists(mail->trans->cache_view, data->seq,
-					    cache_field_parts) > 0) {
+		    mail_cache_field_exists(_mail->transaction->cache_view,
+					    _mail->seq, cache_field_parts) > 0) {
 			/* cached it as flag + message_parts */
 			plain_bodystructure = TRUE;
 		}
@@ -587,12 +596,12 @@
 	else if (field == MAIL_CACHE_IMAP_BODYSTRUCTURE ||
 		 (mail->wanted_fields & MAIL_FETCH_IMAP_BODYSTRUCTURE) != 0) {
 		cache_bodystructure =
-			mail_cache_field_can_add(mail->trans->cache_trans,
-				data->seq, cache_field_bodystructure);
+			mail_cache_field_can_add(_mail->transaction->cache_trans,
+				_mail->seq, cache_field_bodystructure);
 	} else {
 		cache_bodystructure =
-			mail_cache_field_want_add(mail->trans->cache_trans,
-				data->seq, cache_field_bodystructure);
+			mail_cache_field_want_add(_mail->transaction->cache_trans,
+				_mail->seq, cache_field_bodystructure);
 	}
 	if (cache_bodystructure) {
 		str = str_new(mail->data_pool, 128);
@@ -604,13 +613,13 @@
 		bodystructure_cached = TRUE;
 	} else {
 		bodystructure_cached =
-			mail_cache_field_exists(mail->trans->cache_view,
-				data->seq, cache_field_bodystructure) > 0;
+			mail_cache_field_exists(_mail->transaction->cache_view,
+				_mail->seq, cache_field_bodystructure) > 0;
 	}
 
 	/* normally don't cache both BODY and BODYSTRUCTURE, but do it
 	   if BODY is forced to be cached */
-	dec = mail_cache_field_get_decision(mail->mail.mail.box->cache,
+	dec = mail_cache_field_get_decision(_mail->box->cache,
 					    cache_field_body);
 	if (plain_bodystructure ||
 	    (bodystructure_cached &&
@@ -618,12 +627,12 @@
 		cache_body = FALSE;
 	else if (field == MAIL_CACHE_IMAP_BODY) {
 		cache_body =
-			mail_cache_field_can_add(mail->trans->cache_trans,
-				data->seq, cache_field_body);
+			mail_cache_field_can_add(_mail->transaction->cache_trans,
+				_mail->seq, cache_field_body);
 	} else {
 		cache_body =
-			mail_cache_field_want_add(mail->trans->cache_trans,
-				data->seq, cache_field_body);
+			mail_cache_field_want_add(_mail->transaction->cache_trans,
+				_mail->seq, cache_field_body);
 	}
 
 	if (cache_body) {
@@ -639,6 +648,7 @@
 static bool
 index_mail_want_cache(struct index_mail *mail, enum index_cache_field field)
 {
+	struct mail *_mail = &mail->mail.mail;
 	enum mail_fetch_field fetch_field;
 	unsigned int cache_field;
 
@@ -667,11 +677,11 @@
 
 	cache_field = mail->ibox->cache_fields[field].idx;
 	if ((mail->data.cache_fetch_fields & fetch_field) != 0) {
-		return mail_cache_field_can_add(mail->trans->cache_trans,
-						mail->data.seq, cache_field);
+		return mail_cache_field_can_add(_mail->transaction->cache_trans,
+						_mail->seq, cache_field);
 	} else {
-		return mail_cache_field_want_add(mail->trans->cache_trans,
-						 mail->data.seq, cache_field);
+		return mail_cache_field_want_add(_mail->transaction->cache_trans,
+						 _mail->seq, cache_field);
 	}
 }
 
@@ -804,7 +814,8 @@
 
 enum index_mail_access_part index_mail_get_access_part(struct index_mail *mail)
 {
-	struct mail_cache_field *cache_fields = mail->ibox->cache_fields;
+	struct mail *_mail = &mail->mail.mail;
+	const struct mail_cache_field *cache_fields = mail->ibox->cache_fields;
 
 	if ((mail->data.access_part & (READ_HDR | PARSE_HDR)) != 0 &&
 	    (mail->data.access_part & (READ_BODY | PARSE_BODY)) != 0)
@@ -812,12 +823,11 @@
 
 	/* lazy virtual size access check */
 	if ((mail->wanted_fields & MAIL_FETCH_VIRTUAL_SIZE) != 0) {
-		unsigned int cache_field =
+		const unsigned int cache_field =
 			cache_fields[MAIL_CACHE_VIRTUAL_FULL_SIZE].idx;
 
-		if (mail_cache_field_exists(mail->trans->cache_view,
-					    mail->mail.mail.seq,
-					    cache_field) <= 0)
+		if (mail_cache_field_exists(_mail->transaction->cache_view,
+					    _mail->seq, cache_field) <= 0)
 			mail->data.access_part |= READ_HDR | READ_BODY;
 	}
 	return mail->data.access_part;
@@ -979,14 +989,14 @@
 {
 	struct index_mail *mail = (struct index_mail *)_mail;
 	struct index_mail_data *data = &mail->data;
-	struct mail_cache_field *cache_fields = mail->ibox->cache_fields;
+	const struct mail_cache_field *cache_fields = mail->ibox->cache_fields;
 	string_t *str;
 
 	switch (field) {
 	case MAIL_FETCH_IMAP_BODY: {
-		unsigned int body_cache_field =
+		const unsigned int body_cache_field =
                         cache_fields[MAIL_CACHE_IMAP_BODY].idx;
-		unsigned int bodystructure_cache_field =
+		const unsigned int bodystructure_cache_field =
                         cache_fields[MAIL_CACHE_IMAP_BODYSTRUCTURE].idx;
 
 		if (data->body != NULL) {
@@ -1036,7 +1046,7 @@
 		return 0;
 	}
 	case MAIL_FETCH_IMAP_BODYSTRUCTURE: {
-		unsigned int bodystructure_cache_field =
+		const unsigned int bodystructure_cache_field =
                         cache_fields[MAIL_CACHE_IMAP_BODYSTRUCTURE].idx;
 
 		if (data->bodystructure != NULL) {
@@ -1109,36 +1119,31 @@
 }
 
 void index_mail_init(struct index_mail *mail,
-		     struct mailbox_transaction_context *_t,
+		     struct mailbox_transaction_context *t,
 		     enum mail_fetch_field wanted_fields,
-		     struct mailbox_header_lookup_ctx *_wanted_headers)
+		     struct mailbox_header_lookup_ctx *wanted_headers)
 {
-	struct index_transaction_context *t =
-		(struct index_transaction_context *)_t;
-	struct index_header_lookup_ctx *wanted_headers =
-		(struct index_header_lookup_ctx *)_wanted_headers;
 	const struct mail_index_header *hdr;
 
 	array_create(&mail->mail.module_contexts, mail->mail.pool,
 		     sizeof(void *), 5);
 
-	mail->mail.v = *_t->box->mail_vfuncs;
-	mail->mail.mail.box = _t->box;
-	mail->mail.mail.transaction = &t->mailbox_ctx;
+	mail->mail.v = *t->box->mail_vfuncs;
+	mail->mail.mail.box = t->box;
+	mail->mail.mail.transaction = t;
 	mail->mail.wanted_fields = wanted_fields;
-	mail->mail.wanted_headers = _wanted_headers;
+	mail->mail.wanted_headers = wanted_headers;
 
-	hdr = mail_index_get_header(_t->box->view);
+	hdr = mail_index_get_header(t->box->view);
 	mail->uid_validity = hdr->uid_validity;
 
 	t->mail_ref_count++;
 	mail->data_pool = pool_alloconly_create("index_mail", 16384);
-	mail->ibox = INDEX_STORAGE_CONTEXT(_t->box);
-	mail->trans = t;
+	mail->ibox = INDEX_STORAGE_CONTEXT(t->box);
 	mail->wanted_fields = wanted_fields;
 	if (wanted_headers != NULL) {
 		mail->wanted_headers = wanted_headers;
-		mailbox_header_lookup_ref(_wanted_headers);
+		mailbox_header_lookup_ref(wanted_headers);
 	}
 }
 
@@ -1198,7 +1203,8 @@
 
 static void check_envelope(struct index_mail *mail)
 {
-	unsigned int cache_field_envelope =
+	struct mail *_mail = &mail->mail.mail;
+	const unsigned int cache_field_envelope =
 		mail->ibox->cache_fields[MAIL_CACHE_IMAP_ENVELOPE].idx;
 	unsigned int cache_field_hdr;
 
@@ -1208,20 +1214,18 @@
 	}
 
 	/* if "imap.envelope" is cached, that's all we need */
-	if (mail_cache_field_exists(mail->trans->cache_view,
-				    mail->mail.mail.seq,
-				    cache_field_envelope) > 0)
+	if (mail_cache_field_exists(_mail->transaction->cache_view,
+				    _mail->seq, cache_field_envelope) > 0)
 		return;
 
 	/* don't waste time doing full checks for all required
 	   headers. assume that if we have "hdr.message-id" cached,
 	   we don't need to parse the header. */
-	cache_field_hdr = mail_cache_register_lookup(mail->mail.mail.box->cache,
+	cache_field_hdr = mail_cache_register_lookup(_mail->box->cache,
 						     "hdr.message-id");
 	if (cache_field_hdr == (unsigned int)-1 ||
-	    mail_cache_field_exists(mail->trans->cache_view,
-				    mail->mail.mail.seq,
-				    cache_field_hdr) <= 0)
+	    mail_cache_field_exists(_mail->transaction->cache_view,
+				    _mail->seq, cache_field_hdr) <= 0)
 		mail->data.access_part |= PARSE_HDR;
 	mail->data.save_envelope = TRUE;
 }
@@ -1230,8 +1234,8 @@
 {
 	struct index_mail *mail = (struct index_mail *)_mail;
 	struct index_mail_data *data = &mail->data;
-	struct mail_cache_field *cache_fields = mail->ibox->cache_fields;
-	struct mail_cache_view *cache_view = mail->trans->cache_view;
+	const struct mail_cache_field *cache_fields = mail->ibox->cache_fields;
+	struct mail_cache_view *cache_view = _mail->transaction->cache_view;
 	const struct mail_index_header *hdr;
 	struct istream *input;
 
@@ -1266,7 +1270,7 @@
 	/* see if wanted_fields can tell us if we need to read/parse
 	   header/body */
 	if ((mail->wanted_fields & MAIL_FETCH_MESSAGE_PARTS) != 0) {
-		unsigned int cache_field =
+		const unsigned int cache_field =
 			cache_fields[MAIL_CACHE_MESSAGE_PARTS].idx;
 
 		if (mail_cache_field_exists(cache_view, seq,
@@ -1282,9 +1286,9 @@
 	if ((mail->wanted_fields & MAIL_FETCH_IMAP_BODY) != 0 &&
 	    (data->cache_flags & MAIL_CACHE_FLAG_TEXT_PLAIN_7BIT_ASCII) == 0) {
 		/* we need either imap.body or imap.bodystructure */
-		unsigned int cache_field1 =
+		const unsigned int cache_field1 =
 			cache_fields[MAIL_CACHE_IMAP_BODY].idx;
-		unsigned int cache_field2 =
+		const unsigned int cache_field2 =
 			cache_fields[MAIL_CACHE_IMAP_BODYSTRUCTURE].idx;
 
 		if (mail_cache_field_exists(cache_view,
@@ -1299,7 +1303,7 @@
 
 	if ((mail->wanted_fields & MAIL_FETCH_IMAP_BODYSTRUCTURE) != 0 &&
 	    (data->cache_flags & MAIL_CACHE_FLAG_TEXT_PLAIN_7BIT_ASCII) == 0) {
-		unsigned int cache_field =
+		const unsigned int cache_field =
 			cache_fields[MAIL_CACHE_IMAP_BODYSTRUCTURE].idx;
 
                 if (mail_cache_field_exists(cache_view, seq,
@@ -1311,7 +1315,7 @@
 	}
 
 	if ((mail->wanted_fields & MAIL_FETCH_DATE) != 0) {
-		unsigned int cache_field =
+		const unsigned int cache_field =
 			cache_fields[MAIL_CACHE_SENT_DATE].idx;
 
 		if (mail_cache_field_exists(cache_view, seq,
@@ -1369,8 +1373,8 @@
 
 	mail->mail.v.close(_mail);
 
-	i_assert(mail->trans->mail_ref_count > 0);
-	mail->trans->mail_ref_count--;
+	i_assert(_mail->transaction->mail_ref_count > 0);
+	_mail->transaction->mail_ref_count--;
 
 	if (mail->header_data != NULL)
 		buffer_free(&mail->header_data);
@@ -1543,7 +1547,7 @@
 	}
 
 	/* make sure we don't cache invalid values */
-	mail_cache_transaction_reset(imail->trans->cache_trans);
+	mail_cache_transaction_reset(mail->transaction->cache_trans);
 	imail->data.no_caching = TRUE;
 	imail->data.forced_no_caching = TRUE;
 	mail_cache_set_corrupted(mail->box->cache,

--- a/src/lib-storage/index/index-mail.h	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/index-mail.h	Sat Jan 01 15:59:02 2011 +0200
@@ -120,11 +120,10 @@
 	struct index_mailbox_context *ibox;
 
 	pool_t data_pool;
-	struct index_transaction_context *trans;
 	uint32_t uid_validity;
 
 	enum mail_fetch_field wanted_fields;
-	struct index_header_lookup_ctx *wanted_headers;
+	struct mailbox_header_lookup_ctx *wanted_headers;
 
 	int pop3_state;
 

--- a/src/lib-storage/index/index-search.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/index-search.c	Sat Jan 01 15:59:02 2011 +0200
@@ -88,7 +88,7 @@
 static void search_init_arg(struct mail_search_arg *arg,
 			    struct index_search_context *ctx)
 {
-	uint8_t guid[MAIL_GUID_128_SIZE];
+	struct mailbox_metadata metadata;
 	bool match;
 
 	switch (arg->type) {
@@ -105,12 +105,13 @@
 		ctx->have_index_args = TRUE;
 		break;
 	case SEARCH_MAILBOX_GUID:
-		if (mailbox_get_guid(ctx->box, guid) < 0) {
+		if (mailbox_get_metadata(ctx->box, MAILBOX_METADATA_GUID,
+					 &metadata) < 0) {
 			/* result will be unknown */
 			break;
 		}
 
-		match = strcmp(mail_guid_128_to_string(guid),
+		match = strcmp(mail_guid_128_to_string(metadata.guid),
 			       arg->value.str) == 0;
 		if (match != arg->not)
 			arg->match_always = TRUE;
@@ -1079,7 +1080,7 @@
 	if (gettimeofday(&ctx->last_nonblock_timeval, NULL) < 0)
 		i_fatal("gettimeofday() failed: %m");
 
-	mailbox_get_status(t->box, STATUS_MESSAGES, &status);
+	mailbox_get_open_status(t->box, STATUS_MESSAGES, &status);
 	ctx->mail_ctx.progress_max = status.messages;
 
 	i_array_init(&ctx->mail_ctx.results, 5);

--- a/src/lib-storage/index/index-status.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/index-status.c	Sat Jan 01 15:59:02 2011 +0200
@@ -7,9 +7,54 @@
 #include "index-storage.h"
 #include "mail-index-modseq.h"
 
+int index_storage_get_status(struct mailbox *box,
+			     enum mailbox_status_items items,
+			     struct mailbox_status *status_r)
+{
+	const struct mail_index_header *hdr;
+
+	memset(status_r, 0, sizeof(struct mailbox_status));
+
+	if (!box->opened) {
+		if (mailbox_open(box) < 0)
+			return -1;
+		if (mailbox_sync(box, 0) < 0)
+			return -1;
+	}
+
+	/* we can get most of the status items without any trouble */
+	hdr = mail_index_get_header(box->view);
+	status_r->messages = hdr->messages_count;
+	if ((items & STATUS_RECENT) != 0) {
+		status_r->recent = index_mailbox_get_recent_count(box);
+		i_assert(status_r->recent <= status_r->messages);
+	}
+	status_r->unseen = hdr->messages_count - hdr->seen_messages_count;
+	status_r->uidvalidity = hdr->uid_validity;
+	status_r->uidnext = hdr->next_uid;
+	status_r->nonpermanent_modseqs = mail_index_is_in_memory(box->index);
+	if ((items & STATUS_HIGHESTMODSEQ) != 0) {
+		status_r->highest_modseq =
+			mail_index_modseq_get_highest(box->view);
+		if (status_r->highest_modseq == 0) {
+			/* modseqs not enabled yet, but we can't return 0 */
+			status_r->highest_modseq = 1;
+		}
+	}
+
+	if ((items & STATUS_FIRST_UNSEEN_SEQ) != 0) {
+		mail_index_lookup_first(box->view, 0, MAIL_SEEN,
+					&status_r->first_unseen_seq);
+	}
+
+	if ((items & STATUS_KEYWORDS) != 0)
+		status_r->keywords = mail_index_get_keywords(box->index);
+	return 0;
+}
+
 static void
-index_storage_get_status_cache_fields(struct mailbox *box,
-				      struct mailbox_status *status_r)
+get_metadata_cache_fields(struct mailbox *box,
+			  struct mailbox_metadata *metadata_r)
 {
 	const struct mail_cache_field *fields;
 	enum mail_cache_decision_type dec;
@@ -26,12 +71,12 @@
 		if (dec != MAIL_CACHE_DECISION_NO)
 			array_append(cache_fields, &fields[i].name, 1);
 	}
-	status_r->cache_fields = cache_fields;
+	metadata_r->cache_fields = cache_fields;
 }
 
-static void
-index_storage_virtual_size_add_new(struct mailbox *box,
-				   struct index_vsize_header *vsize_hdr)
+static int
+virtual_size_add_new(struct mailbox *box,
+		     struct index_vsize_header *vsize_hdr)
 {
 	struct index_mailbox_context *ibox = INDEX_STORAGE_CONTEXT(box);
 	const struct mail_index_header *hdr;
@@ -94,18 +139,21 @@
 	mail_index_update_header_ext(trans->itrans, ibox->vsize_hdr_ext_id,
 				     0, vsize_hdr, sizeof(*vsize_hdr));
 	(void)mailbox_transaction_commit(&trans);
-
+	return ret;
 }
 
-static void
-index_storage_get_status_virtual_size(struct mailbox *box,
-				      struct mailbox_status *status_r)
+static int
+get_metadata_virtual_size(struct mailbox *box,
+			  struct mailbox_metadata *metadata_r)
 {
 	struct index_mailbox_context *ibox = INDEX_STORAGE_CONTEXT(box);
 	struct index_vsize_header vsize_hdr;
+	struct mailbox_status status;
 	const void *data;
 	size_t size;
+	int ret;
 
+	mailbox_get_open_status(box, STATUS_MESSAGES | STATUS_UIDNEXT, &status);
 	mail_index_get_header_ext(box->view, ibox->vsize_hdr_ext_id,
 				  &data, &size);
 	if (size == sizeof(vsize_hdr))
@@ -119,61 +167,32 @@
 		memset(&vsize_hdr, 0, sizeof(vsize_hdr));
 	}
 
-	if (vsize_hdr.highest_uid + 1 == status_r->uidnext &&
-	    vsize_hdr.message_count == status_r->messages) {
+	if (vsize_hdr.highest_uid + 1 == status.uidnext &&
+	    vsize_hdr.message_count == status.messages) {
 		/* up to date */
-		status_r->virtual_size = vsize_hdr.vsize;
-		return;
+		metadata_r->virtual_size = vsize_hdr.vsize;
+		return 0;
 	}
-	if (vsize_hdr.highest_uid >= status_r->uidnext) {
+	if (vsize_hdr.highest_uid >= status.uidnext) {
 		mail_storage_set_critical(box->storage,
 			"vsize-hdr has invalid highest-uid (%u >= %u)",
-			vsize_hdr.highest_uid, status_r->uidnext);
+			vsize_hdr.highest_uid, status.uidnext);
 		memset(&vsize_hdr, 0, sizeof(vsize_hdr));
 	}
-	index_storage_virtual_size_add_new(box, &vsize_hdr);
-	status_r->virtual_size = vsize_hdr.vsize;
+	ret = virtual_size_add_new(box, &vsize_hdr);
+	metadata_r->virtual_size = vsize_hdr.vsize;
+	return ret;
 }
 
-void index_storage_get_status(struct mailbox *box,
-			      enum mailbox_status_items items,
-			      struct mailbox_status *status_r)
+int index_mailbox_get_metadata(struct mailbox *box,
+			       enum mailbox_metadata_items items,
+			       struct mailbox_metadata *metadata_r)
 {
-	const struct mail_index_header *hdr;
-
-	i_assert(box->opened);
-
-	memset(status_r, 0, sizeof(struct mailbox_status));
-
-	/* we can get most of the status items without any trouble */
-	hdr = mail_index_get_header(box->view);
-	status_r->messages = hdr->messages_count;
-	if ((items & STATUS_RECENT) != 0) {
-		status_r->recent = index_mailbox_get_recent_count(box);
-		i_assert(status_r->recent <= status_r->messages);
+	if ((items & MAILBOX_METADATA_CACHE_FIELDS) != 0)
+		get_metadata_cache_fields(box, metadata_r);
+	if ((items & MAILBOX_METADATA_VIRTUAL_SIZE) != 0) {
+		if (get_metadata_virtual_size(box, metadata_r) < 0)
+			return -1;
 	}
-	status_r->unseen = hdr->messages_count - hdr->seen_messages_count;
-	status_r->uidvalidity = hdr->uid_validity;
-	status_r->uidnext = hdr->next_uid;
-	status_r->nonpermanent_modseqs = mail_index_is_in_memory(box->index);
-	if ((items & STATUS_HIGHESTMODSEQ) != 0) {
-		status_r->highest_modseq =
-			mail_index_modseq_get_highest(box->view);
-		if (status_r->highest_modseq == 0) {
-			/* modseqs not enabled yet, but we can't return 0 */
-			status_r->highest_modseq = 1;
-		}
-	}
-
-	if ((items & STATUS_FIRST_UNSEEN_SEQ) != 0) {
-		mail_index_lookup_first(box->view, 0, MAIL_SEEN,
-					&status_r->first_unseen_seq);
-	}
-
-	if ((items & STATUS_KEYWORDS) != 0)
-		status_r->keywords = mail_index_get_keywords(box->index);
-	if ((items & STATUS_CACHE_FIELDS) != 0)
-		index_storage_get_status_cache_fields(box, status_r);
-	if ((items & STATUS_VIRTUAL_SIZE) != 0)
-		index_storage_get_status_virtual_size(box, status_r);
+	return 0;
 }

--- a/src/lib-storage/index/index-storage.c	Sat Jan 01 14:34:14 2011 +0200
+++ b/src/lib-storage/index/index-storage.c	Sat Jan 01 15:59:02 2011 +0200
@@ -5,7 +5,6 @@
 #include "istream.h"
 #include "ioloop.h"
 #include "str.h"
-#include "imap-parser.h"
 #include "mkdir-parents.h"
 #include "mail-index-alloc-cache.h"
 #include "mail-index-private.h"
@@ -27,22 +26,6 @@
 struct index_storage_module index_storage_module =
 	MODULE_CONTEXT_INIT(&mail_storage_module_register);
 
-static struct mail_index *
-index_storage_alloc(struct mailbox_list *list, const char *name,
-		    enum mailbox_flags flags, const char *prefix)
-{
-	const char *index_dir, *mailbox_path;
-
-	mailbox_path = mailbox_list_get_path(list, name,
-					     MAILBOX_LIST_PATH_TYPE_MAILBOX);
-	index_dir = (flags & MAILBOX_FLAG_NO_INDEX_FILES) != 0 ? "" :
-		mailbox_list_get_path(list, name, MAILBOX_LIST_PATH_TYPE_INDEX);
-	if (*index_dir == '\0')
-		index_dir = NULL;
-
-	return mail_index_alloc_cache_get(mailbox_path, index_dir, prefix);
-}
-
 static void set_cache_decisions(const char *set, const char *fields,
 				enum mail_cache_decision_type dec)
 {
@@ -150,6 +133,23 @@
 	ibox->last_notify_type = MAILBOX_LOCK_NOTIFY_NONE;
 }
 
+static struct mail_index *
+index_mailbox_alloc_index(struct mailbox *box)
+{
+	const char *index_dir, *mailbox_path;
+
+	mailbox_path = mailbox_list_get_path(box->list, box->name,
+					     MAILBOX_LIST_PATH_TYPE_MAILBOX);
+	index_dir = (box->flags & MAILBOX_FLAG_NO_INDEX_FILES) != 0 ? "" :
+		mailbox_list_get_path(box->list, box->name,
+				      MAILBOX_LIST_PATH_TYPE_INDEX);
+	if (*index_dir == '\0')
+		index_dir = NULL;
+
+	return mail_index_alloc_cache_get(mailbox_path, index_dir,
+					  box->index_prefix);
+}
+
 int index_storage_mailbox_open(struct mailbox *box, bool move_to_memory)
 {
 	struct index_mailbox_context *ibox = INDEX_STORAGE_CONTEXT(box);
@@ -162,19 +162,21 @@
 	if (move_to_memory)
 		ibox->index_flags &= ~MAIL_INDEX_OPEN_FLAG_CREATE;
 
-	if ((index_flags & MAIL_INDEX_OPEN_FLAG_NEVER_IN_MEMORY) != 0) {
-		if (mail_index_is_in_memory(box->index)) {
-			mail_storage_set_critical(box->storage,
-				"Couldn't create index file");
-			return -1;
-		}
-	}
-
 	if (mailbox_list_create_missing_index_dir(box->list, box->name) < 0) {
 		mail_storage_set_internal_error(box->storage);
 		return -1;
 	}
 
+	box->index = index_mailbox_alloc_index(box);
+	mail_index_set_fsync_mode(box->index,
+				  box->storage->set->parsed_fsync_mode, 0);
+	mail_index_set_lock_method(box->index,
+		box->storage->set->parsed_lock_method,
+		mail_storage_get_lock_timeout(box->storage, -1U));
+
+	/* make sure mail_index_set_permissions() has been called */
+	(void)mailbox_get_permissions(box);
+
 	ret = mail_index_open(box->index, index_flags);
 	if (ret <= 0 || move_to_memory) {
 		if ((index_flags & MAIL_INDEX_OPEN_FLAG_NEVER_IN_MEMORY) != 0) {
@@ -191,6 +193,13 @@
 				i_panic("in-memory index creation failed");
 		}
 	}
+	if ((index_flags & MAIL_INDEX_OPEN_FLAG_NEVER_IN_MEMORY) != 0) {
+		if (mail_index_is_in_memory(box->index)) {
+			mail_storage_set_critical(box->storage,
+				"Couldn't create index file");
+			return -1;
+		}
+	}
 
 	box->cache = mail_index_get_cache(box->index);
 	index_cache_register_defaults(box);
@@ -221,7 +230,6 @@
 				 const char *index_prefix)
 {
 	struct index_mailbox_context *ibox;
-	const char *path;
 	string_t *vname;
 
 	i_assert(name != NULL);
@@ -230,7 +238,9 @@
 	vname = t_str_new(128);
 	mail_namespace_get_vname(box->list->ns, vname, name);
 	box->vname = p_strdup(box->pool, str_c(vname));
+
 	box->flags = flags;
+	box->index_prefix = p_strdup(box->pool, index_prefix);
 
 	p_array_init(&box->search_results, box->pool, 16);
 	array_create(&box->module_contexts,
@@ -242,24 +252,10 @@
 	ibox->next_lock_notify = time(NULL) + LOCK_NOTIFY_INTERVAL;
 	MODULE_CONTEXT_SET(box, index_storage_module, ibox);
 
-	path = mailbox_list_get_path(box->list, name,
-				     MAILBOX_LIST_PATH_TYPE_MAILBOX);
-	box->path = p_strdup(box->pool, path);
-	box->index = index_storage_alloc(box->list, name, flags, index_prefix);
 	box->inbox_user = strcmp(name, "INBOX") == 0 &&
 		(box->list->ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0;
 	box->inbox_any = strcmp(name, "INBOX") == 0 &&
 		(box->list->ns->flags & NAMESPACE_FLAG_INBOX_ANY) != 0;
-	if (box->file_create_mode == 0)
-		mailbox_refresh_permissions(box);
-	mail_index_set_permissions(box->index, box->file_create_mode,
-				   box->file_create_gid,
-				   box->file_create_gid_origin);
-	mail_index_set_fsync_mode(box->index,
-				  box->storage->set->parsed_fsync_mode, 0);
-	mail_index_set_lock_method(box->index,
-		box->storage->set->parsed_lock_method,
-		mail_storage_get_lock_timeout(box->storage, -1U));
 }
 
 int index_storage_mailbox_enable(struct mailbox *box,
@@ -301,7 +297,8 @@
 
 void index_storage_mailbox_free(struct mailbox *box)
 {
-	mail_index_alloc_cache_unref(&box->index);
+	if (box->index != NULL)
+		mail_index_alloc_cache_unref(&box->index);
 }
 
 void index_storage_mailbox_update_cache_fields(struct mailbox *box,
@@ -426,7 +423,7 @@
 
 int index_storage_mailbox_delete(struct mailbox *box)
 {
-	uint8_t mailbox_guid[MAIL_GUID_128_SIZE];
+	struct mailbox_metadata metadata;
 
 	if (!box->opened) {
 		/* \noselect mailbox, try deleting only the directory */
@@ -436,7 +433,7 @@
 	if (mailbox_mark_index_deleted(box, TRUE) < 0)
 		return -1;
 
-	if (mailbox_get_guid(box, mailbox_guid) < 0)
+	if (mailbox_get_metadata(box, MAILBOX_METADATA_GUID, &metadata) < 0)
 		return -1;
 
 	/* Make sure the indexes are closed before trying to delete the
@@ -452,7 +449,7 @@
 	} 
 
 	mailbox_list_add_change(box->list, MAILBOX_LOG_RECORD_DELETE_MAILBOX,
-				mailbox_guid);
+				metadata.guid);
 	return index_storage_mailbox_delete_dir(box, TRUE);
 }
 
@@ -477,16 +474,7 @@
 
 bool index_storage_is_readonly(struct mailbox *box)
 {
-	if ((box->flags & MAILBOX_FLAG_READONLY) != 0)
-		return TRUE;
-
-	if (box->backend_readonly) {
-		/* return read-only only if there are no private flags
-		   (that are stored in index files) */
-		if (box->private_flags_mask == 0)
-			return TRUE;
-	}
-	return FALSE;
+	return (box->flags & MAILBOX_FLAG_READONLY) != 0;
 }
 
 bool index_storage_allow_new_keywords(struct mailbox *box)
@@ -500,99 +488,6 @@
 	return mail_index_view_is_inconsistent(box->view);
 }
 
-bool index_keyword_is_valid(struct mailbox *box, const char *keyword,
-			    const char **error_r)
-{
-	unsigned int i, idx;
-
-	/* if it already exists, skip validity checks */
-	if (mail_index_keyword_lookup(box->index, keyword, &idx))
-		return TRUE;
-
-	if (*keyword == '\0') {
-		*error_r = "Empty keywords not allowed";
-		return FALSE;
-	}
-
-	/* these are IMAP-specific restrictions, but for now IMAP is all we
-	   care about */
-	for (i = 0; keyword[i] != '\0'; i++) {
-		if (IS_ATOM_SPECIAL((unsigned char)keyword[i])) {
-			*error_r = "Invalid characters in keyword";
-			return FALSE;
-		}
-		if ((unsigned char)keyword[i] >= 0x80) {
-			*error_r = "8bit characters in keyword";
-			return FALSE;
-		}
-	}
-	if (i > box->storage->set->mail_max_keyword_length) {
-		*error_r = "Keyword length too long";
-		return FALSE;
-	}
-	return TRUE;
-}
-
-static struct mail_keywords *
-index_keywords_create_skip(struct mailbox *box,
-			   const char *const keywords[])
-{
-	ARRAY_DEFINE(valid_keywords, const char *);
-	const char *error;
-
-	t_array_init(&valid_keywords, 32);
-	for (; *keywords != NULL; keywords++) {
-		if (mailbox_keyword_is_valid(box, *keywords, &error))
-			array_append(&valid_keywords, keywords, 1);
-	}
-	(void)array_append_space(&valid_keywords); /* NULL-terminate */
-	return mail_index_keywords_create(box->index, keywords);
-}
-
-int index_keywords_create(struct mailbox *box, const char *const keywords[],
-			  struct mail_keywords **keywords_r, bool skip_invalid)
-{
-	const char *error;
-	unsigned int i;
-
-	for (i = 0; keywords[i] != NULL; i++) {
-		if (mailbox_keyword_is_valid(box, keywords[i], &error))
-			continue;
-
-		if (!skip_invalid) {
-			mail_storage_set_error(box->storage,
-					       MAIL_ERROR_PARAMS, error);
-			return -1;
-		}
-
-		/* found invalid keywords, do this the slow way */
-		T_BEGIN {
-			*keywords_r = index_keywords_create_skip(box, keywords);
-		} T_END;
-		return 0;
-	}
-
-	*keywords_r = mail_index_keywords_create(box->index, keywords);
-	return 0;
-}
-
-struct mail_keywords *
-index_keywords_create_from_indexes(struct mailbox *_box,
-				   const ARRAY_TYPE(keyword_indexes) *idx)
-{
-	return mail_index_keywords_create_from_indexes(_box->index, idx);
-}
-
-void index_keywords_ref(struct mail_keywords *keywords)
-{
-	mail_index_keywords_ref(keywords);
-}
-
-void index_keywords_unref(struct mail_keywords *keywords)
-{
-	mail_index_keywords_unref(&keywords);
-}
-
 void index_save_context_free(struct mail_save_context *ctx)
 {
 	i_free_and_null(ctx->from_envelope);
@@ -606,10 +501,6 @@
 		      uint32_t dest_seq, const char *name, buffer_t *buf)
 {
 	struct mailbox_transaction_context *dest_trans = ctx->transaction;
-	struct index_transaction_context *dest_itrans =
-		(struct index_transaction_context *)dest_trans;
-	struct index_transaction_context *src_itrans =
-		(struct index_transaction_context *)src_mail->transaction;
 	const struct mail_cache_field *dest_field;
 	unsigned int src_field_idx, dest_field_idx;
 
@@ -630,9 +521,9 @@
 	}
 
 	buffer_set_used_size(buf, 0);
-	if (mail_cache_lookup_field(src_itrans->cache_view, buf,
+	if (mail_cache_lookup_field(src_mail->transaction->cache_view, buf,
 				    src_mail->seq, src_field_idx) > 0) {
-		mail_cache_add(dest_itrans->cache_trans, dest_seq,
+		mail_cache_add(dest_trans->cache_trans, dest_seq,
 			       dest_field_idx, buf->data, buf->used);
 	}
 }
@@ -641,15 +532,17 @@
 			     struct mail *src_mail, uint32_t dest_seq)
 {
 	T_BEGIN {
-		struct mailbox_status src_status;
+		struct mailbox_metadata src_metadata;
 		const char *const *namep;
 		buffer_t *buf;
 
-		index_storage_get_status(src_mail->box, STATUS_CACHE_FIELDS,
-					 &src_status);
+		if (mailbox_get_metadata(src_mail->box,
+					 MAILBOX_METADATA_CACHE_FIELDS,
+					 &src_metadata) < 0)
+			i_unreached();
 
 		buf = buffer_create_dynamic(pool_datastack_create(), 1024);
-		array_foreach(src_status.cache_fields, namep) {
+		array_foreach(src_metadata.cache_fields, namep) {
 			mail_copy_cache_field(ctx, src_mail, dest_seq,
 					      *namep, buf);
 		}