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