static int
mbox_mailbox_get_guid(struct mailbox *box, uint8_t guid[MAIL_GUID_128_SIZE])
{
struct mbox_mailbox *mbox = (struct mbox_mailbox *)box;
if (mail_index_is_in_memory(box->index)) {
mail_storage_set_error(box->storage, MAIL_ERROR_NOTPOSSIBLE,
"Mailbox GUIDs are not permanent without index files");
return -1;
}
if (mail_guid_128_is_empty(mbox->mbox_hdr.mailbox_guid)) {
if (mailbox_sync(&mbox->box, 0) < 0)
return -1;
}
memcpy(guid, mbox->mbox_hdr.mailbox_guid, MAIL_GUID_128_SIZE);
return 0;
}
static int
mbox_mailbox_get_guid(struct mbox_mailbox *mbox, guid_128_t guid_r)
{
const char *errstr;
if (mail_index_is_in_memory(mbox->box.index)) {
errstr = "Mailbox GUIDs are not permanent without index files";
if (mbox->storage->set->mbox_min_index_size != 0) {
errstr = t_strconcat(errstr,
" (mbox_min_index_size is non-zero)", NULL);
}
mail_storage_set_error(mbox->box.storage,
MAIL_ERROR_NOTPOSSIBLE, errstr);
return -1;
}
if (mbox_sync_header_refresh(mbox) < 0)
return -1;
if (!guid_128_is_empty(mbox->mbox_hdr.mailbox_guid)) {
/* we have the GUID */
} else if (mbox_file_open(mbox) < 0)
return -1;
else if (mbox->backend_readonly) {
mail_storage_set_error(mbox->box.storage, MAIL_ERROR_PERM,
"Can't set mailbox GUID to a read-only mailbox");
return -1;
} else {
/* create another mailbox and sync */
struct mailbox *box2;
struct mbox_mailbox *mbox2;
int ret;
i_assert(mbox->mbox_lock_type == F_UNLCK);
box2 = mailbox_alloc(mbox->box.list, mbox->box.vname, 0);
ret = mailbox_sync(box2, 0);
mbox2 = (struct mbox_mailbox *)box2;
memcpy(guid_r, mbox2->mbox_hdr.mailbox_guid, GUID_128_SIZE);
mailbox_free(&box2);
return ret;
}
memcpy(guid_r, mbox->mbox_hdr.mailbox_guid, GUID_128_SIZE);
return 0;
}
void index_storage_get_status(struct mailbox *box,
enum mailbox_status_items items,
struct mailbox_status *status_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);
}
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);
}
void index_storage_get_open_status(struct mailbox *box,
enum mailbox_status_items items,
struct mailbox_status *status_r)
{
const struct mail_index_header *hdr;
/* 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) {
if ((box->flags & MAILBOX_FLAG_DROP_RECENT) != 0) {
/* recent flags are set and dropped by the previous
sync while index was locked. if we updated the
recent flags here we'd have a race condition. */
i_assert(box->synced);
} else {
/* make sure recent count is set, in case we haven't
synced yet */
index_sync_update_recent_count(box);
}
status_r->recent = index_mailbox_get_recent_count(box);
i_assert(status_r->recent <= status_r->messages);
}
if ((items & STATUS_UNSEEN) != 0) {
if (box->view_pvt == NULL ||
(mailbox_get_private_flags_mask(box) & MAIL_SEEN) == 0) {
status_r->unseen = hdr->messages_count -
hdr->seen_messages_count;
} else {
status_r->unseen = index_storage_count_pvt_unseen(box);
}
}
status_r->uidvalidity = hdr->uid_validity;
status_r->uidnext = hdr->next_uid;
status_r->first_recent_uid = hdr->first_recent_uid;
if ((items & STATUS_HIGHESTMODSEQ) != 0) {
status_r->nonpermanent_modseqs =
mail_index_is_in_memory(box->index);
status_r->no_modseq_tracking =
!mail_index_have_modseq_tracking(box->index);
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_HIGHESTPVTMODSEQ) != 0 && box->view_pvt != NULL) {
status_r->highest_pvt_modseq =
mail_index_modseq_get_highest(box->view_pvt);
if (status_r->highest_pvt_modseq == 0) {
/* modseqs not enabled yet, but we can't return 0 */
status_r->highest_pvt_modseq = 1;
}
}
if ((items & STATUS_FIRST_UNSEEN_SEQ) != 0) {
if (box->view_pvt == NULL ||
(mailbox_get_private_flags_mask(box) & MAIL_SEEN) == 0) {
mail_index_lookup_first(box->view, 0, MAIL_SEEN,
&status_r->first_unseen_seq);
} else {
status_r->first_unseen_seq =
index_storage_find_first_pvt_unseen_seq(box);
}
}
if ((items & STATUS_LAST_CACHED_SEQ) != 0)
get_last_cached_seq(box, &status_r->last_cached_seq);
if ((items & STATUS_KEYWORDS) != 0)
status_r->keywords = mail_index_get_keywords(box->index);
if ((items & STATUS_PERMANENT_FLAGS) != 0) {
if (!mailbox_is_readonly(box)) {
status_r->permanent_flags = MAIL_FLAGS_NONRECENT;
status_r->permanent_keywords = TRUE;
status_r->allow_new_keywords =
!box->disallow_new_keywords;
}
}
}
int index_storage_mailbox_open(struct mailbox *box, bool move_to_memory)
{
struct index_mailbox_context *ibox = INDEX_STORAGE_CONTEXT(box);
enum mail_index_open_flags index_flags;
int ret;
i_assert(!box->opened);
index_flags = ibox->index_flags;
if (move_to_memory)
ibox->index_flags &= ~MAIL_INDEX_OPEN_FLAG_CREATE;
if (index_storage_mailbox_alloc_index(box) < 0)
return -1;
/* 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) {
i_assert(ret <= 0);
mailbox_set_index_error(box);
return -1;
}
if (mail_index_move_to_memory(box->index) < 0) {
/* try opening once more. it should be created
directly into memory now. */
if (mail_index_open_or_create(box->index,
index_flags) < 0)
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");
mail_index_close(box->index);
return -1;
}
}
if ((box->flags & MAILBOX_FLAG_OPEN_DELETED) == 0) {
if (mail_index_is_deleted(box->index)) {
mailbox_set_deleted(box);
mail_index_close(box->index);
return -1;
}
}
box->cache = mail_index_get_cache(box->index);
index_cache_register_defaults(box);
box->view = mail_index_view_open(box->index);
ibox->keyword_names = mail_index_get_keywords(box->index);
ibox->vsize_hdr_ext_id =
mail_index_ext_register(box->index, "hdr-vsize",
sizeof(struct index_vsize_header), 0,
sizeof(uint64_t));
box->opened = TRUE;
if ((box->enabled_features & MAILBOX_FEATURE_CONDSTORE) != 0)
mail_index_modseq_enable(box->index);
index_thread_mailbox_opened(box);
hook_mailbox_opened(box);
return 0;
}
