// Return 1 if there is still stuff needing to be sent.
static int do_stuff_to_send(struct asfd *asfd,
struct sbuf *p1b, char **last_requested)
{
static struct iobuf wbuf;
if(p1b->flags & SBUFL_SEND_DATAPTH)
{
iobuf_copy(&wbuf, &p1b->burp1->datapth);
if(asfd->append_all_to_write_buffer(asfd, &wbuf))
return 1;
p1b->flags &= ~SBUFL_SEND_DATAPTH;
}
if(p1b->flags & SBUFL_SEND_STAT)
{
iobuf_copy(&wbuf, &p1b->attr);
if(asfd->append_all_to_write_buffer(asfd, &wbuf))
return 1;
p1b->flags &= ~SBUFL_SEND_STAT;
}
if(p1b->flags & SBUFL_SEND_PATH)
{
iobuf_copy(&wbuf, &p1b->path);
if(asfd->append_all_to_write_buffer(asfd, &wbuf))
return 1;
p1b->flags &= ~SBUFL_SEND_PATH;
if(*last_requested) free(*last_requested);
if(!(*last_requested=strdup_w(p1b->path.buf, __func__)))
return -1;
}
if(p1b->burp1->sigjob && !(p1b->flags & SBUFL_SEND_ENDOFSIG))
{
rs_result sigresult;
sigresult=rs_async(p1b->burp1->sigjob, &(p1b->burp1->rsbuf),
p1b->burp1->infb, p1b->burp1->outfb);
if(sigresult==RS_DONE)
{
p1b->flags |= SBUFL_SEND_ENDOFSIG;
}
else if(sigresult==RS_BLOCKED || sigresult==RS_RUNNING)
{
// keep going round the loop.
return 1;
}
else
{
logp("error in rs_async: %d\n", sigresult);
return -1;
}
}
if(p1b->flags & SBUFL_SEND_ENDOFSIG)
{
iobuf_from_str(&wbuf, CMD_END_FILE, (char *)"endfile");
if(asfd->append_all_to_write_buffer(asfd, &wbuf)) return 1;
p1b->flags &= ~SBUFL_SEND_ENDOFSIG;
}
return 0;
}
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;
}
// Return 1 if there is still stuff needing to be sent.
// FIX THIS: lots of repeated code.
static int do_stuff_to_send(struct asfd *asfd,
struct sbuf *p1b, char **last_requested)
{
static struct iobuf wbuf;
if(p1b->flags & SBUF_SEND_DATAPTH)
{
iobuf_copy(&wbuf, &p1b->protocol1->datapth);
switch(asfd->append_all_to_write_buffer(asfd, &wbuf))
{
case APPEND_OK: break;
case APPEND_BLOCKED: return 1;
default: return -1;
}
p1b->flags &= ~SBUF_SEND_DATAPTH;
}
if(p1b->flags & SBUF_SEND_STAT)
{
iobuf_copy(&wbuf, &p1b->attr);
switch(asfd->append_all_to_write_buffer(asfd, &wbuf))
{
case APPEND_OK: break;
case APPEND_BLOCKED: return 1;
default: return -1;
}
p1b->flags &= ~SBUF_SEND_STAT;
}
if(p1b->flags & SBUF_SEND_PATH)
{
iobuf_copy(&wbuf, &p1b->path);
switch(asfd->append_all_to_write_buffer(asfd, &wbuf))
{
case APPEND_OK: break;
case APPEND_BLOCKED: return 1;
default: return -1;
}
p1b->flags &= ~SBUF_SEND_PATH;
free_w(last_requested);
if(!(*last_requested=strdup_w(p1b->path.buf, __func__)))
return -1;
}
if(p1b->protocol1->sigjob && !(p1b->flags & SBUF_SEND_ENDOFSIG))
{
rs_result sigresult;
switch((sigresult=rs_async(p1b->protocol1->sigjob,
&(p1b->protocol1->rsbuf),
p1b->protocol1->infb, p1b->protocol1->outfb)))
{
case RS_DONE:
p1b->flags |= SBUF_SEND_ENDOFSIG;
break;
case RS_BLOCKED:
case RS_RUNNING:
// keep going round the loop.
return 1;
default:
logp("error in rs_async: %d\n", sigresult);
return -1;
}
}
if(p1b->flags & SBUF_SEND_ENDOFSIG)
{
iobuf_from_str(&wbuf, CMD_END_FILE, (char *)"endfile");
switch(asfd->append_all_to_write_buffer(asfd, &wbuf))
{
case APPEND_OK: break;
case APPEND_BLOCKED: return 1;
default: return -1;
}
p1b->flags &= ~SBUF_SEND_ENDOFSIG;
}
return 0;
}
// Return 1 if there is still stuff needing to be sent.
static int do_stuff_to_send(struct sbuf *p1b, char **last_requested)
{
//size_t junk=0;
if(p1b->senddatapth)
{
size_t l=strlen(p1b->datapth);
if(async_append_all_to_write_buffer(CMD_DATAPTH, p1b->datapth, &l))
return 1;
p1b->senddatapth=0;
//if(async_rw(NULL, NULL, NULL, NULL, NULL, &junk)) return -1;
}
if(p1b->sendstat)
{
size_t l=p1b->slen;
if(async_append_all_to_write_buffer(CMD_STAT, p1b->statbuf, &l))
return 1;
p1b->sendstat=0;
//if(async_rw(NULL, NULL, NULL, NULL, NULL, &junk)) return -1;
}
if(p1b->sendpath)
{
size_t l=p1b->plen;
if(async_append_all_to_write_buffer(p1b->cmd,
p1b->path, &l)) return 1;
p1b->sendpath=0;
if(*last_requested) free(*last_requested);
*last_requested=strdup(p1b->path);
//if(async_rw(NULL, NULL, NULL, NULL, NULL, &junk)) return -1;
}
if(p1b->sigjob && !p1b->sendendofsig)
{
rs_result sigresult;
sigresult=rs_async(p1b->sigjob,
&(p1b->rsbuf), p1b->infb, p1b->outfb);
//logp("after rs_async: %d %c %s\n", sigresult, p1b->cmd, p1b->path);
if(sigresult==RS_DONE)
{
p1b->sendendofsig++;
//if(async_rw(NULL, NULL, NULL, NULL, NULL, &junk))
// return -1;
}
else if(sigresult==RS_BLOCKED || sigresult==RS_RUNNING)
{
// keep going round the loop.
//if(async_rw(NULL, NULL, NULL, NULL, NULL, &junk))
// return -1;
return 1;
}
else
{
logp("error in rs_async: %d\n", sigresult);
return -1;
}
}
if(p1b->sendendofsig)
{
size_t l;
const char *endfile="endfile";
l=strlen(endfile);
if(async_append_all_to_write_buffer(CMD_END_FILE, endfile, &l))
return 1;
//if(async_rw(NULL, NULL, NULL, NULL, NULL, &junk)) return -1;
p1b->sendendofsig=0;
}
return 0;
}
