Merge branch 'x86-debug-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6.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/slab.h>
23
24 #endif /* STATIC */
25
26 #include <linux/decompress/mm.h>
27
28 #define GZIP_IOBUF_SIZE (16*1024)
29
30 /* Included from initramfs et al code */
31 STATIC int INIT gunzip(unsigned char *buf, int len,
32                        int(*fill)(void*, unsigned int),
33                        int(*flush)(void*, unsigned int),
34                        unsigned char *out_buf,
35                        int *pos,
36                        void(*error_fn)(char *x)) {
37         u8 *zbuf;
38         struct z_stream_s *strm;
39         int rc;
40         size_t out_len;
41
42         set_error_fn(error_fn);
43         rc = -1;
44         if (flush) {
45                 out_len = 0x8000; /* 32 K */
46                 out_buf = malloc(out_len);
47         } else {
48                 out_len = 0x7fffffff; /* no limit */
49         }
50         if (!out_buf) {
51                 error("Out of memory while allocating output buffer");
52                 goto gunzip_nomem1;
53         }
54
55         if (buf)
56                 zbuf = buf;
57         else {
58                 zbuf = malloc(GZIP_IOBUF_SIZE);
59                 len = 0;
60         }
61         if (!zbuf) {
62                 error("Out of memory while allocating input buffer");
63                 goto gunzip_nomem2;
64         }
65
66         strm = malloc(sizeof(*strm));
67         if (strm == NULL) {
68                 error("Out of memory while allocating z_stream");
69                 goto gunzip_nomem3;
70         }
71
72         strm->workspace = malloc(flush ? zlib_inflate_workspacesize() :
73                                  sizeof(struct inflate_state));
74         if (strm->workspace == NULL) {
75                 error("Out of memory while allocating workspace");
76                 goto gunzip_nomem4;
77         }
78
79         if (len == 0)
80                 len = fill(zbuf, GZIP_IOBUF_SIZE);
81
82         /* verify the gzip header */
83         if (len < 10 ||
84            zbuf[0] != 0x1f || zbuf[1] != 0x8b || zbuf[2] != 0x08) {
85                 if (pos)
86                         *pos = 0;
87                 error("Not a gzip file");
88                 goto gunzip_5;
89         }
90
91         /* skip over gzip header (1f,8b,08... 10 bytes total +
92          * possible asciz filename)
93          */
94         strm->next_in = zbuf + 10;
95         /* skip over asciz filename */
96         if (zbuf[3] & 0x8) {
97                 while (strm->next_in[0])
98                         strm->next_in++;
99                 strm->next_in++;
100         }
101         strm->avail_in = len - (strm->next_in - zbuf);
102
103         strm->next_out = out_buf;
104         strm->avail_out = out_len;
105
106         rc = zlib_inflateInit2(strm, -MAX_WBITS);
107
108         if (!flush) {
109                 WS(strm)->inflate_state.wsize = 0;
110                 WS(strm)->inflate_state.window = NULL;
111         }
112
113         while (rc == Z_OK) {
114                 if (strm->avail_in == 0) {
115                         /* TODO: handle case where both pos and fill are set */
116                         len = fill(zbuf, GZIP_IOBUF_SIZE);
117                         if (len < 0) {
118                                 rc = -1;
119                                 error("read error");
120                                 break;
121                         }
122                         strm->next_in = zbuf;
123                         strm->avail_in = len;
124                 }
125                 rc = zlib_inflate(strm, 0);
126
127                 /* Write any data generated */
128                 if (flush && strm->next_out > out_buf) {
129                         int l = strm->next_out - out_buf;
130                         if (l != flush(out_buf, l)) {
131                                 rc = -1;
132                                 error("write error");
133                                 break;
134                         }
135                         strm->next_out = out_buf;
136                         strm->avail_out = out_len;
137                 }
138
139                 /* after Z_FINISH, only Z_STREAM_END is "we unpacked it all" */
140                 if (rc == Z_STREAM_END) {
141                         rc = 0;
142                         break;
143                 } else if (rc != Z_OK) {
144                         error("uncompression error");
145                         rc = -1;
146                 }
147         }
148
149         zlib_inflateEnd(strm);
150         if (pos)
151                 /* add + 8 to skip over trailer */
152                 *pos = strm->next_in - zbuf+8;
153
154 gunzip_5:
155         free(strm->workspace);
156 gunzip_nomem4:
157         free(strm);
158 gunzip_nomem3:
159         if (!buf)
160                 free(zbuf);
161 gunzip_nomem2:
162         if (flush)
163                 free(out_buf);
164 gunzip_nomem1:
165         return rc; /* returns Z_OK (0) if successful */
166 }
167
168 #define decompress gunzip