int restore_switch_protocol1(struct asfd *asfd, struct sbuf *sb,
const char *fullpath, enum action act,
BFILE *bfd, int vss_restore, struct cntr *cntr,
const char *encryption_password)
{
switch(sb->path.cmd)
{
case CMD_FILE:
case CMD_VSS_T:
case CMD_ENC_FILE:
case CMD_ENC_VSS_T:
case CMD_EFS_FILE:
if(!sb->protocol1->datapth.buf)
{
char msg[256];
snprintf(msg, sizeof(msg),
"datapth not supplied for %c:%s in %s\n",
sb->path.cmd, sb->path.buf, __func__);
log_and_send(asfd, msg);
return -1;
}
return restore_file_or_get_meta(asfd, bfd, sb,
fullpath, act,
NULL, NULL, vss_restore, cntr,
encryption_password);
case CMD_METADATA:
case CMD_VSS:
case CMD_ENC_METADATA:
case CMD_ENC_VSS:
return restore_metadata(asfd, bfd, sb,
fullpath, act,
vss_restore, cntr, encryption_password);
default:
// Other cases (dir/links/etc) are handled in the
// calling function.
logp("unknown cmd: %c\n", sb->path.cmd);
return -1;
}
}
int do_restore_client_burp1(struct asfd *asfd,
struct conf *conf, enum action act, int vss_restore)
{
int ars=0;
int ret=-1;
char msg[512]="";
struct sbuf *sb=NULL;
// Windows needs to have the VSS data written first, and the actual data
// written immediately afterwards. The server is transferring them in two
// chunks. So, leave bfd open after a Windows metadata transfer.
BFILE bfd;
#ifdef HAVE_WIN32
binit(&bfd, 0, conf);
#endif
logp("doing %s\n", act_str(act));
snprintf(msg, sizeof(msg), "%s %s:%s", act_str(act),
conf->backup?conf->backup:"", conf->regex?conf->regex:"");
if(asfd->write_str(asfd, CMD_GEN, msg)
|| asfd->read_expect(asfd, CMD_GEN, "ok"))
return -1;
logp("doing %s confirmed\n", act_str(act));
if(conf->send_client_cntr)
{
// FIX THIS
// if(cntr_recv(conf)) goto end;
}
#if defined(HAVE_WIN32)
if(act==ACTION_RESTORE) win32_enable_backup_privileges();
#endif
if(!(sb=sbuf_alloc(conf))) goto end;
while(1)
{
char *fullpath=NULL;
sbuf_free_content(sb);
if((ars=sbufl_fill(sb, asfd, NULL, NULL, conf->cntr)))
{
if(ars<0) goto end;
else
{
// ars==1 means it ended ok.
//logp("got %s end\n", act_str(act));
if(asfd->write_str(asfd,
CMD_GEN, "restoreend ok")) goto end;
}
break;
}
switch(sb->path.cmd)
{
case CMD_DIRECTORY:
case CMD_FILE:
case CMD_ENC_FILE:
case CMD_SOFT_LINK:
case CMD_HARD_LINK:
case CMD_SPECIAL:
case CMD_METADATA:
case CMD_ENC_METADATA:
case CMD_VSS:
case CMD_ENC_VSS:
case CMD_VSS_T:
case CMD_ENC_VSS_T:
case CMD_EFS_FILE:
if(conf->strip)
{
int s;
s=strip_path_components(asfd, sb,
&(sb->path.buf), conf);
if(s<0) goto end; // error
else if(s==0)
{
// Too many components stripped
// - carry on.
continue;
}
// It is OK, sb->path is now stripped.
}
if(!(fullpath=prepend_s(conf->restoreprefix,
sb->path.buf)))
{
log_and_send_oom(asfd, __func__);
goto end;
}
if(act==ACTION_RESTORE)
{
strip_invalid_characters(&fullpath);
if(!overwrite_ok(sb, conf, &bfd, fullpath))
{
char msg[512]="";
// Something exists at that path.
snprintf(msg, sizeof(msg),
"Path exists: %s", fullpath);
if(restore_interrupt(asfd, sb, msg, conf))
goto end;
else
{
if(fullpath) free(fullpath);
continue;
}
}
}
break;
default:
break;
}
switch(sb->path.cmd)
{
case CMD_WARNING:
cntr_add(conf->cntr, sb->path.cmd, 1);
printf("\n");
logp("%s", sb->path);
break;
case CMD_DIRECTORY:
if(restore_dir(asfd, sb, fullpath, act, conf))
goto end;
break;
case CMD_FILE:
case CMD_VSS_T:
// Have it a separate statement to the
// encrypted version so that encrypted and not
// encrypted files can be restored at the
// same time.
if(restore_file_or_get_meta(asfd, &bfd, sb,
fullpath, act,
NULL, NULL, NULL,
vss_restore, conf))
{
logp("restore_file error\n");
goto end;
}
break;
case CMD_ENC_FILE:
case CMD_ENC_VSS_T:
if(restore_file_or_get_meta(asfd, &bfd, sb,
fullpath, act,
conf->encryption_password,
NULL, NULL, vss_restore, conf))
{
logp("restore_file error\n");
goto end;
}
break;
case CMD_SOFT_LINK:
case CMD_HARD_LINK:
if(restore_link(asfd, sb, fullpath,
conf->restoreprefix, act, conf))
goto end;
break;
case CMD_SPECIAL:
if(restore_special(asfd, sb, fullpath, act, conf))
goto end;
break;
case CMD_METADATA:
case CMD_VSS:
if(restore_metadata(asfd, &bfd, sb, fullpath,
act, NULL, vss_restore, conf))
goto end;
break;
case CMD_ENC_METADATA:
case CMD_ENC_VSS:
if(restore_metadata(asfd, &bfd, sb, fullpath,
act, conf->encryption_password,
vss_restore, conf))
goto end;
break;
case CMD_EFS_FILE:
if(restore_file_or_get_meta(asfd, &bfd, sb,
fullpath, act,
NULL, NULL, NULL, vss_restore, conf))
{
logp("restore_file error\n");
goto end;
}
break;
default:
logp("unknown cmd: %c\n", sb->path.cmd);
goto end;
break;
}
if(fullpath) free(fullpath);
}
ret=0;
end:
sbuf_free(sb);
#ifdef HAVE_WIN32
// It is possible for a bfd to still be open.
bclose(&bfd, asfd);
#endif
cntr_print_end(conf->cntr);
cntr_print(conf->cntr, act);
if(!ret) logp("%s finished\n", act_str(act));
else logp("ret: %d\n", ret);
return ret;
}
int restore_switch_burp1(struct asfd *asfd, struct sbuf *sb,
const char *fullpath, enum action act,
BFILE *bfd, int vss_restore, struct conf *conf)
{
switch(sb->path.cmd)
{
case CMD_FILE:
case CMD_VSS_T:
// Have it a separate statement to the
// encrypted version so that encrypted and not
// encrypted files can be restored at the
// same time.
if(restore_file_or_get_meta(asfd, bfd, sb,
fullpath, act,
NULL, NULL, NULL,
vss_restore, conf))
{
logp("restore_file error\n");
goto error;
}
break;
case CMD_ENC_FILE:
case CMD_ENC_VSS_T:
if(restore_file_or_get_meta(asfd, bfd, sb,
fullpath, act,
conf->encryption_password,
NULL, NULL, vss_restore, conf))
{
logp("restore_file error\n");
goto error;
}
break;
case CMD_METADATA:
case CMD_VSS:
if(restore_metadata(asfd, bfd, sb, fullpath,
act, NULL, vss_restore, conf))
goto error;
break;
case CMD_ENC_METADATA:
case CMD_ENC_VSS:
if(restore_metadata(asfd, bfd, sb, fullpath,
act, conf->encryption_password,
vss_restore, conf))
goto error;
break;
case CMD_EFS_FILE:
if(restore_file_or_get_meta(asfd, bfd, sb,
fullpath, act,
NULL, NULL, NULL, vss_restore, conf))
{
logp("restore_file error\n");
goto error;
}
break;
default:
// Other cases (dir/links/etc) are handled in the
// calling function.
logp("unknown cmd: %c\n", sb->path.cmd);
goto error;
}
return 0;
error:
return -1;
}
static int
compress_file(struct deflate_compressor *compressor, const tchar *path,
const struct options *options)
{
tchar *newpath = NULL;
struct file_stream in;
struct file_stream out;
struct stat stbuf;
int ret;
int ret2;
if (path != NULL && !options->to_stdout) {
size_t path_nchars, suffix_nchars;
if (!options->force && has_suffix(path, options->suffix)) {
msg("%"TS": already has .%"TS" suffix -- skipping",
path, options->suffix);
ret = -2;
goto out;
}
path_nchars = tstrlen(path);
suffix_nchars = tstrlen(options->suffix);
newpath = xmalloc((path_nchars + 1 + suffix_nchars + 1) *
sizeof(tchar));
tmemcpy(newpath, path, path_nchars);
newpath[path_nchars] = '.';
tmemcpy(&newpath[path_nchars + 1], options->suffix,
suffix_nchars + 1);
}
ret = xopen_for_read(path, &in);
if (ret != 0)
goto out_free_newpath;
ret = stat_file(&in, &stbuf, options->force || newpath == NULL);
if (ret != 0)
goto out_close_in;
ret = xopen_for_write(newpath, options->force, &out);
if (ret != 0)
goto out_close_in;
if (!options->force && isatty(out.fd)) {
msg("Refusing to write compressed data to terminal. "
"Use -f to override.\nFor help, use -h.");
ret = -1;
goto out_close_out;
}
ret = map_file_contents(&in, stbuf.st_size);
if (ret)
goto out_close_out;
ret = do_compress(compressor, &in, &out);
if (ret != 0)
goto out_close_out;
if (path != NULL && newpath != NULL)
restore_metadata(&out, newpath, &stbuf);
ret = 0;
out_close_out:
ret2 = xclose(&out);
if (ret == 0)
ret = ret2;
if (ret != 0 && newpath != NULL)
tunlink(newpath);
out_close_in:
xclose(&in);
if (ret == 0 && path != NULL && newpath != NULL && !options->keep)
tunlink(path);
out_free_newpath:
free(newpath);
out:
return ret;
}
static int
decompress_file(struct deflate_decompressor *decompressor, const tchar *path,
const struct options *options)
{
tchar *newpath = NULL;
struct file_stream in;
struct file_stream out;
struct stat stbuf;
int ret;
int ret2;
if (path != NULL && !options->to_stdout) {
const tchar *suffix = get_suffix(path, options->suffix);
if (suffix == NULL) {
msg("\"%"TS"\" does not end with the .%"TS" suffix -- "
"skipping", path, options->suffix);
ret = -2;
goto out;
}
newpath = xmalloc((suffix - path + 1) * sizeof(tchar));
tmemcpy(newpath, path, suffix - path);
newpath[suffix - path] = '\0';
}
ret = xopen_for_read(path, &in);
if (ret != 0)
goto out_free_newpath;
if (!options->force && isatty(in.fd)) {
msg("Refusing to read compressed data from terminal. "
"Use -f to override.\nFor help, use -h.");
ret = -1;
goto out_close_in;
}
ret = stat_file(&in, &stbuf, options->force || newpath == NULL);
if (ret != 0)
goto out_close_in;
ret = xopen_for_write(newpath, options->force, &out);
if (ret != 0)
goto out_close_in;
ret = map_file_contents(&in, stbuf.st_size);
if (ret != 0)
goto out_close_out;
ret = do_decompress(decompressor, &in, &out);
if (ret != 0)
goto out_close_out;
if (path != NULL && newpath != NULL)
restore_metadata(&out, newpath, &stbuf);
ret = 0;
out_close_out:
ret2 = xclose(&out);
if (ret == 0)
ret = ret2;
if (ret != 0 && newpath != NULL)
tunlink(newpath);
out_close_in:
xclose(&in);
if (ret == 0 && path != NULL && newpath != NULL && !options->keep)
tunlink(path);
out_free_newpath:
free(newpath);
out:
return ret;
}
int restore_switch_protocol2(struct asfd *asfd, struct sbuf *sb,
const char *fullpath, enum action act,
BFILE *bfd, int vss_restore, struct cntr *cntr)
{
switch(sb->path.cmd)
{
case CMD_FILE:
// Have it a separate statement to the
// encrypted version so that encrypted and not
// encrypted files can be restored at the
// same time.
if(start_restore_file(asfd,
bfd, sb, fullpath, act,
NULL, NULL, NULL,
vss_restore, cntr))
{
logp("restore_file error\n");
goto error;
}
break;
/* FIX THIS: Encryption currently not working in protocol2
case CMD_ENC_FILE:
if(start_restore_file(asfd,
bfd, sb, fullpath, act,
get_string(confs[OPT_ENCRYPTION_PASSWORD]),
NULL, NULL, vss_restore, confs))
{
logp("restore_file error\n");
goto error;
}
break;
*/
case CMD_METADATA:
if(restore_metadata(asfd,
sb, fullpath, act,
NULL, vss_restore, cntr))
goto error;
break;
/* FIX THIS: Encryption and EFS not supported yet.
case CMD_ENC_METADATA:
if(restore_metadata(
bfd, sb, fullpath, act,
get_string(confs[OPT_ENCRYPTION_PASSWORD]),
vss_restore, confs))
goto error;
break;
case CMD_EFS_FILE:
if(start_restore_file(asfd,
bfd, sb,
fullpath, act,
NULL,
NULL, NULL, vss_restore, confs))
{
logp("restore_file error\n");
goto error;
}
break;
*/
default:
logp("unknown cmd: %c\n", sb->path.cmd);
goto error;
}
return 0;
error:
return -1;
}
