[people/arne_f/kernel.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"

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