static ERL_NIF_TERM sig_init(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
state_t *state = init_state();
state->job = rs_sig_begin(RS_DEFAULT_BLOCK_LEN, RS_DEFAULT_STRONG_LEN);
state->type = SIGNATURE;
ERL_NIF_TERM result = enif_make_resource(env, state);
enif_release_resource(state);
return result;
}
static PyObject*
_librsync_new_sigmaker(PyObject* self, PyObject* args)
{
_librsync_SigMakerObject* sm;
long blocklen;
if (!PyArg_ParseTuple(args, "l:new_sigmaker", &blocklen))
return NULL;
sm = PyObject_New(_librsync_SigMakerObject, &_librsync_SigMakerType);
if (sm == NULL) return NULL;
#ifdef RS_DEFAULT_STRONG_LEN /* librsync < 1.0.0 */
sm->sig_job = rs_sig_begin((size_t)blocklen,
(size_t)RS_DEFAULT_STRONG_LEN);
#else /* librsync >= 1.0.0 */
sm->sig_job = rs_sig_begin((size_t)blocklen,
(size_t)8, RS_MD4_SIG_MAGIC);
#endif
return (PyObject*)sm;
}
/**
* Generate the signature of a basis file, and write it out to
* another.
*
* \param new_block_len block size for signature generation, in bytes
*
* \param strong_len truncated length of strong checksums, in bytes
*
* \sa rs_sig_begin()
*/
rs_result
rs_sig_file(FILE *old_file, FILE *sig_file, size_t new_block_len,
size_t strong_len, rs_stats_t *stats)
{
rs_job_t *job;
rs_result r;
job = rs_sig_begin(new_block_len, strong_len);
r = rs_whole_run(job, old_file, sig_file);
if (stats)
memcpy(stats, &job->stats, sizeof *stats);
rs_job_free(job);
return r;
}
rs_result rs_sig_gzfile(FILE *old_file, gzFile old_zfile, FILE *sig_file, size_t new_block_len, size_t strong_len, rs_stats_t *stats, struct cntr *cntr)
{
rs_job_t *job;
rs_result r;
job = rs_sig_begin(new_block_len, strong_len);
r = rs_whole_gzrun(job, old_file, old_zfile, sig_file, NULL, cntr);
/*
if (stats)
memcpy(stats, &job->stats, sizeof *stats);
*/
rs_job_free(job);
return r;
}
static PyObject*
_librsync_new_sigmaker(PyObject* self, PyObject* args)
{
_librsync_SigMakerObject* sm;
long blocklen;
if (!PyArg_ParseTuple(args, "l:new_sigmaker", &blocklen))
return NULL;
sm = PyObject_New(_librsync_SigMakerObject, &_librsync_SigMakerType);
if (sm == NULL) return NULL;
sm->x_attr = NULL;
sm->sig_job = rs_sig_begin((size_t)blocklen,
(size_t)RS_DEFAULT_STRONG_LEN);
return (PyObject*)sm;
}
executer_result
_executer_send_signature (executer_job_t * job)
{
rs_job_t *sigjob;
executer_rs inrs;
executer_rs outrs;
rs_buffers_t rsbuf;
utils_debug ("Sending signature");
int openfile = open (job->realpath, O_RDONLY);
inrs.sock = openfile;
inrs.type = _EXECUTER_FILE;
inrs.size = RS_DEFAULT_BLOCK_LEN;
inrs.buf = malloc (inrs.size);
outrs.sock = job->peer_sock;
outrs.type = _EXECUTER_SOCKET;
outrs.size = _EXECUTER_DEFAULT_OUT;
outrs.buf = malloc (outrs.size);
sigjob = rs_sig_begin (RS_DEFAULT_BLOCK_LEN, RS_DEFAULT_STRONG_LEN);
rs_result result =
rs_job_drive (sigjob, &rsbuf, _executer_in_callback, &inrs,
_executer_out_callback, &outrs);
// Free the memory
rs_job_free (sigjob);
free (inrs.buf);
free (outrs.buf);
close (openfile);
if (result != RS_DONE)
{
utils_error ("Error sending signature");
return EXECUTER_ERROR;
}
_executer_send_finish (job->peer_sock);
job->next_operation = _executer_recive_delta;
return EXECUTER_RUNNING;
}
rs_result rs_sig_gzfile(struct asfd *asfd,
struct fzp *old_file, struct fzp *sig_file,
size_t new_block_len, size_t strong_len,
rs_stats_t *stats, struct conf **confs)
{
rs_job_t *job;
rs_result r;
job=
rs_sig_begin(new_block_len, strong_len
#ifndef RS_DEFAULT_STRONG_LEN
, rshash_to_magic_number(
get_e_rshash(confs[OPT_RSHASH]))
#endif
);
r=rs_whole_gzrun(asfd, job, old_file, sig_file,
get_cntr(confs[OPT_CNTR]));
rs_job_free(job);
return r;
}
static int process_changed_file(struct asfd *asfd,
struct sdirs *sdirs, struct conf **cconfs,
struct sbuf *cb, struct sbuf *p1b,
const char *adir)
{
size_t blocklen=0;
char *curpath=NULL;
//logp("need to process changed file: %s (%s)\n",
// cb->path, cb->datapth);
// Move datapth onto p1b.
iobuf_move(&p1b->protocol1->datapth, &cb->protocol1->datapth);
if(!(curpath=prepend_s(adir, p1b->protocol1->datapth.buf)))
{
log_out_of_memory(__func__);
return -1;
}
if(dpth_protocol1_is_compressed(cb->compression, curpath))
p1b->protocol1->sigfzp=fzp_gzopen(curpath, "rb");
else
p1b->protocol1->sigfzp=fzp_open(curpath, "rb");
if(!p1b->protocol1->sigfzp)
{
logp("could not open %s: %s\n", curpath, strerror(errno));
free(curpath);
return -1;
}
free(curpath);
blocklen=get_librsync_block_len(cb->protocol1->endfile.buf);
if(!(p1b->protocol1->sigjob=
#ifdef RS_DEFAULT_STRONG_LEN
rs_sig_begin(blocklen, RS_DEFAULT_STRONG_LEN)
#else
// This is for librsync-1.0.0. RS_DEFAULT_STRONG_LEN was 8 in
// librsync-0.9.7.
rs_sig_begin(blocklen, 8,
rshash_to_magic_number(get_e_rshash(cconfs[OPT_RSHASH])))
#endif
))
{
logp("could not start signature job.\n");
return -1;
}
//logp("sig begin: %s\n", p1b->protocol1->datapth.buf);
if(!(p1b->protocol1->infb=rs_filebuf_new(asfd, NULL,
p1b->protocol1->sigfzp,
-1, blocklen, -1, get_cntr(cconfs[OPT_CNTR]))))
{
logp("could not rs_filebuf_new for infb.\n");
return -1;
}
if(!(p1b->protocol1->outfb=rs_filebuf_new(asfd, NULL, NULL,
asfd->fd, ASYNC_BUF_LEN, -1, get_cntr(cconfs[OPT_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->flags |= SBUFL_SEND_DATAPTH;
p1b->flags |= SBUFL_SEND_STAT;
p1b->flags |= SBUFL_SEND_PATH;
//logp("sending sig for %s\n", p1b->path);
//logp("(%s)\n", p1b->datapth);
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;
}
static int process_changed_file(struct asfd *asfd,
struct sdirs *sdirs, struct conf *cconf,
struct sbuf *cb, struct sbuf *p1b,
const char *adir)
{
size_t blocklen=0;
char *curpath=NULL;
//logp("need to process changed file: %s (%s)\n", cb->path, cb->datapth);
// Move datapth onto p1b.
iobuf_copy(&p1b->burp1->datapth, &cb->burp1->datapth);
cb->burp1->datapth.buf=NULL;
if(!(curpath=prepend_s(adir, p1b->burp1->datapth.buf)))
{
log_out_of_memory(__func__);
return -1;
}
if(dpthl_is_compressed(cb->compression, curpath))
p1b->burp1->sigzp=gzopen_file(curpath, "rb");
else
p1b->burp1->sigfp=open_file(curpath, "rb");
if(!p1b->burp1->sigzp && !p1b->burp1->sigfp)
{
logp("could not open %s: %s\n", curpath, strerror(errno));
free(curpath);
return -1;
}
free(curpath);
blocklen=get_librsync_block_len(cb->burp1->endfile.buf);
if(!(p1b->burp1->sigjob=rs_sig_begin(blocklen, RS_DEFAULT_STRONG_LEN)))
{
logp("could not start signature job.\n");
return -1;
}
//logp("sig begin: %s\n", p1b->burp1->datapth.buf);
if(!(p1b->burp1->infb=rs_filebuf_new(asfd, NULL,
p1b->burp1->sigfp, p1b->burp1->sigzp,
-1, blocklen, -1, cconf->cntr)))
{
logp("could not rs_filebuf_new for infb.\n");
return -1;
}
if(!(p1b->burp1->outfb=rs_filebuf_new(asfd, NULL, NULL, NULL,
asfd->fd, ASYNC_BUF_LEN, -1, cconf->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->flags |= SBUFL_SEND_DATAPTH;
p1b->flags |= SBUFL_SEND_STAT;
p1b->flags |= SBUFL_SEND_PATH;
//logp("sending sig for %s\n", p1b->path);
//logp("(%s)\n", p1b->datapth);
return 0;
}
