dbox-sync.c revision 8ecbb74bc4c7f6f6145da3525941d1d0e20e67f1
/* Copyright (C) 2005 Timo Sirainen */
#include "lib.h"
#include "ioloop.h"
#include "array.h"
#include "hash.h"
#include "seq-range-array.h"
#include "write-full.h"
#include "dbox-file.h"
#include "dbox-keywords.h"
#include "dbox-sync.h"
#include "dbox-uidlist.h"
#include "dbox-storage.h"
#include <stddef.h>
{
int ret;
if (ret <= 0) {
if (ret == 0) {
"Unexpectedly lost seq %u in "
}
return -1;
}
return 0;
}
const struct dbox_sync_rec *sync_rec)
{
struct dbox_sync_file_entry *entry;
return -1;
return 0; /* already added in last sequence */
/* check if it's already added */
const struct dbox_sync_rec *sync_recs;
unsigned int count;
return 0; /* already added */
} else {
struct dbox_sync_rec, 3);
}
return 0;
}
const struct mail_index_sync_rec *sync_rec)
{
struct dbox_sync_rec dbox_sync_rec;
/* don't care about appends */
return 0;
}
return -1;
}
if (seq1 == 0) {
/* already expunged everything. nothing to do. */
return 0;
}
/* convert to dbox_sync_rec, which takes a bit less space and has
sequences instead of UIDs. */
break;
break;
break;
}
/* now, add the same sync_rec to each file_seq's entry */
ctx->prev_file_seq = 0;
return -1;
}
return 0;
}
static int
const struct dbox_sync_rec *sync_rec,
unsigned int first_flag_offset, unsigned int flag_count,
{
unsigned int i, start;
int ret;
return -1;
return -1;
}
return ret;
for (i = 0; i < flag_count; ) {
if (!mask[i])
continue;
start = i;
while (i < flag_count) {
if (!mask[i])
break;
i++;
}
if (ret < 0) {
"pwrite(%s) failed: %m",
return -1;
}
}
if (ret <= 0) {
if (ret == 0)
break;
return -1;
}
}
return 0;
}
const struct dbox_sync_rec *sync_rec)
{
static enum mail_flags dbox_flag_list[] = {
0 /* expunged */
};
unsigned char dbox_flag_array[DBOX_FLAG_COUNT];
unsigned char dbox_flag_mask[DBOX_FLAG_COUNT];
unsigned int i, first_flag_offset;
/* first build flag array and mask */
} else {
for (i = 0; i < DBOX_FLAG_COUNT; i++) {
dbox_flag_array[i] =
dbox_flag_mask[i] = dbox_flag_array[i] ||
dbox_flag_list[i]) != 0;
}
}
}
static int
{
unsigned int file_idx, first_flag_offset;
/* not found. if removing, just ignore.
if adding, it currently happens only if the maximum keyword
count was reached. once we support moving mails to new file
to grow keywords count, this should never happen.
for now, just ignore this. */
return 0;
}
}
static int
const struct dbox_sync_rec *sync_rec)
{
unsigned char *keyword_array, *keyword_mask;
unsigned int first_flag_offset;
int ret;
return 0;
t_push();
first_flag_offset = sizeof(struct dbox_mail_header);
t_pop();
return ret;
}
static int
const struct dbox_sync_file_entry *entry,
unsigned int i)
{
const struct dbox_sync_rec *sync_recs;
int ret = 0;
return -1;
/* Get a list of all new keywords. Using seq_range is the easiest
way to do this and should be pretty fast too. */
t_push();
for (; i < count; i++) {
continue;
/* check if it's already in the file */
keyword_idx, &file_idx))
continue;
/* add it. if it already exists, it's handled internally. */
}
/* now, write them to file */
if (count > 0) {
}
t_pop();
return ret;
}
const struct dbox_sync_file_entry *entry)
{
const struct dbox_sync_rec *sync_recs;
unsigned int i, count;
bool first_keyword = TRUE;
int ret;
for (i = 0; i < count; i++) {
if (ret > 0) {
/* handled expunging by copying the file.
while at it, also wrote all the other sync
changes to the file. */
return 0;
}
if (ret < 0)
return -1;
/* handled expunging by writing expunge flags */
break;
return -1;
break;
if (first_keyword) {
/* add all new keywords in one go */
i) < 0)
return -1;
}
TRUE) < 0)
return -1;
break;
FALSE) < 0)
return -1;
break;
return -1;
break;
i_unreached();
}
}
return 0;
}
{
struct mail_index_sync_rec sync_rec;
struct hash_iterate_context *iter;
int ret;
/* read all changes and sort them to file_seq order */
for (;;) {
if (ret <= 0) {
if (ret < 0)
break;
}
ret = -1;
break;
}
}
ret = -1;
break;
}
}
return ret;
}
{
struct dbox_sync_context ctx;
const struct mail_index_header *hdr;
int ret;
/* always start index syncing before uidlist, so we don't get
deadlocks */
if (ret <= 0) {
if (ret < 0)
return ret;
}
&mtime) < 0) {
return -1;
}
/* indexes aren't synced. we'll do a full sync. */
}
if (force)
else
if (ret < 0) {
return -1;
}
}
}
return -1;
}
}
return -1;
}
if (force) {
/* now that indexes are ok, sync changes from the index */
} else {
return -1;
}
}
return 0;
}
struct mailbox_sync_context *
{
int ret = 0;
if ((flags & MAILBOX_SYNC_FLAG_FAST) == 0 ||
}
{
const struct mail_index_header *hdr;
if (hdr->sync_stamp == 0)
return 1;
return -1;
}