[thirdparty/linux.git] / lib / decompress_inflate.c

// SPDX-License-Identifier: GPL-2.0
#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"
#ifdef CONFIG_ZLIB_DFLTCC
#include "zlib_dfltcc/dfltcc.c"
#include "zlib_dfltcc/dfltcc_inflate.c"
#endif

#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() :
#ifdef CONFIG_ZLIB_DFLTCC
	/* Always allocate the full workspace for DFLTCC */
				 zlib_inflate_workspacesize());
#else
				 sizeof(struct inflate_state));
#endif
	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);

#ifdef CONFIG_ZLIB_DFLTCC
	/* Always keep the window for DFLTCC */
#else
	if (!flush) {
		WS(strm)->inflate_state.wsize = 0;
		WS(strm)->inflate_state.window = NULL;
	}
#endif

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