int transfer_gzfile_inl(struct asfd *asfd,
struct sbuf *sb, const char *path, BFILE *bfd,
uint64_t *rcvd, uint64_t *sent,
const char *encpassword, int enccompressed,
struct cntr *cntr, char **metadata)
{
int quit=0;
int ret=-1;
uint8_t out[ZCHUNK];
int doutlen=0;
//uint8_t doutbuf[1000+EVP_MAX_BLOCK_LENGTH];
uint8_t doutbuf[ZCHUNK-EVP_MAX_BLOCK_LENGTH];
struct iobuf *rbuf=asfd->rbuf;
z_stream zstrm;
EVP_CIPHER_CTX *enc_ctx=NULL;
// Checksum stuff
//MD5_CTX md5;
//uint8_t checksum[MD5_DIGEST_LENGTH];
#ifdef HAVE_WIN32
if(sb && sb->path.cmd==CMD_EFS_FILE)
return transfer_efs_in(asfd, bfd, rcvd, sent, cntr);
#endif
//if(!MD5_Init(&md5))
//{
// logp("MD5_Init() failed");
// return -1;
//}
zstrm.zalloc=Z_NULL;
zstrm.zfree=Z_NULL;
zstrm.opaque=Z_NULL;
zstrm.avail_in=0;
zstrm.next_in=Z_NULL;
if(inflateInit2(&zstrm, (15+16)))
{
logp("unable to init inflate\n");
return -1;
}
if(encpassword && !(enc_ctx=enc_setup(0, encpassword)))
{
inflateEnd(&zstrm);
return -1;
}
while(!quit)
{
iobuf_free_content(rbuf);
if(asfd->read(asfd))
{
if(enc_ctx)
{
EVP_CIPHER_CTX_cleanup(enc_ctx);
free(enc_ctx);
}
inflateEnd(&zstrm);
return -1;
}
(*rcvd)+=rbuf->len;
//logp("transfer in: %c:%s\n", rbuf->cmd, rbuf->buf);
switch(rbuf->cmd)
{
case CMD_APPEND: // append
if(!bfd && !metadata)
{
logp("given append, but no file or metadata to write to\n");
asfd->write_str(asfd, CMD_ERROR,
"append with no file or metadata");
quit++; ret=-1;
}
else
{
size_t lentouse;
uint8_t *buftouse=NULL;
/*
if(!MD5_Update(&md5, rbuf->buf, rbuf->len))
{
logp("MD5 update enc error\n");
quit++; ret=-1;
break;
}
*/
// If doing decryption, it needs
// to be done before uncompressing.
if(enc_ctx)
{
// updating our checksum needs to
// be done first
/*
if(!MD5_Update(&md5, rbuf->buf, rbuf->len))
{
logp("MD5 update enc error\n");
quit++; ret=-1;
break;
}
else
*/
if(!EVP_CipherUpdate(enc_ctx,
doutbuf, &doutlen,
(uint8_t *)rbuf->buf,
rbuf->len))
{
logp("Decryption error\n");
quit++; ret=-1;
break;
}
if(!doutlen) break;
lentouse=(size_t)doutlen;
buftouse=doutbuf;
}
else
{
lentouse=rbuf->len;
buftouse=(uint8_t *)rbuf->buf;
}
//logp("want to write: %d\n", zstrm.avail_in);
if(do_inflate(asfd, &zstrm, bfd, out,
buftouse, lentouse, metadata,
encpassword,
enccompressed,
sent))
{
ret=-1; quit++;
break;
}
}
break;
case CMD_END_FILE: // finish up
if(enc_ctx)
{
if(!EVP_CipherFinal_ex(enc_ctx,
doutbuf, &doutlen))
{
logp("Decryption failure at the end.\n");
ret=-1; quit++;
break;
}
if(doutlen && do_inflate(asfd,
&zstrm, bfd,
out, doutbuf, (size_t)doutlen,
metadata, encpassword,
enccompressed, sent))
{
ret=-1; quit++;
break;
}
}
/*
if(MD5_Final(checksum, &md5))
{
char *oldsum=NULL;
const char *newsum=NULL;
if((oldsum=strchr(buf, ':')))
{
oldsum++;
newsum=bytes_to_md5str(checksum);
// log if the checksum differed
if(strcmp(newsum, oldsum))
logw(asfd, cntr, "md5sum for '%s' did not match! (%s!=%s)\n", path, newsum, oldsum);
}
}
else
{
logp("MD5_Final() failed\n");
}
*/
quit++;
ret=0;
break;
case CMD_MESSAGE:
case CMD_WARNING:
log_recvd(rbuf, cntr, 0);
break;
default:
iobuf_log_unexpected(rbuf, __func__);
quit++;
ret=-1;
break;
}
}
inflateEnd(&zstrm);
if(enc_ctx)
{
EVP_CIPHER_CTX_cleanup(enc_ctx);
free(enc_ctx);
}
iobuf_free_content(rbuf);
if(ret) logp("transfer file returning: %d\n", ret);
return ret;
}
/* OK, this function is getting a bit out of control.
One problem is that, if you give deflateInit2 compression=0, it still
writes gzip headers and footers, so I had to add extra
if(compression) and if(!compression) bits all over the place that would
skip the actual compression.
This is needed for the case where encryption is on and compression is off.
Encryption off and compression off uses send_whole_file().
Perhaps a separate function is needed for encryption on compression off.
*/
int send_whole_file_gzl(struct asfd *asfd, const char *datapth,
int quick_read, uint64_t *bytes, const char *encpassword,
struct cntr *cntr, int compression, struct BFILE *bfd,
const char *extrameta, size_t elen)
{
int ret=0;
int zret=0;
MD5_CTX md5;
size_t metalen=0;
const char *metadata=NULL;
struct iobuf wbuf;
int have;
z_stream strm;
int flush=Z_NO_FLUSH;
uint8_t in[ZCHUNK];
uint8_t out[ZCHUNK];
int eoutlen;
uint8_t eoutbuf[ZCHUNK+EVP_MAX_BLOCK_LENGTH];
EVP_CIPHER_CTX *enc_ctx=NULL;
#ifdef HAVE_WIN32
int do_known_byte_count=0;
size_t datalen=bfd->datalen;
if(datalen>0) do_known_byte_count=1;
#endif
if(encpassword && !(enc_ctx=enc_setup(1, encpassword)))
return -1;
if(!MD5_Init(&md5))
{
logp("MD5_Init() failed\n");
return -1;
}
//logp("send_whole_file_gz: %s%s\n", fname, extrameta?" (meta)":"");
if((metadata=extrameta))
{
metalen=elen;
}
/* allocate deflate state */
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
if((zret=deflateInit2(&strm, compression, Z_DEFLATED, (15+16),
8, Z_DEFAULT_STRATEGY))!=Z_OK)
{
return -1;
}
do
{
if(metadata)
{
if(metalen>ZCHUNK)
strm.avail_in=ZCHUNK;
else
strm.avail_in=metalen;
memcpy(in, metadata, strm.avail_in);
metadata+=strm.avail_in;
metalen-=strm.avail_in;
}
else
{
// Windows VSS headers give us how much data to
// expect to read.
#ifdef HAVE_WIN32
if(do_known_byte_count)
{
if(datalen<=0) strm.avail_in=0;
else strm.avail_in=
(uint32_t)bfd->read(bfd, in,
min((size_t)ZCHUNK, datalen));
datalen-=strm.avail_in;
}
else
#endif
strm.avail_in=
(uint32_t)bfd->read(bfd, in, ZCHUNK);
}
if(!compression && !strm.avail_in) break;
*bytes+=strm.avail_in;
// The checksum needs to be later if encryption is being used.
if(!enc_ctx)
{
if(!MD5_Update(&md5, in, strm.avail_in))
{
logp("MD5_Update() failed\n");
ret=-1;
break;
}
}
#ifdef HAVE_WIN32
if(do_known_byte_count && datalen<=0) flush=Z_FINISH;
else
#endif
if(strm.avail_in) flush=Z_NO_FLUSH;
else flush=Z_FINISH;
strm.next_in=in;
/* run deflate() on input until output buffer not full, finish
compression if all of source has been read in */
do
{
if(compression)
{
strm.avail_out = ZCHUNK;
strm.next_out = out;
zret = deflate(&strm, flush); /* no bad return value */
if(zret==Z_STREAM_ERROR) /* state not clobbered */
{
logp("z_stream_error\n");
ret=-1;
break;
}
have = ZCHUNK-strm.avail_out;
}
else
{
have=strm.avail_in;
memcpy(out, in, have);
}
if(enc_ctx)
{
if(do_encryption(asfd, enc_ctx, out, have,
eoutbuf, &eoutlen, &md5))
{
ret=-1;
break;
}
}
else
{
iobuf_set(&wbuf, CMD_APPEND, (char *)out, have);
if(asfd->write(asfd, &wbuf))
{
ret=-1;
break;
}
}
if(quick_read && datapth)
{
int qr;
if((qr=do_quick_read(asfd, datapth, cntr))<0)
{
ret=-1;
break;
}
if(qr) // client wants to interrupt
{
goto cleanup;
}
}
if(!compression) break;
} while (!strm.avail_out);
if(ret) break;
if(!compression) continue;
if(strm.avail_in) /* all input will be used */
{
ret=-1;
logp("strm.avail_in=%d\n", strm.avail_in);
break;
}
} while(flush!=Z_FINISH);
if(!ret)
{
if(compression && zret!=Z_STREAM_END)
{
logp("ret OK, but zstream not finished: %d\n", zret);
ret=-1;
}
else if(enc_ctx)
{
if(!EVP_CipherFinal_ex(enc_ctx, eoutbuf, &eoutlen))
{
logp("Encryption failure at the end\n");
ret=-1;
}
else if(eoutlen>0)
{
iobuf_set(&wbuf, CMD_APPEND,
(char *)eoutbuf, (size_t)eoutlen);
if(asfd->write(asfd, &wbuf))
ret=-1;
else if(!MD5_Update(&md5, eoutbuf, eoutlen))
{
logp("MD5_Update() failed\n");
ret=-1;
}
}
}
}
cleanup:
deflateEnd(&strm);
if(enc_ctx)
{
EVP_CIPHER_CTX_cleanup(enc_ctx);
free(enc_ctx);
}
if(!ret)
{
uint8_t checksum[MD5_DIGEST_LENGTH];
if(!MD5_Final(checksum, &md5))
{
logp("MD5_Final() failed\n");
return -1;
}
return write_endfile(asfd, *bytes, checksum);
}
//logp("end of send\n");
return ret;
}
int transfer_gzfile_in(struct sbuf *sb, const char *path, BFILE *bfd, FILE *fp, unsigned long long *rcvd, unsigned long long *sent, const char *encpassword, int enccompressed, struct cntr *cntr, char **metadata)
{
char cmd;
char *buf=NULL;
size_t len=0;
int quit=0;
int ret=-1;
unsigned char out[ZCHUNK];
size_t doutlen=0;
//unsigned char doutbuf[1000+EVP_MAX_BLOCK_LENGTH];
unsigned char doutbuf[ZCHUNK-EVP_MAX_BLOCK_LENGTH];
z_stream zstrm;
EVP_CIPHER_CTX *enc_ctx=NULL;
// Checksum stuff
//MD5_CTX md5;
//unsigned char checksum[MD5_DIGEST_LENGTH+1];
//logp("in transfer_gzfile_in\n");
#ifdef HAVE_WIN32
if(sb && sb->cmd==CMD_EFS_FILE)
return transfer_efs_in(bfd, rcvd, sent, cntr);
#endif
//if(!MD5_Init(&md5))
//{
// logp("MD5_Init() failed");
// return -1;
//}
zstrm.zalloc=Z_NULL;
zstrm.zfree=Z_NULL;
zstrm.opaque=Z_NULL;
zstrm.avail_in=0;
zstrm.next_in=Z_NULL;
if(inflateInit2(&zstrm, (15+16)))
{
logp("unable to init inflate\n");
return -1;
}
if(encpassword && !(enc_ctx=enc_setup(0, encpassword)))
{
inflateEnd(&zstrm);
return -1;
}
while(!quit)
{
if(async_read(&cmd, &buf, &len))
{
if(enc_ctx)
{
EVP_CIPHER_CTX_cleanup(enc_ctx);
free(enc_ctx);
}
inflateEnd(&zstrm);
return -1;
}
(*rcvd)+=len;
//logp("transfer in: %c:%s\n", cmd, buf);
switch(cmd)
{
case CMD_APPEND: // append
if(!fp && !bfd && !metadata)
{
logp("given append, but no file or metadata to write to\n");
async_write_str(CMD_ERROR, "append with no file or metadata");
quit++; ret=-1;
}
else
{
size_t lentouse;
unsigned char *buftouse=NULL;
/*
if(!MD5_Update(&md5, buf, len))
{
logp("MD5 update enc error\n");
quit++; ret=-1;
break;
}
*/
// If doing decryption, it needs
// to be done before uncompressing.
if(enc_ctx)
{
// updating our checksum needs to
// be done first
/*
if(!MD5_Update(&md5, buf, len))
{
logp("MD5 update enc error\n");
quit++; ret=-1;
break;
}
else
*/
if(!EVP_CipherUpdate(enc_ctx,
doutbuf, (int *)&doutlen,
(unsigned char *)buf,
len))
{
logp("Decryption error\n");
quit++; ret=-1;
break;
}
if(!doutlen) break;
lentouse=doutlen;
buftouse=doutbuf;
}
else
{
lentouse=len;
buftouse=(unsigned char *)buf;
}
//logp("want to write: %d\n", zstrm.avail_in);
if(do_inflate(&zstrm, bfd, fp, out,
buftouse, lentouse, metadata,
encpassword,
enccompressed,
sent))
{
ret=-1; quit++;
break;
}
}
break;
case CMD_END_FILE: // finish up
if(enc_ctx)
{
if(!EVP_CipherFinal_ex(enc_ctx,
doutbuf, (int *)&doutlen))
{
logp("Decryption failure at the end.\n");
ret=-1; quit++;
break;
}
if(doutlen && do_inflate(&zstrm, bfd,
fp, out, doutbuf, doutlen, metadata,
encpassword,
enccompressed, sent))
{
ret=-1; quit++;
break;
}
}
/*
if(MD5_Final(checksum, &md5))
{
char *oldsum=NULL;
const char *newsum=NULL;
if((oldsum=strchr(buf, ':')))
{
oldsum++;
newsum=get_checksum_str(checksum);
// log if the checksum differed
if(strcmp(newsum, oldsum))
logw(cntr, "md5sum for '%s' did not match! (%s!=%s)\n", path, newsum, oldsum);
}
}
else
{
logp("MD5_Final() failed\n");
}
*/
quit++;
ret=0;
break;
case CMD_WARNING:
logp("WARNING: %s\n", buf);
do_filecounter(cntr, cmd, 0);
break;
default:
logp("unknown append cmd: %c\n", cmd);
quit++;
ret=-1;
break;
}
if(buf) free(buf);
buf=NULL;
}
inflateEnd(&zstrm);
if(enc_ctx)
{
EVP_CIPHER_CTX_cleanup(enc_ctx);
free(enc_ctx);
}
if(ret) logp("transfer file returning: %d\n", ret);
return ret;
}
