END_TEST
static void test_manifest_tell_seek(enum protocol protocol, int phase)
{
struct slist *slist;
struct manio *manio;
struct sbuf *sb=NULL;
man_off_t *offset=NULL;
int entries=1000;
prng_init(0);
base64_init();
hexmap_init();
recursive_delete(path);
slist=build_manifest(path, protocol, entries, phase);
fail_unless(slist!=NULL);
sb=slist->head;
fail_unless((manio=do_manio_open(path, "rb", protocol, phase))!=NULL);
read_manifest(&sb, manio, 0, entries/2, protocol, phase);
fail_unless((offset=manio_tell(manio))!=NULL);
fail_unless(sb!=NULL);
fail_unless(!manio_close(&manio));
fail_unless((manio=do_manio_open(path, "rb", protocol, phase))!=NULL);
fail_unless(!manio_seek(manio, offset));
read_manifest(&sb, manio, entries/2, entries, protocol, phase);
fail_unless(sb==NULL);
fail_unless(!manio_close(&manio));
fail_unless(!manio);
slist_free(&slist);
man_off_t_free(&offset);
tear_down();
}
struct manios *manios_open_phase2(struct sdirs *sdirs, man_off_t *p1pos,
enum protocol p)
{
struct manios *m=NULL;
if(!(m=manios_alloc())
|| !(m->current=manio_open(sdirs->cmanifest, "rb", p))
|| !(m->phase1=manio_open_phase1(sdirs->phase1data, "rb", p))
|| !(m->changed=manio_open_phase2(sdirs->changed, "ab", p))
|| !(m->unchanged=manio_open_phase2(sdirs->unchanged, "ab", p))
|| (p1pos && manio_seek(m->phase1, p1pos)))
manios_close(&m);
return m;
}
int backup_phase2_server_protocol1(struct async *as, struct sdirs *sdirs,
const char *incexc, int resume, struct conf **cconfs)
{
int ret=0;
man_off_t *p1pos=NULL;
struct manio *p1manio=NULL;
struct dpth *dpth=NULL;
char *deltmppath=NULL;
char *last_requested=NULL;
struct manio *chmanio=NULL; // changed data
struct manio *ucmanio=NULL; // unchanged data
struct manio *cmanio=NULL; // previous (current) manifest.
struct sbuf *cb=NULL; // file list in current manifest
struct sbuf *p1b=NULL; // file list from client
struct sbuf *rb=NULL; // receiving file from client
struct asfd *asfd=NULL;
int breaking=0;
int breakcount=0;
struct cntr *cntr=NULL;
if(!as)
{
logp("async not provided to %s()\n", __func__);
goto error;
}
if(!sdirs)
{
logp("sdirs not provided to %s()\n", __func__);
goto error;
}
if(!cconfs)
{
logp("cconfs not provided to %s()\n", __func__);
goto error;
}
asfd=as->asfd;
if(!asfd)
{
logp("asfd not provided to %s()\n", __func__);
goto error;
}
cntr=get_cntr(cconfs);
if(get_int(cconfs[OPT_BREAKPOINT])>=2000
&& get_int(cconfs[OPT_BREAKPOINT])<3000)
{
breaking=get_int(cconfs[OPT_BREAKPOINT]);
breakcount=breaking-2000;
}
logp("Begin phase2 (receive file data)\n");
if(!(dpth=dpth_alloc())
|| dpth_protocol1_init(dpth, sdirs->currentdata,
get_int(cconfs[OPT_MAX_STORAGE_SUBDIRS])))
goto error;
if(open_previous_manifest(&cmanio, sdirs, incexc, cconfs))
goto error;
if(get_int(cconfs[OPT_DIRECTORY_TREE]))
{
// Need to make sure we do not try to create a path that is
// too long.
if(build_path_w(sdirs->treepath)) goto error;
mkdir(sdirs->treepath, 0777);
treepathlen=strlen(sdirs->treepath);
if(init_fs_max(sdirs->treepath))
goto error;
}
if(resume && !(p1pos=do_resume(sdirs, dpth, cconfs)))
goto error;
if(!(p1manio=manio_open_phase1(sdirs->phase1data, "rb", PROTO_1))
|| (resume && manio_seek(p1manio, p1pos)))
goto error;
if(!(cb=sbuf_alloc(PROTO_1))
|| !(p1b=sbuf_alloc(PROTO_1))
|| !(rb=sbuf_alloc(PROTO_1)))
goto error;
// Unchanged and changed should now be truncated correctly, we just
// have to open them for appending.
// Data is not getting written to a compressed file.
// This is important for recovery if the power goes.
if(!(ucmanio=manio_open_phase2(sdirs->unchanged, "ab", PROTO_1))
|| !(chmanio=manio_open_phase2(sdirs->changed, "ab", PROTO_1)))
goto error;
while(1)
{
if(breaking && breakcount--==0)
return breakpoint(breaking, __func__);
if(write_status(CNTR_STATUS_BACKUP,
rb->path.buf?rb->path.buf:p1b->path.buf, cntr))
goto error;
if(last_requested
|| !p1manio
|| asfd->writebuflen)
{
switch(do_stuff_to_receive(asfd, sdirs,
cconfs, rb, chmanio, dpth, &last_requested))
{
case 0: break;
case 1: goto end; // Finished ok.
case -1: goto error;
}
}
switch(do_stuff_to_send(asfd, p1b, &last_requested))
{
case 0: break;
case 1: continue;
case -1: goto error;
}
if(!p1manio) continue;
sbuf_free_content(p1b);
switch(manio_read(p1manio, p1b))
{
case 0: break;
case 1: manio_close(&p1manio);
if(asfd->write_str(asfd,
CMD_GEN, "backupphase2end")) goto error;
break;
case -1: goto error;
}
if(!cmanio)
{
// No old manifest, need to ask for a new file.
if(process_new(sdirs, cconfs, p1b, ucmanio))
goto error;
continue;
}
// Have an old manifest, look for it there.
// Might already have it, or be ahead in the old
// manifest.
if(cb->path.buf) switch(maybe_process_file(asfd,
sdirs, cb, p1b, ucmanio, cconfs))
{
case 0: break;
case 1: continue;
case -1: goto error;
}
while(cmanio)
{
sbuf_free_content(cb);
switch(manio_read(cmanio, cb))
{
case 0: break;
case 1: manio_close(&cmanio);
if(process_new(sdirs, cconfs, p1b,
ucmanio)) goto error;
continue;
case -1: goto error;
}
switch(maybe_process_file(asfd, sdirs,
cb, p1b, ucmanio, cconfs))
{
case 0: continue;
case 1: break;
case -1: goto error;
}
break;
}
}
error:
ret=-1;
end:
if(manio_close(&chmanio))
{
logp("error closing %s in %s\n", sdirs->changed, __func__);
ret=-1;
}
if(manio_close(&ucmanio))
{
logp("error closing %s in %s\n", sdirs->unchanged, __func__);
ret=-1;
}
free_w(&deltmppath);
free_w(&last_requested);
sbuf_free(&cb);
sbuf_free(&p1b);
sbuf_free(&rb);
manio_close(&p1manio);
manio_close(&cmanio);
dpth_free(&dpth);
man_off_t_free(&p1pos);
if(!ret && sdirs)
unlink(sdirs->phase1data);
logp("End phase2 (receive file data)\n");
return ret;
}