mail-index.c revision 0f203eb6e0524641e415ce6b555212b5395a54ce
/* Copyright (C) 2002 Timo Sirainen */
#include "lib.h"
#include "ioloop.h"
#include "file-lock.h"
#include "file-set-size.h"
#include "mmap-util.h"
#include "mail-index.h"
#include "mail-index-data.h"
#include "mail-index-util.h"
#include "mail-tree.h"
#include "mail-modifylog.h"
#include "mail-custom-flags.h"
#include <unistd.h>
#include <fcntl.h>
#include <utime.h>
{
struct mail_index_header *hdr;
unsigned int extra;
index->mmap_used_length = 0;
return FALSE;
}
sizeof(struct mail_index_record);
if (extra != 0) {
/* partial write or corrupted -
truncate the file to valid length */
}
/* keep the header set even if we fail, so we can update the flags */
"used_file_size larger than real file size "
return FALSE;
}
sizeof(struct mail_index_record) != 0) {
return FALSE;
}
return FALSE;
}
return FALSE;
}
return TRUE;
}
{
return mmap_verify(index);
/* make sure file size hasn't changed */
i_panic("Index file size was grown without "
"updating sync_id");
}
return TRUE;
}
}
index->mmap_used_length = 0;
return FALSE;
}
return mmap_verify(index);
}
{
index->set_cache_fields = 0;
}
}
}
}
}
}
}
}
}
}
{
unsigned int i;
return TRUE;
fsync_fds[i] = -1;
return FALSE;
}
}
}
return !failed;
}
{
/* keep index's modify stamp same as the sync file's stamp */
}
{
}
return TRUE;
}
{
}
if (index->set_cache_fields != 0) {
index->set_cache_fields = 0;
}
}
{
int failed;
/* use our own locking here so we don't mess up with any other
index states, like inconsistency. */
return FALSE;
#ifdef DEBUG
#endif
sizeof(struct mail_index_header), MS_SYNC) < 0;
if (failed)
#ifdef DEBUG
#endif
return FALSE;
return !failed;
}
{
enum mail_lock_type old_lock_type;
return FALSE;
if (old_lock_type == MAIL_LOCK_SHARED) {
/* releasing shared lock. we may need to update some
flags in header. */
unsigned int old_flags;
enum mail_data_field old_cache;
return mail_index_write_header_changes(index);
}
return TRUE;
}
{
int ret, fd_lock_type;
/* shared -> exclusive isn't allowed without try_lock */
if (index->inconsistent) {
/* index is in inconsistent state and nothing else than
free() is allowed for it. */
return FALSE;
}
if (try_lock) {
if (ret < 0)
if (ret <= 0)
return FALSE;
} else {
return FALSE;
}
if (!mail_index_mmap_update(index)) {
return FALSE;
}
/* index was rebuilt, there's no way we can maintain
consistency */
"%s was rebuilt while we had it open",
return FALSE;
}
/* someone just partially updated the index, need to fsck it */
if (lock_type == MAIL_LOCK_SHARED) {
/* we need exclusive lock so fsck()'s set_lock() won't
get us back here */
if (!mail_index_lock_remove(index))
return FALSE;
return FALSE;
}
/* check again, in case it was already fscked while we had
it unlocked for a while */
return FALSE;
}
if (lock_type == MAIL_LOCK_SHARED) {
/* drop exclusive lock */
}
}
if (lock_type == MAIL_LOCK_EXCLUSIVE) {
/* while holding exclusive lock, keep the FSCK flag on.
when the lock is released, the FSCK flag will also be
removed. */
if (!mail_index_fmdatasync(index,
sizeof(struct mail_index_header))) {
return FALSE;
}
}
return TRUE;
}
{
int keep_fsck;
return TRUE;
/* anonymous mmaps are private and don't need any locking */
index);
return TRUE;
}
/* dropping exclusive lock (either unlock or to shared) */
/* remove the FSCK flag only after successful fsync() */
sizeof(struct mail_index_header),
MS_SYNC) < 0) {
/* we only failed to remove the fsck flag,
so this isn't fatal. */
}
}
}
if (lock_type == MAIL_LOCK_UNLOCK)
return mail_index_lock_remove(index);
else
}
{
}
{
}
void *context)
{
}
{
struct mail_index_header *hdr;
unsigned int max_records;
if (hdr->first_hole_records == 0)
return TRUE;
"first_hole_index points outside file");
return FALSE;
}
/* check that first_hole_records is in valid range */
"first_hole_records points outside file");
return FALSE;
}
return TRUE;
}
{
}
unsigned int seq)
{
struct mail_index_header *hdr;
struct mail_index_record *rec;
const char *error;
unsigned int idx;
/* out of range */
return NULL;
}
return NULL;
/* easy, it's just at the expected index */
"%u", idx);
} else if (hdr->first_hole_records ==
/* only one hole in file, skip it and we're at
correct position */
idx);
} else {
/* find from binary tree */
if (idx == (unsigned int)-1) {
"Sequence %u not found from binary tree "
"(%u msgs says header)",
return NULL;
}
"binary tree: %u", idx);
}
return NULL;
}
return NULL;
}
return rec;
}
struct mail_index_record *rec)
{
struct mail_index_record *end_rec;
return NULL;
/* go to the next non-deleted record */
return rec;
}
return NULL;
}
struct mail_index_record *
{
struct mail_index_record *rec;
unsigned int idx;
if (idx == (unsigned int)-1)
return NULL;
"lookup returned index outside range "
return NULL;
}
"lookup returned offset to wrong UID "
return NULL;
}
return rec;
}
struct mail_index_record *rec,
enum mail_data_field field)
{
struct mail_index_data_record *datarec;
return NULL;
/* index is corrupted, it will be rebuilt */
return NULL;
}
}
struct mail_index_record *rec,
enum mail_data_field field,
{
struct mail_index_data_record_header *datahdr;
struct mail_index_data_record *datarec;
*size = 0;
return NULL;
}
if (field < DATA_FIELD_LAST) {
/* read data field */
*size = 0;
return NULL;
}
}
/* read header field */
*size = 0;
return NULL;
}
switch (field) {
case DATA_HDR_INTERNAL_DATE:
return &datahdr->internal_date;
case DATA_HDR_VIRTUAL_SIZE:
return &datahdr->virtual_size;
case DATA_HDR_HEADER_SIZE:
return &datahdr->header_size;
case DATA_HDR_BODY_SIZE:
default:
*size = 0;
return NULL;
}
}
enum mail_data_field field)
{
/* first check if the field even could be in the file */
/* no, but make sure the future records will have it.
we don't immediately mark the index to cache this
field for old messages as some clients never ask
the info again */
} else {
/* this is at least the second time it's being asked,
make sure it'll be cached soon. */
}
}
}
struct mail_index_record *rec)
{
return (time_t)-1;
else {
return *date;
}
}
struct mail_index_record *rec,
enum mail_flags old_flags,
enum mail_flags new_flags)
{
/* unseen -> seen */
/* seen -> unseen */
/* this is the first unseen message */
"seen_messages_count in header is invalid");
} else {
}
}
/* undeleted -> deleted */
/* this is the first deleted message */
} else if ((old_flags & MAIL_DELETED) &&
(new_flags & MAIL_DELETED) == 0) {
/* deleted -> undeleted */
"deleted_messages_count in header is invalid");
} else {
}
}
}
{
/* see if first_hole_records can be grown */
rec++;
}
}
{
sizeof(struct mail_index_record);
if (!mail_index_truncate(index))
return FALSE;
/* all mail was deleted, truncate data file */
return FALSE;
}
return TRUE;
}
((records) > INDEX_MIN_RECORDS_COUNT && \
(hdr)->messages_count)
unsigned int seq, int external_change)
{
struct mail_index_header *hdr;
return FALSE;
/* setting UID to 0 is enough for deleting the mail from index */
/* update first hole */
if (hdr->first_hole_records == 0) {
/* first deleted message in index */
/* deleted the previous record before hole */
hdr->first_hole_index--;
/* deleted the next record after hole */
} else {
/* second hole coming to index file */
/* new hole before the old hole */
}
}
/* update message counts */
if (hdr->messages_count == 0) {
/* corrupted */
"Header says there's no mail while expunging");
return FALSE;
}
hdr->messages_count--;
/* the hole reaches end of file, truncate it */
(void)mail_index_truncate_hole(index);
} else {
}
/* expunge() may be called while index is being rebuilt and when
tree file hasn't been opened yet */
else {
/* make sure it also gets updated */
}
return FALSE;
}
return TRUE;
}
struct mail_index_record *rec,
int external_change)
{
return TRUE; /* no changes */
}
{
unsigned int grow_count;
void *base;
INDEX_GROW_PERCENTAGE / 100;
if (grow_count < 16)
grow_count = 16;
(grow_count * sizeof(struct mail_index_record));
if (base == MAP_FAILED)
return mmap_verify(index);
}
/* file size changed, let others know about it too by changing
sync_id in header. */
if (!mail_index_mmap_update(index))
return FALSE;
return TRUE;
}
{
struct mail_index_record *rec;
if (!mail_index_grow(index))
return NULL;
}
return rec;
}
struct mail_index_record *rec)
{
return FALSE;
}
}
return TRUE;
}
{
if (index->inconsistent)
return MAIL_INDEX_ERROR_INCONSISTENT;
if (index->nodiskspace)
return MAIL_INDEX_ERROR_DISKSPACE;
if (index->index_lock_timeout)
if (index->mailbox_lock_timeout)
return MAIL_INDEX_ERROR_INTERNAL;
return MAIL_INDEX_ERROR_NONE;
}
{
}