sipp11
/
mbsync
mirror of https://git.code.sf.net/p/isync/isync
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

let driver_t::openbox_box() return the UID validity 

... and make 'uidvalidity' private to the drivers.
wip/movedetect
Oswald Buddenhagen 8 years ago
parent
48ad58b9a3
commit
bbe4567bce
4 changed files with 56 additions and 39 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      src/driver.h
  2. 41
      src/drv_imap.c
  3. 20
      src/drv_maildir.c
  4. 29
      src/sync.c

5
src/driver.h
Unescape View File

@ -88,9 +88,6 @@ typedef struct message {
typedef struct store {
struct store *next;
store_conf_t *conf; /* foreign */
/* currently open mailbox */
int uidvalidity;
} store_t;
typedef struct {
@ -174,7 +171,7 @@ struct driver {
/* Open the selected mailbox.
* Note that this should not directly complain about failure to open. */
void (*open_box)( store_t *ctx,
void (*cb)( int sts, void *aux ), void *aux );
void (*cb)( int sts, int uidvalidity, void *aux ), void *aux );
/* Return the minimal UID the next stored message will have. */
int (*get_uidnext)( store_t *ctx );

41
src/drv_imap.c
Unescape View File

@ -112,7 +112,7 @@ struct imap_store {
// note that the message counts do _not_ reflect stats from msgs,
// but mailbox totals. also, don't trust them beyond the initial load.
int total_msgs, recent_msgs;
int uidnext;
int uidvalidity, uidnext;
message_t *msgs;
message_t **msgapp; /* FETCH results */
uint caps; /* CAPABILITY results */
@ -1166,7 +1166,7 @@ parse_response_code( imap_store_t *ctx, imap_cmd_t *cmd, char *s )
goto bad_resp;
if (!strcmp( "UIDVALIDITY", arg )) {
if (!(arg = next_arg( &s )) ||
(ctx->gen.uidvalidity = strtoll( arg, &earg, 10 ), *earg))
(ctx->uidvalidity = strtoll( arg, &earg, 10 ), *earg))
{
error( "IMAP error: malformed UIDVALIDITY status\n" );
return RESP_CANCEL;
@ -1186,7 +1186,7 @@ parse_response_code( imap_store_t *ctx, imap_cmd_t *cmd, char *s )
error( "*** IMAP ALERT *** %s\n", p );
} else if (cmd && !strcmp( "APPENDUID", arg )) {
if (!(arg = next_arg( &s )) ||
(ctx->gen.uidvalidity = strtoll( arg, &earg, 10 ), *earg) ||
(ctx->uidvalidity = strtoll( arg, &earg, 10 ), *earg) ||
!(arg = next_arg( &s )) ||
!(((imap_cmd_out_uid_t *)cmd)->out_uid = atoi( arg )))
{
@ -2340,25 +2340,33 @@ imap_get_box_path( store_t *gctx ATTR_UNUSED )
return 0;
}
typedef struct {
imap_cmd_t gen;
void (*callback)( int sts, int uidvalidity, void *aux );
void *callback_aux;
} imap_cmd_open_box_t;
static void imap_open_box_p2( imap_store_t *, imap_cmd_t *, int );
static void imap_open_box_p3( imap_store_t *, imap_cmd_t *, int );
static void imap_open_box_p4( imap_store_t *, imap_cmd_open_box_t *, int );
static void
imap_open_box( store_t *gctx,
void (*cb)( int sts, void *aux ), void *aux )
void (*cb)( int sts, int uidvalidity, void *aux ), void *aux )
{
imap_store_t *ctx = (imap_store_t *)gctx;
imap_cmd_simple_t *cmd;
imap_cmd_open_box_t *cmd;
char *buf;
if (prepare_box( &buf, ctx ) < 0) {
cb( DRV_BOX_BAD, aux );
cb( DRV_BOX_BAD, UIDVAL_BAD, aux );
return;
}
ctx->uidvalidity = UIDVAL_BAD;
ctx->uidnext = 0;
INIT_IMAP_CMD(imap_cmd_simple_t, cmd, cb, aux)
INIT_IMAP_CMD(imap_cmd_open_box_t, cmd, cb, aux)
cmd->gen.param.failok = 1;
imap_exec( ctx, &cmd->gen, imap_open_box_p2,
"SELECT \"%\\s\"", buf );
@ -2368,15 +2376,15 @@ imap_open_box( store_t *gctx,
static void
imap_open_box_p2( imap_store_t *ctx, imap_cmd_t *gcmd, int response )
{
imap_cmd_simple_t *cmdp = (imap_cmd_simple_t *)gcmd;
imap_cmd_simple_t *cmd;
imap_cmd_open_box_t *cmdp = (imap_cmd_open_box_t *)gcmd;
imap_cmd_open_box_t *cmd;
if (response != RESP_OK || ctx->uidnext) {
imap_done_simple_box( ctx, &cmdp->gen, response );
imap_open_box_p4( ctx, cmdp, response );
return;
}
INIT_IMAP_CMD(imap_cmd_simple_t, cmd, cmdp->callback, cmdp->callback_aux)
INIT_IMAP_CMD(imap_cmd_open_box_t, cmd, cmdp->callback, cmdp->callback_aux)
cmd->gen.param.lastuid = 1;
imap_exec( ctx, &cmd->gen, imap_open_box_p3,
"UID FETCH *:* (UID)" );
@ -2385,11 +2393,20 @@ imap_open_box_p2( imap_store_t *ctx, imap_cmd_t *gcmd, int response )
static void
imap_open_box_p3( imap_store_t *ctx, imap_cmd_t *gcmd, int response )
{
imap_cmd_open_box_t *cmdp = (imap_cmd_open_box_t *)gcmd;
// This will happen if the box is empty.
if (!ctx->uidnext)
ctx->uidnext = 1;
imap_done_simple_box( ctx, gcmd, response );
imap_open_box_p4( ctx, cmdp, response );
}
static void
imap_open_box_p4( imap_store_t *ctx, imap_cmd_open_box_t *cmdp, int response )
{
transform_box_response( &response );
cmdp->callback( response, ctx->uidvalidity, cmdp->callback_aux );
}
static int

20
src/drv_maildir.c
Unescape View File

@ -70,7 +70,7 @@ typedef struct {
typedef struct {
store_t gen;
uint opts;
int uvfd, uvok, nuid, is_inbox, fresh[3];
int uvfd, uvok, uidvalidity, nuid, is_inbox, fresh[3];
int minuid, maxuid, newuid, seenuid;
int_array_t excs;
char *path; /* own */
@ -657,7 +657,7 @@ maildir_store_uidval( maildir_store_t *ctx )
if (ctx->db) {
key.data = (void *)"UIDVALIDITY";
key.size = 11;
uv[0] = ctx->gen.uidvalidity;
uv[0] = ctx->uidvalidity;
uv[1] = ctx->nuid;
value.data = uv;
value.size = sizeof(uv);
@ -672,7 +672,7 @@ maildir_store_uidval( maildir_store_t *ctx )
} else
#endif /* USE_DB */
{
n = sprintf( buf, "%d\n%d\n", ctx->gen.uidvalidity, ctx->nuid );
n = sprintf( buf, "%d\n%d\n", ctx->uidvalidity, ctx->nuid );
lseek( ctx->uvfd, 0, SEEK_SET );
if (write( ctx->uvfd, buf, n ) != n || ftruncate( ctx->uvfd, n ) || (UseFSync && fdatasync( ctx->uvfd ))) {
error( "Maildir error: cannot write UIDVALIDITY.\n" );
@ -686,7 +686,7 @@ maildir_store_uidval( maildir_store_t *ctx )
static int
maildir_init_uidval( maildir_store_t *ctx )
{
ctx->gen.uidvalidity = time( 0 );
ctx->uidvalidity = time( 0 );
ctx->nuid = 0;
ctx->uvok = 0;
#ifdef USE_DB
@ -754,14 +754,14 @@ maildir_uidval_lock( maildir_store_t *ctx )
}
return maildir_init_uidval_new( ctx );
}
ctx->gen.uidvalidity = ((int *)value.data)[0];
ctx->uidvalidity = ((int *)value.data)[0];
ctx->nuid = ((int *)value.data)[1];
} else
#endif
{
lseek( ctx->uvfd, 0, SEEK_SET );
if ((n = read( ctx->uvfd, buf, sizeof(buf) - 1 )) <= 0 ||
(buf[n] = 0, sscanf( buf, "%d\n%d", &ctx->gen.uidvalidity, &ctx->nuid ) != 2)) {
(buf[n] = 0, sscanf( buf, "%d\n%d", &ctx->uidvalidity, &ctx->nuid ) != 2)) {
#if 1
/* In a generic driver, resetting the UID validity would be the right thing.
* But this would mess up the sync state completely. So better bail out and
@ -1266,7 +1266,7 @@ maildir_get_box_path( store_t *gctx )
static void
maildir_open_box( store_t *gctx,
void (*cb)( int sts, void *aux ), void *aux )
void (*cb)( int sts, int uidvalidity, void *aux ), void *aux )
{
maildir_store_t *ctx = (maildir_store_t *)gctx;
int ret;
@ -1279,7 +1279,7 @@ maildir_open_box( store_t *gctx,
#ifndef USE_DB
if ((ctx->uvfd = open( uvpath, O_RDWR|O_CREAT, 0600 )) < 0) {
sys_error( "Maildir error: cannot write %s", uvpath );
cb( DRV_BOX_BAD, aux );
cb( DRV_BOX_BAD, UIDVAL_BAD, aux );
return;
}
#else
@ -1296,7 +1296,7 @@ maildir_open_box( store_t *gctx,
goto fnok;
}
sys_error( "Maildir error: cannot write %s", uvpath );
cb( DRV_BOX_BAD, aux );
cb( DRV_BOX_BAD, UIDVAL_BAD, aux );
return;
} else {
dbok:
@ -1308,7 +1308,7 @@ maildir_open_box( store_t *gctx,
ret = maildir_uidval_lock( ctx );
bail:
cb( ret, aux );
cb( ret, ctx->uidvalidity, aux );
}
static int

29
src/sync.c
Unescape View File

@ -158,6 +158,7 @@ typedef struct {
int maxuid[2]; /* highest UID that was already propagated */
int newmaxuid[2]; /* highest UID that is currently being propagated */
int uidval[2]; /* UID validity value */
int newuidval[2]; /* UID validity obtained from driver */
int newuid[2]; /* TUID lookup makes sense only for UIDs >= this */
int mmaxxuid; /* highest expired UID on master */
} sync_vars_t;
@ -962,11 +963,11 @@ delete_state( sync_vars_t *svars )
}
}
static void box_confirmed( int sts, void *aux );
static void box_confirmed( int sts, int uidvalidity, void *aux );
static void box_confirmed2( sync_vars_t *svars, int t );
static void box_deleted( int sts, void *aux );
static void box_created( int sts, void *aux );
static void box_opened( int sts, void *aux );
static void box_opened( int sts, int uidvalidity, void *aux );
static void box_opened2( sync_vars_t *svars, int t );
static void load_box( sync_vars_t *svars, int t, int minwuid, int_array_t mexcs );
@ -1002,7 +1003,6 @@ sync_boxes( store_t *ctx[], const char *names[], int present[], channel_conf_t *
sync_bail3( svars );
return;
}
ctx[t]->uidvalidity = UIDVAL_BAD;
svars->drv[t] = ctx[t]->conf->driver;
svars->drv[t]->set_bad_callback( ctx[t], store_bad, AUX );
}
@ -1043,7 +1043,7 @@ sync_boxes( store_t *ctx[], const char *names[], int present[], channel_conf_t *
}
static void
box_confirmed( int sts, void *aux )
box_confirmed( int sts, int uidvalidity, void *aux )
{
DECL_SVARS;
@ -1053,8 +1053,10 @@ box_confirmed( int sts, void *aux )
if (check_cancel( svars ))
return;
if (sts == DRV_OK)
if (sts == DRV_OK) {
svars->state[t] |= ST_PRESENT;
svars->newuidval[t] = uidvalidity;
}
box_confirmed2( svars, t );
}
@ -1100,7 +1102,7 @@ box_confirmed2( sync_vars_t *svars, int t )
svars->drv[1-t]->delete_box( svars->ctx[1-t], box_deleted, INV_AUX );
} else {
if (!(svars->chan->ops[t] & OP_CREATE)) {
box_opened( DRV_BOX_BAD, AUX );
box_opened( DRV_BOX_BAD, UIDVAL_BAD, AUX );
} else {
info( "Creating %s %s...\n", str_ms[t], svars->orig_name[t] );
svars->drv[t]->create_box( svars->ctx[t], box_created, AUX );
@ -1142,7 +1144,7 @@ box_created( int sts, void *aux )
}
static void
box_opened( int sts, void *aux )
box_opened( int sts, int uidvalidity, void *aux )
{
DECL_SVARS;
@ -1158,6 +1160,7 @@ box_opened( int sts, void *aux )
svars->ret = SYNC_FAIL;
sync_bail( svars );
} else {
svars->newuidval[t] = uidvalidity;
box_opened2( svars, t );
}
}
@ -1180,13 +1183,13 @@ box_opened2( sync_vars_t *svars, int t )
fails = 0;
for (t = 0; t < 2; t++)
if (svars->uidval[t] != UIDVAL_BAD && svars->uidval[t] != ctx[t]->uidvalidity)
if (svars->uidval[t] != UIDVAL_BAD && svars->uidval[t] != svars->newuidval[t])
fails++;
if (fails == 2) {
error( "Error: channel %s: UIDVALIDITY of both master and slave changed\n"
"(master got %d, expected %d; slave got %d, expected %d).\n",
svars->chan->name,
ctx[M]->uidvalidity, svars->uidval[M], ctx[S]->uidvalidity, svars->uidval[S] );
svars->newuidval[M], svars->uidval[M], svars->newuidval[S], svars->uidval[S] );
bail:
svars->ret = SYNC_FAIL;
sync_bail( svars );
@ -1429,7 +1432,7 @@ box_loaded( int sts, message_t *msgs, int total_msgs, int recent_msgs, void *aux
return;
for (t = 0; t < 2; t++) {
if (svars->uidval[t] != UIDVAL_BAD && svars->uidval[t] != svars->ctx[t]->uidvalidity) {
if (svars->uidval[t] != UIDVAL_BAD && svars->uidval[t] != svars->newuidval[t]) {
unsigned need = 0, got = 0;
debug( "trying to re-approve uid validity of %s\n", str_ms[t] );
for (srec = svars->srecs; srec; srec = srec->next) {
@ -1460,7 +1463,7 @@ box_loaded( int sts, message_t *msgs, int total_msgs, int recent_msgs, void *aux
error( "Error: channel %s, %s %s: Unable to recover from UIDVALIDITY change\n"
"(got %d, expected %d).\n",
svars->chan->name, str_ms[t], svars->orig_name[t],
svars->ctx[t]->uidvalidity, svars->uidval[t] );
svars->newuidval[t], svars->uidval[t] );
goto uvchg;
}
notice( "Notice: channel %s, %s %s: Recovered from change of UIDVALIDITY.\n",
@ -1470,8 +1473,8 @@ box_loaded( int sts, message_t *msgs, int total_msgs, int recent_msgs, void *aux
}
if (svars->uidval[M] == UIDVAL_BAD || svars->uidval[S] == UIDVAL_BAD) {
svars->uidval[M] = svars->ctx[M]->uidvalidity;
svars->uidval[S] = svars->ctx[S]->uidvalidity;
svars->uidval[M] = svars->newuidval[M];
svars->uidval[S] = svars->newuidval[S];
jFprintf( svars, "| %d %d\n", svars->uidval[M], svars->uidval[S] );
}

Write Preview
Loading…
Cancel
Save