static int make_rev_sig(const char *dst, const char *sig, const char *endfile, int compression, struct cntr *cntr)
{
FILE *dstfp=NULL;
gzFile dstzp=NULL;
FILE *sigp=NULL;
rs_result result;
//logp("make rev sig: %s %s\n", dst, sig);
if(dpth_is_compressed(compression, dst))
dstzp=gzopen_file(dst, "rb");
else
dstfp=open_file(dst, "rb");
if((!dstzp && !dstfp)
|| !(sigp=open_file(sig, "wb")))
{
gzclose_fp(&dstzp);
close_fp(&dstfp);
return -1;
}
result=rs_sig_gzfile(dstfp, dstzp, sigp,
get_librsync_block_len(endfile),
RS_DEFAULT_STRONG_LEN, NULL, cntr);
gzclose_fp(&dstzp);
close_fp(&dstfp);
close_fp(&sigp);
//logp("end of make rev sig\n");
return result;
}
static int inflate_or_link_oldfile(const char *oldpath, const char *infpath)
{
int ret=0;
struct stat statp;
if(lstat(oldpath, &statp))
{
logp("could not lstat %s\n", oldpath);
return -1;
}
if(dpth_is_compressed(oldpath))
{
FILE *source=NULL;
FILE *dest=NULL;
//logp("inflating...\n");
if(!(dest=open_file(infpath, "wb")))
{
close_fp(&dest);
return -1;
}
if(!statp.st_size)
{
// Empty file - cannot inflate.
// just close the destination and we have duplicated a
// zero length file.
logp("asked to inflate zero length file: %s\n", oldpath);
close_fp(&dest);
return 0;
}
if(!(source=open_file(oldpath, "rb")))
{
close_fp(&dest);
return -1;
}
if((ret=zlib_inflate(source, dest))!=Z_OK)
logp("zlib_inflate returned: %d\n", ret);
close_fp(&source);
close_fp(&dest);
}
else
{
// Not compressed - just hard link it.
if(link(oldpath, infpath))
{
logp("hardlink %s to %s failed: %s\n",
infpath, oldpath, strerror(errno));
ret=-1;
}
}
return ret;
}
// Also used by backup_phase4_server.c
int do_patch(const char *dst, const char *del, const char *upd, bool gzupd, struct cntr *cntr, struct config *cconf)
{
FILE *dstp=NULL;
FILE *delfp=NULL;
gzFile delzp=NULL;
gzFile updp=NULL;
FILE *updfp=NULL;
rs_result result;
//logp("patching...\n");
if(!(dstp=fopen(dst, "rb")))
{
logp("could not open %s for reading\n", dst);
return -1;
}
if(dpth_is_compressed(del))
delzp=gzopen(del, "rb");
else
delfp=fopen(del, "rb");
if(!delzp && !delfp)
{
logp("could not open %s for reading\n", del);
close_fp(&dstp);
return -1;
}
if(gzupd)
updp=gzopen(upd, comp_level(cconf));
else
updfp=fopen(upd, "wb");
if(!updp && !updfp)
{
logp("could not open %s for writing\n", upd);
close_fp(&dstp);
gzclose_fp(&delzp);
close_fp(&delfp);
return -1;
}
result=rs_patch_gzfile(dstp, delfp, delzp, updfp, updp, NULL, cntr);
fclose(dstp);
gzclose_fp(&delzp);
close_fp(&delfp);
if(updp) gzclose_fp(&updp);
if(updfp) fclose(updfp);
return result;
}
static int send_file(const char *fname, int patches, const char *best, const char *datapth, unsigned long long *bytes, char cmd, int64_t winattr, int compression, struct cntr *cntr, struct config *cconf)
{
int ret=0;
size_t datalen=0;
FILE *fp=NULL;
if(open_file_for_send(NULL, &fp, best, winattr, &datalen, cntr))
return -1;
//logp("sending: %s\n", best);
if(async_write(cmd, fname, strlen(fname)))
ret=-1;
else if(patches)
{
// If we did some patches, the resulting file
// is not gzipped. Gzip it during the send.
ret=send_whole_file_gz(best, datapth, 1, bytes, NULL, cntr,
9, NULL, fp, NULL, 0, -1);
}
else
{
// If it was encrypted, it may or may not have been compressed
// before encryption. Send it as it as, and let the client
// sort it out.
if(cmd==CMD_ENC_FILE
|| cmd==CMD_ENC_METADATA
|| cmd==CMD_ENC_VSS
|| cmd==CMD_ENC_VSS_T
|| cmd==CMD_EFS_FILE)
{
ret=send_whole_file(cmd, best, datapth, 1, bytes,
cntr, NULL, fp, NULL, 0, -1);
}
// It might have been stored uncompressed. Gzip it during
// the send. If the client knew what kind of file it would be
// receiving, this step could disappear.
else if(!dpth_is_compressed(compression, datapth))
{
ret=send_whole_file_gz(best, datapth, 1, bytes,
NULL, cntr, 9, NULL, fp, NULL, 0, -1);
}
else
{
// If we did not do some patches, the resulting
// file might already be gzipped. Send it as it is.
ret=send_whole_file(cmd, best, datapth, 1, bytes,
cntr, NULL, fp, NULL, 0, -1);
}
}
close_file_for_send(NULL, &fp);
return ret;
}
static int verify_file(const char *fname, int patches, const char *best, const char *datapth, unsigned long long *bytes, const char *endfile, char cmd, int compression, struct cntr *cntr)
{
MD5_CTX md5;
size_t b=0;
const char *cp=NULL;
const char *newsum=NULL;
unsigned char in[ZCHUNK];
unsigned char checksum[MD5_DIGEST_LENGTH+1];
unsigned long long cbytes=0;
if(!(cp=strrchr(endfile, ':')))
{
logw(cntr, "%s has no md5sum!\n", datapth);
return 0;
}
cp++;
if(!MD5_Init(&md5))
{
logp("MD5_Init() failed\n");
return -1;
}
if(patches
|| cmd==CMD_ENC_FILE || cmd==CMD_ENC_METADATA || cmd==CMD_EFS_FILE
|| cmd==CMD_ENC_VSS
|| (!patches && !dpth_is_compressed(compression, best)))
{
// If we did some patches or encryption, or the compression
// was turned off, the resulting file is not gzipped.
FILE *fp=NULL;
if(!(fp=open_file(best, "rb")))
{
logw(cntr, "could not open %s\n", best);
return 0;
}
while((b=fread(in, 1, ZCHUNK, fp))>0)
{
cbytes+=b;
if(!MD5_Update(&md5, in, b))
{
logp("MD5_Update() failed\n");
close_fp(&fp);
return -1;
}
}
if(!feof(fp))
{
logw(cntr, "error while reading %s\n", best);
close_fp(&fp);
return 0;
}
close_fp(&fp);
}
else
{
gzFile zp=NULL;
if(!(zp=gzopen_file(best, "rb")))
{
logw(cntr, "could not gzopen %s\n", best);
return 0;
}
while((b=gzread(zp, in, ZCHUNK))>0)
{
cbytes+=b;
if(!MD5_Update(&md5, in, b))
{
logp("MD5_Update() failed\n");
gzclose_fp(&zp);
return -1;
}
}
if(!gzeof(zp))
{
logw(cntr, "error while gzreading %s\n", best);
gzclose_fp(&zp);
return 0;
}
gzclose_fp(&zp);
}
if(!MD5_Final(checksum, &md5))
{
logp("MD5_Final() failed\n");
return -1;
}
newsum=get_checksum_str(checksum);
if(strcmp(newsum, cp))
{
logp("%s %s\n", newsum, cp);
logw(cntr, "md5sum for '%s (%s)' did not match!\n", fname, datapth);
logp("md5sum for '%s (%s)' did not match!\n", fname, datapth);
return 0;
}
*bytes+=cbytes;
// Just send the file name to the client, so that it can show counters.
if(async_write(cmd, fname, strlen(fname))) return -1;
return 0;
}
static int make_rev_delta(const char *src, const char *sig, const char *del, int compression, struct cntr *cntr, struct config *cconf)
{
gzFile srczp=NULL;
FILE *srcfp=NULL;
FILE *sigp=NULL;
rs_result result;
rs_signature_t *sumset=NULL;
//logp("make rev delta: %s %s %s\n", src, sig, del);
if(!(sigp=open_file(sig, "rb"))) return -1;
if((result=rs_loadsig_file(sigp, &sumset, NULL))
|| (result=rs_build_hash_table(sumset)))
{
fclose(sigp);
rs_free_sumset(sumset);
return result;
}
fclose(sigp);
//logp("make rev deltb: %s %s %s\n", src, sig, del);
if(dpth_is_compressed(compression, src))
srczp=gzopen_file(src, "rb");
else
srcfp=open_file(src, "rb");
if(!srczp && !srcfp)
{
rs_free_sumset(sumset);
return -1;
}
if(cconf->compression)
{
gzFile delzp=NULL;
if(!(delzp=gzopen_file(del, comp_level(cconf))))
{
gzclose_fp(&srczp);
close_fp(&srcfp);
rs_free_sumset(sumset);
return -1;
}
result=rs_delta_gzfile(sumset, srcfp, srczp, NULL, delzp, NULL, cntr);
gzclose_fp(&delzp);
}
else
{
FILE *delfp=NULL;
if(!(delfp=open_file(del, "wb")))
{
gzclose_fp(&srczp);
close_fp(&srcfp);
rs_free_sumset(sumset);
return -1;
}
result=rs_delta_gzfile(sumset, srcfp, srczp, delfp, NULL, NULL, cntr);
close_fp(&delfp);
}
rs_free_sumset(sumset);
gzclose_fp(&srczp);
close_fp(&srcfp);
return result;
}
static int inflate_or_link_oldfile(const char *oldpath, const char *infpath, int compression, struct config *cconf)
{
int ret=0;
struct stat statp;
if(lstat(oldpath, &statp))
{
logp("could not lstat %s\n", oldpath);
return -1;
}
if(dpth_is_compressed(compression, oldpath))
{
FILE *source=NULL;
FILE *dest=NULL;
//logp("inflating...\n");
if(!(dest=open_file(infpath, "wb")))
{
close_fp(&dest);
return -1;
}
if(!statp.st_size)
{
// Empty file - cannot inflate.
// just close the destination and we have duplicated a
// zero length file.
logp("asked to inflate zero length file: %s\n", oldpath);
if(close_fp(&dest))
{
logp("error closing %s in inflate_or_link_oldfile\n", infpath);
return -1;
}
return 0;
}
if(!(source=open_file(oldpath, "rb")))
{
close_fp(&dest);
return -1;
}
if((ret=zlib_inflate(source, dest))!=Z_OK)
logp("zlib_inflate returned: %d\n", ret);
close_fp(&source);
if(close_fp(&dest))
{
logp("error closing %s in inflate_or_link_oldfile\n",
infpath);
return -1;
}
}
else
{
// If it was not a compressed file, just hard link it.
// It is possible that infpath already exists, if the server
// was interrupted on a previous run just after this point.
if(do_link(oldpath, infpath, &statp, cconf,
TRUE /* allow overwrite of infpath */))
ret=-1;
}
return ret;
}
// return 1 to say that a file was processed
static int maybe_process_file(struct sbuf *cb, struct sbuf *p1b, FILE *ucfp, const char *currentdata, const char *datadirtmp, const char *deltmppath, struct dpth *dpth, int *resume_partial, struct cntr *cntr, struct config *cconf)
{
int pcmp;
// logp("in maybe_proc %s\n", p1b->path);
if(!(pcmp=sbuf_pathcmp(cb, p1b)))
{
int oldcompressed=0;
// If the file type changed, I think it is time to back it
// up again (for example, EFS changing to normal file, or
// back again).
if(cb->cmd!=p1b->cmd)
return process_new_file(cb, p1b, ucfp, currentdata,
datadirtmp, deltmppath,
dpth, resume_partial,
cntr, cconf);
// mtime is the actual file data.
// ctime is the attributes or meta data.
if(cb->statp.st_mtime==p1b->statp.st_mtime
&& cb->statp.st_ctime==p1b->statp.st_ctime)
{
// got an unchanged file
//logp("got unchanged file: %s %c %c\n", cb->path, cb->cmd, p1b->cmd);
return process_unchanged_file(cb, ucfp, cntr);
}
if(cb->statp.st_mtime==p1b->statp.st_mtime
&& cb->statp.st_ctime!=p1b->statp.st_ctime)
{
// File data stayed the same, but attributes or meta
// data changed. We already have the attributes, but
// may need to get extra meta data.
if(cb->cmd==CMD_ENC_METADATA
|| p1b->cmd==CMD_ENC_METADATA
// TODO: make unencrypted metadata use the librsync
|| cb->cmd==CMD_METADATA
|| p1b->cmd==CMD_METADATA
|| cb->cmd==CMD_VSS
|| p1b->cmd==CMD_VSS
|| cb->cmd==CMD_ENC_VSS
|| p1b->cmd==CMD_ENC_VSS
|| cb->cmd==CMD_VSS_T
|| p1b->cmd==CMD_VSS_T
|| cb->cmd==CMD_ENC_VSS_T
|| p1b->cmd==CMD_ENC_VSS_T
|| cb->cmd==CMD_EFS_FILE
|| p1b->cmd==CMD_EFS_FILE)
return process_new_file(cb,
p1b, ucfp, currentdata,
datadirtmp, deltmppath,
dpth, resume_partial,
cntr, cconf);
else
return process_unchanged_file(cb, ucfp, cntr);
}
// Got a changed file.
//logp("got changed file: %s\n", p1b->path);
// If either old or new is encrypted, or librsync is off,
// we need to get a new file.
if(!cconf->librsync
|| cb->cmd==CMD_ENC_FILE
|| p1b->cmd==CMD_ENC_FILE
|| cb->cmd==CMD_ENC_METADATA
|| p1b->cmd==CMD_ENC_METADATA
|| cb->cmd==CMD_EFS_FILE
|| p1b->cmd==CMD_EFS_FILE
// TODO: make unencrypted metadata use the librsync
|| cb->cmd==CMD_METADATA
|| p1b->cmd==CMD_METADATA
|| cb->cmd==CMD_VSS
|| p1b->cmd==CMD_VSS
|| cb->cmd==CMD_ENC_VSS
|| p1b->cmd==CMD_ENC_VSS
|| cb->cmd==CMD_VSS_T
|| p1b->cmd==CMD_VSS_T
|| cb->cmd==CMD_ENC_VSS_T
|| p1b->cmd==CMD_ENC_VSS_T)
return process_new_file(cb, p1b, ucfp, currentdata,
datadirtmp, deltmppath,
dpth, resume_partial,
cntr, cconf);
// Get new files if they have switched between compression on
// or off.
if(cb->datapth && dpth_is_compressed(cb->compression, cb->datapth))
oldcompressed=1;
if( ( oldcompressed && !cconf->compression)
|| (!oldcompressed && cconf->compression))
return process_new_file(cb, p1b, ucfp, currentdata,
datadirtmp, deltmppath,
dpth, resume_partial,
cntr, cconf);
// Otherwise, do the delta stuff (if possible).
if(filedata(p1b->cmd))
{
if(process_changed_file(cb, p1b, currentdata,
datadirtmp, deltmppath, resume_partial,
cntr, cconf)) return -1;
}
else
{
if(changed_non_file(p1b, ucfp, p1b->cmd, cntr))
return -1;
}
free_sbuf(cb);
return 1;
}
else if(pcmp>0)
{
//logp("ahead: %s\n", p1b->path);
// ahead - need to get the whole file
if(process_new(p1b, ucfp, currentdata, datadirtmp, deltmppath,
dpth, resume_partial, cntr, cconf)) return -1;
// do not free
return 1;
}
else
{
//logp("behind: %s\n", p1b->path);
// behind - need to read more from the old
// manifest
// Count a deleted file - it was in the old manifest but not
// the new.
do_filecounter_deleted(cntr, cb->cmd);
}
return 0;
}
static int process_changed_file(struct sbuf *cb, struct sbuf *p1b, const char *currentdata, const char *datadirtmp, const char *deltmppath, int *resume_partial, struct cntr *cntr, struct config *cconf)
{
size_t blocklen=0;
char *curpath=NULL;
//logp("need to process changed file: %s (%s)\n", cb->path, cb->datapth);
// Move datapth onto p1b.
if(p1b->datapth) free(p1b->datapth);
p1b->datapth=cb->datapth;
cb->datapth=NULL;
if(!(curpath=prepend_s(currentdata,
p1b->datapth, strlen(p1b->datapth))))
{
log_out_of_memory(__FUNCTION__);
return -1;
}
if(dpth_is_compressed(cb->compression, curpath))
p1b->sigzp=gzopen_file(curpath, "rb");
else
p1b->sigfp=open_file(curpath, "rb");
if(!p1b->sigzp && !p1b->sigfp)
{
logp("could not open %s: %s\n",
curpath, strerror(errno));
free(curpath);
return -1;
}
if(*resume_partial
&& p1b->cmd==CMD_FILE
&& cconf->librsync)
// compression?
{
if(resume_partial_changed_file(cb, p1b, currentdata, curpath,
datadirtmp, deltmppath, cconf, cntr)) return -1;
// Burp only transfers one file at a time, so
// if there was an interruption, there is only
// a possibility of one partial file to resume.
*resume_partial=0;
}
free(curpath);
blocklen=get_librsync_block_len(cb->endfile);
if(!(p1b->sigjob=rs_sig_begin(blocklen, RS_DEFAULT_STRONG_LEN)))
{
logp("could not start signature job.\n");
return -1;
}
//logp("sig begin: %s\n", p1b->datapth);
if(!(p1b->infb=rs_filebuf_new(NULL,
p1b->sigfp, p1b->sigzp, -1, blocklen, -1, cntr)))
{
logp("could not rs_filebuf_new for infb.\n");
return -1;
}
if(!(p1b->outfb=rs_filebuf_new(NULL, NULL, NULL,
async_get_fd(), ASYNC_BUF_LEN, -1, cntr)))
{
logp("could not rs_filebuf_new for in_outfb.\n");
return -1;
}
// Flag the things that need to be sent (to the client)
p1b->senddatapth++;
p1b->sendstat++;
p1b->sendpath++;
//logp("sending sig for %s\n", p1b->path);
//logp("(%s)\n", p1b->datapth);
return 0;
}
