rs_result rs_delta_gzfile(struct asfd *asfd,
rs_signature_t *sig, struct fzp *new_file,
struct fzp *delta_file,
rs_stats_t *stats, struct cntr *cntr)
{
rs_job_t *job;
rs_result r;
job=rs_delta_begin(sig);
r=rs_whole_gzrun(asfd, job, new_file, delta_file, cntr);
rs_job_free(job);
return r;
}
rs_result rs_delta_gzfile(rs_signature_t *sig, FILE *new_file, gzFile new_zfile, FILE *delta_file, gzFile delta_zfile, rs_stats_t *stats, struct cntr *cntr)
{
rs_job_t *job;
rs_result r;
job = rs_delta_begin(sig);
r = rs_whole_gzrun(job, new_file, new_zfile, delta_file, delta_zfile, cntr);
/*
if (stats)
memcpy(stats, &job->stats, sizeof *stats);
*/
rs_job_free(job);
return r;
}
rs_result
rs_delta_file(rs_signature_t *sig, FILE *new_file, FILE *delta_file,
rs_stats_t *stats)
{
rs_job_t *job;
rs_result r;
job = rs_delta_begin(sig);
r = rs_whole_run(job, new_file, delta_file);
if (stats)
memcpy(stats, &job->stats, sizeof *stats);
rs_job_free(job);
return r;
}
/* Call with the entire signature loaded into one big string */
static PyObject*
_librsync_new_deltamaker(PyObject* self, PyObject* args)
{
_librsync_DeltaMakerObject* dm;
char *sig_string, outbuf[RS_JOB_BLOCKSIZE];
int sig_length;
rs_job_t *sig_loader;
rs_signature_t *sig_ptr;
rs_buffers_t buf;
rs_result result;
if (!PyArg_ParseTuple(args,"s#:new_deltamaker", &sig_string, &sig_length))
return NULL;
dm = PyObject_New(_librsync_DeltaMakerObject, &_librsync_DeltaMakerType);
if (dm == NULL) return NULL;
dm->x_attr = NULL;
/* Put signature at sig_ptr and build hash */
sig_loader = rs_loadsig_begin(&sig_ptr);
buf.next_in = sig_string;
buf.avail_in = (size_t)sig_length;
buf.next_out = outbuf;
buf.avail_out = (size_t)RS_JOB_BLOCKSIZE;
buf.eof_in = 1;
result = rs_job_iter(sig_loader, &buf);
rs_job_free(sig_loader);
if (result != RS_DONE) {
_librsync_seterror(result, "delta rs_signature_t builder");
return NULL;
}
if ((result = rs_build_hash_table(sig_ptr)) != RS_DONE) {
_librsync_seterror(result, "delta rs_build_hash_table");
return NULL;
}
dm->sig_ptr = sig_ptr;
dm->delta_job = rs_delta_begin(sig_ptr);
return (PyObject*)dm;
}
static ERL_NIF_TERM delta_init(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
state_t *state = NULL;
rs_result res;
if (!enif_get_resource(env, argv[0], state_r, (void *) &state))
return enif_make_badarg(env);
if (state->type != LOADSIG)
return enif_make_badarg(env);
res = rs_build_hash_table(state->sig);
if (res != RS_DONE)
return mk_error(env, res);
if (state->job) rs_job_free(state->job);
state->job = rs_delta_begin(state->sig);
state->in_size = 0;
state->out_size = 0;
state->type = DELTA;
return enif_make_atom(env, "ok");
}
static int load_signature_and_send_delta(BFILE *bfd, FILE *in, unsigned long long *bytes, unsigned long long *sentbytes, struct cntr *cntr, size_t datalen)
{
rs_job_t *job;
rs_result r;
rs_signature_t *sumset=NULL;
unsigned char checksum[MD5_DIGEST_LENGTH+1];
rs_filebuf_t *infb=NULL;
rs_filebuf_t *outfb=NULL;
rs_buffers_t rsbuf;
memset(&rsbuf, 0, sizeof(rsbuf));
if(load_signature(&sumset, cntr)) return -1;
//logp("start delta\n");
if(!(job=rs_delta_begin(sumset)))
{
logp("could not start delta job.\n");
rs_free_sumset(sumset);
return RS_IO_ERROR;
}
if(!(infb=rs_filebuf_new(bfd,
in, NULL, -1, ASYNC_BUF_LEN, datalen, cntr))
|| !(outfb=rs_filebuf_new(NULL, NULL,
NULL, async_get_fd(), ASYNC_BUF_LEN, -1, cntr)))
{
logp("could not rs_filebuf_new for delta\n");
if(infb) rs_filebuf_free(infb);
return -1;
}
//logp("start delta loop\n");
while(1)
{
size_t wlen=0;
rs_result delresult;
delresult=rs_async(job, &rsbuf, infb, outfb);
if(delresult==RS_DONE)
{
r=delresult;
// logp("delresult done\n");
break;
}
else if(delresult==RS_BLOCKED || delresult==RS_RUNNING)
{
// logp("delresult running/blocked: %d\n", delresult);
// Keep going
}
else
{
logp("error in rs_async for delta: %d\n", delresult);
r=delresult;
break;
}
// FIX ME: get it to read stuff (errors, for example) here too.
if(async_rw(NULL, NULL, '\0', '\0', NULL, &wlen))
return -1;
}
if(r!=RS_DONE)
logp("delta loop returned: %d\n", r);
//logp("after delta loop: %d\n", r);
//logp("\n");
if(r==RS_DONE)
{
*bytes=infb->bytes;
*sentbytes=outfb->bytes;
if(!MD5_Final(checksum, &(infb->md5)))
{
logp("MD5_Final() failed\n");
r=RS_IO_ERROR;
}
}
rs_filebuf_free(infb);
rs_filebuf_free(outfb);
rs_job_free(job);
rs_free_sumset(sumset);
if(r==RS_DONE && write_endfile(*bytes, checksum)) // finish delta file
return -1;
//logp("end of load_sig_send_delta\n");
return r;
}
static int load_signature_and_send_delta(struct asfd *asfd,
BFILE *bfd, FILE *in,
unsigned long long *bytes, unsigned long long *sentbytes,
struct conf *conf, size_t datalen)
{
rs_job_t *job;
rs_result r;
rs_signature_t *sumset=NULL;
unsigned char checksum[MD5_DIGEST_LENGTH+1];
rs_filebuf_t *infb=NULL;
rs_filebuf_t *outfb=NULL;
rs_buffers_t rsbuf;
memset(&rsbuf, 0, sizeof(rsbuf));
if(load_signature(asfd, &sumset, conf)) return -1;
if(!(job=rs_delta_begin(sumset)))
{
logp("could not start delta job.\n");
rs_free_sumset(sumset);
return RS_IO_ERROR;
}
if(!(infb=rs_filebuf_new(asfd, bfd,
in, NULL, -1, ASYNC_BUF_LEN, datalen, conf->cntr))
|| !(outfb=rs_filebuf_new(asfd, NULL, NULL,
NULL, asfd->fd, ASYNC_BUF_LEN, -1, conf->cntr)))
{
logp("could not rs_filebuf_new for delta\n");
if(infb) rs_filebuf_free(infb);
return -1;
}
while(1)
{
rs_result delresult;
delresult=rs_async(job, &rsbuf, infb, outfb);
if(delresult==RS_DONE)
{
r=delresult;
break;
}
else if(delresult==RS_BLOCKED || delresult==RS_RUNNING)
{
// Keep going
}
else
{
logp("error in rs_async for delta: %d\n", delresult);
r=delresult;
break;
}
// FIX ME: get it to read stuff (errors, for example) here too.
if(asfd->as->rw(asfd->as)) return -1;
}
if(r!=RS_DONE)
logp("delta loop returned: %d\n", r);
if(r==RS_DONE)
{
*bytes=infb->bytes;
*sentbytes=outfb->bytes;
if(!MD5_Final(checksum, &(infb->md5)))
{
logp("MD5_Final() failed\n");
r=RS_IO_ERROR;
}
}
rs_filebuf_free(infb);
rs_filebuf_free(outfb);
rs_job_free(job);
rs_free_sumset(sumset);
if(r==RS_DONE && write_endfile(asfd, *bytes, checksum))
return -1;
return r;
}
executer_result
_executer_send_delta (executer_job_t * job)
{
// The opaque pointer is to signature
rs_signature_t *signature = job->signature;
rs_job_t *deltajob;
char *realpath;
executer_rs inrs;
executer_rs outrs;
rs_result result;
rs_buffers_t rsbuf;
utils_debug ("Sending delta data");
deltajob = rs_delta_begin (signature);
_executer_real_path (job->file, &realpath);
int file2 = open (realpath, O_RDONLY);
inrs.type = _EXECUTER_FILE;
inrs.sock = file2;
inrs.size = RS_DEFAULT_BLOCK_LEN;
inrs.buf = malloc (inrs.size);
outrs.type = _EXECUTER_SOCKET;
outrs.sock = job->peer_sock;
outrs.size = _EXECUTER_DEFAULT_OUT;
outrs.buf = malloc (outrs.size);
if (rs_build_hash_table (signature) != RS_DONE)
{
utils_error ("Error building hash table");
return EXECUTER_ERROR;
}
result =
rs_job_drive (deltajob, &rsbuf, _executer_in_callback, &inrs,
_executer_out_callback, &outrs);
// Free the memory
free (realpath);
rs_job_free (deltajob);
free (inrs.buf);
free (outrs.buf);
// Send finish to the socket
if (!_executer_send_finish (job->peer_sock))
{
utils_error ("Error sending finish message: %s", strerror (errno));
return EXECUTER_ERROR;
}
if (result != RS_DONE)
{
utils_error ("Error calculating delta");
return EXECUTER_ERROR;
}
else
{
// Ok, send the stat
job->next_operation = _executer_send_stat;
// Ok, the delta is send, no need more process
return EXECUTER_RUNNING;
}
}
