自学教程：C++ zerr函数代码示例

intstuff(char *fn){    FILE *in;    char *buf;    off_t len;    if (!(in = fopen(unmeta(fn), "r"))) {	zerr("can't open %s", fn);	return 1;    }    fseek(in, 0, 2);    len = ftell(in);    fseek(in, 0, 0);    buf = (char *)zalloc(len + 1);    if (!(fread(buf, len, 1, in))) {	zerr("read error on %s", fn);	fclose(in);	zfree(buf, len + 1);	return 1;    }    fclose(in);    buf[len] = '/0';    fwrite(buf, len, 1, stderr);    fflush(stderr);    inputsetline(metafy(buf, len, META_REALLOC), INP_FREE);    return 0;}

/* compress or decompress from stdin to stdout */int main(int argc, char **argv){	jlg_log("Start...");	int ret;    /* avoid end-of-line conversions */    SET_BINARY_MODE(stdin);    SET_BINARY_MODE(stdout);    /* do compression if no arguments */    if (argc == 1) {    	jlg_log("Compressing...");        ret = def(stdin, stdout, Z_DEFAULT_COMPRESSION);        if (ret != Z_OK)            zerr(ret);        return ret;    }    /* do decompression if -d specified */    else if (argc == 2 && strcmp(argv[1], "-d") == 0) {    	jlg_log("Decompressing...");        ret = inf(stdin, stdout);        if (ret != Z_OK)            zerr(ret);        return ret;    }    /* otherwise, report usage */    else {        fputs("zpipe usage: zpipe [-d] < source > dest/n", stderr);        return 1;    }}

/* compress or decompress from stdin to stdout */int main(int argc, char **argv){    int ret;    /* do compression if no arguments */    if (argc == 1) {        ret = def(stdin, stdout, Z_DEFAULT_COMPRESSION);        if (ret != Z_OK)            zerr(ret);        return ret;    }    /* do decompression if -d specified */    else if (argc == 2 && strcmp(argv[1], "-d") == 0) {        ret = inf(stdin, stdout);        if (ret != Z_OK)            zerr(ret);        return ret;    }    /* otherwise, report usage */    else {        fputs("zpipe usage: zpipe [-d] < source > dest/n", stderr);        return 1;    }}

intmain(int argc, char *argv[]){	elf_object *elf;	add_fixup_anchor_list(zlib_anchors);	elf = elf_dlopen("/lib/x86_64-linux-gnu/libz.so.1.2.7");	if (elf == NULL)		return -1;	deflateInit = (deflateInit_fn)elf_dlsym(elf, "deflateInit_");	if (deflateInit == NULL)		goto out;	deflateEnd = (deflateEnd_fn)elf_dlsym(elf, "deflateEnd");	if (deflateEnd == NULL)		goto out;	deflate = (deflate_fn)elf_dlsym(elf, "deflate");	if (deflate == NULL)		goto out;	inflateInit = (inflateInit_fn)elf_dlsym(elf, "inflateInit_");	if (inflateInit == NULL)		goto out;	inflateEnd = (inflateEnd_fn)elf_dlsym(elf, "inflateEnd");	if (inflateEnd == NULL)		goto out;	inflate = (inflate_fn)elf_dlsym(elf, "inflate");	if (inflate == NULL)		goto out;	if (argc == 1) {		int ret;		ret = def(stdin, stdout, -1);		if (ret != 0)			zerr(ret);		return ret;	}	if (argc == 2 && !strcmp(argv[1], "-d")) {		int ret = inf(stdin, stdout);		if (ret != 0)			zerr(ret);		return ret;	}	fprintf(stderr, "usage: a.out [-d] <source> dest/n");	elf_dlclose(elf);	return 0;out:	elf_dlclose(elf);	return -2;}

intzlib_decompress(void *src, uint64_t srclen, void *dst, uint64_t *dstlen,		int level, uchar_t chdr, int btype, void *data){	int err;	unsigned int slen, dlen;	uint64_t _srclen = srclen;	uint64_t _dstlen = *dstlen;	uchar_t *dst1 = (uchar_t *)dst;	uchar_t *src1 = (uchar_t *)src;	z_stream *zs = (z_stream *)data;	while (_srclen > 0) {		if (_srclen > SINGLE_CALL_MAX) {			slen = SINGLE_CALL_MAX;		} else {			slen = _srclen;		}		if (_dstlen > SINGLE_CALL_MAX) {			dlen = SINGLE_CALL_MAX;		} else {			dlen = _dstlen;		}		zs->next_in = src1;		zs->avail_in = slen;		zs->next_out = dst1;		zs->avail_out = dlen;		err = inflate(zs, Z_NO_FLUSH);		if (err != Z_OK && err != Z_STREAM_END) {			zerr(err, 0);			return (-1);		}		dst1 += (dlen - zs->avail_out);		_dstlen -= (dlen - zs->avail_out);		src1 += (slen - zs->avail_in);		_srclen -= (slen - zs->avail_in);		if (err == Z_STREAM_END) {			if (_srclen > 0) {				zerr(Z_DATA_ERROR, 0);				return (-1);			} else {				break;			}		}	}	*dstlen = *dstlen - _dstlen;	err = inflateReset(zs);	if (err != Z_OK) {		zerr(err, 1);		return (-1);	}	return (0);}

/* Compress from file source to file dest until EOF on source.   def() returns Z_OK on success, Z_MEM_ERROR if memory could not be   allocated for processing, Z_STREAM_ERROR if an invalid compression   level is supplied, Z_VERSION_ERROR if the version of zlib.h and the   version of the library linked do not match, or Z_ERRNO if there is   an error reading or writing the files. */bool Misc::deflate(const uint8_t* in, size_t inlen, std::ostream& dest, string& err, int CHUNK, int level){  int ret, flush;  unsigned have;  z_stream strm;  if ( level == -1 ) level = Z_BEST_COMPRESSION;  if ( CHUNK == -1 ) CHUNK = CL_Z_DEFAULT_CHUNK;  uint8_t* out = (uint8_t*)malloc(CHUNK);  /* allocate deflate state */  strm.zalloc = Z_NULL;  strm.zfree = Z_NULL;  strm.opaque = Z_NULL;  ret = deflateInit(&strm, level);  if (ret != Z_OK){    free(out);    zerr(ret, err);    return false;  }  /* compress until end of file */  do {    strm.avail_in = inlen;    strm.next_in = (uint8_t*)in;    flush = Z_FINISH;    /* run deflate() on input until output buffer not full, finish       compression if all of source has been read in */    do {      strm.avail_out = CHUNK;      strm.next_out = out;      ret = ::deflate(&strm, flush);  /* no bad return value */      assert(ret != Z_STREAM_ERROR);  /* state not clobbered */      have = CHUNK - strm.avail_out;      dest.write( (char*)out,have);      if ( dest.fail() ) {        (void)deflateEnd(&strm);        free(out);        zerr(Z_ERRNO, err);        return false;      }    } while (strm.avail_out == 0);    assert(strm.avail_in == 0);   /* all input will be used */    /* done when last data in file processed */  } while (flush != Z_FINISH);  assert(ret == Z_STREAM_END);    /* stream will be complete */  /* clean up and return */  (void)deflateEnd(&strm);  free(out);  return true;}

/* compress or decompress from stdin to stdout */int main(int argc, char **argv){    int ret;    /* avoid end-of-line conversions */    /* do compression if no arguments */    if (argc == 3) {           char *addr;           int fdr, fdw;           struct stat sb;           size_t out_len =6000*1000;           out_len*=1000 ;           char *outbuff= (char*)malloc(out_len );           off_t offset, pa_offset;           size_t length;           fdr = open( argv[1], O_RDONLY);           fstat(fdr, &sb);           length = sb.st_size;           addr = mmap(NULL, length, PROT_READ,                       MAP_PRIVATE, fdr, 0);           printf("input length = %lld/n",  length);           length = deflate_mmap(addr, length , outbuff, out_len, 7 );           printf("output length = %lld/n",  length);           size_t len;           fdw = open( argv[2], O_CREAT | O_WRONLY, 0666);                      while ( len = write(fdw, outbuff, length)){                length -=len;                outbuff +=len;            }           //ret = def(stdin, stdout, Z_DEFAULT_COMPRESSION);           if (ret != Z_OK)               zerr(ret);           return ret;    }    /* do decompression if -d specified */    else if (argc == 2 && strcmp(argv[1], "-d") == 0) {        ret = inf(stdin, stdout);        if (ret != Z_OK)            zerr(ret);        return ret;    }    /* otherwise, report usage */    else {        fputs("zpipe usage: zpipe [-d] source dest/n", stderr);        return 1;    }}

mod_export intparsestr(char *s){    int err;    if ((err = parsestrnoerr(s))) {	untokenize(s);	if (err > 32 && err < 127)	    zerr("parse error near `%c'", NULL, err);	else	    zerr("parse error", NULL, 0);    }    return err;}

    void squeeze(disk_stream *inflight, unsigned long superp)    {      z_stream *zlib_stream =  inflight->zlib_streams[superp];      int ret;      unsigned long disk_buffer_pos;      while(zlib_stream->avail_in) {	ret = deflate(zlib_stream, Z_NO_FLUSH);	if(ret != Z_OK) {	  BOOST_LOG_TRIVIAL(fatal) << "Compression failure:("				   << ret << ")"				   << zerr(ret);	  exit(-1);	}	if(zlib_stream->avail_out == 0) {	  disk_buffer_pos = inflight->disk_pos[superp];	  inflight->disk_pos[superp]   += stream_unit;	  inflight->disk_bytes[superp] += stream_unit;	  do_flip_IO(inflight->flip_buffers[superp],		     disk_buffer_pos,		     stream_unit,		     false);	  zlib_stream->avail_out = stream_unit;	  zlib_stream->next_out = inflight->flip_buffers[superp]->ready;	}      }    }

static mnumbersetmathvar(struct mathvalue *mvp, mnumber v){    if (mvp->pval) {	/*	 * This value may have been hanging around for a while.	 * Be ultra-paranoid in checking the variable is still valid.	 */	char *s = mvp->lval, *ptr;	Param pm;	DPUTS(!mvp->lval, "no variable name but variable value in math");	if ((ptr = strchr(s, '[')))	    s = dupstrpfx(s, ptr - s);	pm = (Param) paramtab->getnode(paramtab, s);	if (pm == mvp->pval->pm) {	    if (noeval)		return v;	    setnumvalue(mvp->pval, v);	    return v;	}	/* Different parameter, start again from scratch */	mvp->pval = NULL;    }    if (!mvp->lval) {	zerr("lvalue required");	v.type = MN_INTEGER;	v.u.l = 0;	return v;    }    if (noeval)	return v;    untokenize(mvp->lval);    setnparam(mvp->lval, v);    return v;}

intmodentry(int boot, Module m, void *ptr){    switch (boot) {    case 0:	return setup_(m);	break;    case 1:	return boot_(m);	break;    case 2:	return cleanup_(m);	break;    case 3:	return finish_(m);	break;    case 4:	return features_(m, (char ***)ptr);	break;    case 5:	return enables_(m, (int **)ptr);	break;    default:	zerr("bad call to modentry");	return 1;	break;    }}

int decode_out(Gzb64* gzb64, unsigned char* buf, const size_t length){	int zret, ret;	/* should be guaranteed at least length after inflate */	int gz_in_bytes = evbuffer_get_contiguous_space(gzb64->decode_output_buffer);	unsigned char* gzin_buf = evbuffer_pullup(gzb64->decode_output_buffer, gz_in_bytes );	if(DEBUG) hex_debug(gzin_buf, gz_in_bytes);		gzb64->gz_decode_strm.next_in = gzin_buf;	gzb64->gz_decode_strm.avail_in = gz_in_bytes;	gzb64->gz_decode_strm.next_out = buf;    gzb64->gz_decode_strm.avail_out = length;	zret = inflate (& gzb64->gz_decode_strm, Z_NO_FLUSH);	if(zret < 0) zerr(zret);	evbuffer_drain(gzb64->decode_output_buffer, gz_in_bytes - gzb64->gz_decode_strm.avail_in);	ret = length - gzb64->gz_decode_strm.avail_out;		if(gzb64->decoded_last_chunk && 0 == ret) {		resetDecoder(gzb64);	}	return ret;}

int __compress__(struct strbuf *src, struct strbuf *dest, int level){    z_stream stream;    z_stream_init(&stream);    int ret, flush;    unsigned have;    ret = deflateInit(&stream, Z_DEFAULT_COMPRESSION);    if (ret != Z_OK)        zerr(ret);    char buffer[CHUNK_LENGTH];    stream.avail_in = src->len;    stream.next_in = (Bytef *)src->buf;    do {        flush = (stream.avail_in < CHUNK_LENGTH) ? Z_FINISH : Z_NO_FLUSH;        do {            stream.avail_out = CHUNK_LENGTH;            stream.next_out = (Bytef *)buffer;            ret = deflate(&stream, flush);            have = CHUNK_LENGTH - stream.avail_out;            strbuf_add(dest, buffer, have);        } while (stream.avail_out == 0);        assert(stream.avail_in == 0);    } while (flush != Z_FINISH);    assert(ret == Z_STREAM_END);    deflateEnd(&stream);    return ret;}

intzlib_init(void **data, int *level, int nthreads, uint64_t chunksize,	  int file_version, compress_op_t op){	z_stream *zs;	int ret;	zs = (z_stream *)slab_alloc(NULL, sizeof (z_stream));	zs->zalloc = slab_alloc_ui;	zs->zfree = slab_free;	zs->opaque = NULL;	if (*level > 9) *level = 9;	if (op == COMPRESS) {		ret = deflateInit2(zs, *level, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);	} else {		if (file_version < 5) {			ret = inflateInit(zs);		} else {			ret = inflateInit2(zs, -15);		}	}	if (ret != Z_OK) {		zerr(ret, 0);		return (-1);	}	*data = zs;	return (0);}

mod_export intparsestr(char **s){    int err;    if ((err = parsestrnoerr(s))) {	untokenize(*s);	if (!(errflag & ERRFLAG_INT)) {	    if (err > 32 && err < 127)		zerr("parse error near `%c'", err);	    else		zerr("parse error");	}    }    return err;}

Gzb64* gzb64_init(){	int zret;	Gzb64* gzb64 = (Gzb64*) malloc(sizeof(Gzb64));	if( gzb64 == NULL ) { fprintf(stderr, "Failed to malloc/n"); exit(EXIT_FAILURE); }	/* Encode */	/* setup zlib encode struc */    gzb64->gz_encode_strm.zalloc = Z_NULL;    gzb64->gz_encode_strm.zfree  = Z_NULL;    gzb64->gz_encode_strm.opaque = Z_NULL;    zret = deflateInit2 (& gzb64->gz_encode_strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED,                             windowBits | GZIP_ENCODING, 8,                             Z_DEFAULT_STRATEGY);	if(zret < 0) zerr(zret);	gzb64->encode_gzout_buffer = evbuffer_new();	/* setup base64 encoder */	gzb64->b64_encoder = BIO_new(BIO_f_base64());	BIO_set_flags(gzb64->b64_encoder, BIO_FLAGS_BASE64_NO_NL); //Do not use newlines to flush buffer	gzb64->encode_output_buffer = BIO_new(BIO_s_mem());	BIO_set_mem_eof_return(gzb64->encode_output_buffer, 0);    gzb64->b64_encoder = BIO_push(gzb64->b64_encoder, gzb64->encode_output_buffer);	/* Decode */	gzb64->decode_input_buffer = evbuffer_new();	/* setup base64 decoder */	gzb64->b64_decoder = BIO_new(BIO_f_base64());	BIO_set_flags(gzb64->b64_decoder, BIO_FLAGS_BASE64_NO_NL); //Do not use newlines to flush buffer	gzb64->decode_output_buffer = evbuffer_new();	/* setup zlib decode struc */    gzb64->gz_decode_strm.avail_in = 0;    gzb64->gz_decode_strm.next_in = Z_NULL;	zret = inflateInit2 (& gzb64->gz_decode_strm, windowBits | ENABLE_ZLIB_GZIP);	if(zret < 0) zerr(zret);	/* State */	gzb64->encoded_last_chunk = false;	gzb64->decoded_last_chunk = false;	return gzb64;}

int encode_in(Gzb64* gzb64, const unsigned char* buf, const size_t length, const bool last){	int flush_type, zret;	struct evbuffer_iovec v[2];	int n, i, written;	size_t n_to_add = BUFF_SIZE;	if(last) {		flush_type = Z_FINISH;		gzb64->encoded_last_chunk = true;	} else {		flush_type = Z_NO_FLUSH;		}	gzb64->gz_encode_strm.next_in = buf;	gzb64->gz_encode_strm.avail_in = length;	/* loop as long as more input available */	while( 0 != gzb64->gz_encode_strm.avail_in || Z_FINISH == flush_type )	{		/* Reserve BUFF_SIZE bytes.*/		n = evbuffer_reserve_space(gzb64->encode_gzout_buffer, n_to_add, v, 2);		if (n<=0)		   return -1; /* Unable to reserve the space for some reason. */		for (i=0; i<n && n_to_add > 0; ++i) {		   size_t len = v[i].iov_len;		   if (len > n_to_add) /* Don't write more than n_to_add bytes. */			  len = n_to_add;			gzb64->gz_encode_strm.avail_out = len;			gzb64->gz_encode_strm.next_out = v[i].iov_base;						zret = deflate (& gzb64->gz_encode_strm, flush_type);			if(zret < 0) zerr(zret);			written = len - gzb64->gz_encode_strm.avail_out;			if(DEBUG) printf("Deflate Out:%d/n", written);		  /* If there was a problem during data generation, we can just stop			 here; no data will be committed to the buffer. */		   /* Set iov_len to the number of bytes we actually wrote, so we			  don't commit too much. */		   v[i].iov_len = written;		}		/* We commit the space here.  Note that we give it 'i' (the number of		   vectors we actually used) rather than 'n' (the number of vectors we		   had available. */		if (evbuffer_commit_space(gzb64->encode_gzout_buffer, v, i) < 0)		   return -1; /* Error committing */		if( Z_FINISH == flush_type && 0 == written ) break;	} 	return 0;	}

static void resetDecoder(Gzb64* gzb64){	int zret = inflateReset(& gzb64->gz_decode_strm);	if(zret < 0) zerr(zret);	zret = BIO_reset(gzb64->b64_decoder);	gzb64->decoded_last_chunk = false;	if(DEBUG) printf("Decoder reset/n");}

static intnotzero(mnumber a){    if ((a.type & MN_INTEGER) ? a.u.l == 0 : a.u.d == 0.0) {	zerr("division by zero");	return 0;    }    return 1;}

static intcomp_check(void){    if (incompfunc != 1) {	zerr("condition can only be used in completion function");	return 0;    }    return 1;}

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

voidloop(int toplevel){    List list;#ifdef DEBUG    int oasp = toplevel ? 0 : alloc_stackp;#endif    pushheap();    for (;;) {	freeheap();	errflag = 0;	if (interact && isset(SHINSTDIN))	    preprompt();	hbegin();		/* init history mech        */	intr();			/* interrupts on            */	lexinit();              /* initialize lexical state */	if (!(list = parse_event())) {	/* if we couldn't parse a list */	    hend();	    if (tok == ENDINPUT && !errflag)		break;	    continue;	}	if (hend()) {	    int toksav = tok;	    if (stopmsg)	/* unset 'you have stopped jobs' flag */		stopmsg--;	    execlist(list, 0, 0);	    tok = toksav;	    if (toplevel)		noexitct = 0;	}	DPUTS(alloc_stackp != oasp, "BUG: alloc_stackp changed in loop()");	if (ferror(stderr)) {	    zerr("write error", NULL, 0);	    clearerr(stderr);	}	if (subsh)		/* how'd we get this far in a subshell? */	    exit(lastval);	if (((!interact || sourcelevel) && errflag) || retflag)	    break;	if (trapreturn) {	    lastval = trapreturn;	    trapreturn = 0;	}	if (isset(SINGLECOMMAND) && toplevel) {	    if (sigtrapped[SIGEXIT])		dotrap(SIGEXIT);	    exit(lastval);	}    }    popheap();}

void compressZlib(SharedBuffer<u8> data, std::ostream &os){	z_stream z;	const s32 bufsize = 16384;	//char input_buffer[bufsize];	char output_buffer[bufsize];	int input_i = 0;	int status = 0;	int ret;	z.zalloc = Z_NULL;	z.zfree = Z_NULL;	z.opaque = Z_NULL;	ret = deflateInit(&z, -1);	if(ret != Z_OK)		throw SerializationError("compressZlib: deflateInit failed");	z.avail_in = 0;	for(;;)	{		int flush = Z_NO_FLUSH;		z.next_out = (Bytef*)output_buffer;		z.avail_out = bufsize;		if(z.avail_in == 0)		{			//z.next_in = (char*)&data[input_i];			z.next_in = (Bytef*)&data[input_i];			z.avail_in = data.getSize() - input_i;			input_i += z.avail_in;			if(input_i == (int)data.getSize())				flush = Z_FINISH;		}		if(z.avail_in == 0)			break;		status = deflate(&z, flush);		if(status == Z_NEED_DICT || status == Z_DATA_ERROR				|| status == Z_MEM_ERROR)		{			zerr(status);			throw SerializationError("compressZlib: deflate failed");		}		int count = bufsize - z.avail_out;		if(count)			os.write(output_buffer, count);	}	deflateEnd(&z);}

voidgloblist(LinkList list){    LinkNode node, next;    badcshglob = 0;    for (node = firstnode(list); !errflag && node; node = next) {	next = nextnode(node);	glob(list, node);    }    if (badcshglob == 1)	zerr("no match", NULL, 0);}

static voidpush(mnumber val, char *lval, int getme){    if (sp == STACKSZ - 1)	zerr("stack overflow");    else	sp++;    stack[sp].val = val;    stack[sp].lval = lval;    stack[sp].pval = NULL;    if (getme)	stack[sp].val.type = MN_UNSET;}

voidzshlex(void){    if (tok == LEXERR)	return;    do {	if (inrepeat_)	    ++inrepeat_;	if (inrepeat_ == 3 && isset(SHORTLOOPS))	    incmdpos = 1;	tok = gettok();    } while (tok != ENDINPUT && exalias());    nocorrect &= 1;    if (tok == NEWLIN || tok == ENDINPUT) {	while (hdocs) {	    struct heredocs *next = hdocs->next;	    char *doc, *munged_term;	    hwbegin(0);	    cmdpush(hdocs->type == REDIR_HEREDOC ? CS_HEREDOC : CS_HEREDOCD);	    munged_term = dupstring(hdocs->str);	    STOPHIST	    doc = gethere(&munged_term, hdocs->type);	    ALLOWHIST	    cmdpop();	    hwend();	    if (!doc) {		zerr("here document too large");		while (hdocs) {		    next = hdocs->next;		    zfree(hdocs, sizeof(struct heredocs));		    hdocs = next;		}		tok = LEXERR;		break;	    }	    setheredoc(hdocs->pc, REDIR_HERESTR, doc, hdocs->str,		       munged_term);	    zfree(hdocs, sizeof(struct heredocs));	    hdocs = next;	}    }    if (tok != NEWLIN)	isnewlin = 0;    else	isnewlin = (inbufct) ? -1 : 1;    if (tok == SEMI || (tok == NEWLIN && !(lexflags & LEXFLAGS_NEWLINE)))	tok = SEPER;}

    void reset_inflate_state(z_stream *strm)    {      inflateEnd(strm);      strm->zalloc = Z_NULL;      strm->zfree = Z_NULL;      strm->opaque = Z_NULL;      strm->avail_in = 0;      strm->next_in = Z_NULL;      int ret = inflateInit(strm);      if (ret != Z_OK) {	BOOST_LOG_TRIVIAL(fatal) << "Unable to initialize zlib stream:"				 <<"(" << ret << ")" << zerr(ret);	exit(-1);      }    }

voidsourcehome(char *s){    char buf[PATH_MAX];    char *h;    if (emulation == EMULATE_SH || emulation == EMULATE_KSH ||	!(h = getsparam("ZDOTDIR")))	h = home;    if (strlen(h) + strlen(s) + 1 >= PATH_MAX) {	zerr("path too long: %s", s, 0);	return;    }    sprintf(buf, "%s/%s", h, s);    source(buf);}

    void reset_deflate_state(z_stream *strm, unsigned char *buffer)    {      deflateEnd(strm);      strm->zalloc = Z_NULL;      strm->zfree = Z_NULL;      strm->opaque = Z_NULL;      strm->avail_in = 0;      strm->next_in = Z_NULL;      strm->avail_out = stream_unit;      strm->next_out  = buffer;      int ret = deflateInit(strm, ZLIB_COMPRESSION_LEVEL);      if (ret != Z_OK) {	BOOST_LOG_TRIVIAL(fatal) << "Unable to initialize zlib stream" <<	      "(" << ret << ")" << zerr(ret);	exit(-1);      }    }

void compressZlib(SharedBuffer<u8> data, std::ostream &os){	z_stream z;	const s32 bufsize = 16384;	char output_buffer[bufsize];	int status = 0;	int ret;	z.zalloc = Z_NULL;	z.zfree = Z_NULL;	z.opaque = Z_NULL;	ret = deflateInit(&z, -1);	if(ret != Z_OK)		throw SerializationError("compressZlib: deflateInit failed");		// Point zlib to our input buffer	z.next_in = (Bytef*)&data[0];	z.avail_in = data.getSize();	// And get all output	for(;;)	{		z.next_out = (Bytef*)output_buffer;		z.avail_out = bufsize;				status = deflate(&z, Z_FINISH);		if(status == Z_NEED_DICT || status == Z_DATA_ERROR				|| status == Z_MEM_ERROR)		{			zerr(status);			throw SerializationError("compressZlib: deflate failed");		}		int count = bufsize - z.avail_out;		if(count)			os.write(output_buffer, count);		// This determines zlib has given all output		if(status == Z_STREAM_END)			break;	}	deflateEnd(&z);}