mail-index.c revision bc1d1497d715cc5c820ff518f070f78c39ef6cdc
52N/A/* Copyright (C) 2003-2004 Timo Sirainen */
52N/A
52N/A#include "lib.h"
52N/A#include "array.h"
121N/A#include "buffer.h"
52N/A#include "hash.h"
52N/A#include "mmap-util.h"
52N/A#include "nfs-workarounds.h"
52N/A#include "read-full.h"
52N/A#include "write-full.h"
52N/A#include "mail-index-private.h"
52N/A#include "mail-index-view-private.h"
52N/A#include "mail-index-sync-private.h"
52N/A#include "mail-transaction-log.h"
52N/A#include "mail-cache.h"
52N/A
52N/A#include <stdio.h>
52N/A#include <stddef.h>
52N/A#include <time.h>
52N/A#include <sys/stat.h>
52N/A
52N/Astruct mail_index_module_register mail_index_module_register = { 0 };
52N/A
52N/Astruct mail_index *mail_index_alloc(const char *dir, const char *prefix)
52N/A{
52N/A struct mail_index *index;
52N/A
52N/A index = i_new(struct mail_index, 1);
52N/A index->dir = i_strdup(dir);
52N/A index->prefix = i_strdup(prefix);
52N/A index->fd = -1;
52N/A
52N/A index->extension_pool =
52N/A pool_alloconly_create(MEMPOOL_GROWING"index extension", 1024);
52N/A p_array_init(&index->extensions, index->extension_pool, 5);
52N/A i_array_init(&index->sync_lost_handlers, 4);
52N/A i_array_init(&index->module_contexts,
6N/A I_MIN(5, mail_index_module_register.id));
6N/A
6N/A index->mode = 0600;
6N/A index->gid = (gid_t)-1;
6N/A
15N/A index->keywords_ext_id =
6N/A mail_index_ext_register(index, "keywords", 128, 2, 1);
6N/A index->keywords_pool = pool_alloconly_create("keywords", 512);
128N/A i_array_init(&index->keywords, 16);
6N/A index->keywords_hash =
15N/A hash_create(default_pool, index->keywords_pool, 0,
6N/A strcase_hash, (hash_cmp_callback_t *)strcasecmp);
6N/A index->log = mail_transaction_log_alloc(index);
6N/A return index;
6N/A}
6N/A
6N/Avoid mail_index_free(struct mail_index **_index)
6N/A{
6N/A struct mail_index *index = *_index;
6N/A
6N/A *_index = NULL;
6N/A mail_index_close(index);
15N/A
6N/A mail_transaction_log_free(&index->log);
6N/A hash_destroy(index->keywords_hash);
6N/A pool_unref(index->extension_pool);
6N/A pool_unref(index->keywords_pool);
6N/A
6N/A array_free(&index->sync_lost_handlers);
6N/A array_free(&index->keywords);
6N/A array_free(&index->module_contexts);
6N/A
6N/A i_free(index->error);
6N/A i_free(index->dir);
128N/A i_free(index->prefix);
121N/A i_free(index);
128N/A}
6N/A
6N/Avoid mail_index_set_permissions(struct mail_index *index,
15N/A mode_t mode, gid_t gid)
15N/A{
15N/A index->mode = mode & 0666;
15N/A index->gid = gid;
15N/A}
15N/A
15N/Auint32_t mail_index_ext_register(struct mail_index *index, const char *name,
15N/A uint32_t default_hdr_size,
15N/A uint16_t default_record_size,
15N/A uint16_t default_record_align)
44N/A{
44N/A const struct mail_index_registered_ext *extensions;
44N/A struct mail_index_registered_ext rext;
44N/A unsigned int i, ext_count;
44N/A
44N/A extensions = array_get(&index->extensions, &ext_count);
6N/A
6N/A /* see if it's already there */
6N/A for (i = 0; i < ext_count; i++) {
6N/A if (strcmp(extensions[i].name, name) == 0)
6N/A return i;
6N/A }
6N/A
6N/A memset(&rext, 0, sizeof(rext));
6N/A rext.name = p_strdup(index->extension_pool, name);
6N/A rext.index_idx = ext_count;
6N/A rext.hdr_size = default_hdr_size;
6N/A rext.record_size = default_record_size;
6N/A rext.record_align = default_record_align;
6N/A
6N/A array_append(&index->extensions, &rext, 1);
6N/A return ext_count;
6N/A}
6N/A
6N/Avoid mail_index_register_expunge_handler(struct mail_index *index,
6N/A uint32_t ext_id, bool call_always,
6N/A mail_index_expunge_handler_t *cb,
6N/A void *context)
63N/A{
63N/A struct mail_index_registered_ext *rext;
63N/A
63N/A rext = array_idx_modifiable(&index->extensions, ext_id);
63N/A i_assert(rext->expunge_handler == NULL || rext->expunge_handler == cb);
63N/A
63N/A rext->expunge_handler = cb;
63N/A rext->expunge_context = context;
63N/A rext->expunge_handler_call_always = call_always;
63N/A}
63N/A
63N/Avoid mail_index_unregister_expunge_handler(struct mail_index *index,
63N/A uint32_t ext_id)
63N/A{
63N/A struct mail_index_registered_ext *rext;
63N/A
63N/A rext = array_idx_modifiable(&index->extensions, ext_id);
63N/A i_assert(rext->expunge_handler != NULL);
63N/A
63N/A rext->expunge_handler = NULL;
63N/A}
63N/A
63N/Avoid mail_index_register_sync_handler(struct mail_index *index, uint32_t ext_id,
63N/A mail_index_sync_handler_t *cb,
63N/A enum mail_index_sync_handler_type type)
63N/A{
63N/A struct mail_index_registered_ext *rext;
63N/A
63N/A rext = array_idx_modifiable(&index->extensions, ext_id);
63N/A i_assert(rext->sync_handler.callback == NULL);
63N/A
63N/A rext->sync_handler.callback = cb;
63N/A rext->sync_handler.type = type;
63N/A}
63N/A
63N/Avoid mail_index_unregister_sync_handler(struct mail_index *index,
131N/A uint32_t ext_id)
63N/A{
63N/A struct mail_index_registered_ext *rext;
63N/A
6N/A rext = array_idx_modifiable(&index->extensions, ext_id);
26N/A i_assert(rext->sync_handler.callback != NULL);
6N/A
44N/A rext->sync_handler.callback = NULL;
44N/A rext->sync_handler.type = 0;
44N/A}
44N/A
44N/Avoid mail_index_register_sync_lost_handler(struct mail_index *index,
44N/A mail_index_sync_lost_handler_t *cb)
44N/A{
44N/A array_append(&index->sync_lost_handlers, &cb, 1);
44N/A}
44N/A
44N/Avoid mail_index_unregister_sync_lost_handler(struct mail_index *index,
44N/A mail_index_sync_lost_handler_t *cb)
44N/A{
44N/A mail_index_sync_lost_handler_t *const *handlers;
44N/A unsigned int i, count;
44N/A
44N/A handlers = array_get(&index->sync_lost_handlers, &count);
44N/A for (i = 0; i < count; i++) {
44N/A if (handlers[i] == cb) {
44N/A array_delete(&index->sync_lost_handlers, i, 1);
44N/A break;
44N/A }
44N/A }
44N/A}
44N/A
44N/Abool mail_index_keyword_lookup(struct mail_index *index,
44N/A const char *keyword, bool autocreate,
44N/A unsigned int *idx_r)
44N/A{
44N/A char *keyword_dup;
44N/A void *value;
44N/A
44N/A /* keywords_hash keeps a name => index mapping of keywords.
44N/A Keywords are never removed from it, so the index values are valid
6N/A for the lifetime of the mail_index. */
6N/A if (hash_lookup_full(index->keywords_hash, keyword, NULL, &value)) {
6N/A *idx_r = POINTER_CAST_TO(value, unsigned int);
6N/A return TRUE;
6N/A }
6N/A
6N/A if (!autocreate) {
6N/A *idx_r = (unsigned int)-1;
6N/A return FALSE;
15N/A }
15N/A
15N/A keyword = keyword_dup = p_strdup(index->keywords_pool, keyword);
15N/A *idx_r = array_count(&index->keywords);
15N/A
44N/A hash_insert(index->keywords_hash, keyword_dup, POINTER_CAST(*idx_r));
44N/A array_append(&index->keywords, &keyword, 1);
44N/A return TRUE;
44N/A}
44N/A
44N/Aint mail_index_map_parse_keywords(struct mail_index *index,
44N/A struct mail_index_map *map)
44N/A{
15N/A const struct mail_index_ext *ext;
15N/A const struct mail_index_keyword_header *kw_hdr;
15N/A const struct mail_index_keyword_header_rec *kw_rec;
15N/A const char *name;
15N/A unsigned int i, name_area_end_offset, old_count;
15N/A uint32_t ext_id;
15N/A
15N/A map->keywords_read = TRUE;
15N/A
15N/A ext_id = mail_index_map_lookup_ext(map, "keywords");
15N/A if (ext_id == (uint32_t)-1) {
15N/A if (array_is_created(&map->keyword_idx_map))
15N/A array_clear(&map->keyword_idx_map);
15N/A return 0;
15N/A }
15N/A
15N/A ext = array_idx(&map->extensions, ext_id);
15N/A
15N/A /* Extension header contains:
15N/A - struct mail_index_keyword_header
15N/A - struct mail_index_keyword_header_rec * keywords_count
15N/A - const char names[] * keywords_count
15N/A */
15N/A i_assert(ext->hdr_offset < map->hdr.header_size);
15N/A kw_hdr = CONST_PTR_OFFSET(map->hdr_base, ext->hdr_offset);
15N/A kw_rec = (const void *)(kw_hdr + 1);
15N/A name = (const char *)(kw_rec + kw_hdr->keywords_count);
15N/A
15N/A old_count = !array_is_created(&map->keyword_idx_map) ? 0 :
15N/A array_count(&map->keyword_idx_map);
6N/A
6N/A /* Keywords can only be added into same mapping. Removing requires a
6N/A new mapping (recreating the index file) */
6N/A if (kw_hdr->keywords_count == old_count) {
6N/A /* nothing changed */
6N/A return 0;
6N/A }
6N/A
6N/A /* make sure the header is valid */
6N/A if (kw_hdr->keywords_count < old_count) {
6N/A mail_index_set_error(index, "Corrupted index file %s: "
6N/A "Keywords removed unexpectedly",
6N/A index->filepath);
6N/A return -1;
6N/A }
6N/A
6N/A if ((size_t)(name - (const char *)kw_hdr) > ext->hdr_size) {
6N/A mail_index_set_error(index, "Corrupted index file %s: "
6N/A "keywords_count larger than header size",
6N/A index->filepath);
6N/A return -1;
6N/A }
6N/A
121N/A name_area_end_offset = (const char *)kw_hdr + ext->hdr_size - name;
6N/A for (i = 0; i < kw_hdr->keywords_count; i++) {
6N/A if (kw_rec[i].name_offset > name_area_end_offset) {
6N/A mail_index_set_error(index, "Corrupted index file %s: "
6N/A "name_offset points outside allocated header",
6N/A index->filepath);
6N/A return -1;
6N/A }
6N/A }
6N/A if (name[name_area_end_offset-1] != '\0') {
63N/A mail_index_set_error(index, "Corrupted index file %s: "
63N/A "Keyword header doesn't end with NUL",
63N/A index->filepath);
63N/A return -1;
63N/A }
63N/A
63N/A /* create file -> index mapping */
63N/A if (!array_is_created(&map->keyword_idx_map))
63N/A i_array_init(&map->keyword_idx_map, kw_hdr->keywords_count);
6N/A
63N/A#ifdef DEBUG
164N/A /* Check that existing headers are still the same. It's behind DEBUG
164N/A since it's pretty useless waste of CPU normally. */
164N/A for (i = 0; i < array_count(&map->keyword_idx_map); i++) {
164N/A const char *keyword = name + kw_rec[i].name_offset;
164N/A const unsigned int *old_idx;
164N/A unsigned int idx;
164N/A
164N/A old_idx = array_idx(&map->keyword_idx_map, i);
164N/A if (!mail_index_keyword_lookup(index, keyword, FALSE, &idx) ||
164N/A idx != *old_idx) {
164N/A mail_index_set_error(index, "Corrupted index file %s: "
164N/A "Keywords changed unexpectedly",
164N/A index->filepath);
164N/A return -1;
164N/A }
164N/A }
164N/A#endif
63N/A /* Register the newly seen keywords */
63N/A i = array_count(&map->keyword_idx_map);
63N/A for (; i < kw_hdr->keywords_count; i++) {
63N/A const char *keyword = name + kw_rec[i].name_offset;
63N/A unsigned int idx;
63N/A
63N/A (void)mail_index_keyword_lookup(index, keyword, TRUE, &idx);
63N/A array_append(&map->keyword_idx_map, &idx, 1);
63N/A }
63N/A return 0;
63N/A}
63N/A
63N/Aconst ARRAY_TYPE(keywords) *mail_index_get_keywords(struct mail_index *index)
6N/A{
6N/A /* Make sure all the keywords are in index->keywords. It's quick to do
32N/A if nothing has changed. */
32N/A (void)mail_index_map_parse_keywords(index, index->map);
32N/A
32N/A return &index->keywords;
32N/A}
32N/A
32N/Aint mail_index_try_open_only(struct mail_index *index)
32N/A{
32N/A i_assert(index->fd == -1);
32N/A i_assert(!MAIL_INDEX_IS_IN_MEMORY(index));
32N/A
32N/A /* Note that our caller must close index->fd by itself. */
32N/A index->fd = nfs_safe_open(index->filepath, O_RDWR);
32N/A index->readonly = FALSE;
32N/A
32N/A if (index->fd == -1 && errno == EACCES) {
32N/A index->fd = open(index->filepath, O_RDONLY);
32N/A index->readonly = TRUE;
32N/A }
32N/A
32N/A if (index->fd == -1) {
32N/A if (errno != ENOENT)
32N/A return mail_index_set_syscall_error(index, "open()");
32N/A
32N/A /* have to create it */
32N/A return 0;
32N/A }
32N/A return 1;
32N/A}
32N/A
32N/Astatic int
32N/Amail_index_try_open(struct mail_index *index)
32N/A{
32N/A unsigned int lock_id;
32N/A int ret;
6N/A
6N/A i_assert(index->fd == -1);
6N/A
6N/A if (MAIL_INDEX_IS_IN_MEMORY(index))
6N/A return 0;
6N/A
6N/A ret = mail_index_map(index, MAIL_INDEX_SYNC_HANDLER_HEAD, &lock_id);
6N/A mail_index_unlock(index, lock_id);
6N/A
6N/A if (ret == 0) {
6N/A /* it's corrupted - recreate it */
6N/A if (close(index->fd) < 0)
6N/A mail_index_set_syscall_error(index, "close()");
6N/A index->fd = -1;
6N/A }
6N/A return ret;
63N/A}
63N/A
63N/Aint mail_index_create_tmp_file(struct mail_index *index, const char **path_r)
63N/A{
63N/A mode_t old_mask;
6N/A const char *path;
6N/A int fd;
i_assert(!MAIL_INDEX_IS_IN_MEMORY(index));
path = *path_r = t_strconcat(index->filepath, ".tmp", NULL);
old_mask = umask(0);
fd = open(path, O_RDWR|O_CREAT|O_TRUNC, index->mode);
umask(old_mask);
if (fd == -1)
return mail_index_file_set_syscall_error(index, path, "open()");
if (index->gid != (gid_t)-1 && fchown(fd, (uid_t)-1, index->gid) < 0) {
mail_index_file_set_syscall_error(index, path, "fchown()");
return -1;
}
return fd;
}
static bool mail_index_open_files(struct mail_index *index,
enum mail_index_open_flags flags)
{
int ret;
bool created = FALSE;
ret = mail_transaction_log_open(index->log);
if (ret == 0) {
if ((flags & MAIL_INDEX_OPEN_FLAG_CREATE) == 0)
return FALSE;
ret = mail_transaction_log_create(index->log);
created = TRUE;
}
if (ret >= 0) {
ret = created ? 0 : mail_index_try_open(index);
if (ret == 0) {
/* doesn't exist / corrupted */
index->map = mail_index_map_alloc(index);
}
}
if (ret < 0) {
/* open/create failed, fallback to in-memory indexes */
if ((flags & MAIL_INDEX_OPEN_FLAG_CREATE) == 0)
return FALSE;
if (mail_index_move_to_memory(index) < 0)
return FALSE;
}
index->cache = created ? mail_cache_create(index) :
mail_cache_open_or_create(index);
return TRUE;
}
int mail_index_open(struct mail_index *index, enum mail_index_open_flags flags,
enum file_lock_method lock_method)
{
int i = 0, ret = 1;
if (index->opened) {
if (index->map != NULL &&
(index->map->hdr.flags &
MAIL_INDEX_HDR_FLAG_CORRUPTED) != 0) {
/* corrupted, reopen files */
mail_index_close(index);
} else {
i_assert(index->map != NULL);
return 1;
}
}
index->filepath = MAIL_INDEX_IS_IN_MEMORY(index) ?
i_strdup("(in-memory index)") :
i_strconcat(index->dir, "/", index->prefix, NULL);
for (;;) {
index->shared_lock_count = 0;
index->excl_lock_count = 0;
index->lock_type = F_UNLCK;
index->lock_id = 2;
index->readonly = FALSE;
index->nodiskspace = FALSE;
index->index_lock_timeout = FALSE;
index->log_locked = FALSE;
index->mmap_disable =
(flags & MAIL_INDEX_OPEN_FLAG_MMAP_DISABLE) != 0;
index->use_excl_dotlocks =
(flags & MAIL_INDEX_OPEN_FLAG_DOTLOCK_USE_EXCL) != 0;
index->fsync_disable =
(flags & MAIL_INDEX_OPEN_FLAG_FSYNC_DISABLE) != 0;
index->lock_method = lock_method;
i_assert(!index->opened);
if (!mail_index_open_files(index, flags)) {
/* doesn't exist and create flag not used */
ret = 0;
break;
}
i_assert(index->map != NULL);
index->opened = TRUE;
if (index->fsck) {
index->fsck = FALSE;
ret = mail_index_fsck(index);
if (ret == 0) {
/* completely broken, reopen */
if (i++ < 3) {
mail_index_close(index);
continue;
}
/* too many tries */
ret = -1;
}
}
break;
}
if (ret <= 0)
mail_index_close(index);
i_assert(ret <= 0 || index->map != NULL);
return ret;
}
static void mail_index_close_file(struct mail_index *index)
{
if (index->file_lock != NULL)
file_lock_free(&index->file_lock);
if (index->fd != -1) {
if (close(index->fd) < 0)
mail_index_set_syscall_error(index, "close()");
index->fd = -1;
}
if (index->lock_type == F_RDLCK)
index->lock_type = F_UNLCK;
index->lock_id += 2;
index->shared_lock_count = 0;
}
void mail_index_close(struct mail_index *index)
{
mail_transaction_log_close(index->log);
if (index->cache != NULL)
mail_cache_free(&index->cache);
i_free_and_null(index->filepath);
index->indexid = 0;
index->opened = FALSE;
}
int mail_index_reopen_if_changed(struct mail_index *index)
{
struct stat st1, st2;
i_assert(index->excl_lock_count == 0);
if (MAIL_INDEX_IS_IN_MEMORY(index))
return 0;
if (index->fd == -1)
return mail_index_try_open_only(index);
if (fstat(index->fd, &st1) < 0) {
if (errno != ESTALE)
return mail_index_set_syscall_error(index, "fstat()");
/* deleted/recreated, reopen */
return mail_index_try_open_only(index);
}
if (nfs_safe_stat(index->filepath, &st2) < 0) {
if (errno == ENOENT)
return 0;
return mail_index_set_syscall_error(index, "stat()");
}
if (st1.st_ino == st2.st_ino && CMP_DEV_T(st1.st_dev, st2.st_dev)) {
/* the same file */
return 1;
}
/* new file, new locks. the old fd can keep its locks, they don't
matter anymore as no-one's going to modify the file. */
mail_index_close_file(index);
return mail_index_try_open_only(index);
}
int mail_index_refresh(struct mail_index *index)
{
unsigned int lock_id;
int ret;
if (MAIL_INDEX_IS_IN_MEMORY(index))
return 0;
if (index->excl_lock_count > 0) {
/* we have index exclusively locked, nothing could
have changed. */
return 0;
}
ret = mail_index_map(index, MAIL_INDEX_SYNC_HANDLER_HEAD, &lock_id);
mail_index_unlock(index, lock_id);
return ret <= 0 ? -1 : 0;
}
struct mail_cache *mail_index_get_cache(struct mail_index *index)
{
return index->cache;
}
int mail_index_set_error(struct mail_index *index, const char *fmt, ...)
{
va_list va;
i_free(index->error);
if (fmt == NULL)
index->error = NULL;
else {
va_start(va, fmt);
index->error = i_strdup_vprintf(fmt, va);
va_end(va);
i_error("%s", index->error);
}
return -1;
}
void mail_index_set_inconsistent(struct mail_index *index)
{
index->indexid = 0;
}
int mail_index_move_to_memory(struct mail_index *index)
{
struct mail_index_map *map;
if (MAIL_INDEX_IS_IN_MEMORY(index))
return index->map == NULL ? -1 : 0;
/* set the index as being into memory */
i_free_and_null(index->dir);
i_free(index->filepath);
index->filepath = i_strdup("(in-memory index)");
if (index->map == NULL) {
/* index was never even opened. just mark it as being in
memory and let the caller re-open the index. */
i_assert(index->fd == -1);
return -1;
}
/* move index map to memory */
if (!MAIL_INDEX_MAP_IS_IN_MEMORY(index->map)) {
map = mail_index_map_clone(index->map);
mail_index_unmap(index, &index->map);
index->map = map;
}
if (index->log != NULL) {
/* move transaction log to memory */
mail_transaction_log_move_to_memory(index->log);
}
if (index->file_lock != NULL)
file_lock_free(&index->file_lock);
/* close the index file. */
if (close(index->fd) < 0)
mail_index_set_syscall_error(index, "close()");
index->fd = -1;
return 0;
}
void mail_index_mark_corrupted(struct mail_index *index)
{
mail_index_set_inconsistent(index);
index->map->hdr.flags |= MAIL_INDEX_HDR_FLAG_CORRUPTED;
if (unlink(index->filepath) < 0 && errno != ENOENT && errno != ESTALE)
mail_index_set_syscall_error(index, "unlink()");
}
int mail_index_set_syscall_error(struct mail_index *index,
const char *function)
{
i_assert(function != NULL);
if (ENOSPACE(errno)) {
index->nodiskspace = TRUE;
return -1;
}
return mail_index_set_error(index, "%s failed with index file %s: %m",
function, index->filepath);
}
int mail_index_file_set_syscall_error(struct mail_index *index,
const char *filepath,
const char *function)
{
i_assert(filepath != NULL);
i_assert(function != NULL);
if (ENOSPACE(errno)) {
index->nodiskspace = TRUE;
return -1;
}
return mail_index_set_error(index, "%s failed with file %s: %m",
function, filepath);
}
const char *mail_index_get_error_message(struct mail_index *index)
{
return index->error;
}
void mail_index_reset_error(struct mail_index *index)
{
if (index->error != NULL) {
i_free(index->error);
index->error = NULL;
}
index->nodiskspace = FALSE;
index->index_lock_timeout = FALSE;
}
#ifdef WORDS_BIGENDIAN
/* FIXME: Unfortunately these functions were originally written to use
endian-specific code and we can't avoid that without breaking backwards
compatibility. When we do break it, just select one of these. */
uint32_t mail_index_uint32_to_offset(uint32_t offset)
{
i_assert(offset < 0x40000000);
i_assert((offset & 3) == 0);
offset >>= 2;
return 0x00000080 | ((offset & 0x0000007f)) |
0x00008000 | ((offset & 0x00003f80) >> 7 << 8) |
0x00800000 | ((offset & 0x001fc000) >> 14 << 16) |
0x80000000 | ((offset & 0x0fe00000) >> 21 << 24);
}
uint32_t mail_index_offset_to_uint32(uint32_t offset)
{
if ((offset & 0x80808080) != 0x80808080)
return 0;
return (((offset & 0x0000007f)) |
((offset & 0x00007f00) >> 8 << 7) |
((offset & 0x007f0000) >> 16 << 14) |
((offset & 0x7f000000) >> 24 << 21)) << 2;
}
#else
uint32_t mail_index_uint32_to_offset(uint32_t offset)
{
i_assert(offset < 0x40000000);
i_assert((offset & 3) == 0);
offset >>= 2;
return 0x80000000 | ((offset & 0x0000007f) << 24) |
0x00800000 | ((offset & 0x00003f80) >> 7 << 16) |
0x00008000 | ((offset & 0x001fc000) >> 14 << 8) |
0x00000080 | ((offset & 0x0fe00000) >> 21);
}
uint32_t mail_index_offset_to_uint32(uint32_t offset)
{
if ((offset & 0x80808080) != 0x80808080)
return 0;
return (((offset & 0x0000007f) << 21) |
((offset & 0x00007f00) >> 8 << 14) |
((offset & 0x007f0000) >> 16 << 7) |
((offset & 0x7f000000) >> 24)) << 2;
}
#endif