Merge tag 'mips_6.5_1' of git://git.kernel.org/pub/scm/linux/kernel/git/mips/linux
[platform/kernel/linux-starfive.git] / lib / decompress_inflate.c
1 // SPDX-License-Identifier: GPL-2.0
2 #ifdef STATIC
3 #define PREBOOT
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 #ifdef CONFIG_ZLIB_DFLTCC
14 #include "zlib_dfltcc/dfltcc.c"
15 #include "zlib_dfltcc/dfltcc_inflate.c"
16 #endif
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"
28 #include <linux/decompress/inflate.h>
29
30 #endif /* STATIC */
31
32 #include <linux/decompress/mm.h>
33
34 #define GZIP_IOBUF_SIZE (16*1024)
35
36 static long INIT nofill(void *buffer, unsigned long len)
37 {
38         return -1;
39 }
40
41 /* Included from initramfs et al code */
42 static int INIT __gunzip(unsigned char *buf, long len,
43                        long (*fill)(void*, unsigned long),
44                        long (*flush)(void*, unsigned long),
45                        unsigned char *out_buf, long out_len,
46                        long *pos,
47                        void(*error)(char *x)) {
48         u8 *zbuf;
49         struct z_stream_s *strm;
50         int rc;
51
52         rc = -1;
53         if (flush) {
54                 out_len = 0x8000; /* 32 K */
55                 out_buf = malloc(out_len);
56         } else {
57                 if (!out_len)
58                         out_len = ((size_t)~0) - (size_t)out_buf; /* no limit */
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 {
68                 zbuf = malloc(GZIP_IOBUF_SIZE);
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() :
83 #ifdef CONFIG_ZLIB_DFLTCC
84         /* Always allocate the full workspace for DFLTCC */
85                                  zlib_inflate_workspacesize());
86 #else
87                                  sizeof(struct inflate_state));
88 #endif
89         if (strm->workspace == NULL) {
90                 error("Out of memory while allocating workspace");
91                 goto gunzip_nomem4;
92         }
93
94         if (!fill)
95                 fill = nofill;
96
97         if (len == 0)
98                 len = fill(zbuf, GZIP_IOBUF_SIZE);
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;
113         strm->avail_in = len - 10;
114         /* skip over asciz filename */
115         if (zbuf[3] & 0x8) {
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++);
128         }
129
130         strm->next_out = out_buf;
131         strm->avail_out = out_len;
132
133         rc = zlib_inflateInit2(strm, -MAX_WBITS);
134
135 #ifdef CONFIG_ZLIB_DFLTCC
136         /* Always keep the window for DFLTCC */
137 #else
138         if (!flush) {
139                 WS(strm)->inflate_state.wsize = 0;
140                 WS(strm)->inflate_state.window = NULL;
141         }
142 #endif
143
144         while (rc == Z_OK) {
145                 if (strm->avail_in == 0) {
146                         /* TODO: handle case where both pos and fill are set */
147                         len = fill(zbuf, GZIP_IOBUF_SIZE);
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) {
160                         long l = strm->next_out - out_buf;
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
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