static int
index_storage_mailbox_update_pvt(struct mailbox *box,
const struct mailbox_update *update)
{
struct mail_index_transaction *trans;
struct mail_index_view *view;
int ret;
if ((ret = mailbox_open_index_pvt(box)) <= 0)
return ret;
mail_index_refresh(box->index_pvt);
view = mail_index_view_open(box->index_pvt);
trans = mail_index_transaction_begin(view,
MAIL_INDEX_TRANSACTION_FLAG_EXTERNAL);
if (update->min_highest_modseq != 0 &&
mail_index_modseq_get_highest(view) < update->min_highest_pvt_modseq) {
mail_index_modseq_enable(box->index_pvt);
mail_index_update_highest_modseq(trans,
update->min_highest_pvt_modseq);
}
if ((ret = mail_index_transaction_commit(&trans)) < 0)
mailbox_set_index_error(box);
mail_index_view_close(&view);
return ret;
}
static int
maildir_mail_get_fname(struct maildir_mailbox *mbox, struct mail *mail,
const char **fname_r)
{
enum maildir_uidlist_rec_flag flags;
struct mail_index_view *view;
uint32_t seq;
bool exists;
int ret;
ret = maildir_sync_lookup(mbox, mail->uid, &flags, fname_r);
if (ret != 0)
return ret;
/* file exists in index file, but not in dovecot-uidlist anymore. */
mail_set_expunged(mail);
/* one reason this could happen is if we delayed opening
dovecot-uidlist and we're trying to open a mail that got recently
expunged. Let's test this theory first: */
mail_index_refresh(mbox->box.index);
view = mail_index_view_open(mbox->box.index);
exists = mail_index_lookup_seq(view, mail->uid, &seq);
mail_index_view_close(&view);
if (exists) {
/* the message still exists in index. this means there's some
kind of a desync, which doesn't get fixed if cur/ mtime is
the same as in index. fix this by forcing a resync. */
(void)maildir_storage_sync_force(mbox, mail->uid);
}
return 0;
}
int mailbox_list_index_refresh(struct mailbox_list *list)
{
struct mailbox_list_index *ilist = INDEX_LIST_CONTEXT(list);
struct mail_index_view *view;
int ret;
if (ilist->syncing)
return 0;
if (mailbox_list_index_index_open(list) < 0)
return -1;
if (mail_index_refresh(ilist->index) < 0) {
mailbox_list_index_set_index_error(list);
return -1;
}
view = mail_index_view_open(ilist->index);
if (ilist->mailbox_tree == NULL ||
mailbox_list_index_need_refresh(ilist, view)) {
/* refresh list of mailboxes */
ret = mailbox_list_index_sync(list);
} else {
ret = mailbox_list_index_parse(list, view, FALSE);
}
mail_index_view_close(&view);
return ret;
}
void index_transaction_init(struct mailbox_transaction_context *t,
struct mailbox *box,
enum mailbox_transaction_flags flags)
{
enum mail_index_transaction_flags itrans_flags;
i_assert(box->opened);
itrans_flags = index_transaction_flags_get(flags);
if ((flags & MAILBOX_TRANSACTION_FLAG_REFRESH) != 0)
mail_index_refresh(box->index);
t->box = box;
t->itrans = mail_index_transaction_begin(box->view, itrans_flags);
t->view = mail_index_transaction_open_updated_view(t->itrans);
array_create(&t->module_contexts, default_pool,
sizeof(void *), 5);
t->cache_view = mail_cache_view_open(box->cache, t->view);
t->cache_trans = mail_cache_get_transaction(t->cache_view, t->itrans);
if ((flags & MAILBOX_TRANSACTION_FLAG_NO_CACHE_DEC) != 0)
mail_cache_view_update_cache_decisions(t->cache_view, FALSE);
/* set up after mail_cache_get_transaction(), so that we'll still
have the cache_trans available in _index_commit() */
t->super = t->itrans->v;
t->itrans->v.commit = index_transaction_index_commit;
t->itrans->v.rollback = index_transaction_index_rollback;
MODULE_CONTEXT_SET(t->itrans, mail_storage_mail_index_module, t);
}
int index_storage_mailbox_update(struct mailbox *box,
const struct mailbox_update *update)
{
const struct mail_index_header *hdr;
struct mail_index_view *view;
struct mail_index_transaction *trans;
int ret;
if (mailbox_open(box) < 0)
return -1;
/* make sure we get the latest index info */
mail_index_refresh(box->index);
view = mail_index_view_open(box->index);
hdr = mail_index_get_header(view);
trans = mail_index_transaction_begin(view,
MAIL_INDEX_TRANSACTION_FLAG_EXTERNAL);
if (update->uid_validity != 0 &&
hdr->uid_validity != update->uid_validity) {
uint32_t uid_validity = update->uid_validity;
if (hdr->uid_validity != 0) {
/* UIDVALIDITY change requires index to be reset */
mail_index_reset(trans);
}
mail_index_update_header(trans,
offsetof(struct mail_index_header, uid_validity),
&uid_validity, sizeof(uid_validity), TRUE);
}
int mdbox_map_refresh(struct mdbox_map *map)
{
struct mail_index_view_sync_ctx *ctx;
bool delayed_expunges, fscked;
int ret = 0;
/* some open files may have read partially written mails. now that
map syncing makes the new mails visible, we need to make sure the
partial data is flushed out of memory */
mdbox_files_sync_input(map->storage);
if (mail_index_refresh(map->view->index) < 0) {
mail_storage_set_internal_error(MAP_STORAGE(map));
mail_index_reset_error(map->index);
return -1;
}
if (mail_index_view_get_transaction_count(map->view) > 0) {
/* can't sync when there are transactions */
return 0;
}
ctx = mail_index_view_sync_begin(map->view,
MAIL_INDEX_VIEW_SYNC_FLAG_FIX_INCONSISTENT);
fscked = mail_index_reset_fscked(map->view->index);
if (mail_index_view_sync_commit(&ctx, &delayed_expunges) < 0) {
mail_storage_set_internal_error(MAP_STORAGE(map));
mail_index_reset_error(map->index);
ret = -1;
}
if (fscked)
mdbox_storage_set_corrupted(map->storage);
return ret;
}
void index_transaction_init(struct index_transaction_context *it,
struct mailbox *box,
enum mailbox_transaction_flags flags)
{
struct mailbox_transaction_context *t = &it->mailbox_ctx;
enum mail_index_transaction_flags trans_flags;
i_assert(box->opened);
trans_flags = MAIL_INDEX_TRANSACTION_FLAG_AVOID_FLAG_UPDATES;
if ((flags & MAILBOX_TRANSACTION_FLAG_HIDE) != 0)
trans_flags |= MAIL_INDEX_TRANSACTION_FLAG_HIDE;
if ((flags & MAILBOX_TRANSACTION_FLAG_EXTERNAL) != 0)
trans_flags |= MAIL_INDEX_TRANSACTION_FLAG_EXTERNAL;
if ((flags & MAILBOX_TRANSACTION_FLAG_REFRESH) != 0)
(void)mail_index_refresh(box->index);
t->box = box;
t->itrans = mail_index_transaction_begin(box->view, trans_flags);
t->view = mail_index_transaction_open_updated_view(t->itrans);
array_create(&t->module_contexts, default_pool,
sizeof(void *), 5);
it->cache_view = mail_cache_view_open(box->cache, t->view);
it->cache_trans = mail_cache_get_transaction(it->cache_view, t->itrans);
/* set up after mail_cache_get_transaction(), so that we'll still
have the cache_trans available in _index_commit() */
it->super = t->itrans->v;
t->itrans->v.commit = index_transaction_index_commit;
t->itrans->v.rollback = index_transaction_index_rollback;
MODULE_CONTEXT_SET(t->itrans, mail_storage_mail_index_module, it);
}
struct mailbox_sync_context *
index_mailbox_sync_init(struct mailbox *box, enum mailbox_sync_flags flags,
bool failed)
{
struct index_mailbox_sync_context *ctx;
struct index_mailbox_sync_pvt_context *pvt_ctx;
enum mail_index_view_sync_flags sync_flags = 0;
ctx = i_new(struct index_mailbox_sync_context, 1);
ctx->ctx.box = box;
ctx->ctx.flags = flags;
if (failed) {
ctx->failed = TRUE;
return &ctx->ctx;
}
if ((flags & MAILBOX_SYNC_FLAG_NO_EXPUNGES) != 0)
sync_flags |= MAIL_INDEX_VIEW_SYNC_FLAG_NOEXPUNGES;
if ((flags & MAILBOX_SYNC_FLAG_FIX_INCONSISTENT) != 0) {
sync_flags |= MAIL_INDEX_VIEW_SYNC_FLAG_FIX_INCONSISTENT;
ctx->messages_count = 0;
} else {
ctx->messages_count =
mail_index_view_get_messages_count(box->view);
}
if ((flags & MAILBOX_SYNC_FLAG_FAST) != 0) {
/* we most likely did a fast sync. refresh the index anyway in
case there were some new changes. */
(void)mail_index_refresh(box->index);
}
ctx->sync_ctx = mail_index_view_sync_begin(box->view, sync_flags);
if ((flags & MAILBOX_SYNC_FLAG_NO_EXPUNGES) == 0) {
mail_index_view_sync_get_expunges(ctx->sync_ctx,
&ctx->expunges);
ctx->expunge_pos = array_count(ctx->expunges);
}
index_view_sync_recs_get(ctx);
index_sync_search_results_expunge(ctx);
/* sync private index if needed. it doesn't use box->view, so it
doesn't matter if it's called at _sync_init() or _sync_deinit().
however we also need to know if any private flags have changed
since last sync, so we need to call it before _sync_next() calls. */
if (index_mailbox_sync_pvt_init(box, FALSE, &pvt_ctx) > 0) {
(void)index_mailbox_sync_pvt_view(pvt_ctx, &ctx->flag_updates,
&ctx->hidden_updates);
index_mailbox_sync_pvt_deinit(&pvt_ctx);
}
index_view_sync_cleanup_updates(ctx);
return &ctx->ctx;
}
static void dbox_mail_set_expunged(struct dbox_mail *mail, uint32_t map_uid)
{
struct mail *_mail = &mail->imail.mail.mail;
struct mdbox_mailbox *mbox = (struct mdbox_mailbox *)_mail->box;
(void)mail_index_refresh(_mail->box->index);
if (mail_index_is_expunged(_mail->transaction->view, _mail->seq)) {
mail_set_expunged(_mail);
return;
}
mdbox_map_set_corrupted(mbox->storage->map,
"Unexpectedly lost %s uid=%u map_uid=%u",
mailbox_get_vname(_mail->box),
_mail->uid, map_uid);
}
static void mbox_save_init_sync(struct mailbox_transaction_context *t)
{
struct mbox_mailbox *mbox = (struct mbox_mailbox *)t->box;
struct mbox_save_context *ctx = (struct mbox_save_context *)t->save_ctx;
const struct mail_index_header *hdr;
struct mail_index_view *view;
/* open a new view to get the header. this is required if we just
synced the mailbox so we can get updated next_uid. */
(void)mail_index_refresh(mbox->box.index);
view = mail_index_view_open(mbox->box.index);
hdr = mail_index_get_header(view);
ctx->next_uid = hdr->next_uid;
ctx->uid_validity = hdr->uid_validity;
ctx->synced = TRUE;
mail_index_view_close(&view);
}
void index_pop3_uidl_update_exists_finish(struct mailbox_transaction_context *trans)
{
struct mail_index_view *view;
struct mailbox_index_pop3_uidl uidl;
const void *data;
size_t size;
bool seen_all_msgs;
if (trans->highest_pop3_uidl_uid == 0)
return;
/* First check that we actually looked at UIDL for all messages.
Otherwise we can't say for sure if the newest messages had UIDLs. */
if (trans->prev_pop3_uidl_tracking_seq !=
mail_index_view_get_messages_count(trans->view))
return;
/* Just to be sure: Refresh the index and check again. POP3 keeps
transactions open for duration of the entire session. Maybe another
process already added new mails (and already updated this header).
This check is racy, but normally UIDLs aren't added after migration
so it's a bit questionable if it's even worth having this check in
there. */
view = mail_index_view_open(trans->box->index);
seen_all_msgs = mail_index_refresh(trans->box->index) == 0 &&
trans->prev_pop3_uidl_tracking_seq ==
mail_index_view_get_messages_count(view);
mail_index_view_close(&view);
if (!seen_all_msgs)
return;
/* check if we have already the same header */
mail_index_get_header_ext(trans->view, trans->box->pop3_uidl_hdr_ext_id,
&data, &size);
if (size >= sizeof(uidl)) {
memcpy(&uidl, data, size);
if (trans->highest_pop3_uidl_uid == uidl.max_uid_with_pop3_uidl)
return;
}
index_pop3_uidl_set_max_uid(trans->box, trans->itrans,
trans->highest_pop3_uidl_uid);
}
static uint32_t get_next_file_seq(struct mail_cache *cache)
{
const struct mail_index_ext *ext;
struct mail_index_view *view;
uint32_t file_seq;
/* make sure we look up the latest reset_id */
if (mail_index_refresh(cache->index) < 0)
return -1;
view = mail_index_view_open(cache->index);
ext = mail_index_view_get_ext(view, cache->ext_id);
file_seq = ext != NULL ? ext->reset_id + 1 : (uint32_t)ioloop_time;
if (cache->hdr != NULL && file_seq <= cache->hdr->file_seq)
file_seq = cache->hdr->file_seq + 1;
mail_index_view_close(&view);
return file_seq != 0 ? file_seq : 1;
}
static int mbox_mail_seek(struct index_mail *mail)
{
struct mbox_transaction_context *t =
(struct mbox_transaction_context *)mail->mail.mail.transaction;
struct mail *_mail = &mail->mail.mail;
struct mbox_mailbox *mbox = (struct mbox_mailbox *)_mail->box;
enum mbox_sync_flags sync_flags = 0;
int ret, try;
bool deleted;
if (_mail->expunged || mbox->syncing)
return -1;
if (_mail->lookup_abort != MAIL_LOOKUP_ABORT_NEVER) {
mail_set_aborted(_mail);
return -1;
}
if (mbox->mbox_stream != NULL &&
istream_raw_mbox_is_corrupted(mbox->mbox_stream)) {
/* clear the corruption by forcing a full resync */
sync_flags |= MBOX_SYNC_UNDIRTY | MBOX_SYNC_FORCE_SYNC;
}
for (try = 0; try < 2; try++) {
if ((sync_flags & MBOX_SYNC_FORCE_SYNC) != 0) {
/* dirty offsets are broken. make sure we can sync. */
mbox_prepare_resync(_mail);
}
if (mbox->mbox_lock_type == F_UNLCK) {
i_assert(t->read_lock_id == 0);
sync_flags |= MBOX_SYNC_LOCK_READING;
if (mbox_sync(mbox, sync_flags) < 0)
return -1;
t->read_lock_id = mbox_get_cur_lock_id(mbox);
i_assert(t->read_lock_id != 0);
/* refresh index file after mbox has been locked to
make sure we get only up-to-date mbox offsets. */
if (mail_index_refresh(mbox->box.index) < 0) {
mailbox_set_index_error(&mbox->box);
return -1;
}
i_assert(mbox->mbox_lock_type != F_UNLCK);
} else if (t->read_lock_id == 0) {
/* file is already locked by another transaction, but
we must keep it locked for the entire transaction,
so increase the lock counter. */
if (mbox_lock(mbox, mbox->mbox_lock_type,
&t->read_lock_id) < 0)
i_unreached();
}
if (mbox_file_open_stream(mbox) < 0)
return -1;
ret = mbox_file_seek(mbox, _mail->transaction->view,
_mail->seq, &deleted);
if (ret > 0) {
/* success */
break;
}
if (ret < 0) {
if (deleted)
mail_set_expunged(_mail);
return -1;
}
/* we'll need to re-sync it completely */
sync_flags |= MBOX_SYNC_UNDIRTY | MBOX_SYNC_FORCE_SYNC;
}
if (ret == 0) {
mail_storage_set_critical(&mbox->storage->storage,
"Losing sync for mail uid=%u in mbox file %s",
_mail->uid, mailbox_get_path(&mbox->box));
}
return 0;
}
static int mbox_mail_get_received_date(struct mail *_mail, time_t *date_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
struct index_mail_data *data = &mail->data;
struct mbox_mailbox *mbox = (struct mbox_mailbox *)_mail->box;
if (index_mail_get_received_date(_mail, date_r) == 0)
return 0;
if (mbox_mail_seek(mail) < 0)
return -1;
data->received_date =
istream_raw_mbox_get_received_time(mbox->mbox_stream);
if (data->received_date == (time_t)-1) {
/* it's broken and conflicts with our "not found"
return value. change it. */
data->received_date = 0;
}
*date_r = data->received_date;
return 0;
}
static int mbox_mail_get_save_date(struct mail *_mail, time_t *date_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
struct index_mail_data *data = &mail->data;
if (index_mail_get_save_date(_mail, date_r) == 0)
return 0;
/* no way to know this. save the current time into cache and use
that from now on. this works only as long as the index files
are permanent */
data->save_date = ioloop_time;
*date_r = data->save_date;
return 0;
}
static int
mbox_mail_get_md5_header(struct index_mail *mail, const char **value_r)
{
struct mail *_mail = &mail->mail.mail;
static uint8_t empty_md5[16] =
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
struct mbox_mailbox *mbox = (struct mbox_mailbox *)_mail->box;
const void *ext_data;
if (mail->data.guid != NULL) {
*value_r = mail->data.guid;
return 1;
}
mail_index_lookup_ext(_mail->transaction->view, _mail->seq,
mbox->md5hdr_ext_idx, &ext_data, NULL);
if (ext_data != NULL && memcmp(ext_data, empty_md5, 16) != 0) {
mail->data.guid = p_strdup(mail->mail.data_pool,
binary_to_hex(ext_data, 16));
*value_r = mail->data.guid;
return 1;
} else if (mail_index_is_expunged(_mail->transaction->view, _mail->seq)) {
mail_set_expunged(_mail);
return -1;
} else {
return 0;
}
}
static int
mbox_mail_get_special(struct mail *_mail, enum mail_fetch_field field,
const char **value_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
struct mbox_mailbox *mbox = (struct mbox_mailbox *)_mail->box;
uoff_t offset;
bool move_offset;
int ret;
switch (field) {
case MAIL_FETCH_FROM_ENVELOPE:
if (mbox_mail_seek(mail) < 0)
return -1;
*value_r = istream_raw_mbox_get_sender(mbox->mbox_stream);
return 0;
case MAIL_FETCH_GUID:
case MAIL_FETCH_HEADER_MD5:
if ((ret = mbox_mail_get_md5_header(mail, value_r)) != 0)
return ret < 0 ? -1 : 0;
/* i guess in theory the empty_md5 is valid and can happen,
but it's almost guaranteed that it means the MD5 sum is
missing. recalculate it. */
if (mbox->mbox_lock_type == F_UNLCK ||
mbox->mbox_stream == NULL) {
offset = 0;
move_offset = FALSE;
} else {
offset = istream_raw_mbox_get_start_offset(mbox->mbox_stream);
move_offset = TRUE;
}
mbox->mbox_save_md5 = TRUE;
if (mbox_sync(mbox, MBOX_SYNC_FORCE_SYNC |
MBOX_SYNC_READONLY) < 0)
return -1;
if (move_offset) {
if (istream_raw_mbox_seek(mbox->mbox_stream,
offset) < 0) {
i_error("mbox %s sync lost during MD5 syncing",
_mail->box->name);
return -1;
}
}
if ((ret = mbox_mail_get_md5_header(mail, value_r)) == 0) {
i_error("mbox %s resyncing didn't save header MD5 values",
_mail->box->name);
return -1;
}
return ret < 0 ? -1 : 0;
default:
break;
}
return index_mail_get_special(_mail, field, value_r);
}
static int
mbox_mail_get_next_offset(struct index_mail *mail, uoff_t *next_offset_r)
{
struct mbox_mailbox *mbox = (struct mbox_mailbox *)mail->mail.mail.box;
struct mail_index_view *view;
const struct mail_index_header *hdr;
uint32_t seq;
int trailer_size;
int ret = 1;
*next_offset_r = (uoff_t)-1;
hdr = mail_index_get_header(mail->mail.mail.transaction->view);
if (mail->mail.mail.seq > hdr->messages_count) {
/* we're appending a new message */
return 0;
}
/* We can't really trust trans_view. The next message may already be
expunged from it. Also hdr.messages_count may be incorrect there.
So refresh the index to get the latest changes and get the next
message's offset using a new view. */
i_assert(mbox->mbox_lock_type != F_UNLCK);
if (mbox_sync_header_refresh(mbox) < 0)
return -1;
view = mail_index_view_open(mail->mail.mail.box->index);
hdr = mail_index_get_header(view);
if (!mail_index_lookup_seq(view, mail->mail.mail.uid, &seq))
i_panic("Message unexpectedly expunged from index");
if (seq < hdr->messages_count) {
if (mbox_file_lookup_offset(mbox, view, seq + 1,
next_offset_r) <= 0)
ret = -1;
} else if (mail->mail.mail.box->input != NULL) {
/* opened the mailbox as input stream. we can't trust the
sync_size, since it's wrong with compressed mailboxes */
ret = 0;
} else {
/* last message, use the synced mbox size */
trailer_size =
mbox->storage->storage.set->mail_save_crlf ? 2 : 1;
*next_offset_r = mbox->mbox_hdr.sync_size - trailer_size;
}
mail_index_view_close(&view);
return ret;
}
static int mbox_mail_get_physical_size(struct mail *_mail, uoff_t *size_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
struct index_mail_data *data = &mail->data;
struct mbox_mailbox *mbox = (struct mbox_mailbox *)_mail->box;
struct istream *input;
struct message_size hdr_size;
uoff_t old_offset, body_offset, body_size, next_offset;
if (index_mail_get_physical_size(_mail, size_r) == 0)
return 0;
/* we want to return the header size as seen by mail_get_stream(). */
old_offset = data->stream == NULL ? 0 : data->stream->v_offset;
if (mail_get_stream(_mail, &hdr_size, NULL, &input) < 0)
return -1;
/* our header size varies, so don't do any caching */
if (istream_raw_mbox_get_body_offset(mbox->mbox_stream, &body_offset) < 0) {
mail_storage_set_critical(_mail->box->storage,
"mbox %s: Couldn't get body offset for uid=%u",
mailbox_get_path(&mbox->box), mail->mail.mail.uid);
return -1;
}
/* use the next message's offset to avoid reading through the entire
message body to find out its size */
if (mbox_mail_get_next_offset(mail, &next_offset) > 0)
body_size = next_offset - body_offset;
else
body_size = (uoff_t)-1;
/* verify that the calculated body size is correct */
if (istream_raw_mbox_get_body_size(mbox->mbox_stream,
body_size, &body_size) < 0) {
mail_storage_set_critical(_mail->box->storage,
"mbox %s: Couldn't get body size for uid=%u",
mailbox_get_path(&mbox->box), mail->mail.mail.uid);
return -1;
}
data->physical_size = hdr_size.physical_size + body_size;
*size_r = data->physical_size;
i_stream_seek(input, old_offset);
return 0;
}
static int mbox_mail_init_stream(struct index_mail *mail)
{
struct mbox_mailbox *mbox = (struct mbox_mailbox *)mail->mail.mail.box;
struct istream *raw_stream;
uoff_t hdr_offset, next_offset;
int ret;
if (mbox_mail_seek(mail) < 0)
return -1;
ret = mbox_mail_get_next_offset(mail, &next_offset);
if (ret < 0) {
if (mbox_mail_seek(mail) < 0)
return -1;
ret = mbox_mail_get_next_offset(mail, &next_offset);
if (ret < 0) {
i_warning("mbox %s: Can't find next message offset "
"for uid=%u", mailbox_get_path(&mbox->box),
mail->mail.mail.uid);
}
}
raw_stream = mbox->mbox_stream;
if (istream_raw_mbox_get_header_offset(raw_stream, &hdr_offset) < 0) {
mail_storage_set_critical(mbox->box.storage,
"mbox %s: Couldn't get header offset for uid=%u",
mailbox_get_path(&mbox->box), mail->mail.mail.uid);
return -1;
}
i_stream_seek(raw_stream, hdr_offset);
if (next_offset != (uoff_t)-1)
istream_raw_mbox_set_next_offset(raw_stream, next_offset);
raw_stream = i_stream_create_limit(raw_stream, (uoff_t)-1);
mail->data.stream =
i_stream_create_header_filter(raw_stream,
HEADER_FILTER_EXCLUDE | HEADER_FILTER_NO_CR,
mbox_hide_headers, mbox_hide_headers_count,
*null_header_filter_callback, (void *)NULL);
i_stream_unref(&raw_stream);
return 0;
}
static int mbox_mail_get_stream(struct mail *_mail, bool get_body ATTR_UNUSED,
struct message_size *hdr_size,
struct message_size *body_size,
struct istream **stream_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
if (mail->data.stream == NULL) {
if (mbox_mail_init_stream(mail) < 0)
return -1;
}
return index_mail_init_stream(mail, hdr_size, body_size, stream_r);
}
static void mbox_mail_set_seq(struct mail *_mail, uint32_t seq, bool saving)
{
struct index_mail *mail = (struct index_mail *)_mail;
index_mail_set_seq(_mail, seq, saving);
mail->data.dont_cache_fetch_fields |= MAIL_FETCH_PHYSICAL_SIZE;
}
static bool mbox_mail_set_uid(struct mail *_mail, uint32_t uid)
{
struct index_mail *mail = (struct index_mail *)_mail;
bool ret;
ret = index_mail_set_uid(_mail, uid);
mail->data.dont_cache_fetch_fields |= MAIL_FETCH_PHYSICAL_SIZE;
return ret;
}
struct mail_vfuncs mbox_mail_vfuncs = {
index_mail_close,
index_mail_free,
mbox_mail_set_seq,
mbox_mail_set_uid,
index_mail_set_uid_cache_updates,
index_mail_prefetch,
index_mail_precache,
index_mail_add_temp_wanted_fields,
index_mail_get_flags,
index_mail_get_keywords,
index_mail_get_keyword_indexes,
index_mail_get_modseq,
index_mail_get_pvt_modseq,
index_mail_get_parts,
index_mail_get_date,
mbox_mail_get_received_date,
mbox_mail_get_save_date,
index_mail_get_virtual_size,
mbox_mail_get_physical_size,
index_mail_get_first_header,
index_mail_get_headers,
index_mail_get_header_stream,
mbox_mail_get_stream,
index_mail_get_binary_stream,
mbox_mail_get_special,
index_mail_get_real_mail,
index_mail_update_flags,
index_mail_update_keywords,
index_mail_update_modseq,
index_mail_update_pvt_modseq,
NULL,
index_mail_expunge,
index_mail_set_cache_corrupted,
index_mail_opened
};