[mirror_ubuntu-zesty-kernel.git] / lib / decompress_inflate.c

#ifdef STATIC
#define PREBOOT
/* Pre-boot environment: included */

/* prevent inclusion of _LINUX_KERNEL_H in pre-boot environment: lots
 * errors about console_printk etc... on ARM */
#define _LINUX_KERNEL_H

#include "zlib_inflate/inftrees.c"
#include "zlib_inflate/inffast.c"
#include "zlib_inflate/inflate.c"

#else /* STATIC */
/* initramfs et al: linked */

#include <linux/zutil.h>

#include "zlib_inflate/inftrees.h"
#include "zlib_inflate/inffast.h"
#include "zlib_inflate/inflate.h"

#include "zlib_inflate/infutil.h"
#include <linux/decompress/inflate.h>

#endif /* STATIC */

#include <linux/decompress/mm.h>

#define GZIP_IOBUF_SIZE (16*1024)

static long INIT nofill(void *buffer, unsigned long len)
{
	return -1;
}

/* Included from initramfs et al code */
STATIC int INIT __gunzip(unsigned char *buf, long len,
		       long (*fill)(void*, unsigned long),
		       long (*flush)(void*, unsigned long),
		       unsigned char *out_buf, long out_len,
		       long *pos,
		       void(*error)(char *x)) {
	u8 *zbuf;
	struct z_stream_s *strm;
	int rc;

	rc = -1;
	if (flush) {
		out_len = 0x8000; /* 32 K */
		out_buf = malloc(out_len);
	} else {
		if (!out_len)
			out_len = ((size_t)~0) - (size_t)out_buf; /* no limit */
	}
	if (!out_buf) {
		error("Out of memory while allocating output buffer");
		goto gunzip_nomem1;
	}

	if (buf)
		zbuf = buf;
	else {
		zbuf = malloc(GZIP_IOBUF_SIZE);
		len = 0;
	}
	if (!zbuf) {
		error("Out of memory while allocating input buffer");
		goto gunzip_nomem2;
	}

	strm = malloc(sizeof(*strm));
	if (strm == NULL) {
		error("Out of memory while allocating z_stream");
		goto gunzip_nomem3;
	}

	strm->workspace = malloc(flush ? zlib_inflate_workspacesize() :
				 sizeof(struct inflate_state));
	if (strm->workspace == NULL) {
		error("Out of memory while allocating workspace");
		goto gunzip_nomem4;
	}

	if (!fill)
		fill = nofill;

	if (len == 0)
		len = fill(zbuf, GZIP_IOBUF_SIZE);

	/* verify the gzip header */
	if (len < 10 ||
	   zbuf[0] != 0x1f || zbuf[1] != 0x8b || zbuf[2] != 0x08) {
		if (pos)
			*pos = 0;
		error("Not a gzip file");
		goto gunzip_5;
	}

	/* skip over gzip header (1f,8b,08... 10 bytes total +
	 * possible asciz filename)
	 */
	strm->next_in = zbuf + 10;
	strm->avail_in = len - 10;
	/* skip over asciz filename */
	if (zbuf[3] & 0x8) {
		do {
			/*
			 * If the filename doesn't fit into the buffer,
			 * the file is very probably corrupt. Don't try
			 * to read more data.
			 */
			if (strm->avail_in == 0) {
				error("header error");
				goto gunzip_5;
			}
			--strm->avail_in;
		} while (*strm->next_in++);
	}

	strm->next_out = out_buf;
	strm->avail_out = out_len;

	rc = zlib_inflateInit2(strm, -MAX_WBITS);

	if (!flush) {
		WS(strm)->inflate_state.wsize = 0;
		WS(strm)->inflate_state.window = NULL;
	}

	while (rc == Z_OK) {
		if (strm->avail_in == 0) {
			/* TODO: handle case where both pos and fill are set */
			len = fill(zbuf, GZIP_IOBUF_SIZE);
			if (len < 0) {
				rc = -1;
				error("read error");
				break;
			}
			strm->next_in = zbuf;
			strm->avail_in = len;
		}
		rc = zlib_inflate(strm, 0);

		/* Write any data generated */
		if (flush && strm->next_out > out_buf) {
			long l = strm->next_out - out_buf;
			if (l != flush(out_buf, l)) {
				rc = -1;
				error("write error");
				break;
			}
			strm->next_out = out_buf;
			strm->avail_out = out_len;
		}

		/* after Z_FINISH, only Z_STREAM_END is "we unpacked it all" */
		if (rc == Z_STREAM_END) {
			rc = 0;
			break;
		} else if (rc != Z_OK) {
			error("uncompression error");
			rc = -1;
		}
	}

	zlib_inflateEnd(strm);
	if (pos)
		/* add + 8 to skip over trailer */
		*pos = strm->next_in - zbuf+8;

gunzip_5:
	free(strm->workspace);
gunzip_nomem4:
	free(strm);
gunzip_nomem3:
	if (!buf)
		free(zbuf);
gunzip_nomem2:
	if (flush)
		free(out_buf);
gunzip_nomem1:
	return rc; /* returns Z_OK (0) if successful */
}

#ifndef PREBOOT
STATIC int INIT gunzip(unsigned char *buf, long len,
		       long (*fill)(void*, unsigned long),
		       long (*flush)(void*, unsigned long),
		       unsigned char *out_buf,
		       long *pos,
		       void (*error)(char *x))
{
	return __gunzip(buf, len, fill, flush, out_buf, 0, pos, error);
}
#else
STATIC int INIT __decompress(unsigned char *buf, long len,
			   long (*fill)(void*, unsigned long),
			   long (*flush)(void*, unsigned long),
			   unsigned char *out_buf, long out_len,
			   long *pos,
			   void (*error)(char *x))
{
	return __gunzip(buf, len, fill, flush, out_buf, out_len, pos, error);
}
#endif
Commit	Line	Data
bc22c17e	1	#ifdef STATIC
2d3862d2	2	#define PREBOOT
bc22c17e AK	3	/* Pre-boot environment: included */
	4
	5	/* prevent inclusion of _LINUX_KERNEL_H in pre-boot environment: lots
	6	* errors about console_printk etc... on ARM */
	7	#define _LINUX_KERNEL_H
	8
	9	#include "zlib_inflate/inftrees.c"
	10	#include "zlib_inflate/inffast.c"
	11	#include "zlib_inflate/inflate.c"
	12
	13	#else /* STATIC */
	14	/* initramfs et al: linked */
	15
	16	#include <linux/zutil.h>
	17
	18	#include "zlib_inflate/inftrees.h"
	19	#include "zlib_inflate/inffast.h"
	20	#include "zlib_inflate/inflate.h"
	21
	22	#include "zlib_inflate/infutil.h"
af661e83	23	#include <linux/decompress/inflate.h>
bc22c17e AK	24
	25	#endif /* STATIC */
	26
	27	#include <linux/decompress/mm.h>
	28
daeb6b6f	29	#define GZIP_IOBUF_SIZE (16*1024)
bc22c17e	30
d97b07c5	31	static long INIT nofill(void *buffer, unsigned long len)
6a881162 PL	32	{
	33	return -1;
	34	}
	35
bc22c17e	36	/* Included from initramfs et al code */
2d3862d2	37	STATIC int INIT __gunzip(unsigned char *buf, long len,
d97b07c5 YL	38	long (fill)(void, unsigned long),
d97b07c5 YL	39	long (flush)(void, unsigned long),
2d3862d2	40	unsigned char *out_buf, long out_len,
d97b07c5	41	long *pos,
93685ad2	42	void(error)(char x)) {
bc22c17e AK	43	u8 *zbuf;
	44	struct z_stream_s *strm;
	45	int rc;
bc22c17e	46
bc22c17e AK	47	rc = -1;
bc22c17e AK	48	if (flush) {
5619448f	49	out_len = 0x8000; /* 32 K */
bc22c17e AK	50	out_buf = malloc(out_len);
bc22c17e AK	51	} else {
2d3862d2 YL	52	if (!out_len)
2d3862d2 YL	53	out_len = ((size_t)~0) - (size_t)out_buf; /* no limit */
bc22c17e AK	54	}
	55	if (!out_buf) {
	56	error("Out of memory while allocating output buffer");
	57	goto gunzip_nomem1;
	58	}
	59
	60	if (buf)
	61	zbuf = buf;
	62	else {
daeb6b6f	63	zbuf = malloc(GZIP_IOBUF_SIZE);
bc22c17e AK	64	len = 0;
	65	}
	66	if (!zbuf) {
	67	error("Out of memory while allocating input buffer");
	68	goto gunzip_nomem2;
	69	}
	70
	71	strm = malloc(sizeof(*strm));
	72	if (strm == NULL) {
	73	error("Out of memory while allocating z_stream");
	74	goto gunzip_nomem3;
	75	}
	76
	77	strm->workspace = malloc(flush ? zlib_inflate_workspacesize() :
	78	sizeof(struct inflate_state));
	79	if (strm->workspace == NULL) {
	80	error("Out of memory while allocating workspace");
	81	goto gunzip_nomem4;
	82	}
	83
6a881162 PL	84	if (!fill)
	85	fill = nofill;
	86
bc22c17e	87	if (len == 0)
daeb6b6f	88	len = fill(zbuf, GZIP_IOBUF_SIZE);
bc22c17e AK	89
	90	/* verify the gzip header */
	91	if (len < 10 \|\|
	92	zbuf[0] != 0x1f \|\| zbuf[1] != 0x8b \|\| zbuf[2] != 0x08) {
	93	if (pos)
	94	*pos = 0;
	95	error("Not a gzip file");
	96	goto gunzip_5;
	97	}
	98
	99	/* skip over gzip header (1f,8b,08... 10 bytes total +
	100	* possible asciz filename)
	101	*/
	102	strm->next_in = zbuf + 10;
1da914e0	103	strm->avail_in = len - 10;
bc22c17e AK	104	/* skip over asciz filename */
bc22c17e AK	105	if (zbuf[3] & 0x8) {
1da914e0 LC	106	do {
	107	/*
	108	* If the filename doesn't fit into the buffer,
	109	* the file is very probably corrupt. Don't try
	110	* to read more data.
	111	*/
	112	if (strm->avail_in == 0) {
	113	error("header error");
	114	goto gunzip_5;
	115	}
	116	--strm->avail_in;
	117	} while (*strm->next_in++);
bc22c17e	118	}
bc22c17e AK	119
	120	strm->next_out = out_buf;
	121	strm->avail_out = out_len;
	122
	123	rc = zlib_inflateInit2(strm, -MAX_WBITS);
	124
	125	if (!flush) {
	126	WS(strm)->inflate_state.wsize = 0;
	127	WS(strm)->inflate_state.window = NULL;
	128	}
	129
	130	while (rc == Z_OK) {
	131	if (strm->avail_in == 0) {
	132	/* TODO: handle case where both pos and fill are set */
daeb6b6f	133	len = fill(zbuf, GZIP_IOBUF_SIZE);
bc22c17e AK	134	if (len < 0) {
	135	rc = -1;
	136	error("read error");
	137	break;
	138	}
	139	strm->next_in = zbuf;
	140	strm->avail_in = len;
	141	}
	142	rc = zlib_inflate(strm, 0);
	143
	144	/* Write any data generated */
	145	if (flush && strm->next_out > out_buf) {
d97b07c5	146	long l = strm->next_out - out_buf;
bc22c17e AK	147	if (l != flush(out_buf, l)) {
	148	rc = -1;
	149	error("write error");
	150	break;
	151	}
	152	strm->next_out = out_buf;
	153	strm->avail_out = out_len;
	154	}
	155
	156	/* after Z_FINISH, only Z_STREAM_END is "we unpacked it all" */
	157	if (rc == Z_STREAM_END) {
	158	rc = 0;
	159	break;
	160	} else if (rc != Z_OK) {
	161	error("uncompression error");
	162	rc = -1;
	163	}
	164	}
	165
	166	zlib_inflateEnd(strm);
	167	if (pos)
	168	/* add + 8 to skip over trailer */
	169	*pos = strm->next_in - zbuf+8;
	170
	171	gunzip_5:
	172	free(strm->workspace);
	173	gunzip_nomem4:
	174	free(strm);
	175	gunzip_nomem3:
	176	if (!buf)
	177	free(zbuf);
	178	gunzip_nomem2:
	179	if (flush)
	180	free(out_buf);
	181	gunzip_nomem1:
	182	return rc; /* returns Z_OK (0) if successful */
	183	}
	184
2d3862d2 YL	185	#ifndef PREBOOT
	186	STATIC int INIT gunzip(unsigned char *buf, long len,
	187	long (fill)(void, unsigned long),
	188	long (flush)(void, unsigned long),
	189	unsigned char *out_buf,
	190	long *pos,
	191	void (error)(char x))
	192	{
	193	return __gunzip(buf, len, fill, flush, out_buf, 0, pos, error);
	194	}
	195	#else
	196	STATIC int INIT __decompress(unsigned char *buf, long len,
	197	long (fill)(void, unsigned long),
	198	long (flush)(void, unsigned long),
	199	unsigned char *out_buf, long out_len,
	200	long *pos,
	201	void (error)(char x))
	202	{
	203	return __gunzip(buf, len, fill, flush, out_buf, out_len, pos, error);
	204	}
	205	#endif