[thirdparty/git.git] / zlib.c

/*
 * zlib wrappers to make sure we don't silently miss errors
 * at init time.
 */
#include "cache.h"

static const char *zerr_to_string(int status)
{
	switch (status) {
	case Z_MEM_ERROR:
		return "out of memory";
	case Z_VERSION_ERROR:
		return "wrong version";
	case Z_NEED_DICT:
		return "needs dictionary";
	case Z_DATA_ERROR:
		return "data stream error";
	case Z_STREAM_ERROR:
		return "stream consistency error";
	default:
		return "unknown error";
	}
}

/*
 * avail_in and avail_out in zlib are counted in uInt, which typically
 * limits the size of the buffer we can use to 4GB when interacting
 * with zlib in a single call to inflate/deflate.
 */
/* #define ZLIB_BUF_MAX ((uInt)-1) */
#define ZLIB_BUF_MAX ((uInt) 1024 * 1024 * 1024) /* 1GB */
static inline uInt zlib_buf_cap(unsigned long len)
{
	return (ZLIB_BUF_MAX < len) ? ZLIB_BUF_MAX : len;
}

static void zlib_pre_call(git_zstream *s)
{
	s->z.next_in = s->next_in;
	s->z.next_out = s->next_out;
	s->z.total_in = s->total_in;
	s->z.total_out = s->total_out;
	s->z.avail_in = zlib_buf_cap(s->avail_in);
	s->z.avail_out = zlib_buf_cap(s->avail_out);
}

static void zlib_post_call(git_zstream *s)
{
	unsigned long bytes_consumed;
	unsigned long bytes_produced;

	bytes_consumed = s->z.next_in - s->next_in;
	bytes_produced = s->z.next_out - s->next_out;
	if (s->z.total_out != s->total_out + bytes_produced)
		BUG("total_out mismatch");
	if (s->z.total_in != s->total_in + bytes_consumed)
		BUG("total_in mismatch");

	s->total_out = s->z.total_out;
	s->total_in = s->z.total_in;
	s->next_in = s->z.next_in;
	s->next_out = s->z.next_out;
	s->avail_in -= bytes_consumed;
	s->avail_out -= bytes_produced;
}

void git_inflate_init(git_zstream *strm)
{
	int status;

	zlib_pre_call(strm);
	status = inflateInit(&strm->z);
	zlib_post_call(strm);
	if (status == Z_OK)
		return;
	die("inflateInit: %s (%s)", zerr_to_string(status),
	    strm->z.msg ? strm->z.msg : "no message");
}

void git_inflate_init_gzip_only(git_zstream *strm)
{
	/*
	 * Use default 15 bits, +16 is to accept only gzip and to
	 * yield Z_DATA_ERROR when fed zlib format.
	 */
	const int windowBits = 15 + 16;
	int status;

	zlib_pre_call(strm);
	status = inflateInit2(&strm->z, windowBits);
	zlib_post_call(strm);
	if (status == Z_OK)
		return;
	die("inflateInit2: %s (%s)", zerr_to_string(status),
	    strm->z.msg ? strm->z.msg : "no message");
}

void git_inflate_end(git_zstream *strm)
{
	int status;

	zlib_pre_call(strm);
	status = inflateEnd(&strm->z);
	zlib_post_call(strm);
	if (status == Z_OK)
		return;
	error("inflateEnd: %s (%s)", zerr_to_string(status),
	      strm->z.msg ? strm->z.msg : "no message");
}

int git_inflate(git_zstream *strm, int flush)
{
	int status;

	for (;;) {
		zlib_pre_call(strm);
		/* Never say Z_FINISH unless we are feeding everything */
		status = inflate(&strm->z,
				 (strm->z.avail_in != strm->avail_in)
				 ? 0 : flush);
		if (status == Z_MEM_ERROR)
			die("inflate: out of memory");
		zlib_post_call(strm);

		/*
		 * Let zlib work another round, while we can still
		 * make progress.
		 */
		if ((strm->avail_out && !strm->z.avail_out) &&
		    (status == Z_OK || status == Z_BUF_ERROR))
			continue;
		break;
	}

	switch (status) {
	/* Z_BUF_ERROR: normal, needs more space in the output buffer */
	case Z_BUF_ERROR:
	case Z_OK:
	case Z_STREAM_END:
		return status;
	default:
		break;
	}
	error("inflate: %s (%s)", zerr_to_string(status),
	      strm->z.msg ? strm->z.msg : "no message");
	return status;
}

#if defined(NO_DEFLATE_BOUND) || ZLIB_VERNUM < 0x1200
#define deflateBound(c,s)  ((s) + (((s) + 7) >> 3) + (((s) + 63) >> 6) + 11)
#endif

unsigned long git_deflate_bound(git_zstream *strm, unsigned long size)
{
	return deflateBound(&strm->z, size);
}

void git_deflate_init(git_zstream *strm, int level)
{
	int status;

	memset(strm, 0, sizeof(*strm));
	zlib_pre_call(strm);
	status = deflateInit(&strm->z, level);
	zlib_post_call(strm);
	if (status == Z_OK)
		return;
	die("deflateInit: %s (%s)", zerr_to_string(status),
	    strm->z.msg ? strm->z.msg : "no message");
}

static void do_git_deflate_init(git_zstream *strm, int level, int windowBits)
{
	int status;

	memset(strm, 0, sizeof(*strm));
	zlib_pre_call(strm);
	status = deflateInit2(&strm->z, level,
				  Z_DEFLATED, windowBits,
				  8, Z_DEFAULT_STRATEGY);
	zlib_post_call(strm);
	if (status == Z_OK)
		return;
	die("deflateInit2: %s (%s)", zerr_to_string(status),
	    strm->z.msg ? strm->z.msg : "no message");
}

void git_deflate_init_gzip(git_zstream *strm, int level)
{
	/*
	 * Use default 15 bits, +16 is to generate gzip header/trailer
	 * instead of the zlib wrapper.
	 */
	do_git_deflate_init(strm, level, 15 + 16);
}

void git_deflate_init_raw(git_zstream *strm, int level)
{
	/*
	 * Use default 15 bits, negate the value to get raw compressed
	 * data without zlib header and trailer.
	 */
	do_git_deflate_init(strm, level, -15);
}

int git_deflate_abort(git_zstream *strm)
{
	int status;

	zlib_pre_call(strm);
	status = deflateEnd(&strm->z);
	zlib_post_call(strm);
	return status;
}

void git_deflate_end(git_zstream *strm)
{
	int status = git_deflate_abort(strm);

	if (status == Z_OK)
		return;
	error("deflateEnd: %s (%s)", zerr_to_string(status),
	      strm->z.msg ? strm->z.msg : "no message");
}

int git_deflate_end_gently(git_zstream *strm)
{
	int status;

	zlib_pre_call(strm);
	status = deflateEnd(&strm->z);
	zlib_post_call(strm);
	return status;
}

int git_deflate(git_zstream *strm, int flush)
{
	int status;

	for (;;) {
		zlib_pre_call(strm);

		/* Never say Z_FINISH unless we are feeding everything */
		status = deflate(&strm->z,
				 (strm->z.avail_in != strm->avail_in)
				 ? 0 : flush);
		if (status == Z_MEM_ERROR)
			die("deflate: out of memory");
		zlib_post_call(strm);

		/*
		 * Let zlib work another round, while we can still
		 * make progress.
		 */
		if ((strm->avail_out && !strm->z.avail_out) &&
		    (status == Z_OK || status == Z_BUF_ERROR))
			continue;
		break;
	}

	switch (status) {
	/* Z_BUF_ERROR: normal, needs more space in the output buffer */
	case Z_BUF_ERROR:
	case Z_OK:
	case Z_STREAM_END:
		return status;
	default:
		break;
	}
	error("deflate: %s (%s)", zerr_to_string(status),
	      strm->z.msg ? strm->z.msg : "no message");
	return status;
}
Commit	Line	Data
	1	/*
	2	* zlib wrappers to make sure we don't silently miss errors
	3	* at init time.
	4	*/
	5	#include "cache.h"
	6
	7	static const char *zerr_to_string(int status)
	8	{
	9	switch (status) {
	10	case Z_MEM_ERROR:
	11	return "out of memory";
	12	case Z_VERSION_ERROR:
	13	return "wrong version";
	14	case Z_NEED_DICT:
	15	return "needs dictionary";
	16	case Z_DATA_ERROR:
	17	return "data stream error";
	18	case Z_STREAM_ERROR:
	19	return "stream consistency error";
	20	default:
	21	return "unknown error";
	22	}
	23	}
	24
	25	/*
	26	* avail_in and avail_out in zlib are counted in uInt, which typically
	27	* limits the size of the buffer we can use to 4GB when interacting
	28	* with zlib in a single call to inflate/deflate.
	29	*/
	30	/* #define ZLIB_BUF_MAX ((uInt)-1) */
	31	#define ZLIB_BUF_MAX ((uInt) 1024 * 1024 * 1024) /* 1GB */
	32	static inline uInt zlib_buf_cap(unsigned long len)
	33	{
	34	return (ZLIB_BUF_MAX < len) ? ZLIB_BUF_MAX : len;
	35	}
	36
	37	static void zlib_pre_call(git_zstream *s)
	38	{
	39	s->z.next_in = s->next_in;
	40	s->z.next_out = s->next_out;
	41	s->z.total_in = s->total_in;
	42	s->z.total_out = s->total_out;
	43	s->z.avail_in = zlib_buf_cap(s->avail_in);
	44	s->z.avail_out = zlib_buf_cap(s->avail_out);
	45	}
	46
	47	static void zlib_post_call(git_zstream *s)
	48	{
	49	unsigned long bytes_consumed;
	50	unsigned long bytes_produced;
	51
	52	bytes_consumed = s->z.next_in - s->next_in;
	53	bytes_produced = s->z.next_out - s->next_out;
	54	if (s->z.total_out != s->total_out + bytes_produced)
	55	BUG("total_out mismatch");
	56	if (s->z.total_in != s->total_in + bytes_consumed)
	57	BUG("total_in mismatch");
	58
	59	s->total_out = s->z.total_out;
	60	s->total_in = s->z.total_in;
	61	s->next_in = s->z.next_in;
	62	s->next_out = s->z.next_out;
	63	s->avail_in -= bytes_consumed;
	64	s->avail_out -= bytes_produced;
	65	}
	66
	67	void git_inflate_init(git_zstream *strm)
	68	{
	69	int status;
	70
	71	zlib_pre_call(strm);
	72	status = inflateInit(&strm->z);
	73	zlib_post_call(strm);
	74	if (status == Z_OK)
	75	return;
	76	die("inflateInit: %s (%s)", zerr_to_string(status),
	77	strm->z.msg ? strm->z.msg : "no message");
	78	}
	79
	80	void git_inflate_init_gzip_only(git_zstream *strm)
	81	{
	82	/*
	83	* Use default 15 bits, +16 is to accept only gzip and to
	84	* yield Z_DATA_ERROR when fed zlib format.
	85	*/
	86	const int windowBits = 15 + 16;
	87	int status;
	88
	89	zlib_pre_call(strm);
	90	status = inflateInit2(&strm->z, windowBits);
	91	zlib_post_call(strm);
	92	if (status == Z_OK)
	93	return;
	94	die("inflateInit2: %s (%s)", zerr_to_string(status),
	95	strm->z.msg ? strm->z.msg : "no message");
	96	}
	97
	98	void git_inflate_end(git_zstream *strm)
	99	{
	100	int status;
	101
	102	zlib_pre_call(strm);
	103	status = inflateEnd(&strm->z);
	104	zlib_post_call(strm);
	105	if (status == Z_OK)
	106	return;
	107	error("inflateEnd: %s (%s)", zerr_to_string(status),
	108	strm->z.msg ? strm->z.msg : "no message");
	109	}
	110
	111	int git_inflate(git_zstream *strm, int flush)
	112	{
	113	int status;
	114
	115	for (;;) {
	116	zlib_pre_call(strm);
	117	/* Never say Z_FINISH unless we are feeding everything */
	118	status = inflate(&strm->z,
	119	(strm->z.avail_in != strm->avail_in)
	120	? 0 : flush);
	121	if (status == Z_MEM_ERROR)
	122	die("inflate: out of memory");
	123	zlib_post_call(strm);
	124
	125	/*
	126	* Let zlib work another round, while we can still
	127	* make progress.
	128	*/
	129	if ((strm->avail_out && !strm->z.avail_out) &&
	130	(status == Z_OK \|\| status == Z_BUF_ERROR))
	131	continue;
	132	break;
	133	}
	134
	135	switch (status) {
	136	/* Z_BUF_ERROR: normal, needs more space in the output buffer */
	137	case Z_BUF_ERROR:
	138	case Z_OK:
	139	case Z_STREAM_END:
	140	return status;
	141	default:
	142	break;
	143	}
	144	error("inflate: %s (%s)", zerr_to_string(status),
	145	strm->z.msg ? strm->z.msg : "no message");
	146	return status;
	147	}
	148
	149	#if defined(NO_DEFLATE_BOUND) \|\| ZLIB_VERNUM < 0x1200
	150	#define deflateBound(c,s) ((s) + (((s) + 7) >> 3) + (((s) + 63) >> 6) + 11)
	151	#endif
	152
	153	unsigned long git_deflate_bound(git_zstream *strm, unsigned long size)
	154	{
	155	return deflateBound(&strm->z, size);
	156	}
	157
	158	void git_deflate_init(git_zstream *strm, int level)
	159	{
	160	int status;
	161
	162	memset(strm, 0, sizeof(*strm));
	163	zlib_pre_call(strm);
	164	status = deflateInit(&strm->z, level);
	165	zlib_post_call(strm);
	166	if (status == Z_OK)
	167	return;
	168	die("deflateInit: %s (%s)", zerr_to_string(status),
	169	strm->z.msg ? strm->z.msg : "no message");
	170	}
	171
	172	static void do_git_deflate_init(git_zstream *strm, int level, int windowBits)
	173	{
	174	int status;
	175
	176	memset(strm, 0, sizeof(*strm));
	177	zlib_pre_call(strm);
	178	status = deflateInit2(&strm->z, level,
	179	Z_DEFLATED, windowBits,
	180	8, Z_DEFAULT_STRATEGY);
	181	zlib_post_call(strm);
	182	if (status == Z_OK)
	183	return;
	184	die("deflateInit2: %s (%s)", zerr_to_string(status),
	185	strm->z.msg ? strm->z.msg : "no message");
	186	}
	187
	188	void git_deflate_init_gzip(git_zstream *strm, int level)
	189	{
	190	/*
	191	* Use default 15 bits, +16 is to generate gzip header/trailer
	192	* instead of the zlib wrapper.
	193	*/
	194	do_git_deflate_init(strm, level, 15 + 16);
	195	}
	196
	197	void git_deflate_init_raw(git_zstream *strm, int level)
	198	{
	199	/*
	200	* Use default 15 bits, negate the value to get raw compressed
	201	* data without zlib header and trailer.
	202	*/
	203	do_git_deflate_init(strm, level, -15);
	204	}
	205
	206	int git_deflate_abort(git_zstream *strm)
	207	{
	208	int status;
	209
	210	zlib_pre_call(strm);
	211	status = deflateEnd(&strm->z);
	212	zlib_post_call(strm);
	213	return status;
	214	}
	215
	216	void git_deflate_end(git_zstream *strm)
	217	{
	218	int status = git_deflate_abort(strm);
	219
	220	if (status == Z_OK)
	221	return;
	222	error("deflateEnd: %s (%s)", zerr_to_string(status),
	223	strm->z.msg ? strm->z.msg : "no message");
	224	}
	225
	226	int git_deflate_end_gently(git_zstream *strm)
	227	{
	228	int status;
	229
	230	zlib_pre_call(strm);
	231	status = deflateEnd(&strm->z);
	232	zlib_post_call(strm);
	233	return status;
	234	}
	235
	236	int git_deflate(git_zstream *strm, int flush)
	237	{
	238	int status;
	239
	240	for (;;) {
	241	zlib_pre_call(strm);
	242
	243	/* Never say Z_FINISH unless we are feeding everything */
	244	status = deflate(&strm->z,
	245	(strm->z.avail_in != strm->avail_in)
	246	? 0 : flush);
	247	if (status == Z_MEM_ERROR)
	248	die("deflate: out of memory");
	249	zlib_post_call(strm);
	250
	251	/*
	252	* Let zlib work another round, while we can still
	253	* make progress.
	254	*/
	255	if ((strm->avail_out && !strm->z.avail_out) &&
	256	(status == Z_OK \|\| status == Z_BUF_ERROR))
	257	continue;
	258	break;
	259	}
	260
	261	switch (status) {
	262	/* Z_BUF_ERROR: normal, needs more space in the output buffer */
	263	case Z_BUF_ERROR:
	264	case Z_OK:
	265	case Z_STREAM_END:
	266	return status;
	267	default:
	268	break;
	269	}
	270	error("deflate: %s (%s)", zerr_to_string(status),
	271	strm->z.msg ? strm->z.msg : "no message");
	272	return status;
	273	}