static rs_result rs_whole_gzrun(rs_job_t *job, FILE *in_file, gzFile in_zfile, FILE *out_file, gzFile out_zfile, struct cntr *cntr) { rs_buffers_t buf; rs_result result; rs_filebuf_t *in_fb = NULL, *out_fb = NULL; if (in_file || in_zfile) in_fb = rs_filebuf_new(NULL, in_file, in_zfile, -1, ASYNC_BUF_LEN, -1, cntr); if (out_file || out_zfile) out_fb = rs_filebuf_new(NULL, out_file, out_zfile, -1, ASYNC_BUF_LEN, -1, cntr); //logp("before drive\n"); result = rs_job_drive(job, &buf, in_fb ? rs_infilebuf_fill : NULL, in_fb, out_fb ? rs_outfilebuf_drain : NULL, out_fb); //logp("after drive\n"); if (in_fb) rs_filebuf_free(in_fb); if (out_fb) rs_filebuf_free(out_fb); return result; }
/** * Run a job continuously, with input to/from the two specified files. * The job should already be set up, and must be free by the caller * after return. * * Buffers of ::rs_inbuflen and ::rs_outbuflen are allocated for * temporary storage. * * \param in_file Source of input bytes, or NULL if the input buffer * should not be filled. * * \return RS_DONE if the job completed, or otherwise an error result. */ rs_result rs_whole_run(rs_job_t *job, FILE *in_file, FILE *out_file) { rs_buffers_t buf; rs_result result; rs_filebuf_t *in_fb = NULL, *out_fb = NULL; if (in_file) in_fb = rs_filebuf_new(in_file, rs_inbuflen); if (out_file) out_fb = rs_filebuf_new(out_file, rs_outbuflen); result = rs_job_drive(job, &buf, in_fb ? rs_infilebuf_fill : NULL, in_fb, out_fb ? rs_outfilebuf_drain : NULL, out_fb); if (in_fb) rs_filebuf_free(in_fb); if (out_fb) rs_filebuf_free(out_fb); return result; }
rs_result do_rs_run(rs_job_t *job, BFILE *bfd, FILE *in_file, FILE *out_file, gzFile in_zfile, gzFile out_zfile, int infd, int outfd, struct cntr *cntr) { rs_buffers_t buf; rs_result result; rs_filebuf_t *in_fb=NULL; rs_filebuf_t *out_fb=NULL; if(in_file && infd>=0) { logp("do not specify both input file and input fd in do_rs_run()\n"); return RS_IO_ERROR; } if(out_file && outfd>=0) { logp("do not specify both output file and output fd in do_rs_run()\n"); return RS_IO_ERROR; } if((bfd || in_file || in_zfile || infd>=0) && !(in_fb=rs_filebuf_new(bfd, in_file, in_zfile, infd, ASYNC_BUF_LEN, -1, cntr))) return RS_MEM_ERROR; if((out_file || out_zfile || outfd>=0) && !(out_fb=rs_filebuf_new(NULL, out_file, out_zfile, outfd, ASYNC_BUF_LEN, -1, cntr))) { if(in_fb) rs_filebuf_free(in_fb); return RS_MEM_ERROR; } //logp("before rs_job_drive\n"); result = rs_job_drive(job, &buf, in_fb ? rs_infilebuf_fill : NULL, in_fb, out_fb ? rs_outfilebuf_drain : NULL, out_fb); //logp("after rs_job_drive\n"); if(in_fb) rs_filebuf_free(in_fb); if(out_fb) rs_filebuf_free(out_fb); return result; }
static rs_filebuf_t *setup(rs_buffers_t *rsbuf, int data_len) { rs_filebuf_t *fb; alloc_check_init(); if(rsbuf) memset(rsbuf, 0, sizeof(rs_buffers_t)); fail_unless((fb=rs_filebuf_new( NULL, // bfd NULL, // fzp NULL, // asfd 32, // buf_len data_len ))!=NULL); return fb; }
END_TEST START_TEST(test_protocol1_rs_buf_alloc_failure) { rs_filebuf_t *fb; alloc_errors=1; fail_unless((fb=rs_filebuf_new( NULL, // bfd NULL, // fzp NULL, // asfd 32, // buf_len 20 // data_len ))==NULL); }
static rs_result rs_whole_gzrun(struct asfd *asfd, rs_job_t *job, struct fzp *in_file, struct fzp *out_file, struct cntr *cntr) { rs_buffers_t buf; rs_result result; rs_filebuf_t *in_fb=NULL; rs_filebuf_t *out_fb=NULL; if(in_file) in_fb=rs_filebuf_new(asfd, NULL, in_file, -1, ASYNC_BUF_LEN, -1, cntr); if(out_file) out_fb=rs_filebuf_new(asfd, NULL, out_file, -1, ASYNC_BUF_LEN, -1, cntr); result=rs_job_drive(job, &buf, in_fb ? rs_infilebuf_fill : NULL, in_fb, out_fb ? rs_outfilebuf_drain : NULL, out_fb); rs_filebuf_free(&in_fb); rs_filebuf_free(&out_fb); return result; }
rs_result rs_loadsig_network_run(struct asfd *asfd, rs_job_t *job, struct cntr *cntr) { rs_buffers_t buf; rs_result result; rs_filebuf_t *in_fb=NULL; if(!(in_fb=rs_filebuf_new(asfd, NULL, NULL, asfd->fd, ASYNC_BUF_LEN, -1, cntr))) { result=RS_MEM_ERROR; goto end; } result=rs_job_drive(job, &buf, rs_infilebuf_fill, in_fb, NULL, NULL); end: rs_filebuf_free(&in_fb); return result; }
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; }
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; }