static int my_send_file(struct asfd *asfd, struct FF_PKT *ff, struct conf **confs)
{
static struct sbuf *sb=NULL;
struct cntr *cntr=get_cntr(confs);
if(!sb && !(sb=sbuf_alloc(get_protocol(confs)))) return -1;
#ifdef HAVE_WIN32
if(ff->winattr & FILE_ATTRIBUTE_ENCRYPTED)
{
if(ff->type==FT_REG
|| ff->type==FT_DIR)
return to_server(asfd, confs, ff, sb, CMD_EFS_FILE);
return logw(asfd, cntr,
"EFS type %d not yet supported: %s\n",
ff->type, ff->fname);
}
#endif
switch(ff->type)
{
case FT_REG:
case FT_RAW:
case FT_FIFO:
return do_to_server(asfd, confs, ff, sb, filesymbol,
in_exclude_comp(get_strlist(confs[OPT_EXCOM]),
ff->fname, get_int(confs[OPT_COMPRESSION])));
case FT_DIR:
case FT_REPARSE:
case FT_JUNCTION:
return to_server(asfd, confs, ff, sb, dirsymbol);
case FT_LNK_S:
return to_server(asfd, confs, ff, sb, CMD_SOFT_LINK);
case FT_LNK_H:
return to_server(asfd, confs, ff, sb, CMD_HARD_LINK);
case FT_SPEC:
return to_server(asfd, confs, ff, sb, CMD_SPECIAL);
case FT_NOFSCHG:
return ft_err(asfd, confs, ff, "Will not descend: "
"file system change not allowed");
case FT_NOFOLLOW:
return ft_err(asfd, confs, ff, "Could not follow link");
case FT_NOSTAT:
return ft_err(asfd, confs, ff, "Could not stat");
case FT_NOOPEN:
return ft_err(asfd, confs, ff, "Could not open directory");
default:
return logw(asfd, cntr,
"Err: Unknown file type %d: %s\n",
ff->type, ff->fname);
}
}
int send_file(struct asfd *asfd, FF_PKT *ff, bool top_level, struct conf *conf)
{
static struct sbuf *sb=NULL;
if(!sb && !(sb=sbuf_alloc(conf))) return -1;
if(!file_is_included(conf, ff->fname, top_level)) return 0;
#ifdef HAVE_WIN32
if(ff->winattr & FILE_ATTRIBUTE_ENCRYPTED)
{
if(ff->type==FT_REG
|| ff->type==FT_DIR)
return to_server(asfd, conf, ff, sb, CMD_EFS_FILE);
return logw(asfd, conf, "EFS type %d not yet supported: %s",
ff->type, ff->fname);
}
#endif
switch(ff->type)
{
case FT_REG:
case FT_RAW:
case FT_FIFO:
return do_to_server(asfd, conf, ff, sb, filesymbol,
in_exclude_comp(conf->excom,
ff->fname, conf->compression));
case FT_DIR:
case FT_REPARSE:
case FT_JUNCTION:
return to_server(asfd, conf, ff, sb, dirsymbol);
case FT_LNK_S:
return to_server(asfd, conf, ff, sb, CMD_SOFT_LINK);
case FT_LNK_H:
return to_server(asfd, conf, ff, sb, CMD_HARD_LINK);
case FT_SPEC:
return to_server(asfd, conf, ff, sb, CMD_SPECIAL);
case FT_NOFSCHG:
return logw(asfd, conf, "Dir: %s [will not descend: "
"file system change not allowed]\n", ff->fname);
case FT_NOFOLLOW:
return ft_err(asfd, conf, ff, "Could not follow link");
case FT_NOSTAT:
return ft_err(asfd, conf, ff, "Could not stat");
case FT_NOOPEN:
return ft_err(asfd, conf, ff, "Could not open directory");
default:
return logw(asfd, conf,
_("Err: Unknown file type %d: %s"),
ff->type, ff->fname);
}
}
static int do_backup_phase2_client(struct config *conf, int resume, struct cntr *p1cntr, struct cntr *cntr)
{
int ret=0;
int quit=0;
char cmd;
char *buf=NULL;
size_t len=0;
char attribs[MAXSTRING];
// For efficiency, open Windows files for the VSS data, and do not
// close them until another time around the loop, when the actual
// data is read.
BFILE bfd;
// Windows VSS headers tell us how much file
// data to expect.
size_t datalen=0;
#ifdef HAVE_WIN32
binit(&bfd, 0);
#endif
struct sbuf sb;
init_sbuf(&sb);
if(!resume)
{
// Only do this bit if the server did not tell us to resume.
if(async_write_str(CMD_GEN, "backupphase2")
|| async_read_expect(CMD_GEN, "ok"))
return -1;
}
else if(conf->send_client_counters)
{
// On resume, the server might update the client with the
// counters.
if(recv_counters(p1cntr, cntr))
return -1;
}
while(!quit)
{
if(async_read(&cmd, &buf, &len))
{
ret=-1;
quit++;
}
else if(buf)
{
//logp("now: %c:%s\n", cmd, buf);
if(cmd==CMD_DATAPTH)
{
sb.datapth=buf;
buf=NULL;
continue;
}
else if(cmd==CMD_STAT)
{
// Ignore the stat data - we will fill it
// in again. Some time may have passed by now,
// and it is best to make it as fresh as
// possible.
free(buf);
buf=NULL;
continue;
}
else if(cmd==CMD_FILE
|| cmd==CMD_ENC_FILE
|| cmd==CMD_METADATA
|| cmd==CMD_ENC_METADATA
|| cmd==CMD_VSS
|| cmd==CMD_ENC_VSS
|| cmd==CMD_VSS_T
|| cmd==CMD_ENC_VSS_T
|| cmd==CMD_EFS_FILE)
{
int forget=0;
int64_t winattr=0;
struct stat statbuf;
char *extrameta=NULL;
size_t elen=0;
unsigned long long bytes=0;
FILE *fp=NULL;
int compression=conf->compression;
sb.path=buf;
buf=NULL;
#ifdef HAVE_WIN32
if(win32_lstat(sb.path, &statbuf, &winattr))
#else
if(lstat(sb.path, &statbuf))
#endif
{
logw(cntr, "Path has vanished: %s", sb.path);
if(forget_file(&sb, cmd, cntr))
{
ret=-1;
quit++;
}
free_sbuf(&sb);
continue;
}
if(conf->min_file_size
&& statbuf.st_size<
(boffset_t)conf->min_file_size
&& (cmd==CMD_FILE
|| cmd==CMD_ENC_FILE
|| cmd==CMD_EFS_FILE))
{
logw(cntr, "File size decreased below min_file_size after initial scan: %c:%s", cmd, sb.path);
forget++;
}
else if(conf->max_file_size
&& statbuf.st_size>
(boffset_t)conf->max_file_size
&& (cmd==CMD_FILE
|| cmd==CMD_ENC_FILE
|| cmd==CMD_EFS_FILE))
{
logw(cntr, "File size increased above max_file_size after initial scan: %c:%s", cmd, sb.path);
forget++;
}
if(!forget)
{
compression=in_exclude_comp(conf->excom,
conf->excmcount, sb.path,
conf->compression);
encode_stat(attribs,
&statbuf, winattr, compression);
if(open_file_for_send(
#ifdef HAVE_WIN32
&bfd, NULL,
#else
NULL, &fp,
#endif
sb.path, winattr,
&datalen, cntr))
forget++;
}
if(forget)
{
if(forget_file(&sb, cmd, cntr))
{
ret=-1;
quit++;
}
free_sbuf(&sb);
continue;
}
if(cmd==CMD_METADATA
|| cmd==CMD_ENC_METADATA
|| cmd==CMD_VSS
|| cmd==CMD_ENC_VSS
#ifdef HAVE_WIN32
|| conf->strip_vss
#endif
)
{
if(get_extrameta(
#ifdef HAVE_WIN32
&bfd,
#else
NULL,
#endif
sb.path,
&statbuf, &extrameta, &elen,
winattr, cntr,
&datalen))
{
logw(cntr, "Meta data error for %s", sb.path);
free_sbuf(&sb);
close_file_for_send(&bfd, &fp);
continue;
}
if(extrameta)
{
#ifdef HAVE_WIN32
if(conf->strip_vss)
{
free(extrameta);
extrameta=NULL;
elen=0;
}
#endif
}
else
{
logw(cntr, "No meta data after all: %s", sb.path);
free_sbuf(&sb);
close_file_for_send(&bfd, &fp);
continue;
}
}
if(cmd==CMD_FILE && sb.datapth)
{
unsigned long long sentbytes=0;
// Need to do sig/delta stuff.
if(async_write_str(CMD_DATAPTH, sb.datapth)
|| async_write_str(CMD_STAT, attribs)
|| async_write_str(CMD_FILE, sb.path)
|| load_signature_and_send_delta(
&bfd, fp,
&bytes, &sentbytes, cntr,
datalen))
{
logp("error in sig/delta for %s (%s)\n", sb.path, sb.datapth);
ret=-1;
quit++;
}
else
{
do_filecounter(cntr, CMD_FILE_CHANGED, 1);
do_filecounter_bytes(cntr, bytes);
do_filecounter_sentbytes(cntr, sentbytes);
}
}
else
{
//logp("need to send whole file: %s\n",
// sb.path);
// send the whole file.
if((async_write_str(CMD_STAT, attribs)
|| async_write_str(cmd, sb.path))
|| send_whole_file_w(cmd, sb.path,
NULL, 0, &bytes,
conf->encryption_password,
cntr, compression,
&bfd, fp,
extrameta, elen,
datalen))
{
ret=-1;
quit++;
}
else
{
do_filecounter(cntr, cmd, 1);
do_filecounter_bytes(cntr, bytes);
do_filecounter_sentbytes(cntr, bytes);
}
}
#ifdef HAVE_WIN32
// If using Windows do not close bfd - it needs
// to stay open to read VSS/file data/VSS.
// It will get closed either when given a
// different file path, or when this function
// exits.
//if(cmd!=CMD_VSS
// && cmd!=CMD_ENC_VSS)
// close_file_for_send(&bfd, NULL);
#else
close_file_for_send(NULL, &fp);
#endif
free_sbuf(&sb);
if(extrameta) free(extrameta);
}
else if(cmd==CMD_WARNING)
{
do_filecounter(cntr, cmd, 0);
free(buf);
buf=NULL;
}
else if(cmd==CMD_GEN && !strcmp(buf, "backupphase2end"))
{
if(async_write_str(CMD_GEN, "okbackupphase2end"))
ret=-1;
quit++;
}
else
{
logp("unexpected cmd from server: %c %s\n",
cmd, buf);
ret=-1;
quit++;
free(buf);
buf=NULL;
}
}
}
#ifdef HAVE_WIN32
// It is possible for a bfd to still be open.
close_file_for_send(&bfd, NULL);
#endif
return ret;
}
int send_file(FF_PKT *ff, bool top_level, struct config *conf, struct cntr *p1cntr)
{
char msg[128]="";
char attribs[MAXSTRING];
if(!file_is_included(conf->incexcdir, conf->iecount,
conf->incext, conf->incount,
conf->excext, conf->excount,
conf->increg, conf->ircount,
conf->excreg, conf->ercount,
ff->fname, top_level)) return 0;
#ifdef HAVE_WIN32
// Useful Windows attributes debug
/*
printf("\n%llu", ff->winattr);
printf("\n%s\n", ff->fname);
if(ff->winattr & FILE_ATTRIBUTE_READONLY) printf("readonly\n");
if(ff->winattr & FILE_ATTRIBUTE_HIDDEN) printf("hidden\n");
if(ff->winattr & FILE_ATTRIBUTE_SYSTEM) printf("system\n");
if(ff->winattr & FILE_ATTRIBUTE_DIRECTORY) printf("directory\n");
if(ff->winattr & FILE_ATTRIBUTE_ARCHIVE) printf("archive\n");
if(ff->winattr & FILE_ATTRIBUTE_DEVICE) printf("device\n");
if(ff->winattr & FILE_ATTRIBUTE_NORMAL) printf("normal\n");
if(ff->winattr & FILE_ATTRIBUTE_TEMPORARY) printf("temporary\n");
if(ff->winattr & FILE_ATTRIBUTE_SPARSE_FILE) printf("sparse\n");
if(ff->winattr & FILE_ATTRIBUTE_REPARSE_POINT) printf("reparse\n");
if(ff->winattr & FILE_ATTRIBUTE_COMPRESSED) printf("compressed\n");
if(ff->winattr & FILE_ATTRIBUTE_OFFLINE) printf("offline\n");
if(ff->winattr & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) printf("notcont\n");
if(ff->winattr & FILE_ATTRIBUTE_ENCRYPTED) printf("encrypted\n");
if(ff->winattr & FILE_ATTRIBUTE_VIRTUAL) printf("virtual\n");
*/
if(ff->winattr & FILE_ATTRIBUTE_ENCRYPTED)
{
// if(ff->type!=FT_DIREND)
// logw(p1cntr, "EFS not yet supported: %s", ff->fname);
// return 0;
if(ff->type==FT_REGE
|| ff->type==FT_REG
|| ff->type==FT_DIRBEGIN)
{
encode_stat(attribs,
&ff->statp, ff->winattr, conf->compression);
if(async_write_str(CMD_STAT, attribs)
|| async_write_str(CMD_EFS_FILE, ff->fname))
return -1;
do_filecounter(p1cntr, CMD_EFS_FILE, 1);
if(ff->type==FT_REG)
do_filecounter_bytes(p1cntr,
(unsigned long long)ff->statp.st_size);
return 0;
}
else if(ff->type==FT_DIREND)
return 0;
else
{
// Hopefully, here is never reached.
logw(p1cntr, "EFS type %d not yet supported: %s",
ff->type,
ff->fname);
return 0;
}
}
#endif
//logp("%d: %s\n", ff->type, ff->fname);
switch (ff->type) {
case FT_LNKSAVED:
//printf("Lnka: %s -> %s\n", ff->fname, ff->link);
encode_stat(attribs, &ff->statp, ff->winattr, conf->compression);
if(async_write_str(CMD_STAT, attribs)
|| async_write_str(CMD_HARD_LINK, ff->fname)
|| async_write_str(CMD_HARD_LINK, ff->link))
return -1;
do_filecounter(p1cntr, CMD_HARD_LINK, 1);
// At least FreeBSD 8.2 can have different xattrs on hard links.
if(maybe_send_extrameta(ff->fname, CMD_HARD_LINK, attribs, p1cntr))
return -1;
break;
case FT_FIFO:
case FT_REGE:
case FT_REG:
encode_stat(attribs, &ff->statp, ff->winattr,
in_exclude_comp(conf->excom, conf->excmcount,
ff->fname, conf->compression));
if(async_write_str(CMD_STAT, attribs)
|| async_write_str(filesymbol, ff->fname))
return -1;
do_filecounter(p1cntr, filesymbol, 1);
if(ff->type==FT_REG)
do_filecounter_bytes(p1cntr, (unsigned long long)ff->statp.st_size);
if(maybe_send_extrameta(ff->fname, filesymbol, attribs, p1cntr))
return -1;
break;
case FT_LNK:
//printf("link: %s -> %s\n", ff->fname, ff->link);
encode_stat(attribs, &ff->statp, ff->winattr, conf->compression);
if(async_write_str(CMD_STAT, attribs)
|| async_write_str(CMD_SOFT_LINK, ff->fname)
|| async_write_str(CMD_SOFT_LINK, ff->link))
return -1;
do_filecounter(p1cntr, CMD_SOFT_LINK, 1);
if(maybe_send_extrameta(ff->fname, CMD_SOFT_LINK, attribs, p1cntr))
return -1;
break;
case FT_DIREND:
return 0;
case FT_NOFSCHG:
case FT_DIRBEGIN:
case FT_REPARSE:
case FT_JUNCTION:
{
char errmsg[100] = "";
if (ff->type == FT_NOFSCHG)
snprintf(errmsg, sizeof(errmsg), _("\t[will not descend: file system change not allowed]"));
if(*errmsg)
{
snprintf(msg, sizeof(msg),
"%s%s%s\n", "Dir: ", ff->fname, errmsg);
logw(p1cntr, "%s", msg);
}
else
{
encode_stat(attribs,
&ff->statp, ff->winattr, conf->compression);
if(async_write_str(CMD_STAT, attribs)) return -1;
#if defined(WIN32_VSS)
if(async_write_str(filesymbol, ff->fname)) return -1;
do_filecounter(p1cntr, filesymbol, 1);
#else
if(async_write_str(CMD_DIRECTORY, ff->fname)) return -1;
do_filecounter(p1cntr, CMD_DIRECTORY, 1);
if(maybe_send_extrameta(ff->fname, CMD_DIRECTORY,
attribs, p1cntr)) return -1;
#endif
}
}
break;
case FT_SPEC: // special file - fifo, socket, device node...
encode_stat(attribs, &ff->statp, ff->winattr, conf->compression);
if(async_write_str(CMD_STAT, attribs)
|| async_write_str(CMD_SPECIAL, ff->fname))
return -1;
do_filecounter(p1cntr, CMD_SPECIAL, 1);
if(maybe_send_extrameta(ff->fname, CMD_SPECIAL, attribs, p1cntr))
return -1;
break;
case FT_NOACCESS:
logw(p1cntr, _("Err: Could not access %s: %s"), ff->fname, strerror(errno));
break;
case FT_NOFOLLOW:
logw(p1cntr, _("Err: Could not follow ff->link %s: %s"), ff->fname, strerror(errno));
break;
case FT_NOSTAT:
logw(p1cntr, _("Err: Could not stat %s: %s"), ff->fname, strerror(errno));
break;
case FT_NOCHG:
logw(p1cntr, _("Skip: File not saved. No change. %s"), ff->fname);
break;
case FT_ISARCH:
logw(p1cntr, _("Err: Attempt to backup archive. Not saved. %s"), ff->fname);
break;
case FT_NOOPEN:
logw(p1cntr, _("Err: Could not open directory %s: %s"), ff->fname, strerror(errno));
break;
case FT_RAW:
logw(p1cntr, _("Err: Raw partition: %s"), ff->fname);
break;
default:
logw(p1cntr, _("Err: Unknown file ff->type %d: %s"), ff->type, ff->fname);
break;
}
return 0;
}
static int deal_with_data(struct asfd *asfd, struct sbuf *sb,
BFILE *bfd, size_t *datalen, struct conf *conf)
{
int ret=-1;
int forget=0;
FILE *fp=NULL;
size_t elen=0;
char *extrameta=NULL;
unsigned long long bytes=0;
sb->compression=conf->compression;
iobuf_copy(&sb->path, asfd->rbuf);
iobuf_init(asfd->rbuf);
#ifdef HAVE_WIN32
if(win32_lstat(sb->path.buf, &sb->statp, &sb->winattr))
#else
if(lstat(sb->path.buf, &sb->statp))
#endif
{
logw(asfd, conf, "Path has vanished: %s", sb->path.buf);
if(forget_file(asfd, sb, conf)) goto error;
goto end;
}
if(size_checks(asfd, sb, conf)) forget++;
if(!forget)
{
sb->compression=in_exclude_comp(conf->excom,
sb->path.buf, conf->compression);
if(attribs_encode(sb)) goto error;
else if(open_file_for_sendl(asfd,
#ifdef HAVE_WIN32
bfd, NULL,
#else
NULL, &fp,
#endif
sb->path.buf, sb->winattr, datalen, conf->atime, conf))
forget++;
}
if(forget)
{
if(forget_file(asfd, sb, conf)) goto error;
goto end;
}
if(sb->path.cmd==CMD_METADATA
|| sb->path.cmd==CMD_ENC_METADATA
|| sb->path.cmd==CMD_VSS
|| sb->path.cmd==CMD_ENC_VSS
#ifdef HAVE_WIN32
|| conf->strip_vss
#endif
)
{
if(get_extrameta(asfd,
#ifdef HAVE_WIN32
bfd,
#endif
sb->path.buf, &sb->statp, &extrameta, &elen,
sb->winattr, conf, datalen))
{
logw(asfd, conf, "Meta data error for %s", sb->path.buf);
goto end;
}
if(extrameta)
{
#ifdef HAVE_WIN32
if(conf->strip_vss)
{
free(extrameta);
extrameta=NULL;
elen=0;
}
#endif
}
else
{
logw(asfd, conf,
"No meta data after all: %s", sb->path.buf);
goto end;
}
}
if(sb->path.cmd==CMD_FILE
&& sb->burp1->datapth.buf)
{
unsigned long long sentbytes=0;
// Need to do sig/delta stuff.
if(asfd->write(asfd, &(sb->burp1->datapth))
|| asfd->write(asfd, &sb->attr)
|| asfd->write(asfd, &sb->path)
|| load_signature_and_send_delta(asfd, bfd, fp,
&bytes, &sentbytes, conf, *datalen))
{
logp("error in sig/delta for %s (%s)\n",
sb->path.buf, sb->burp1->datapth.buf);
goto end;
}
else
{
cntr_add(conf->cntr, CMD_FILE_CHANGED, 1);
cntr_add_bytes(conf->cntr, bytes);
cntr_add_sentbytes(conf->cntr, sentbytes);
}
}
else
{
//logp("need to send whole file: %s\n", sb.path);
// send the whole file.
if((asfd->write(asfd, &sb->attr)
|| asfd->write(asfd, &sb->path))
|| send_whole_file_w(asfd, sb, NULL, 0, &bytes,
conf->encryption_password, conf, sb->compression,
bfd, fp, extrameta, elen, *datalen))
goto end;
else
{
cntr_add(conf->cntr, sb->path.cmd, 1);
cntr_add_bytes(conf->cntr, bytes);
cntr_add_sentbytes(conf->cntr, bytes);
}
}
end:
ret=0;
error:
#ifdef HAVE_WIN32
// If using Windows do not close bfd - it needs
// to stay open to read VSS/file data/VSS.
// It will get closed either when given a
// different file path, or when this function
// exits.
#else
close_file_for_sendl(NULL, &fp, asfd);
#endif
sbuf_free_content(sb);
if(extrameta) free(extrameta);
return ret;
}