bool inflateZlibHeaderless(byte *dst, uint dstLen, const byte *src, uint srcLen, const byte *dict, uint dictLen) {
if (!dst || !dstLen || !src || !srcLen)
return false;
// Initialize zlib
z_stream stream;
stream.next_in = const_cast<byte *>(src);
stream.avail_in = srcLen;
stream.next_out = dst;
stream.avail_out = dstLen;
stream.zalloc = Z_NULL;
stream.zfree = Z_NULL;
stream.opaque = Z_NULL;
// Negative MAX_WBITS tells zlib there's no zlib header
int err = inflateInit2(&stream, -MAX_WBITS);
if (err != Z_OK)
return false;
// Set the dictionary, if provided
if (dict != 0) {
err = inflateSetDictionary(&stream, const_cast<byte *>(dict), dictLen);
if (err != Z_OK)
return false;
}
err = inflate(&stream, Z_SYNC_FLUSH);
if (err != Z_OK && err != Z_STREAM_END) {
inflateEnd(&stream);
return false;
}
inflateEnd(&stream);
return true;
}
/* cover all inflate() header and trailer cases and code after inflate() */
local void cover_wrap(void)
{
int ret;
z_stream strm, copy;
unsigned char dict[257];
ret = inflate(Z_NULL, 0); assert(ret == Z_STREAM_ERROR);
ret = inflateEnd(Z_NULL); assert(ret == Z_STREAM_ERROR);
ret = inflateCopy(Z_NULL, Z_NULL); assert(ret == Z_STREAM_ERROR);
fputs("inflate bad parameters\n", stderr);
inf("1f 8b 0 0", "bad gzip method", 0, 31, 0, Z_DATA_ERROR);
inf("1f 8b 8 80", "bad gzip flags", 0, 31, 0, Z_DATA_ERROR);
inf("77 85", "bad zlib method", 0, 15, 0, Z_DATA_ERROR);
inf("8 99", "set window size from header", 0, 0, 0, Z_OK);
inf("78 9c", "bad zlib window size", 0, 8, 0, Z_DATA_ERROR);
inf("78 9c 63 0 0 0 1 0 1", "check adler32", 0, 15, 1, Z_STREAM_END);
inf("1f 8b 8 1e 0 0 0 0 0 0 1 0 0 0 0 0 0", "bad header crc", 0, 47, 1,
Z_DATA_ERROR);
inf("1f 8b 8 2 0 0 0 0 0 0 1d 26 3 0 0 0 0 0 0 0 0 0", "check gzip length",
0, 47, 0, Z_STREAM_END);
inf("78 90", "bad zlib header check", 0, 47, 0, Z_DATA_ERROR);
inf("8 b8 0 0 0 1", "need dictionary", 0, 8, 0, Z_NEED_DICT);
inf("78 9c 63 0", "compute adler32", 0, 15, 1, Z_OK);
mem_setup(&strm);
strm.avail_in = 0;
strm.next_in = Z_NULL;
ret = inflateInit2(&strm, -8);
strm.avail_in = 2;
strm.next_in = (void *)"\x63";
strm.avail_out = 1;
strm.next_out = (void *)&ret;
mem_limit(&strm, 1);
ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_MEM_ERROR);
ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_MEM_ERROR);
mem_limit(&strm, 0);
memset(dict, 0, 257);
ret = inflateSetDictionary(&strm, dict, 257);
assert(ret == Z_OK);
mem_limit(&strm, (sizeof(struct inflate_state) << 1) + 256);
ret = inflatePrime(&strm, 16, 0); assert(ret == Z_OK);
strm.avail_in = 2;
strm.next_in = (void *)"\x80";
ret = inflateSync(&strm); assert(ret == Z_DATA_ERROR);
ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_STREAM_ERROR);
strm.avail_in = 4;
strm.next_in = (void *)"\0\0\xff\xff";
ret = inflateSync(&strm); assert(ret == Z_OK);
(void)inflateSyncPoint(&strm);
ret = inflateCopy(©, &strm); assert(ret == Z_MEM_ERROR);
mem_limit(&strm, 0);
ret = inflateUndermine(&strm, 1); assert(ret == Z_DATA_ERROR);
(void)inflateMark(&strm);
ret = inflateEnd(&strm); assert(ret == Z_OK);
mem_done(&strm, "miscellaneous, force memory errors");
}
int SpdyZlibFilter::spdyHeaderInflate( char* pSource, uint32_t length, AutoBuf& bufInflate)
{
int ret;
m_stream.avail_in = length;
m_stream.next_in = ( unsigned char * )pSource;
m_stream.avail_out = bufInflate.available();
m_stream.next_out = ( unsigned char* )bufInflate.end();
while( m_stream.avail_in )
{
ret = inflate( &m_stream, Z_SYNC_FLUSH );
if ( ret == Z_STREAM_ERROR )
return -1;
switch ( ret )
{
case Z_NEED_DICT:
/* Setting the dictionary for the SPDY zlib compression. */
ret = inflateSetDictionary( &m_stream, s_dicts[ m_version ],
s_dictsLen[ m_version ] );
if ( ret != Z_OK )
{
inflateEnd( &m_stream );
return -1;
}
continue;
case Z_DATA_ERROR:
return Z_DATA_ERROR;
case Z_MEM_ERROR:
return Z_MEM_ERROR;
case Z_OK:
break;
default:
return ret;
}
bufInflate.used( m_stream.next_out - ( unsigned char* )bufInflate.end() );
if(m_stream.avail_out == 0)
{
bufInflate.grow(512);
m_stream.avail_out = bufInflate.available();
m_stream.next_out = ( unsigned char* )bufInflate.end();
}
else
{
break;
}
}
return bufInflate.size();
}
static TACommandVerdict inflateSetDictionary_cmd(TAThread thread,TAInputStream stream)
{
z_stream strm;
int res, is_null;
Bytef * dictionary;
uInt dictlen;
is_null = readZStream(&stream, &strm);
dictionary = (Bytef*) readPointer(&stream);
dictlen = readUInt(&stream);
/*ta_debug_printf( "next_in==%d\navail_in==%u\ntotal_in==%lu\nnext_out==%d\n"
"avail_out==%u\ntotal_out==%lu\n",
strm.next_in, strm.avail_in, strm.total_in, strm.next_out,
strm.avail_out,strm.total_out);
ta_debug_printf( "msg==%s\nstate==%d\nzalloc==%d\nzfree==%d\n"
"opaque==%d\ndata_type==%d\nadler==%lu\nreserved==%lu\n",
strm.msg, strm.state,
strm.zalloc, strm.zfree, strm.opaque, strm.data_type, strm.adler,
strm.reserved);*/
START_TARGET_OPERATION(thread);
if(!is_null)
res = inflateSetDictionary(&strm, dictionary, dictlen);
else
res = inflateSetDictionary(0, dictionary, dictlen);
END_TARGET_OPERATION(thread);
// Response
if(!is_null)
writeZStream(thread, &strm);
else
writeZStream(thread, 0);
writeInt(thread, res);
sendResponse(thread);
return taDefaultVerdict;
}
/* ===========================================================================
* Test inflate() with a preset dictionary
*/
void test_dict_inflate(
Byte *compr,
uLong comprLen,
Byte *uncompr,
uLong uncomprLen)
{
int err;
z_stream d_stream; /* decompression stream */
strcpy((char*)uncompr, "garbage");
d_stream.zalloc = (alloc_func)0;
d_stream.zfree = (free_func)0;
d_stream.opaque = (voidpf)0;
d_stream.next_in = compr;
d_stream.avail_in = (uInt)comprLen;
err = inflateInit(&d_stream);
CHECK_ERR(err, "inflateInit");
d_stream.next_out = uncompr;
d_stream.avail_out = (uInt)uncomprLen;
for (;;) {
err = inflate(&d_stream, Z_NO_FLUSH);
if (err == Z_STREAM_END) break;
if (err == Z_NEED_DICT) {
if (d_stream.adler != dictId) {
fprintf(stderr, "unexpected dictionary");
exit(1);
}
err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
sizeof(dictionary));
}
CHECK_ERR(err, "inflate with dict");
}
err = inflateEnd(&d_stream);
CHECK_ERR(err, "inflateEnd");
if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad inflate with dict\n");
exit(1);
} else {
printf("inflate with dictionary: %s\n", (char *)uncompr);
}
}
ssize_t spdylay_zlib_inflate_hd(spdylay_zlib *inflater,
spdylay_buffer* buf,
const uint8_t *in, size_t inlen)
{
int r;
inflater->zst.avail_in = inlen;
inflater->zst.next_in = (uint8_t*)in;
while(1) {
if(spdylay_buffer_avail(buf) == 0) {
if((r = spdylay_buffer_alloc(buf)) != 0) {
return r;
}
}
inflater->zst.avail_out = spdylay_buffer_avail(buf);
inflater->zst.next_out = spdylay_buffer_get(buf);
r = inflate(&inflater->zst, Z_NO_FLUSH);
if(r == Z_STREAM_ERROR || r == Z_STREAM_END || r == Z_DATA_ERROR) {
return SPDYLAY_ERR_ZLIB;
} else if(r == Z_NEED_DICT) {
const uint8_t *hd_dict;
size_t hd_dict_length;
hd_dict = spdylay_select_hd_dict(&hd_dict_length, inflater->version);
assert(hd_dict);
if(Z_OK != inflateSetDictionary(&inflater->zst, (uint8_t*)hd_dict,
hd_dict_length)) {
return SPDYLAY_ERR_ZLIB;
}
} else {
if(r == Z_OK) {
size_t adv = spdylay_buffer_avail(buf)-inflater->zst.avail_out;
spdylay_buffer_advance(buf, adv);
}
if(inflater->zst.avail_in == 0 && inflater->zst.avail_out > 0) {
break;
}
}
}
return spdylay_buffer_length(buf);
}
JNIEXPORT void JNICALL
Java_java_util_zip_Inflater_setDictionary(JNIEnv *env, jclass cls, jlong addr,
jarray b, jint off, jint len)
{
Bytef *buf = (*env)->GetPrimitiveArrayCritical(env, b, 0);
int res;
if (buf == 0) /* out of memory */
return;
res = inflateSetDictionary(jlong_to_ptr(addr), buf + off, len);
(*env)->ReleasePrimitiveArrayCritical(env, b, buf, 0);
switch (res) {
case Z_OK:
break;
case Z_STREAM_ERROR:
case Z_DATA_ERROR:
JNU_ThrowIllegalArgumentException(env, ((z_stream *)jlong_to_ptr(addr))->msg);
break;
default:
JNU_ThrowInternalError(env, ((z_stream *)jlong_to_ptr(addr))->msg);
break;
}
}
range<byte*> read(const range<byte*>& buf)
{
zstream.avail_out = uInt(buf.size());
zstream.next_out = (Bytef*)buf.begin();
for(;zstream.avail_out != 0;){
if (zstream.avail_in == 0){
new_input_();
}
auto res = ::inflate(&zstream, Z_NO_FLUSH);
switch(res)
{
case Z_NEED_DICT:
{
if (dict.empty())
AIO_THROW(inflate_exception)("Need dictionary");
auto dic_err = inflateSetDictionary(&zstream, (Bytef*)dict.begin(), dict.size());
if (dic_err != Z_OK)
AIO_THROW(inflate_exception)("Bad dictionary");
}
case Z_OK:
break;
case Z_DATA_ERROR:
AIO_THROW(inflate_exception)("Z_DATA_ERROR");
case Z_MEM_ERROR:
AIO_THROW(inflate_exception)("Z_MEM_ERROR");
case Z_STREAM_END:
uncompressed_size = zstream.total_out;
return range<byte*>((buf.size() - zstream.avail_out) + buf.begin(), buf.end());
default:
AIO_THROW(inflate_exception)("zlib internal error");
}
}
return range<byte*>(buf.end() - zstream.avail_out, buf.end());
}
/* cover all of the lines in inflate.c up to inflate() */
local void cover_support(void)
{
int ret;
z_stream strm;
mem_setup(&strm);
strm.avail_in = 0;
strm.next_in = Z_NULL;
ret = inflateInit(&strm); assert(ret == Z_OK);
mem_used(&strm, "inflate init");
ret = inflatePrime(&strm, 5, 31); assert(ret == Z_OK);
ret = inflatePrime(&strm, -1, 0); assert(ret == Z_OK);
ret = inflateSetDictionary(&strm, Z_NULL, 0);
assert(ret == Z_STREAM_ERROR);
ret = inflateEnd(&strm); assert(ret == Z_OK);
mem_done(&strm, "prime");
inf("63 0", "force window allocation", 0, -15, 1, Z_OK);
inf("63 18 5", "force window replacement", 0, -8, 259, Z_OK);
inf("63 18 68 30 d0 0 0", "force split window update", 4, -8, 259, Z_OK);
inf("3 0", "use fixed blocks", 0, -15, 1, Z_STREAM_END);
inf("", "bad window size", 0, 1, 0, Z_STREAM_ERROR);
mem_setup(&strm);
strm.avail_in = 0;
strm.next_in = Z_NULL;
ret = inflateInit_(&strm, ZLIB_VERSION - 1, (int)sizeof(z_stream));
assert(ret == Z_VERSION_ERROR);
mem_done(&strm, "wrong version");
strm.avail_in = 0;
strm.next_in = Z_NULL;
ret = inflateInit(&strm); assert(ret == Z_OK);
ret = inflateEnd(&strm); assert(ret == Z_OK);
fputs("inflate built-in memory routines\n", stderr);
}
static int lzstream_inflate_block(lua_State *L, lz_stream *s) {
if (lzstream_fetch_block(L, s, LZ_BUFFER_SIZE) || !s->eos) {
int r;
if (s->i_buffer_len == s->i_buffer_pos) {
s->zstream.next_in = NULL;
s->zstream.avail_in = 0;
} else {
s->zstream.next_in = (unsigned char*)(s->i_buffer + s->i_buffer_pos);
s->zstream.avail_in = s->i_buffer_len - s->i_buffer_pos;
}
s->zstream.next_out = (unsigned char*)s->o_buffer + s->o_buffer_len;
s->zstream.avail_out = s->o_buffer_max - s->o_buffer_len;
/* munch some more */
r = inflate(&s->zstream, Z_SYNC_FLUSH);
if (r == Z_NEED_DICT) {
if (s->dictionary == NULL) {
lua_pushliteral(L, "no inflate dictionary provided");
lua_error(L);
}
if (inflateSetDictionary(&s->zstream, s->dictionary, s->dictionary_len) != Z_OK) {
lua_pushliteral(L, "call to inflateSetDictionnary failed");
lua_error(L);
}
r = inflate(&s->zstream, Z_SYNC_FLUSH);
}
if (r != Z_OK && r != Z_STREAM_END && r != Z_BUF_ERROR) {
lzstream_cleanup(L, s);
s->error = r;
#if 1
lua_pushfstring(L, "failed to decompress [%d]", r);
lua_error(L);
#endif
}
if (r == Z_STREAM_END) {
luaL_unref(L, LUA_REGISTRYINDEX, s->i_buffer_ref);
s->i_buffer_ref = LUA_NOREF;
s->i_buffer = NULL;
s->eos = 1;
}
/* number of processed bytes */
if (s->peek) {
size_t processed = s->i_buffer_len - s->i_buffer_pos - s->zstream.avail_in;
lua_rawgeti(L, LUA_REGISTRYINDEX, s->io_cb);
lua_getfield(L, -1, "read");
lua_insert(L, -2);
lua_pushinteger(L, processed);
lua_call(L, 2, 0);
}
s->i_buffer_pos = s->i_buffer_len - s->zstream.avail_in;
s->o_buffer_len = s->o_buffer_max - s->zstream.avail_out;
}
return s->o_buffer_len;
}
int streaming_commons_inflate_set_dictionary(z_stream *stream, const char* dictionary,
unsigned int dictLength) {
return inflateSetDictionary(stream, dictionary, dictLength);
}
/* generic inflate() run, where hex is the hexadecimal input data, what is the
text to include in an error message, step is how much input data to feed
inflate() on each call, or zero to feed it all, win is the window bits
parameter to inflateInit2(), len is the size of the output buffer, and err
is the error code expected from the first inflate() call (the second
inflate() call is expected to return Z_STREAM_END). If win is 47, then
header information is collected with inflateGetHeader(). If a zlib stream
is looking for a dictionary, then an empty dictionary is provided.
inflate() is run until all of the input data is consumed. */
local void inf(char *hex, char *what, unsigned step, int win, unsigned len,
int err)
{
int ret;
unsigned have;
unsigned char *in, *out;
z_stream strm, copy;
gz_header head;
mem_setup(&strm);
strm.avail_in = 0;
strm.next_in = Z_NULL;
ret = inflateInit2(&strm, win);
if (ret != Z_OK) {
mem_done(&strm, what);
return;
}
out = malloc(len); assert(out != NULL);
if (win == 47) {
head.extra = out;
head.extra_max = len;
head.name = out;
head.name_max = len;
head.comment = out;
head.comm_max = len;
ret = inflateGetHeader(&strm, &head); assert(ret == Z_OK);
}
in = h2b(hex, &have); assert(in != NULL);
if (step == 0 || step > have)
step = have;
strm.avail_in = step;
have -= step;
strm.next_in = in;
do {
strm.avail_out = len;
strm.next_out = out;
ret = inflate(&strm, Z_NO_FLUSH); assert(err == 9 || ret == err);
if (ret != Z_OK && ret != Z_BUF_ERROR && ret != Z_NEED_DICT)
break;
if (ret == Z_NEED_DICT) {
ret = inflateSetDictionary(&strm, in, 1);
assert(ret == Z_DATA_ERROR);
mem_limit(&strm, 1);
ret = inflateSetDictionary(&strm, out, 0);
assert(ret == Z_MEM_ERROR);
mem_limit(&strm, 0);
((struct inflate_state *)strm.state)->mode = DICT;
ret = inflateSetDictionary(&strm, out, 0);
assert(ret == Z_OK);
ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_BUF_ERROR);
}
ret = inflateCopy(©, &strm); assert(ret == Z_OK);
ret = inflateEnd(©); assert(ret == Z_OK);
err = 9; /* don't care next time around */
have += strm.avail_in;
strm.avail_in = step > have ? have : step;
have -= strm.avail_in;
} while (strm.avail_in);
free(in);
free(out);
ret = inflateReset2(&strm, -8); assert(ret == Z_OK);
ret = inflateEnd(&strm); assert(ret == Z_OK);
mem_done(&strm, what);
}
static ErlDrvSSizeT zlib_ctl(ErlDrvData drv_data, unsigned int command, char *buf,
ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen)
{
ZLibData* d = (ZLibData*)drv_data;
int res;
switch(command) {
case DEFLATE_INIT:
if (len != 4) goto badarg;
if (d->state != ST_NONE) goto badarg;
res = deflateInit(&d->s, i32(buf));
if (res == Z_OK) {
d->state = ST_DEFLATE;
d->want_crc = 0;
d->crc = crc32(0L, Z_NULL, 0);
}
return zlib_return(res, rbuf, rlen);
case DEFLATE_INIT2: {
int wbits;
if (len != 20) goto badarg;
if (d->state != ST_NONE) goto badarg;
wbits = i32(buf+8);
res = deflateInit2(&d->s, i32(buf), i32(buf+4), wbits,
i32(buf+12), i32(buf+16));
if (res == Z_OK) {
d->state = ST_DEFLATE;
d->want_crc = (wbits < 0);
d->crc = crc32(0L, Z_NULL, 0);
}
return zlib_return(res, rbuf, rlen);
}
case DEFLATE_SETDICT:
if (d->state != ST_DEFLATE) goto badarg;
res = deflateSetDictionary(&d->s, (unsigned char*)buf, len);
if (res == Z_OK) {
return zlib_value(d->s.adler, rbuf, rlen);
} else {
return zlib_return(res, rbuf, rlen);
}
case DEFLATE_RESET:
if (len != 0) goto badarg;
if (d->state != ST_DEFLATE) goto badarg;
driver_deq(d->port, driver_sizeq(d->port));
res = deflateReset(&d->s);
return zlib_return(res, rbuf, rlen);
case DEFLATE_END:
if (len != 0) goto badarg;
if (d->state != ST_DEFLATE) goto badarg;
driver_deq(d->port, driver_sizeq(d->port));
res = deflateEnd(&d->s);
d->state = ST_NONE;
return zlib_return(res, rbuf, rlen);
case DEFLATE_PARAMS:
if (len != 8) goto badarg;
if (d->state != ST_DEFLATE) goto badarg;
res = deflateParams(&d->s, i32(buf), i32(buf+4));
return zlib_return(res, rbuf, rlen);
case DEFLATE:
if (d->state != ST_DEFLATE) goto badarg;
if (len != 4) goto badarg;
res = zlib_deflate(d, i32(buf));
return zlib_return(res, rbuf, rlen);
case INFLATE_INIT:
if (len != 0) goto badarg;
if (d->state != ST_NONE) goto badarg;
res = inflateInit(&d->s);
if (res == Z_OK) {
d->state = ST_INFLATE;
d->inflate_eos_seen = 0;
d->want_crc = 0;
d->crc = crc32(0L, Z_NULL, 0);
}
return zlib_return(res, rbuf, rlen);
case INFLATE_INIT2: {
int wbits;
if (len != 4) goto badarg;
if (d->state != ST_NONE) goto badarg;
wbits = i32(buf);
res = inflateInit2(&d->s, wbits);
if (res == Z_OK) {
d->state = ST_INFLATE;
d->inflate_eos_seen = 0;
d->want_crc = (wbits < 0);
d->crc = crc32(0L, Z_NULL, 0);
}
return zlib_return(res, rbuf, rlen);
}
case INFLATE_SETDICT:
if (d->state != ST_INFLATE) goto badarg;
res = inflateSetDictionary(&d->s, (unsigned char*)buf, len);
return zlib_return(res, rbuf, rlen);
case INFLATE_SYNC:
if (d->state != ST_INFLATE) goto badarg;
if (len != 0) goto badarg;
if (driver_sizeq(d->port) == 0) {
res = Z_BUF_ERROR;
} else {
int vlen;
SysIOVec* iov = driver_peekq(d->port, &vlen);
d->s.next_in = iov[0].iov_base;
d->s.avail_in = iov[0].iov_len;
res = inflateSync(&d->s);
}
return zlib_return(res, rbuf, rlen);
case INFLATE_RESET:
if (d->state != ST_INFLATE) goto badarg;
if (len != 0) goto badarg;
driver_deq(d->port, driver_sizeq(d->port));
res = inflateReset(&d->s);
d->inflate_eos_seen = 0;
return zlib_return(res, rbuf, rlen);
case INFLATE_END:
if (d->state != ST_INFLATE) goto badarg;
if (len != 0) goto badarg;
driver_deq(d->port, driver_sizeq(d->port));
res = inflateEnd(&d->s);
if (res == Z_OK && d->inflate_eos_seen == 0) {
res = Z_DATA_ERROR;
}
d->state = ST_NONE;
return zlib_return(res, rbuf, rlen);
case INFLATE:
if (d->state != ST_INFLATE) goto badarg;
if (len != 4) goto badarg;
res = zlib_inflate(d, i32(buf));
if (res == Z_NEED_DICT) {
return zlib_value2(3, d->s.adler, rbuf, rlen);
} else {
return zlib_return(res, rbuf, rlen);
}
case GET_QSIZE:
return zlib_value(driver_sizeq(d->port), rbuf, rlen);
case GET_BUFSZ:
return zlib_value(d->binsz_need, rbuf, rlen);
case SET_BUFSZ: {
int need;
if (len != 4) goto badarg;
need = i32(buf);
if ((need < 16) || (need > 0x00ffffff))
goto badarg;
if (d->binsz_need != need) {
d->binsz_need = need;
if (d->bin != NULL) {
if (d->s.avail_out == d->binsz) {
driver_free_binary(d->bin);
d->bin = NULL;
d->binsz = 0;
}
else
zlib_output(d);
}
}
return zlib_return(Z_OK, rbuf, rlen);
}
case CRC32_0:
return zlib_value(d->crc, rbuf, rlen);
case CRC32_1: {
uLong crc = crc32(0L, Z_NULL, 0);
crc = crc32(crc, (unsigned char*) buf, len);
return zlib_value(crc, rbuf, rlen);
}
case CRC32_2: {
uLong crc;
if (len < 4) goto badarg;
crc = (unsigned int) i32(buf);
crc = crc32(crc, (unsigned char*) buf+4, len-4);
return zlib_value(crc, rbuf, rlen);
}
case ADLER32_1: {
uLong adler = adler32(0L, Z_NULL, 0);
adler = adler32(adler, (unsigned char*) buf, len);
return zlib_value(adler, rbuf, rlen);
}
case ADLER32_2: {
uLong adler;
if (len < 4) goto badarg;
adler = (unsigned int) i32(buf);
adler = adler32(adler, (unsigned char*) buf+4, len-4);
return zlib_value(adler, rbuf, rlen);
}
case CRC32_COMBINE: {
uLong crc, crc1, crc2, len2;
if (len != 12) goto badarg;
crc1 = (unsigned int) i32(buf);
crc2 = (unsigned int) i32(buf+4);
len2 = (unsigned int) i32(buf+8);
crc = crc32_combine(crc1, crc2, len2);
return zlib_value(crc, rbuf, rlen);
}
case ADLER32_COMBINE: {
uLong adler, adler1, adler2, len2;
if (len != 12) goto badarg;
adler1 = (unsigned int) i32(buf);
adler2 = (unsigned int) i32(buf+4);
len2 = (unsigned int) i32(buf+8);
adler = adler32_combine(adler1, adler2, len2);
return zlib_value(adler, rbuf, rlen);
}
}
badarg:
errno = EINVAL;
return zlib_return(Z_ERRNO, rbuf, rlen);
}
Result<HeaderDecodeResult, HeaderDecodeError>
GzipHeaderCodec::decode(Cursor& cursor, uint32_t length) noexcept {
outHeaders_.clear();
// empty header block
if (length == 0) {
return HeaderDecodeResult{outHeaders_, 0};
}
// Get the thread local buffer space to use
auto& uncompressed = getHeaderBuf();
uint32_t consumed = 0;
// Decompress the headers
while (length > 0) {
auto next = cursor.peek();
uint32_t chunkLen = std::min((uint32_t)next.second, length);
inflater_.avail_in = chunkLen;
inflater_.next_in = (uint8_t *)next.first;
do {
if (uncompressed.tailroom() == 0) {
// This code should not execute, since we throw an error if the
// decompressed size of the headers is too large and we initialize
// the buffer to that size.
LOG(ERROR) << "Doubling capacity of SPDY headers buffer";
uncompressed.reserve(0, uncompressed.capacity());
}
inflater_.next_out = uncompressed.writableTail();
inflater_.avail_out = uncompressed.tailroom();
int r = inflate(&inflater_, Z_NO_FLUSH);
if (r == Z_NEED_DICT) {
// we cannot initialize the inflater dictionary before calling inflate()
// as it checks the adler-32 checksum of the supplied dictionary
r = inflateSetDictionary(&inflater_, versionSettings_.dict,
versionSettings_.dictSize);
if (r != Z_OK) {
LOG(ERROR) << "inflate set dictionary failed with error=" << r;
return HeaderDecodeError::INFLATE_DICTIONARY;
}
inflater_.avail_out = 0;
continue;
}
if (r != 0) {
// probably bad encoding
LOG(ERROR) << "inflate failed with error=" << r;
return HeaderDecodeError::BAD_ENCODING;
}
uncompressed.append(uncompressed.tailroom() - inflater_.avail_out);
if (uncompressed.length() > maxUncompressed_) {
LOG(ERROR) << "Decompressed headers too large";
return HeaderDecodeError::HEADERS_TOO_LARGE;
}
} while (inflater_.avail_in > 0 && inflater_.avail_out == 0);
length -= chunkLen;
consumed += chunkLen;
cursor.skip(chunkLen);
}
decodedSize_.compressed = consumed;
decodedSize_.uncompressed = uncompressed.computeChainDataLength();
if (stats_) {
stats_->recordDecode(Type::GZIP, decodedSize_);
}
size_t expandedHeaderLineBytes = 0;
auto result = parseNameValues(uncompressed);
if (result.isError()) {
return result.error();
}
expandedHeaderLineBytes = result.ok();
if (UNLIKELY(expandedHeaderLineBytes > kMaxExpandedHeaderLineBytes)) {
LOG(ERROR) << "expanded headers too large";
return HeaderDecodeError::HEADERS_TOO_LARGE;
}
return HeaderDecodeResult{outHeaders_, consumed};
}
#define GET_STREAM(THIS) (*(z_stream**)&unhand(this)->strm)
void
java_util_zip_Inflater_setDictionary(struct Hjava_util_zip_Inflater* this, HArrayOfByte* buf, jint from, jint len)
{
int r;
z_stream* dstream;
//
// This function must be synchronized.
//
_lockMutex( (Hjava_lang_Object*)this );
dstream = GET_STREAM(this);
r = inflateSetDictionary (dstream, &unhand(buf)->body[from], len);
if (r < 0) {
SignalError(0, "java.lang.Error", dstream->msg ? dstream->msg : "unknown error");
}
_unlockMutex( (Hjava_lang_Object*)this );
}
jint
java_util_zip_Inflater_inflate(struct Hjava_util_zip_Inflater* this, HArrayOfByte* buf, jint off, jint len)
{
int r;
int ilen;
z_stream* dstream;
jint ret_val;
bool wxZlibInputStream::SetDictionary(const char *data, const size_t datalen)
{
return (inflateSetDictionary(m_inflate, (Bytef*)data, datalen) == Z_OK);
}
int Sg_InflateSetDictionary(SgZStream *strm, SgByteVector *dict)
{
return inflateSetDictionary(strm->strm,
SG_BVECTOR_ELEMENTS(dict),
SG_BVECTOR_SIZE(dict));
}
