/* Handle reading from a compressed stream */
static svn_error_t *
read_handler_gz(void *baton, char *buffer, apr_size_t *len)
{
struct zbaton *btn = baton;
int zerr;
if (btn->in == NULL)
{
btn->in = apr_palloc(btn->pool, sizeof(z_stream));
btn->in->zalloc = zalloc;
btn->in->zfree = zfree;
btn->in->opaque = btn->pool;
btn->read_buffer = apr_palloc(btn->pool, ZBUFFER_SIZE);
btn->in->next_in = btn->read_buffer;
btn->in->avail_in = ZBUFFER_SIZE;
SVN_ERR(read_helper_gz(btn->read, btn->subbaton, btn->read_buffer,
&btn->in->avail_in, &btn->read_flush));
zerr = inflateInit(btn->in);
SVN_ERR(svn_error__wrap_zlib(zerr, "inflateInit", btn->in->msg));
}
btn->in->next_out = (Bytef *) buffer;
btn->in->avail_out = (uInt) *len;
while (btn->in->avail_out > 0)
{
if (btn->in->avail_in <= 0)
{
btn->in->avail_in = ZBUFFER_SIZE;
btn->in->next_in = btn->read_buffer;
SVN_ERR(read_helper_gz(btn->read, btn->subbaton, btn->read_buffer,
&btn->in->avail_in, &btn->read_flush));
}
/* Short read means underlying stream has run out. */
if (btn->in->avail_in == 0)
{
*len = 0;
return SVN_NO_ERROR;
}
zerr = inflate(btn->in, btn->read_flush);
if (zerr == Z_STREAM_END)
break;
else if (zerr != Z_OK)
return svn_error_trace(svn_error__wrap_zlib(zerr, "inflate",
btn->in->msg));
}
*len -= btn->in->avail_out;
return SVN_NO_ERROR;
}
/* Compress data and write it to the substream */
static svn_error_t *
write_handler_gz(void *baton, const char *buffer, apr_size_t *len)
{
struct zbaton *btn = baton;
apr_pool_t *subpool;
void *write_buf;
apr_size_t buf_size, write_len;
int zerr;
if (btn->out == NULL)
{
btn->out = apr_palloc(btn->pool, sizeof(z_stream));
btn->out->zalloc = zalloc;
btn->out->zfree = zfree;
btn->out->opaque = btn->pool;
zerr = deflateInit(btn->out, Z_DEFAULT_COMPRESSION);
SVN_ERR(svn_error__wrap_zlib(zerr, "deflateInit", btn->out->msg));
}
/* The largest buffer we should need is 0.1% larger than the
compressed data, + 12 bytes. This info comes from zlib.h. */
buf_size = *len + (*len / 1000) + 13;
subpool = svn_pool_create(btn->pool);
write_buf = apr_palloc(subpool, buf_size);
btn->out->next_in = (Bytef *) buffer; /* Casting away const! */
btn->out->avail_in = (uInt) *len;
while (btn->out->avail_in > 0)
{
btn->out->next_out = write_buf;
btn->out->avail_out = (uInt) buf_size;
zerr = deflate(btn->out, Z_NO_FLUSH);
SVN_ERR(svn_error__wrap_zlib(zerr, "deflate", btn->out->msg));
write_len = buf_size - btn->out->avail_out;
if (write_len > 0)
SVN_ERR(btn->write(btn->subbaton, write_buf, &write_len));
}
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* Handle flushing and closing the stream */
static svn_error_t *
close_handler_gz(void *baton)
{
struct zbaton *btn = baton;
int zerr;
if (btn->in != NULL)
{
zerr = inflateEnd(btn->in);
SVN_ERR(svn_error__wrap_zlib(zerr, "inflateEnd", btn->in->msg));
}
if (btn->out != NULL)
{
void *buf;
apr_size_t write_len;
buf = apr_palloc(btn->pool, ZBUFFER_SIZE);
while (TRUE)
{
btn->out->next_out = buf;
btn->out->avail_out = ZBUFFER_SIZE;
zerr = deflate(btn->out, Z_FINISH);
if (zerr != Z_STREAM_END && zerr != Z_OK)
return svn_error_trace(svn_error__wrap_zlib(zerr, "deflate",
btn->out->msg));
write_len = ZBUFFER_SIZE - btn->out->avail_out;
if (write_len > 0)
SVN_ERR(btn->write(btn->subbaton, buf, &write_len));
if (zerr == Z_STREAM_END)
break;
}
zerr = deflateEnd(btn->out);
SVN_ERR(svn_error__wrap_zlib(zerr, "deflateEnd", btn->out->msg));
}
if (btn->close != NULL)
return svn_error_trace(btn->close(btn->subbaton));
else
return SVN_NO_ERROR;
}
/* Decode the possibly-zlib compressed string of length INLEN that is in
IN, into OUT. We expect an integer is prepended to IN that specifies
the original size, and that if encoded size == original size, that the
remaining data is not compressed.
In that case, we will simply return pointer into IN as data pointer for
OUT, COPYLESS_ALLOWED has been set. The, the caller is expected not to
modify the contents of OUT.
An error is returned if the decoded length exceeds the given LIMIT.
*/
static svn_error_t *
zlib_decode(const unsigned char *in, apr_size_t inLen, svn_stringbuf_t *out,
apr_size_t limit)
{
apr_size_t len;
apr_uint64_t size;
const unsigned char *oldplace = in;
/* First thing in the string is the original length. */
in = svn__decode_uint(&size, in, in + inLen);
len = (apr_size_t)size;
if (in == NULL || len != size)
return svn_error_create(SVN_ERR_SVNDIFF_INVALID_COMPRESSED_DATA, NULL,
_("Decompression of zlib compressed data failed: no size"));
if (len > limit)
return svn_error_create(SVN_ERR_SVNDIFF_INVALID_COMPRESSED_DATA, NULL,
_("Decompression of zlib compressed data failed: "
"size too large"));
/* We need to subtract the size of the encoded original length off the
* still remaining input length. */
inLen -= (in - oldplace);
if (inLen == len)
{
svn_stringbuf_ensure(out, len);
memcpy(out->data, in, len);
out->data[len] = 0;
out->len = len;
return SVN_NO_ERROR;
}
else
{
unsigned long zlen = len;
int zerr;
svn_stringbuf_ensure(out, len);
zerr = uncompress((unsigned char *)out->data, &zlen, in, inLen);
if (zerr != Z_OK)
return svn_error_trace(svn_error__wrap_zlib(
zerr, "uncompress",
_("Decompression of svndiff data failed")));
/* Zlib should not produce something that has a different size than the
original length we stored. */
if (zlen != len)
return svn_error_create(SVN_ERR_SVNDIFF_INVALID_COMPRESSED_DATA,
NULL,
_("Size of uncompressed data "
"does not match stored original length"));
out->data[zlen] = 0;
out->len = zlen;
}
return SVN_NO_ERROR;
}
/* If IN is a string that is >= MIN_COMPRESS_SIZE and the COMPRESSION_LEVEL
is not SVN_DELTA_COMPRESSION_LEVEL_NONE, zlib compress it and places the
result in OUT, with an integer prepended specifying the original size.
If IN is < MIN_COMPRESS_SIZE, or if the compressed version of IN was no
smaller than the original IN, OUT will be a copy of IN with the size
prepended as an integer. */
static svn_error_t *
zlib_encode(const char *data,
apr_size_t len,
svn_stringbuf_t *out,
int compression_level)
{
unsigned long endlen;
apr_size_t intlen;
unsigned char buf[SVN__MAX_ENCODED_UINT_LEN], *p;
svn_stringbuf_setempty(out);
p = svn__encode_uint(buf, (apr_uint64_t)len);
svn_stringbuf_appendbytes(out, (const char *)buf, p - buf);
intlen = out->len;
/* Compression initialization overhead is considered to large for
short buffers. Also, if we don't actually want to compress data,
ZLIB will produce an output no shorter than the input. Hence,
the DATA would directly appended to OUT, so we can do that directly
without calling ZLIB before. */
if (len < MIN_COMPRESS_SIZE || compression_level == SVN__COMPRESSION_NONE)
{
svn_stringbuf_appendbytes(out, data, len);
}
else
{
int zerr;
svn_stringbuf_ensure(out, svnCompressBound(len) + intlen);
endlen = out->blocksize;
zerr = compress2((unsigned char *)out->data + intlen, &endlen,
(const unsigned char *)data, len,
compression_level);
if (zerr != Z_OK)
return svn_error_trace(svn_error__wrap_zlib(
zerr, "compress2",
_("Compression of svndiff data failed")));
/* Compression didn't help :(, just append the original text */
if (endlen >= len)
{
svn_stringbuf_appendbytes(out, data, len);
return SVN_NO_ERROR;
}
out->len = endlen + intlen;
out->data[out->len] = 0;
}
return SVN_NO_ERROR;
}
