1 | /* inflate.c -- zlib interface to inflate modules |
---|
2 | * Copyright (C) 1995-1998 Mark Adler |
---|
3 | * For conditions of distribution and use, see copyright notice in zlib.h |
---|
4 | */ |
---|
5 | |
---|
6 | #include "zutil.h" |
---|
7 | #include "infblock.h" |
---|
8 | |
---|
9 | struct inflate_blocks_state {int dummy;}; /* for buggy compilers */ |
---|
10 | |
---|
11 | typedef enum { |
---|
12 | METHOD, /* waiting for method byte */ |
---|
13 | FLAG, /* waiting for flag byte */ |
---|
14 | DICT4, /* four dictionary check bytes to go */ |
---|
15 | DICT3, /* three dictionary check bytes to go */ |
---|
16 | DICT2, /* two dictionary check bytes to go */ |
---|
17 | DICT1, /* one dictionary check byte to go */ |
---|
18 | DICT0, /* waiting for inflateSetDictionary */ |
---|
19 | BLOCKS, /* decompressing blocks */ |
---|
20 | CHECK4, /* four check bytes to go */ |
---|
21 | CHECK3, /* three check bytes to go */ |
---|
22 | CHECK2, /* two check bytes to go */ |
---|
23 | CHECK1, /* one check byte to go */ |
---|
24 | DONE, /* finished check, done */ |
---|
25 | BAD} /* got an error--stay here */ |
---|
26 | inflate_mode; |
---|
27 | |
---|
28 | /* inflate private state */ |
---|
29 | struct internal_state { |
---|
30 | |
---|
31 | /* mode */ |
---|
32 | inflate_mode mode; /* current inflate mode */ |
---|
33 | |
---|
34 | /* mode dependent information */ |
---|
35 | union { |
---|
36 | uInt method; /* if FLAGS, method byte */ |
---|
37 | struct { |
---|
38 | uLong was; /* computed check value */ |
---|
39 | uLong need; /* stream check value */ |
---|
40 | } check; /* if CHECK, check values to compare */ |
---|
41 | uInt marker; /* if BAD, inflateSync's marker bytes count */ |
---|
42 | } sub; /* submode */ |
---|
43 | |
---|
44 | /* mode independent information */ |
---|
45 | int nowrap; /* flag for no wrapper */ |
---|
46 | uInt wbits; /* log2(window size) (8..15, defaults to 15) */ |
---|
47 | inflate_blocks_statef |
---|
48 | *blocks; /* current inflate_blocks state */ |
---|
49 | |
---|
50 | }; |
---|
51 | |
---|
52 | |
---|
53 | int ZEXPORT inflateReset(z) |
---|
54 | z_streamp z; |
---|
55 | { |
---|
56 | if (z == Z_NULL || z->state == Z_NULL) |
---|
57 | return Z_STREAM_ERROR; |
---|
58 | z->total_in = z->total_out = 0; |
---|
59 | z->msg = Z_NULL; |
---|
60 | z->state->mode = z->state->nowrap ? BLOCKS : METHOD; |
---|
61 | inflate_blocks_reset(z->state->blocks, z, Z_NULL); |
---|
62 | Tracev((stderr, "inflate: reset\n")); |
---|
63 | return Z_OK; |
---|
64 | } |
---|
65 | |
---|
66 | |
---|
67 | int ZEXPORT inflateEnd(z) |
---|
68 | z_streamp z; |
---|
69 | { |
---|
70 | if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL) |
---|
71 | return Z_STREAM_ERROR; |
---|
72 | if (z->state->blocks != Z_NULL) |
---|
73 | inflate_blocks_free(z->state->blocks, z); |
---|
74 | ZFREE(z, z->state); |
---|
75 | z->state = Z_NULL; |
---|
76 | Tracev((stderr, "inflate: end\n")); |
---|
77 | return Z_OK; |
---|
78 | } |
---|
79 | |
---|
80 | |
---|
81 | int ZEXPORT inflateInit2_(z, w, version, stream_size) |
---|
82 | z_streamp z; |
---|
83 | int w; |
---|
84 | const char *version; |
---|
85 | int stream_size; |
---|
86 | { |
---|
87 | if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || |
---|
88 | stream_size != sizeof(z_stream)) |
---|
89 | return Z_VERSION_ERROR; |
---|
90 | |
---|
91 | /* initialize state */ |
---|
92 | if (z == Z_NULL) |
---|
93 | return Z_STREAM_ERROR; |
---|
94 | z->msg = Z_NULL; |
---|
95 | if (z->zalloc == Z_NULL) |
---|
96 | { |
---|
97 | z->zalloc = zcalloc; |
---|
98 | z->opaque = (voidpf)0; |
---|
99 | } |
---|
100 | if (z->zfree == Z_NULL) z->zfree = zcfree; |
---|
101 | if ((z->state = (struct internal_state FAR *) |
---|
102 | ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL) |
---|
103 | return Z_MEM_ERROR; |
---|
104 | z->state->blocks = Z_NULL; |
---|
105 | |
---|
106 | /* handle undocumented nowrap option (no zlib header or check) */ |
---|
107 | z->state->nowrap = 0; |
---|
108 | if (w < 0) |
---|
109 | { |
---|
110 | w = - w; |
---|
111 | z->state->nowrap = 1; |
---|
112 | } |
---|
113 | |
---|
114 | /* set window size */ |
---|
115 | if (w < 8 || w > 15) |
---|
116 | { |
---|
117 | inflateEnd(z); |
---|
118 | return Z_STREAM_ERROR; |
---|
119 | } |
---|
120 | z->state->wbits = (uInt)w; |
---|
121 | |
---|
122 | /* create inflate_blocks state */ |
---|
123 | if ((z->state->blocks = |
---|
124 | inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w)) |
---|
125 | == Z_NULL) |
---|
126 | { |
---|
127 | inflateEnd(z); |
---|
128 | return Z_MEM_ERROR; |
---|
129 | } |
---|
130 | Tracev((stderr, "inflate: allocated\n")); |
---|
131 | |
---|
132 | /* reset state */ |
---|
133 | inflateReset(z); |
---|
134 | return Z_OK; |
---|
135 | } |
---|
136 | |
---|
137 | |
---|
138 | int ZEXPORT inflateInit_(z, version, stream_size) |
---|
139 | z_streamp z; |
---|
140 | const char *version; |
---|
141 | int stream_size; |
---|
142 | { |
---|
143 | return inflateInit2_(z, DEF_WBITS, version, stream_size); |
---|
144 | } |
---|
145 | |
---|
146 | |
---|
147 | #define NEEDBYTE {if(z->avail_in==0)return r;r=f;} |
---|
148 | #define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++) |
---|
149 | |
---|
150 | int ZEXPORT inflate(z, f) |
---|
151 | z_streamp z; |
---|
152 | int f; |
---|
153 | { |
---|
154 | int r; |
---|
155 | uInt b; |
---|
156 | |
---|
157 | if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL) |
---|
158 | return Z_STREAM_ERROR; |
---|
159 | f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK; |
---|
160 | r = Z_BUF_ERROR; |
---|
161 | while (1) switch (z->state->mode) |
---|
162 | { |
---|
163 | case METHOD: |
---|
164 | NEEDBYTE |
---|
165 | if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED) |
---|
166 | { |
---|
167 | z->state->mode = BAD; |
---|
168 | z->msg = (char*)"unknown compression method"; |
---|
169 | z->state->sub.marker = 5; /* can't try inflateSync */ |
---|
170 | break; |
---|
171 | } |
---|
172 | if ((z->state->sub.method >> 4) + 8 > z->state->wbits) |
---|
173 | { |
---|
174 | z->state->mode = BAD; |
---|
175 | z->msg = (char*)"invalid window size"; |
---|
176 | z->state->sub.marker = 5; /* can't try inflateSync */ |
---|
177 | break; |
---|
178 | } |
---|
179 | z->state->mode = FLAG; |
---|
180 | case FLAG: |
---|
181 | NEEDBYTE |
---|
182 | b = NEXTBYTE; |
---|
183 | if (((z->state->sub.method << 8) + b) % 31) |
---|
184 | { |
---|
185 | z->state->mode = BAD; |
---|
186 | z->msg = (char*)"incorrect header check"; |
---|
187 | z->state->sub.marker = 5; /* can't try inflateSync */ |
---|
188 | break; |
---|
189 | } |
---|
190 | Tracev((stderr, "inflate: zlib header ok\n")); |
---|
191 | if (!(b & PRESET_DICT)) |
---|
192 | { |
---|
193 | z->state->mode = BLOCKS; |
---|
194 | break; |
---|
195 | } |
---|
196 | z->state->mode = DICT4; |
---|
197 | case DICT4: |
---|
198 | NEEDBYTE |
---|
199 | z->state->sub.check.need = (uLong)NEXTBYTE << 24; |
---|
200 | z->state->mode = DICT3; |
---|
201 | case DICT3: |
---|
202 | NEEDBYTE |
---|
203 | z->state->sub.check.need += (uLong)NEXTBYTE << 16; |
---|
204 | z->state->mode = DICT2; |
---|
205 | case DICT2: |
---|
206 | NEEDBYTE |
---|
207 | z->state->sub.check.need += (uLong)NEXTBYTE << 8; |
---|
208 | z->state->mode = DICT1; |
---|
209 | case DICT1: |
---|
210 | NEEDBYTE |
---|
211 | z->state->sub.check.need += (uLong)NEXTBYTE; |
---|
212 | z->adler = z->state->sub.check.need; |
---|
213 | z->state->mode = DICT0; |
---|
214 | return Z_NEED_DICT; |
---|
215 | case DICT0: |
---|
216 | z->state->mode = BAD; |
---|
217 | z->msg = (char*)"need dictionary"; |
---|
218 | z->state->sub.marker = 0; /* can try inflateSync */ |
---|
219 | return Z_STREAM_ERROR; |
---|
220 | case BLOCKS: |
---|
221 | r = inflate_blocks(z->state->blocks, z, r); |
---|
222 | if (r == Z_DATA_ERROR) |
---|
223 | { |
---|
224 | z->state->mode = BAD; |
---|
225 | z->state->sub.marker = 0; /* can try inflateSync */ |
---|
226 | break; |
---|
227 | } |
---|
228 | if (r == Z_OK) |
---|
229 | r = f; |
---|
230 | if (r != Z_STREAM_END) |
---|
231 | return r; |
---|
232 | r = f; |
---|
233 | inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was); |
---|
234 | if (z->state->nowrap) |
---|
235 | { |
---|
236 | z->state->mode = DONE; |
---|
237 | break; |
---|
238 | } |
---|
239 | z->state->mode = CHECK4; |
---|
240 | case CHECK4: |
---|
241 | NEEDBYTE |
---|
242 | z->state->sub.check.need = (uLong)NEXTBYTE << 24; |
---|
243 | z->state->mode = CHECK3; |
---|
244 | case CHECK3: |
---|
245 | NEEDBYTE |
---|
246 | z->state->sub.check.need += (uLong)NEXTBYTE << 16; |
---|
247 | z->state->mode = CHECK2; |
---|
248 | case CHECK2: |
---|
249 | NEEDBYTE |
---|
250 | z->state->sub.check.need += (uLong)NEXTBYTE << 8; |
---|
251 | z->state->mode = CHECK1; |
---|
252 | case CHECK1: |
---|
253 | NEEDBYTE |
---|
254 | z->state->sub.check.need += (uLong)NEXTBYTE; |
---|
255 | |
---|
256 | if (z->state->sub.check.was != z->state->sub.check.need) |
---|
257 | { |
---|
258 | z->state->mode = BAD; |
---|
259 | z->msg = (char*)"incorrect data check"; |
---|
260 | z->state->sub.marker = 5; /* can't try inflateSync */ |
---|
261 | break; |
---|
262 | } |
---|
263 | Tracev((stderr, "inflate: zlib check ok\n")); |
---|
264 | z->state->mode = DONE; |
---|
265 | case DONE: |
---|
266 | return Z_STREAM_END; |
---|
267 | case BAD: |
---|
268 | return Z_DATA_ERROR; |
---|
269 | default: |
---|
270 | return Z_STREAM_ERROR; |
---|
271 | } |
---|
272 | #ifdef NEED_DUMMY_RETURN |
---|
273 | return Z_STREAM_ERROR; /* Some dumb compilers complain without this */ |
---|
274 | #endif |
---|
275 | } |
---|
276 | |
---|
277 | |
---|
278 | int ZEXPORT inflateSetDictionary(z, dictionary, dictLength) |
---|
279 | z_streamp z; |
---|
280 | const Bytef *dictionary; |
---|
281 | uInt dictLength; |
---|
282 | { |
---|
283 | uInt length = dictLength; |
---|
284 | |
---|
285 | if (z == Z_NULL || z->state == Z_NULL || z->state->mode != DICT0) |
---|
286 | return Z_STREAM_ERROR; |
---|
287 | |
---|
288 | if (adler32(1L, dictionary, dictLength) != z->adler) return Z_DATA_ERROR; |
---|
289 | z->adler = 1L; |
---|
290 | |
---|
291 | if (length >= ((uInt)1<<z->state->wbits)) |
---|
292 | { |
---|
293 | length = (1<<z->state->wbits)-1; |
---|
294 | dictionary += dictLength - length; |
---|
295 | } |
---|
296 | inflate_set_dictionary(z->state->blocks, dictionary, length); |
---|
297 | z->state->mode = BLOCKS; |
---|
298 | return Z_OK; |
---|
299 | } |
---|
300 | |
---|
301 | |
---|
302 | int ZEXPORT inflateSync(z) |
---|
303 | z_streamp z; |
---|
304 | { |
---|
305 | uInt n; /* number of bytes to look at */ |
---|
306 | Bytef *p; /* pointer to bytes */ |
---|
307 | uInt m; /* number of marker bytes found in a row */ |
---|
308 | uLong r, w; /* temporaries to save total_in and total_out */ |
---|
309 | |
---|
310 | /* set up */ |
---|
311 | if (z == Z_NULL || z->state == Z_NULL) |
---|
312 | return Z_STREAM_ERROR; |
---|
313 | if (z->state->mode != BAD) |
---|
314 | { |
---|
315 | z->state->mode = BAD; |
---|
316 | z->state->sub.marker = 0; |
---|
317 | } |
---|
318 | if ((n = z->avail_in) == 0) |
---|
319 | return Z_BUF_ERROR; |
---|
320 | p = z->next_in; |
---|
321 | m = z->state->sub.marker; |
---|
322 | |
---|
323 | /* search */ |
---|
324 | while (n && m < 4) |
---|
325 | { |
---|
326 | static const Byte mark[4] = {0, 0, 0xff, 0xff}; |
---|
327 | if (*p == mark[m]) |
---|
328 | m++; |
---|
329 | else if (*p) |
---|
330 | m = 0; |
---|
331 | else |
---|
332 | m = 4 - m; |
---|
333 | p++, n--; |
---|
334 | } |
---|
335 | |
---|
336 | /* restore */ |
---|
337 | z->total_in += p - z->next_in; |
---|
338 | z->next_in = p; |
---|
339 | z->avail_in = n; |
---|
340 | z->state->sub.marker = m; |
---|
341 | |
---|
342 | /* return no joy or set up to restart on a new block */ |
---|
343 | if (m != 4) |
---|
344 | return Z_DATA_ERROR; |
---|
345 | r = z->total_in; w = z->total_out; |
---|
346 | inflateReset(z); |
---|
347 | z->total_in = r; z->total_out = w; |
---|
348 | z->state->mode = BLOCKS; |
---|
349 | return Z_OK; |
---|
350 | } |
---|
351 | |
---|
352 | |
---|
353 | /* Returns true if inflate is currently at the end of a block generated |
---|
354 | * by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP |
---|
355 | * implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH |
---|
356 | * but removes the length bytes of the resulting empty stored block. When |
---|
357 | * decompressing, PPP checks that at the end of input packet, inflate is |
---|
358 | * waiting for these length bytes. |
---|
359 | */ |
---|
360 | int ZEXPORT inflateSyncPoint(z) |
---|
361 | z_streamp z; |
---|
362 | { |
---|
363 | if (z == Z_NULL || z->state == Z_NULL || z->state->blocks == Z_NULL) |
---|
364 | return Z_STREAM_ERROR; |
---|
365 | return inflate_blocks_sync_point(z->state->blocks); |
---|
366 | } |
---|