static
#endif
int write_hook_header(struct fzp *fzp, const char *rmanifest, const char *msg)
{
int ret=0;
char *tmp=NULL;
if(!(tmp=prepend_s(rmanifest, msg))
|| send_msg_fzp(fzp, CMD_MANIFEST, tmp, strlen(tmp)))
ret=-1;
free_w(&tmp);
return ret;
}
int sbuf_to_manifest(struct sbuf *sb, struct fzp *fzp)
{
if(!sb->path.buf) return 0;
if(sb->protocol1)
{
if(sb->protocol1->datapth.buf
&& iobuf_send_msg_fzp(&(sb->protocol1->datapth), fzp))
return -1;
if(iobuf_send_msg_fzp(&sb->attr, fzp))
return -1;
}
else
{
// Hackity hack: Strip the file index from the beginning of
// the attribs so that manifests where nothing changed are
// identical to each other. Better would be to preserve the
// index.
char *cp;
if(!(cp=strchr(sb->attr.buf, ' ')))
{
logp("Strange attributes: %s\n",
iobuf_to_printable(&sb->attr));
return -1;
}
if(send_msg_fzp(fzp, CMD_ATTRIBS,
cp, sb->attr.len-(cp-sb->attr.buf)))
return -1;
}
if(iobuf_send_msg_fzp(&sb->path, fzp))
return -1;
if(sb->link.buf
&& iobuf_send_msg_fzp(&sb->link, fzp))
return -1;
if(sb->endfile.buf
&& iobuf_send_msg_fzp(&sb->endfile, fzp))
return -1;
return 0;
}
static struct slist *build_manifest_phase1(const char *path,
enum protocol protocol, int entries)
{
struct sbuf *sb;
struct slist *slist=NULL;
struct manio *manio=NULL;
slist=build_slist_phase1(NULL /*prefix*/, protocol, entries);
fail_unless((manio=manio_open_phase1(path, "wb", protocol))!=NULL);
for(sb=slist->head; sb; sb=sb->next)
{
fail_unless(!manio_write_sbuf(manio, sb));
if(protocol==PROTO_2) hack_protocol2_attr(&sb->attr);
}
fail_unless(!send_msg_fzp(manio->fzp,
CMD_GEN, "phase1end", strlen("phase1end")));
fail_unless(!manio_close(&manio));
return slist;
}
void build_manifest_phase1_from_slist(const char *path,
struct slist *slist, enum protocol protocol)
{
struct sbuf *sb;
struct manio *manio=NULL;
struct iobuf datapth;
struct iobuf endfile;
iobuf_init(&datapth);
iobuf_init(&endfile);
for(sb=slist->head; sb; sb=sb->next)
set_sbuf(slist, sb, 0 /* with_data_files */);
fail_unless((manio=manio_open_phase1(path, "wb", protocol))!=NULL);
for(sb=slist->head; sb; sb=sb->next)
{
// Might be given an slist that has datapth or endfile set,
// which should not go into a phase1 scan. Deal with it.
if(sb->protocol1
&& sb->protocol1->datapth.buf)
iobuf_move(&datapth, &sb->protocol1->datapth);
if(sb->endfile.buf)
iobuf_move(&endfile, &sb->endfile);
fail_unless(!manio_write_sbuf(manio, sb));
if(datapth.buf)
iobuf_move(&sb->protocol1->datapth, &datapth);
if(endfile.buf)
iobuf_move(&sb->endfile, &endfile);
}
fail_unless(!send_msg_fzp(manio->fzp,
CMD_GEN, "phase1end", strlen("phase1end")));
fail_unless(!manio_close(&manio));
}
int iobuf_send_msg_fzp(struct iobuf *iobuf, struct fzp *fzp)
{
return send_msg_fzp(fzp, iobuf->cmd, iobuf->buf, iobuf->len);
}
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;
}
static int write_sig_msg(struct manio *manio, const char *msg)
{
if(!manio->fzp && manio_open_next_fpath(manio)) return -1;
if(send_msg_fzp(manio->fzp, CMD_SIG, msg, strlen(msg))) return -1;
return check_sig_count(manio, msg);
}