/* This function reads the manifest to determine whether it may be more
efficient to just copy the data files across and unpack them on the other
side. If it thinks it is, it will then do it.
Return -1 on error, 1 if it copied the data across, 0 if it did not. */
static int maybe_copy_data_files_across(struct asfd *asfd,
const char *manifest,
const char *datadir, int srestore, regex_t *regex, struct conf *conf,
struct slist *slist,
enum action act, enum cstat_status status)
{
int ars;
int ret=-1;
struct sbuf *sb=NULL;
struct blk *blk=NULL;
struct manio *manio=NULL;
uint64_t blkcount=0;
uint64_t datcount=0;
struct hash_weak *tmpw;
struct hash_weak *hash_weak;
uint64_t estimate_blks;
uint64_t estimate_dats;
uint64_t estimate_one_dat;
int need_data=0;
int last_ent_was_dir=0;
char sig[128]="";
// If the client has no restore_spool directory, we have to fall back
// to the stream style restore.
if(!conf->restore_spool) return 0;
if(!(manio=manio_alloc())
|| manio_init_read(manio, manifest)
|| !(sb=sbuf_alloc(conf))
|| !(blk=blk_alloc()))
goto end;
while(1)
{
if((ars=manio_sbuf_fill(manio, asfd, sb, blk, NULL, conf))<0)
{
logp("Error from manio_sbuf_fill() in %s\n",
__func__);
goto end; // Error;
}
else if(ars>0)
break; // Finished OK.
if(!blk->got_save_path)
{
sbuf_free_content(sb);
continue;
}
if((!srestore || check_srestore(conf, sb->path.buf))
&& check_regex(regex, sb->path.buf))
{
blkcount++;
if(!hash_weak_find((uint64_t)blk->savepath))
{
if(!hash_weak_add((uint64_t)blk->savepath))
goto end;
datcount++;
}
}
sbuf_free_content(sb);
}
estimate_blks=blkcount*RABIN_AVG;
estimate_one_dat=DATA_FILE_SIG_MAX*RABIN_AVG;
estimate_dats=datcount*estimate_one_dat;
printf("%lu blocks = %lu bytes in stream approx\n",
blkcount, estimate_blks);
printf("%lu data files = %lu bytes approx\n",
datcount, estimate_dats);
if(estimate_blks < estimate_one_dat)
{
printf("Stream is less than the size of a data file.\n");
printf("Use restore stream\n");
return 0;
}
else if(estimate_dats >= 90*(estimate_blks/100))
{
printf("Stream is more than 90%% size of data files.\n");
printf("Use restore stream\n");
return 0;
}
else
{
printf("Data files are less than 90%% size of stream.\n");
printf("Use data files\n");
}
printf("Client is using restore_spool: %s\n", conf->restore_spool);
if(asfd->write_str(asfd, CMD_GEN, "restore_spool")
|| asfd->read_expect(asfd, CMD_GEN, "restore_spool_ok"))
goto end;
// Send each of the data files that we found to the client.
HASH_ITER(hh, hash_table, hash_weak, tmpw)
{
char msg[32];
char path[32];
char *fdatpath=NULL;
snprintf(path, sizeof(path), "%014lX", hash_weak->weak);
path[4]='/';
path[9]='/';
snprintf(msg, sizeof(msg), "dat=%s", path);
printf("got: %s\n", msg);
if(asfd->write_str(asfd, CMD_GEN, msg)) goto end;
if(!(fdatpath=prepend_s(datadir, path)))
goto end;
if(send_a_file(asfd, fdatpath, conf))
{
free(fdatpath);
goto end;
}
free(fdatpath);
}
// a = length of struct bu array
// i = position to restore from
static int restore_manifest(struct bu *arr, int a, int i, const char *tmppath1, const char *tmppath2, regex_t *regex, int srestore, enum action act, const char *client, char **dir_for_notify, struct cntr *p1cntr, struct cntr *cntr, struct config *cconf)
{
int ret=0;
gzFile zp=NULL;
char *manifest=NULL;
char *datadir=NULL;
FILE *logfp=NULL;
char *logpath=NULL;
char *logpathz=NULL;
// For sending status information up to the server.
char status=STATUS_RESTORING;
if(act==ACTION_RESTORE) status=STATUS_RESTORING;
else if(act==ACTION_VERIFY) status=STATUS_VERIFYING;
if(
(act==ACTION_RESTORE && !(logpath=prepend_s(arr[i].path, "restorelog", strlen("restorelog"))))
|| (act==ACTION_RESTORE && !(logpathz=prepend_s(arr[i].path, "restorelog.gz", strlen("restorelog.gz"))))
|| (act==ACTION_VERIFY && !(logpath=prepend_s(arr[i].path, "verifylog", strlen("verifylog"))))
|| (act==ACTION_VERIFY && !(logpathz=prepend_s(arr[i].path, "verifylog.gz", strlen("verifylog.gz"))))
|| !(manifest=prepend_s(arr[i].path, "manifest.gz", strlen("manifest.gz"))))
{
log_and_send_oom(__FUNCTION__);
ret=-1;
}
else if(!(logfp=open_file(logpath, "ab")) || set_logfp(logfp, cconf))
{
char msg[256]="";
snprintf(msg, sizeof(msg),
"could not open log file: %s", logpath);
log_and_send(msg);
ret=-1;
}
*dir_for_notify=strdup(arr[i].path);
log_restore_settings(cconf, srestore);
// First, do a pass through the manifest to set up the counters.
// This is the equivalent of a phase1 scan during backup.
if(!ret && !(zp=gzopen_file(manifest, "rb")))
{
log_and_send("could not open manifest");
ret=-1;
}
else
{
int ars=0;
int quit=0;
struct sbuf sb;
init_sbuf(&sb);
while(!quit)
{
if((ars=sbuf_fill(NULL, zp, &sb, cntr)))
{
if(ars<0) ret=-1;
// ars==1 means end ok
quit++;
}
else
{
if((!srestore
|| check_srestore(cconf, sb.path))
&& check_regex(regex, sb.path))
{
do_filecounter(p1cntr, sb.cmd, 0);
if(sb.endfile)
do_filecounter_bytes(p1cntr,
strtoull(sb.endfile, NULL, 10));
/*
if(sb.cmd==CMD_FILE
|| sb.cmd==CMD_ENC_FILE
|| sb.cmd==CMD_METADATA
|| sb.cmd==CMD_ENC_METADATA
|| sb.cmd==CMD_VSS
|| sb.cmd==CMD_ENC_VSS
|| sb.cmd==CMD_VSS_T
|| sb.cmd==CMD_ENC_VSS_T
|| sb.cmd==CMD_EFS_FILE)
do_filecounter_bytes(p1cntr,
(unsigned long long)
sb.statp.st_size);
*/
}
}
free_sbuf(&sb);
}
free_sbuf(&sb);
gzclose_fp(&zp);
}
if(cconf->send_client_counters)
{
if(send_counters(client, p1cntr, cntr))
{
ret=-1;
}
}
// Now, do the actual restore.
if(!ret && !(zp=gzopen_file(manifest, "rb")))
{
log_and_send("could not open manifest");
ret=-1;
}
else
{
char cmd;
int s=0;
int quit=0;
size_t len=0;
struct sbuf sb;
// For out-of-sequence directory restoring so that the
// timestamps come out right:
int scount=0;
struct sbuf **sblist=NULL;
init_sbuf(&sb);
while(!quit)
{
int ars=0;
char *buf=NULL;
if(async_read_quick(&cmd, &buf, &len))
{
logp("read quick error\n");
ret=-1; quit++; break;
}
if(buf)
{
//logp("got read quick\n");
if(cmd==CMD_WARNING)
{
logp("WARNING: %s\n", buf);
do_filecounter(cntr, cmd, 0);
free(buf); buf=NULL;
continue;
}
else if(cmd==CMD_INTERRUPT)
{
// Client wanted to interrupt the
// sending of a file. But if we are
// here, we have already moved on.
// Ignore.
free(buf); buf=NULL;
continue;
}
else
{
logp("unexpected cmd from client: %c:%s\n", cmd, buf);
free(buf); buf=NULL;
ret=-1; quit++; break;
}
}
if((ars=sbuf_fill(NULL, zp, &sb, cntr)))
{
if(ars<0) ret=-1;
// ars==1 means end ok
quit++;
}
else
{
if((!srestore
|| check_srestore(cconf, sb.path))
&& check_regex(regex, sb.path)
&& restore_ent(client,
&sb, &sblist, &scount,
arr, a, i, tmppath1, tmppath2,
act, status, cconf,
cntr, p1cntr))
{
ret=-1;
quit++;
}
}
free_sbuf(&sb);
}
gzclose_fp(&zp);
// Restore any directories that are left in the list.
if(!ret) for(s=scount-1; s>=0; s--)
{
if(restore_sbuf(sblist[s], arr, a, i,
tmppath1, tmppath2, act, client, status,
p1cntr, cntr, cconf))
{
ret=-1;
break;
}
}
free_sbufs(sblist, scount);
if(!ret) ret=do_restore_end(act, cntr);
//print_endcounter(cntr);
print_filecounters(p1cntr, cntr, act);
reset_filecounter(p1cntr, time(NULL));
reset_filecounter(cntr, time(NULL));
}
set_logfp(NULL, cconf);
compress_file(logpath, logpathz, cconf);
if(manifest) free(manifest);
if(datadir) free(datadir);
if(logpath) free(logpath);
if(logpathz) free(logpathz);
return ret;
}
int want_to_restore(int srestore, struct sbuf *sb,
regex_t *regex, struct conf **cconfs)
{
return (!srestore || check_srestore(cconfs, sb->path.buf))
&& check_regex(regex, sb->path.buf);
}
