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;
}