static rs_result rdiff_patch(poptContext opcon)
{
/* patch BASIS [DELTA [NEWFILE]] */
FILE *basis_file, *delta_file, *new_file;
char const *basis_name;
rs_stats_t stats;
rs_result result;
if (!(basis_name = poptGetArg(opcon))) {
rdiff_usage("Usage for patch: "
"rdiff [OPTIONS] patch BASIS [DELTA [NEW]]");
return RS_SYNTAX_ERROR;
}
basis_file = rs_file_open(basis_name, "rb");
delta_file = rs_file_open(poptGetArg(opcon), "rb");
new_file = rs_file_open(poptGetArg(opcon), "wb");
rdiff_no_more_args(opcon);
result = rs_patch_file(basis_file, delta_file, new_file, &stats);
rs_file_close(new_file);
rs_file_close(delta_file);
rs_file_close(basis_file);
if (show_stats)
rs_log_stats(&stats);
return result;
}
int main(int argc, char *argv[])
{
FILE *basis_file;
FILE *delta_file;
rs_result ret;
FILE *new_file;
rs_stats_t stats;
if(argc != 4)
{
fprintf(stderr, "invalid argument(s)\n");
exit(1);
}
basis_file = fopen(argv[1], "rb");
delta_file = fopen(argv[2], "rb");
new_file = fopen(argv[3], "wb");
ret = rs_patch_file(basis_file, delta_file, new_file, &stats);
fclose(basis_file);
fclose(delta_file);
fclose(new_file);
if(ret != RS_DONE)
{
puts(rs_strerror(ret));
exit(1);
}
rs_log_stats(&stats);
return 0;
}
static rs_result rdiff_delta(poptContext opcon)
{
FILE *sig_file, *new_file, *delta_file;
char const *sig_name;
rs_result result;
rs_signature_t *sumset;
rs_stats_t stats;
if (!(sig_name = poptGetArg(opcon))) {
rdiff_usage("Usage for delta: "
"rdiff [OPTIONS] delta SIGNATURE [NEWFILE [DELTA]]");
return RS_SYNTAX_ERROR;
}
sig_file = rs_file_open(sig_name, "rb");
new_file = rs_file_open(poptGetArg(opcon), "rb");
delta_file = rs_file_open(poptGetArg(opcon), "wb");
rdiff_no_more_args(opcon);
result = rs_loadsig_file(sig_file, &sumset, &stats);
if (result != RS_DONE)
return result;
if (show_stats)
rs_log_stats(&stats);
if ((result = rs_build_hash_table(sumset)) != RS_DONE)
return result;
result = rs_delta_file(sumset, new_file, delta_file, &stats);
rs_free_sumset(sumset);
rs_file_close(delta_file);
rs_file_close(new_file);
rs_file_close(sig_file);
if (show_stats)
rs_log_stats(&stats);
return result;
}
/**
* Generate signature from remaining command line arguments.
*/
static rs_result rdiff_sig(poptContext opcon)
{
FILE *basis_file, *sig_file;
rs_stats_t stats;
rs_result result;
basis_file = rs_file_open(poptGetArg(opcon), "rb");
sig_file = rs_file_open(poptGetArg(opcon), "wb");
rdiff_no_more_args(opcon);
result = rs_sig_file(basis_file, sig_file, block_len, strong_len, &stats);
if (result != RS_DONE)
return result;
if (show_stats)
rs_log_stats(&stats);
return result;
}
/*
Given the originfile and newfile, generating a delta and patch to originfile(at the server side anyway)
para1: originfile: an original file
newfile: new version file
basefile: file to be patched with delta on server
resfile: newly generated file on server
return delta file name
*/
int compute_delta(char *originfile, char *newfile, char *basefile, char *resfile, char *file_delta_path)
{
// generate signature
rs_stats_t stats;
rs_result rsyncresult;
rs_signature_t *sumset;
char filename[NAME_LEN];
char resname[NAME_LEN];
char file_sig_path[PATH_LEN];
strcpy(file_sig_path, TMP_SIG);
//char *file_delta_path = (char *) malloc (PATH_LEN * sizeof(char));
strcpy(file_delta_path, TMP_DELTA);
FILE *ofile, *sigfile, *deltafile, *nfile;
printf("compute_delta:%s %s %s %s\n", originfile, newfile, basefile, resfile);
ofile = fopen(originfile, "rb");
if(ofile == NULL)
{
printf("origin file %s open error.\n", originfile);
return 1;
}
find_filename(basefile, filename);
find_filename(resfile, resname);
strcat(file_sig_path, filename);
sigfile = fopen(file_sig_path, "wb+");
rsyncresult = rs_sig_file(ofile, sigfile, RS_DEFAULT_BLOCK_LEN, RS_DEFAULT_STRONG_LEN, &stats);
if (rsyncresult != RS_DONE) {
printf("generate signature Failed!\n");
return 1;
}
rs_log_stats(&stats);
// load sig file
fseek(sigfile, 0, 0);
rsyncresult = rs_loadsig_file(sigfile, &sumset, &stats, ofile);
//rsyncresult = rs_loadsig_file(sigfile, &sumset, &stats);
// fix a bug
//fclose(ofile);
fclose(sigfile);
remove(file_sig_path);
if (rsyncresult != RS_DONE) {
printf("load signature into librsync Failed!\n");
return 1;
}
rsyncresult = rs_build_hash_table(sumset);
if (rsyncresult != RS_DONE) {
printf("build hash table in librsync Failed!\n");
rs_free_sumset(sumset);
return 1;
}
rs_log_stats(&stats);
// compute delta
strcat(file_delta_path, filename);
char rand_c[4] = {'\0'};
rand_c[0] = (char)(rand() % 26 + 97);
rand_c[1] = (char)(rand() % 26 + 97);
rand_c[2] = (char)(rand() % 26 + 97);
strcat(file_delta_path, rand_c);
deltafile = fopen(file_delta_path, "wb+");
nfile = fopen(newfile,"rb");
if(nfile == NULL)
{
printf("new file %s open error.\n", newfile);
return 1;
}
rsyncresult = rs_delta_file(sumset, nfile, deltafile, &stats);
fclose(ofile);
fclose(nfile);
fclose(deltafile);
if (rsyncresult != RS_DONE) {
printf("delta calculation Failed!\n");
rs_free_sumset(sumset);
return 1;
}
rs_log_stats(&stats);
rs_free_sumset(sumset);
return 0;
}
void send_file_delta(const char* new_file_path, const char *sig_file_path, SSL *ssl)
{
FILE *sig_file;
FILE *new_file;
FILE *delta_file;
size_t result = 0;
const size_t max_buffer_size = 1024;
char delta_buffer[max_buffer_size];
uint64_t delta_length = 0;
rs_result ret;
rs_signature_t *sumset;
rs_stats_t stats;
sig_file = fopen(sig_file_path,"rb");
if(sig_file == NULL)
{
fprintf(stderr, "failed to open signature file '%s'\n", sig_file_path);
exit(1);
}
new_file = fopen(new_file_path,"rb");
if(new_file == NULL)
{
fclose(sig_file);
fprintf(stderr, "failed to open file '%s'\n", new_file_path);
exit(1);
}
delta_file = tmpfile();
if(delta_file == NULL)
{
fclose(sig_file);
fclose(new_file);
fprintf(stderr, "failed to create temporary file\n");
exit(1);
}
ret = rs_loadsig_file(sig_file, &sumset, &stats);
if(ret != RS_DONE)
{
puts(rs_strerror(ret));
exit(1);
}
rs_log_stats(&stats);
if(rs_build_hash_table(sumset) != RS_DONE)
{
puts(rs_strerror(ret));
exit(1);
}
if(rs_delta_file(sumset, new_file, delta_file, &stats) != RS_DONE)
{
puts(rs_strerror(ret));
exit(1);
}
fflush(delta_file);
do
{
struct stat buf;
if(fstat(fileno(delta_file), &buf) < 0)
{
perror("fstat");
exit(1);
}
delta_length = (uint64_t)buf.st_size;
}while(0);
rewind(delta_file);
delta_length = hton64(delta_length);
ssl_write_wrapper(ssl, new_file_path, strlen(new_file_path) + 1);
ssl_write_wrapper(ssl, &delta_length, 8);
while(!feof(delta_file))
{
result = fread(delta_buffer, 1, max_buffer_size, delta_file);
if(result > 0)
ssl_write_wrapper(ssl, delta_buffer, result);
}
rs_log_stats(&stats);
rs_free_sumset(sumset);
fclose(sig_file);
fclose(new_file);
fclose(delta_file);
}
