static ERL_NIF_TERM loadsig_init(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
state_t *state = init_state();
state->job = rs_loadsig_begin(&state->sig);
state->type = LOADSIG;
ERL_NIF_TERM result = enif_make_resource(env, state);
enif_release_resource(state);
return result;
}
/**
* Load signatures from a signature file into memory. Return a
* pointer to the newly allocated structure in SUMSET.
*
* \sa rs_readsig_begin()
*/
rs_result
rs_loadsig_file(FILE *sig_file, rs_signature_t **sumset, rs_stats_t *stats)
{
rs_job_t *job;
rs_result r;
job = rs_loadsig_begin(sumset);
r = rs_whole_run(job, sig_file, NULL);
if (stats)
memcpy(stats, &job->stats, sizeof *stats);
rs_job_free(job);
return r;
}
static int load_signature(struct asfd *asfd,
rs_signature_t **sumset, struct conf *conf)
{
rs_result r;
rs_job_t *job;
job = rs_loadsig_begin(sumset);
if((r=do_rs_run(asfd, job,
NULL, NULL, NULL, NULL, NULL, asfd->fd, -1, conf->cntr)))
{
rs_free_sumset(*sumset);
return r;
}
if((r=rs_build_hash_table(*sumset))) return r;
rs_job_free(job);
return r;
}
executer_result
_executer_recive_signature (executer_job_t * job)
{
rs_signature_t *signature;
rs_job_t *signature_job;
executer_rs inrs;
rs_result result;
rs_buffers_t rsbuf;
utils_debug ("Receiving signature");
//Load the signature
signature_job = rs_loadsig_begin (&signature);
inrs.type = _EXECUTER_SOCKET;
inrs.sock = job->peer_sock;
inrs.size = RS_DEFAULT_BLOCK_LEN;
inrs.buf = malloc (inrs.size);
// Run librsync job
result =
rs_job_drive (signature_job, &rsbuf, _executer_in_callback, &inrs, NULL,
NULL);
// Free the memory
rs_job_free (signature_job);
free (inrs.buf);
if (result != RS_DONE)
{
utils_error ("Error carculating singnature");
return EXECUTER_ERROR;
}
else
{
//After receive signature, we need send delta
job->next_operation = _executer_send_delta;
job->signature = signature;
return EXECUTER_RUNNING;
}
}
/* 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 int load_signature(rs_signature_t **sumset, struct cntr *cntr)
{
rs_result r;
rs_job_t *job;
//logp("loadsig %s\n", rpath);
job = rs_loadsig_begin(sumset);
if((r=do_rs_run(job,
NULL, NULL, NULL, NULL, NULL, async_get_fd(), -1, cntr)))
{
rs_free_sumset(*sumset);
return r;
}
if((r=rs_build_hash_table(*sumset)))
{
return r;
}
rs_job_free(job);
//logp("end loadsig\n");
//logp("\n");
return r;
}
