// Used on resume, this just reads the phase1 file and sets up cntr.
static int read_phase1(struct manio *p1manio, struct conf **cconfs)
{
int ret=-1;
struct sbuf *p1b;
enum protocol protocol=get_protocol(cconfs);
struct cntr *cntr=get_cntr(cconfs);
if(!(p1b=sbuf_alloc(protocol))) return -1;
while(1)
{
sbuf_free_content(p1b);
switch(manio_read(p1manio, p1b))
{
case 0:
break;
case 1:
ret=0;
default:
goto end;
}
cntr_add_phase1(cntr, p1b->path.cmd, 0);
if(sbuf_is_estimatable(p1b))
cntr_add_val(cntr, CMD_BYTES_ESTIMATED,
(uint64_t)p1b->statp.st_size);
}
end:
sbuf_free(&p1b);
return ret;
}
static int usual_stuff(struct asfd *asfd,
struct conf *conf, const char *path, const char *link,
struct sbuf *sb, char cmd)
{
if(asfd->write_str(asfd, CMD_ATTRIBS, sb->attr.buf)
|| asfd->write_str(asfd, cmd, path)
|| ((cmd==CMD_HARD_LINK || cmd==CMD_SOFT_LINK)
&& asfd->write_str(asfd, cmd, link)))
return -1;
cntr_add_phase1(conf->cntr, cmd, 1);
return 0;
}
static int usual_stuff(struct asfd *asfd,
struct cntr *cntr, const char *path, const char *link,
struct sbuf *sb, enum cmd cmd)
{
// When run with ACTION_ESTIMATE, asfd is NULL.
if(asfd)
{
if(asfd->write_str(asfd, CMD_ATTRIBS, sb->attr.buf)
|| asfd->write_str(asfd, cmd, path)
|| ((cmd==CMD_HARD_LINK || cmd==CMD_SOFT_LINK)
&& asfd->write_str(asfd, cmd, link)))
return -1;
}
cntr_add_phase1(cntr, cmd, 1);
return 0;
}
static int setup_cntr(struct asfd *asfd, const char *manifest,
regex_t *regex, int srestore,
enum action act, char status, struct conf **cconfs)
{
int ars=0;
int ret=-1;
struct fzp *fzp=NULL;
struct sbuf *sb=NULL;
struct cntr *cntr=get_cntr(cconfs);
// FIX THIS: this is only trying to work for protocol1.
if(get_protocol(cconfs)!=PROTO_1) return 0;
if(!(sb=sbuf_alloc(PROTO_1))) goto end;
if(!(fzp=fzp_gzopen(manifest, "rb")))
{
log_and_send(asfd, "could not open manifest");
goto end;
}
while(1)
{
if((ars=sbuf_fill_from_file(sb, fzp, NULL, NULL)))
{
if(ars<0) goto end;
// ars==1 means end ok
break;
}
else
{
if(want_to_restore(srestore, sb, regex, cconfs))
{
cntr_add_phase1(cntr, sb->path.cmd, 0);
if(sb->endfile.buf)
cntr_add_val(cntr,
CMD_BYTES_ESTIMATED,
strtoull(sb->endfile.buf,
NULL, 10), 0);
}
}
sbuf_free_content(sb);
}
ret=0;
end:
sbuf_free(&sb);
fzp_close(&fzp);
return ret;
}
int backup_phase1_server_all(struct async *as,
struct sdirs *sdirs, struct conf *conf)
{
int ars=0;
int ret=-1;
struct sbuf *sb=NULL;
gzFile p1zp=NULL;
char *phase1tmp=NULL;
struct asfd *asfd=as->asfd;
logp("Begin phase1 (file system scan)\n");
if(!(phase1tmp=get_tmp_filename(sdirs->phase1data)))
goto end;
if(!(p1zp=gzopen_file(phase1tmp, comp_level(conf))))
goto end;
if(!(sb=sbuf_alloc(conf)))
goto end;
while(1)
{
sbuf_free_content(sb);
if(conf->protocol==PROTO_BURP1)
ars=sbufl_fill(sb, asfd, NULL, NULL, conf->cntr);
else
ars=sbuf_fill(sb, asfd, NULL, NULL, NULL, conf);
if(ars)
{
if(ars<0) goto end;
//ars==1 means it ended ok.
// Last thing the client sends is 'backupphase2', and
// it wants an 'ok' reply.
if(asfd->write_str(asfd, CMD_GEN, "ok")
|| send_msg_zp(p1zp, CMD_GEN,
"phase1end", strlen("phase1end")))
goto end;
break;
}
if(write_status(STATUS_SCANNING, sb->path.buf, conf)
|| sbufl_to_manifest_phase1(sb, NULL, p1zp))
goto end;
cntr_add_phase1(conf->cntr, sb->path.cmd, 0);
if(sb->path.cmd==CMD_FILE
|| sb->path.cmd==CMD_ENC_FILE
|| sb->path.cmd==CMD_METADATA
|| sb->path.cmd==CMD_ENC_METADATA
|| sb->path.cmd==CMD_EFS_FILE)
cntr_add_val(conf->cntr, CMD_BYTES_ESTIMATED,
(unsigned long long)sb->statp.st_size, 0);
}
if(gzclose_fp(&p1zp))
{
logp("error closing %s in backup_phase1_server\n", phase1tmp);
goto end;
}
// Possible rename race condition is of no consequence here, because
// the working directory will always get deleted if phase1 is not
// complete.
if(do_rename(phase1tmp, sdirs->phase1data))
goto end;
//cntr_print(p1cntr, cntr, ACTION_BACKUP);
logp("End phase1 (file system scan)\n");
ret=0;
end:
free(phase1tmp);
gzclose_fp(&p1zp);
sbuf_free(&sb);
return ret;
}
int backup_phase1_server_all(struct async *as,
struct sdirs *sdirs, struct conf **confs)
{
int ret=-1;
struct sbuf *sb=NULL;
char *phase1tmp=NULL;
struct asfd *asfd=as->asfd;
struct manio *manio=NULL;
enum protocol protocol=get_protocol(confs);
struct cntr *cntr=get_cntr(confs);
logp("Begin phase1 (file system scan)\n");
if(!(phase1tmp=get_tmp_filename(sdirs->phase1data))
|| !(manio=manio_open_phase1(phase1tmp,
comp_level(get_int(confs[OPT_COMPRESSION])), protocol))
|| !(sb=sbuf_alloc(protocol)))
goto error;
while(1)
{
sbuf_free_content(sb);
switch(sbuf_fill_from_net(sb, asfd, NULL, NULL, cntr))
{
case 0: break;
case 1: // Last thing the client sends is
// 'backupphase2', and it wants an 'ok' reply.
if(asfd->write_str(asfd, CMD_GEN, "ok")
|| send_msg_fzp(manio->fzp, CMD_GEN,
"phase1end", strlen("phase1end")))
goto error;
goto end;
case -1:
default: goto error;
}
if(write_status(CNTR_STATUS_SCANNING, sb->path.buf, cntr)
|| manio_write_sbuf(manio, sb))
goto error;
cntr_add_phase1(cntr, sb->path.cmd, 0);
if(sbuf_is_filedata(sb))
{
cntr_add_val(cntr, CMD_BYTES_ESTIMATED,
(uint64_t)sb->statp.st_size, 0);
}
}
end:
if(manio_close(&manio))
{
logp("error closing %s in backup_phase1_server\n", phase1tmp);
goto error;
}
if(check_quota(as, cntr,
get_uint64_t(confs[OPT_HARD_QUOTA]),
get_uint64_t(confs[OPT_SOFT_QUOTA])))
goto error;
// Possible rename race condition is of no consequence here, because
// the working directory will always get deleted if phase1 is not
// complete.
if(do_rename(phase1tmp, sdirs->phase1data))
goto error;
//cntr_print(p1cntr, cntr, ACTION_BACKUP);
logp("End phase1 (file system scan)\n");
ret=0;
error:
free_w(&phase1tmp);
manio_close(&manio);
sbuf_free(&sb);
return ret;
}
