int PtexWriterBase::writeZipBlock(FILE* fp, const void* data, int size, bool finish)
{
if (!_ok) return 0;
void* buff = alloca(BlockSize);
_zstream.next_in = (Bytef*)data;
_zstream.avail_in = size;
while (1) {
_zstream.next_out = (Bytef*)buff;
_zstream.avail_out = BlockSize;
int zresult = deflate(&_zstream, finish ? Z_FINISH : Z_NO_FLUSH);
int size = BlockSize - _zstream.avail_out;
if (size > 0) writeBlock(fp, buff, size);
if (zresult == Z_STREAM_END) break;
if (zresult != Z_OK) {
setError("PtexWriter error: data compression internal error");
break;
}
if (!finish && _zstream.avail_out != 0)
// waiting for more input
break;
}
if (!finish) return 0;
int total = _zstream.total_out;
deflateReset(&_zstream);
return total;
}
int GzipBuf::init( int type, int level )
{
int ret;
if ( type == GZIP_INFLATE )
m_type = GZIP_INFLATE;
else
m_type = GZIP_DEFLATE;
if ( m_type == GZIP_DEFLATE )
{
if ( !m_zstr.state )
ret = deflateInit2 (&m_zstr, level, Z_DEFLATED, 15+16, 8,
Z_DEFAULT_STRATEGY);
else
{
ret = deflateReset( &m_zstr );
}
}
else
{
if ( !m_zstr.state )
ret = inflateInit2( &m_zstr, 15+16 );
else
{
ret = inflateReset( &m_zstr );
}
}
return ret;
}
void WebSocketDeflater::reset()
{
m_buffer.clear();
m_isBytesAdded = false;
if (m_contextTakeOverMode == DoNotTakeOverContext)
deflateReset(m_stream.get());
}
int SpdyZlibFilter::init( int isInflator, int verSpdy )
{
int ret;
m_isInflator = isInflator;
assert( (uint)verSpdy < sizeof( s_dicts ) / sizeof( char * ) );
m_version = verSpdy;
if ( isInflator )
{
if ( m_stream.state )
ret = inflateReset( &m_stream );
else
ret = inflateInit2( &m_stream, 15 );
}
else
{
if ( m_stream.state )
ret = deflateReset( &m_stream );
else
ret = deflateInit( &m_stream, -1 );
ret = deflateSetDictionary( &m_stream, s_dicts[ m_version ],
s_dictsLen[ m_version ] );
}
return ret;
}
/* Compress whatever is at avail_in and next_in and write to the output file.
Return -1 if there is an error writing to the output file, otherwise 0.
flush is assumed to be a valid deflate() flush value. If flush is Z_FINISH,
then the deflate() state is reset to start a new gzip stream. If gz->direct
is true, then simply write to the output file without compressing, and
ignore flush. */
static int gz_comp(gz_state *state,
int flush)
{
int ret, got;
unsigned int have;
z_stream *strm = &state->strm;
/* allocate memory if this is the first time through */
if (state->size == 0 && gz_init(state) == -1)
return -1;
/* write directly if requested */
if (state->direct) {
got = write(state->fd, strm->next_in, strm->avail_in);
if (got < 0 || (unsigned int)got != strm->avail_in) {
gz_error(state, Z_ERRNO, strerror(errno));
return -1;
}
strm->avail_in = 0;
return 0;
}
/* run deflate() on provided input until it produces no more output */
ret = Z_OK;
do {
/* write out current buffer contents if full, or if flushing, but if
doing Z_FINISH then don't write until we get to Z_STREAM_END */
if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
(flush != Z_FINISH || ret == Z_STREAM_END))) {
have = (unsigned int)(strm->next_out - state->x.next);
if (have && ((got = write(state->fd, state->x.next, have)) < 0 ||
(unsigned int)got != have)) {
gz_error(state, Z_ERRNO, strerror(errno));
return -1;
}
if (strm->avail_out == 0) {
strm->avail_out = state->size;
strm->next_out = state->out;
}
state->x.next = strm->next_out;
}
/* compress */
have = strm->avail_out;
ret = deflate(strm, flush);
if (ret == Z_STREAM_ERROR) {
gz_error(state, Z_STREAM_ERROR,
"internal error: deflate stream corrupt");
return -1;
}
have -= strm->avail_out;
} while (have);
/* if that completed a deflate stream, allow another to start */
if (flush == Z_FINISH)
deflateReset(strm);
/* all done, no errors */
return 0;
}
static void
pdc_begin_compress(pdc_output *out)
{
pdc_core *pdc = out->pdc;
if (!pdc_get_compresslevel(out)) {
out->compressing = pdc_false;
return;
}
#ifdef HAVE_LIBZ
if (out->compr_changed)
{
if (deflateEnd(&out->z) != Z_OK)
pdc_error(pdc, PDC_E_IO_COMPRESS, "deflateEnd", 0, 0, 0);
if (deflateInit(&out->z, pdc_get_compresslevel(out)) != Z_OK)
pdc_error(pdc, PDC_E_IO_COMPRESS, "deflateInit", 0, 0, 0);
out->compr_changed = pdc_false;
}
else
{
if (deflateReset(&out->z) != Z_OK)
pdc_error(pdc, PDC_E_IO_COMPRESS, "deflateReset", 0, 0, 0);
}
out->z.avail_in = 0;
#endif /* HAVE_LIBZ */
out->compressing = pdc_true;
}
/*Compress Date on a zlib stream*/
CpaStatus deflate_compress(struct z_stream_s *stream,
const Cpa8U *src,
Cpa32U slen,
Cpa8U *dst,
Cpa32U dlen)
{
#ifdef USE_ZLIB
int ret = 0;
int inflate_type = Z_FINISH;
ret = deflateReset(stream);
if(ret != Z_OK)
{
PRINT_ERR("Error in deflateReset\n");
return CPA_STATUS_FAIL;
}
stream->next_in = (Cpa8U *)src;
stream->avail_in = slen;
stream->next_out = (Cpa8U *)dst;
stream->avail_out = dlen;
ret = deflate(stream, inflate_type);
if (ret != Z_STREAM_END)
{
PRINT_ERR("Error in zlib_deflate, ret = %d\n", ret);
return CPA_STATUS_FAIL;
}
#endif
return CPA_STATUS_SUCCESS;
}
void git_zstream_reset(git_zstream *zstream)
{
deflateReset(&zstream->z);
zstream->in = NULL;
zstream->in_len = 0;
zstream->zerr = Z_STREAM_END;
}
/*
* z_comp_init()
*/
static int
z_comp_init(void *arg, uchar_t *options, int opt_len, int unit, int hdrlen,
int debug)
{
struct deflate_state *state = (struct deflate_state *)arg;
if (opt_len < CILEN_DEFLATE ||
(options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) ||
options[1] != CILEN_DEFLATE ||
DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL ||
DEFLATE_SIZE(options[2]) != state->w_size ||
options[3] != DEFLATE_CHK_SEQUENCE) {
return (0);
}
state->seqno = 0;
state->unit = unit;
state->hdrlen = hdrlen;
if (debug)
state->flags |= DS_DEBUG;
else
state->flags &= ~DS_DEBUG;
(void) deflateReset(&state->strm);
return (1);
}
int deflate_reset(struct comp_ctx *comp_ctx)
{
z_stream *strm = &comp_ctx->strm;
if (deflateReset(strm) == Z_OK)
return 0;
return -1;
}
void Java_at_yawk_rjoin_zlib_NZlib_reset(JNIEnv *env, jclass jc, jboolean inf, jlong stream) {
int result;
if (inf) {
result = inflateReset((z_stream*) stream);
} else {
result = deflateReset((z_stream*) stream);
}
}
/* returns the total size of the encoded data */
int zlib_encode(ZlibEncoder *zlib, int level, int input_size,
uint8_t *io_ptr, unsigned int num_io_bytes)
{
int flush;
int enc_size = 0;
int out_size = 0;
int z_ret;
z_ret = deflateReset(&zlib->strm);
if (z_ret != Z_OK) {
red_error("deflateReset failed");
}
zlib->strm.next_out = io_ptr;
zlib->strm.avail_out = num_io_bytes;
if (level != zlib->last_level) {
if (zlib->strm.avail_out == 0) {
zlib->strm.avail_out = zlib->usr->more_space(zlib->usr, &zlib->strm.next_out);
if (zlib->strm.avail_out == 0) {
red_error("not enough space");
}
}
z_ret = deflateParams(&zlib->strm, level, Z_DEFAULT_STRATEGY);
if (z_ret != Z_OK) {
red_error("deflateParams failed");
}
zlib->last_level = level;
}
do {
zlib->strm.avail_in = zlib->usr->more_input(zlib->usr, &zlib->strm.next_in);
if (zlib->strm.avail_in <= 0) {
red_error("more input failed\n");
}
enc_size += zlib->strm.avail_in;
flush = (enc_size == input_size) ? Z_FINISH : Z_NO_FLUSH;
while (1) {
int deflate_size = zlib->strm.avail_out;
z_ret = deflate(&zlib->strm, flush);
ASSERT(z_ret != Z_STREAM_ERROR);
out_size += deflate_size - zlib->strm.avail_out;
if (zlib->strm.avail_out) {
break;
}
zlib->strm.avail_out = zlib->usr->more_space(zlib->usr, &zlib->strm.next_out);
if (zlib->strm.avail_out == 0) {
red_error("not enough space");
}
}
} while (flush != Z_FINISH);
ASSERT(z_ret == Z_STREAM_END);
return out_size;
}
JNIEXPORT void JNICALL
Java_java_util_zip_Deflater_resetImpl (JNIEnv * env, jobject recv,
jlong handle)
{
JCLZipStream *stream;
stream = (JCLZipStream *) ((IDATA) handle);
deflateReset (stream->stream);
}
static int
flushGrain(StreamOptimizedDiskInfo *sodi)
{
int ret;
uint32_t oldLoc;
if (sodi->writer.grainBufferNr == ~0ULL) {
return 0;
}
if (sodi->writer.grainBufferValidEnd == 0) {
return 0;
}
ret = fillGrain(sodi);
if (ret) {
return ret;
}
oldLoc = __le32_to_cpu(sodi->writer.gtInfo.gt[sodi->writer.grainBufferNr]);
if (oldLoc != 0) {
fprintf(stderr, "Cannot update already written grain\n");
return -1;
}
if (!isZeroed(sodi->writer.grainBuffer, sodi->writer.grainBufferValidEnd)) {
size_t dataLen;
uint32_t rem;
SparseGrainLBAHeaderOnDisk *grainHdr = sodi->writer.zlibBuffer.grainHdr;
sodi->writer.gtInfo.gt[sodi->writer.grainBufferNr] = __cpu_to_le32(sodi->writer.curSP);
if (deflateReset(&sodi->writer.zstream) != Z_OK) {
fprintf(stderr, "DeflateReset failed\n");
return -1;
}
sodi->writer.zstream.next_in = sodi->writer.grainBuffer;
sodi->writer.zstream.avail_in = sodi->writer.grainBufferValidEnd;
sodi->writer.zstream.next_out = sodi->writer.zlibBuffer.data + sizeof *grainHdr;
sodi->writer.zstream.avail_out = sodi->writer.zlibBufferSize - sizeof *grainHdr;
if (deflate(&sodi->writer.zstream, Z_FINISH) != Z_STREAM_END) {
fprintf(stderr, "Deflate failed\n");
return -1;
}
dataLen = sodi->writer.zstream.next_out - sodi->writer.zlibBuffer.data;
grainHdr->lba = sodi->writer.grainBufferNr * sodi->diskHdr.grainSize;
grainHdr->cmpSize = __cpu_to_le32(dataLen - sizeof *grainHdr);
rem = dataLen & (VMDK_SECTOR_SIZE - 1);
if (rem != 0) {
rem = VMDK_SECTOR_SIZE - rem;
memset(sodi->writer.zstream.next_out, 0, rem);
dataLen += rem;
}
if (!safeWrite(sodi->writer.fd, grainHdr, dataLen)) {
return -1;
}
sodi->writer.curSP += dataLen / VMDK_SECTOR_SIZE;
}
return 0;
}
static void resetEncoder(Gzb64* gzb64)
{
int zret = deflateReset(& gzb64->gz_encode_strm);
if(zret < 0) zerr(zret);
zret = BIO_reset(gzb64->encode_output_buffer);
zret = BIO_reset(gzb64->b64_encoder);
gzb64->encoded_last_chunk = false;
if(DEBUG) printf("Encoder reset\n");
}
/*
* z_comp_reset()
*/
static void
z_comp_reset(void *arg)
{
struct deflate_state *state = (struct deflate_state *)arg;
state->seqno = 0;
(void) deflateReset(&state->strm);
}
/*
* Reset encoding state at the start of a strip.
*/
static int
ZIPPreEncode(TIFF* tif, tsample_t s) {
ZIPState* sp = EncoderState(tif);
(void) s;
assert(sp != NULL);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = tif->tif_rawdatasize;
return (deflateReset(&sp->stream) == Z_OK);
}
void KGzipFilter::reset()
{
if ( d->mode == QIODevice::ReadOnly )
{
int result = inflateReset(&d->zStream);
} else if ( d->mode == QIODevice::WriteOnly ) {
int result = deflateReset(&d->zStream);
d->headerWritten = false;
}
}
void resetz()
{
if ( deflateReset(&strm) != Z_OK )
{
::libmaus::exception::LibMausException se;
se.getStream() << "deflateReset failed." << std::endl;
se.finish();
throw se;
}
}
gboolean moloch_http_send(void *serverV, char *method, char *key, uint32_t key_len, char *data, uint32_t data_len, char *headers, gboolean dropable, MolochResponse_cb func, gpointer uw)
{
MolochRequest_t *request;
MolochHttp_t *server = serverV;
if (!config.exiting && dropable && server->requestQ.r_count > server->maxOutstandingRequests) {
LOG("ERROR - Dropping request %.*s of size %d queue %d is too big", key_len, key, data_len, server->requestQ.r_count);
if (data) {
MOLOCH_SIZE_FREE(buffer, data);
}
return 1;
}
request = MOLOCH_TYPE_ALLOC(MolochRequest_t);
request->key_len = MIN(key_len, sizeof(request->key)-1);
memcpy(request->key, key, request->key_len);
request->key[request->key_len] = 0;
strncpy(request->method, method, sizeof(request->method));
request->compress = 0;
if (server->compress && data && data_len > 1000) {
char *buf = moloch_http_get_buffer(data_len);
int ret;
z_strm.avail_in = data_len;
z_strm.next_in = (unsigned char *)data;
z_strm.avail_out = data_len;
z_strm.next_out = (unsigned char *)buf;
ret = deflate(&z_strm, Z_FINISH);
if (ret == Z_STREAM_END) {
request->compress = 1;
MOLOCH_SIZE_FREE(buffer, data);
data_len = data_len - z_strm.avail_out;
data = buf;
} else {
MOLOCH_SIZE_FREE(buffer, buf);
}
deflateReset(&z_strm);
}
request->data_len = data_len;
request->data = data;
request->func = func;
request->uw = uw;
if (headers)
strcpy(request->headers, headers);
else
request->headers[0] = 0;
DLL_PUSH_TAIL(r_, &server->requestQ, request);
moloch_http_do_requests(server);
return 0;
}
static bool page_end(struct urf_context *ctx)
{
fprintf(stderr, "\npage %u: %zu bytes\n", ctx->page_n, IMPL(ctx)->idx);
int ret = deflateReset(&IMPL(ctx)->strm);
if (ret < 0) {
URF_SET_ERROR(ctx, "deflateReset", ret);
return false;
}
return xprintf(ctx, "\n%s\nrestore\n", ASCII85 ? "~>" : ">") && xprintf(ctx, "showpage\n");
}
virtual int sync()
{
// first, call overflow to clear in_buff
overflow();
if (! pptr()) return -1;
// then, call deflate asking to finish the zlib stream
zstrm_p->next_in = nullptr;
zstrm_p->avail_in = 0;
if (deflate_loop(Z_FINISH) != 0) return -1;
deflateReset(zstrm_p);
return 0;
}
void zlib_base::reset(bool compress, bool realloc)
{
z_stream* s = static_cast<z_stream*>(stream_);
// Undiagnosed bug:
// deflateReset(), etc., return Z_DATA_ERROR
//zlib_error::check(
realloc ?
(compress ? deflateReset(s) : inflateReset(s)) :
(compress ? deflateEnd(s) : inflateEnd(s))
;
//);
}
static int
DeflateResetOutput(void *v)
{
struct deflate_state *state = (struct deflate_state *)v;
state->seqno = 0;
state->uncomp_rec = 0;
deflateReset(&state->cx);
log_Printf(LogCCP, "Deflate: Output channel reset\n");
return 1; /* Ask FSM to ACK */
}
/*
*
* Encode a frame
*
*/
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pict, int *got_packet)
{
LclEncContext *c = avctx->priv_data;
AVFrame * const p = &c->pic;
int i, ret;
int zret; // Zlib return code
int max_size = deflateBound(&c->zstream, avctx->width * avctx->height * 3);
if (!pkt->data &&
(ret = av_new_packet(pkt, max_size)) < 0) {
av_log(avctx, AV_LOG_ERROR, "Error allocating packet of size %d.\n", max_size);
return ret;
}
*p = *pict;
p->pict_type= AV_PICTURE_TYPE_I;
p->key_frame= 1;
if(avctx->pix_fmt != PIX_FMT_BGR24){
av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
return -1;
}
zret = deflateReset(&c->zstream);
if (zret != Z_OK) {
av_log(avctx, AV_LOG_ERROR, "Deflate reset error: %d\n", zret);
return -1;
}
c->zstream.next_out = pkt->data;
c->zstream.avail_out = pkt->size;
for(i = avctx->height - 1; i >= 0; i--) {
c->zstream.next_in = p->data[0]+p->linesize[0]*i;
c->zstream.avail_in = avctx->width*3;
zret = deflate(&c->zstream, Z_NO_FLUSH);
if (zret != Z_OK) {
av_log(avctx, AV_LOG_ERROR, "Deflate error: %d\n", zret);
return -1;
}
}
zret = deflate(&c->zstream, Z_FINISH);
if (zret != Z_STREAM_END) {
av_log(avctx, AV_LOG_ERROR, "Deflate error: %d\n", zret);
return -1;
}
pkt->size = c->zstream.total_out;
pkt->flags |= AV_PKT_FLAG_KEY;
*got_packet = 1;
return 0;
}
static void
g_zlib_compressor_reset (GConverter *converter)
{
GZlibCompressor *compressor = G_ZLIB_COMPRESSOR (converter);
int res;
res = deflateReset (&compressor->zstream);
if (res != Z_OK)
g_warning ("unexpected zlib error: %s\n", compressor->zstream.msg);
/* deflateReset reset the header too, so re-set it */
g_zlib_compressor_set_gzheader (compressor);
}
static TACommandVerdict deflateReset_cmd(TAThread thread,TAInputStream stream)
{
z_stream strm;
int res, is_null;
is_null = readZStream(&stream, &strm);
/*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 = deflateReset(&strm);
else
res = deflateReset(0);
END_TARGET_OPERATION(thread);
// Response
if(!is_null)
writeZStream(thread, &strm);
else
writeZStream(thread, 0);
writeInt(thread, res);
sendResponse(thread);
return taDefaultVerdict;
}
void zlib_base::reset(bool compress, bool realloc)
{
z_stream* s = static_cast<z_stream*>(stream_);
// Undiagnosed bug:
// deflateReset(), etc., return Z_DATA_ERROR
//zlib_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(
realloc ?
(compress ? deflateReset(s) : inflateReset(s)) :
(compress ? deflateEnd(s) : inflateEnd(s))
;
//);
crc_imp_ = 0;
}
long fn_gzip_str(const char *src,long src_size,char *dest,long dest_size)
{
int ret;
if(dezstream==0)
{
// open a stream and leave it open until channel closes
// because deflateInit does many, large allocs and thrashes
dezstream=frontier_mem_alloc(sizeof(*dezstream));
if(dezstream==0)
return FN_ZLIB_E_NOMEM;
dezstream->zalloc=fn_zalloc;
dezstream->zfree=fn_zfree;
dezstream->opaque=0;
ret=deflateInit(dezstream,9);
if(ret!=Z_OK)
{
fn_decleanup();
if(ret==Z_MEM_ERROR)
return FN_ZLIB_E_NOMEM;
return FN_ZLIB_E_OTHER;
}
}
else
{
// reuse existing stream
ret=deflateReset(dezstream);
if(ret!=Z_OK)
{
fn_decleanup();
return FN_ZLIB_E_OTHER;
}
}
dezstream->next_in=(Bytef *)src;
dezstream->avail_in=(uLongf)src_size;
dezstream->next_out=(Bytef *)dest;
dezstream->avail_out=(uLongf)dest_size;
ret=deflate(dezstream,Z_FINISH);
if(ret==Z_STREAM_END)
{
// leave stream available
return dest_size-(long)dezstream->avail_out;
}
fn_decleanup();
if(ret==Z_BUF_ERROR)
return FN_ZLIB_E_SMALLBUF;
return FN_ZLIB_E_OTHER;
}
int GzipBuf::reinit()
{
int ret;
if ( m_type == GZIP_DEFLATE )
{
ret = deflateReset( &m_zstr );
}
else
{
ret = inflateReset( &m_zstr );
}
m_streamStarted = 1;
return ret;
}
