line |
stmt |
bran |
cond |
sub |
time |
code |
1
|
|
|
|
|
|
/* inflate.c -- zlib decompression |
2
|
|
|
|
|
|
* Copyright (C) 1995-2012 Mark Adler |
3
|
|
|
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h |
4
|
|
|
|
|
|
*/ |
5
|
|
|
|
|
|
|
6
|
|
|
|
|
|
/* |
7
|
|
|
|
|
|
* Change history: |
8
|
|
|
|
|
|
* |
9
|
|
|
|
|
|
* 1.2.beta0 24 Nov 2002 |
10
|
|
|
|
|
|
* - First version -- complete rewrite of inflate to simplify code, avoid |
11
|
|
|
|
|
|
* creation of window when not needed, minimize use of window when it is |
12
|
|
|
|
|
|
* needed, make inffast.c even faster, implement gzip decoding, and to |
13
|
|
|
|
|
|
* improve code readability and style over the previous zlib inflate code |
14
|
|
|
|
|
|
* |
15
|
|
|
|
|
|
* 1.2.beta1 25 Nov 2002 |
16
|
|
|
|
|
|
* - Use pointers for available input and output checking in inffast.c |
17
|
|
|
|
|
|
* - Remove input and output counters in inffast.c |
18
|
|
|
|
|
|
* - Change inffast.c entry and loop from avail_in >= 7 to >= 6 |
19
|
|
|
|
|
|
* - Remove unnecessary second byte pull from length extra in inffast.c |
20
|
|
|
|
|
|
* - Unroll direct copy to three copies per loop in inffast.c |
21
|
|
|
|
|
|
* |
22
|
|
|
|
|
|
* 1.2.beta2 4 Dec 2002 |
23
|
|
|
|
|
|
* - Change external routine names to reduce potential conflicts |
24
|
|
|
|
|
|
* - Correct filename to inffixed.h for fixed tables in inflate.c |
25
|
|
|
|
|
|
* - Make hbuf[] unsigned char to match parameter type in inflate.c |
26
|
|
|
|
|
|
* - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) |
27
|
|
|
|
|
|
* to avoid negation problem on Alphas (64 bit) in inflate.c |
28
|
|
|
|
|
|
* |
29
|
|
|
|
|
|
* 1.2.beta3 22 Dec 2002 |
30
|
|
|
|
|
|
* - Add comments on state->bits assertion in inffast.c |
31
|
|
|
|
|
|
* - Add comments on op field in inftrees.h |
32
|
|
|
|
|
|
* - Fix bug in reuse of allocated window after inflateReset() |
33
|
|
|
|
|
|
* - Remove bit fields--back to byte structure for speed |
34
|
|
|
|
|
|
* - Remove distance extra == 0 check in inflate_fast()--only helps for lengths |
35
|
|
|
|
|
|
* - Change post-increments to pre-increments in inflate_fast(), PPC biased? |
36
|
|
|
|
|
|
* - Add compile time option, POSTINC, to use post-increments instead (Intel?) |
37
|
|
|
|
|
|
* - Make MATCH copy in inflate() much faster for when inflate_fast() not used |
38
|
|
|
|
|
|
* - Use local copies of stream next and avail values, as well as local bit |
39
|
|
|
|
|
|
* buffer and bit count in inflate()--for speed when inflate_fast() not used |
40
|
|
|
|
|
|
* |
41
|
|
|
|
|
|
* 1.2.beta4 1 Jan 2003 |
42
|
|
|
|
|
|
* - Split ptr - 257 statements in inflate_table() to avoid compiler warnings |
43
|
|
|
|
|
|
* - Move a comment on output buffer sizes from inffast.c to inflate.c |
44
|
|
|
|
|
|
* - Add comments in inffast.c to introduce the inflate_fast() routine |
45
|
|
|
|
|
|
* - Rearrange window copies in inflate_fast() for speed and simplification |
46
|
|
|
|
|
|
* - Unroll last copy for window match in inflate_fast() |
47
|
|
|
|
|
|
* - Use local copies of window variables in inflate_fast() for speed |
48
|
|
|
|
|
|
* - Pull out common wnext == 0 case for speed in inflate_fast() |
49
|
|
|
|
|
|
* - Make op and len in inflate_fast() unsigned for consistency |
50
|
|
|
|
|
|
* - Add FAR to lcode and dcode declarations in inflate_fast() |
51
|
|
|
|
|
|
* - Simplified bad distance check in inflate_fast() |
52
|
|
|
|
|
|
* - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new |
53
|
|
|
|
|
|
* source file infback.c to provide a call-back interface to inflate for |
54
|
|
|
|
|
|
* programs like gzip and unzip -- uses window as output buffer to avoid |
55
|
|
|
|
|
|
* window copying |
56
|
|
|
|
|
|
* |
57
|
|
|
|
|
|
* 1.2.beta5 1 Jan 2003 |
58
|
|
|
|
|
|
* - Improved inflateBack() interface to allow the caller to provide initial |
59
|
|
|
|
|
|
* input in strm. |
60
|
|
|
|
|
|
* - Fixed stored blocks bug in inflateBack() |
61
|
|
|
|
|
|
* |
62
|
|
|
|
|
|
* 1.2.beta6 4 Jan 2003 |
63
|
|
|
|
|
|
* - Added comments in inffast.c on effectiveness of POSTINC |
64
|
|
|
|
|
|
* - Typecasting all around to reduce compiler warnings |
65
|
|
|
|
|
|
* - Changed loops from while (1) or do {} while (1) to for (;;), again to |
66
|
|
|
|
|
|
* make compilers happy |
67
|
|
|
|
|
|
* - Changed type of window in inflateBackInit() to unsigned char * |
68
|
|
|
|
|
|
* |
69
|
|
|
|
|
|
* 1.2.beta7 27 Jan 2003 |
70
|
|
|
|
|
|
* - Changed many types to unsigned or unsigned short to avoid warnings |
71
|
|
|
|
|
|
* - Added inflateCopy() function |
72
|
|
|
|
|
|
* |
73
|
|
|
|
|
|
* 1.2.0 9 Mar 2003 |
74
|
|
|
|
|
|
* - Changed inflateBack() interface to provide separate opaque descriptors |
75
|
|
|
|
|
|
* for the in() and out() functions |
76
|
|
|
|
|
|
* - Changed inflateBack() argument and in_func typedef to swap the length |
77
|
|
|
|
|
|
* and buffer address return values for the input function |
78
|
|
|
|
|
|
* - Check next_in and next_out for Z_NULL on entry to inflate() |
79
|
|
|
|
|
|
* |
80
|
|
|
|
|
|
* The history for versions after 1.2.0 are in ChangeLog in zlib distribution. |
81
|
|
|
|
|
|
*/ |
82
|
|
|
|
|
|
|
83
|
|
|
|
|
|
#include "zutil.h" |
84
|
|
|
|
|
|
#include "inftrees.h" |
85
|
|
|
|
|
|
#include "inflate.h" |
86
|
|
|
|
|
|
#include "inffast.h" |
87
|
|
|
|
|
|
|
88
|
|
|
|
|
|
#ifdef MAKEFIXED |
89
|
|
|
|
|
|
# ifndef BUILDFIXED |
90
|
|
|
|
|
|
# define BUILDFIXED |
91
|
|
|
|
|
|
# endif |
92
|
|
|
|
|
|
#endif |
93
|
|
|
|
|
|
|
94
|
|
|
|
|
|
/* function prototypes */ |
95
|
|
|
|
|
|
local void fixedtables OF((struct inflate_state FAR *state)); |
96
|
|
|
|
|
|
local int updatewindow OF((z_streamp strm, const unsigned char FAR *end, |
97
|
|
|
|
|
|
unsigned copy)); |
98
|
|
|
|
|
|
#ifdef BUILDFIXED |
99
|
|
|
|
|
|
void makefixed OF((void)); |
100
|
|
|
|
|
|
#endif |
101
|
|
|
|
|
|
local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf, |
102
|
|
|
|
|
|
unsigned len)); |
103
|
|
|
|
|
|
|
104
|
24772
|
|
|
|
|
int ZEXPORT inflateResetKeep( |
105
|
|
|
|
|
|
z_streamp strm) |
106
|
|
|
|
|
|
{ |
107
|
|
|
|
|
|
struct inflate_state FAR *state; |
108
|
|
|
|
|
|
|
109
|
24772
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
110
|
24772
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
111
|
24772
|
|
|
|
|
strm->total_in = strm->total_out = state->total = 0; |
112
|
24772
|
|
|
|
|
strm->msg = Z_NULL; |
113
|
24772
|
|
|
|
|
if (state->wrap) /* to support ill-conceived Java test suite */ |
114
|
144
|
|
|
|
|
strm->adler = state->wrap & 1; |
115
|
24772
|
|
|
|
|
state->mode = HEAD; |
116
|
24772
|
|
|
|
|
state->last = 0; |
117
|
24772
|
|
|
|
|
state->havedict = 0; |
118
|
24772
|
|
|
|
|
state->dmax = 32768U; |
119
|
24772
|
|
|
|
|
state->head = Z_NULL; |
120
|
24772
|
|
|
|
|
state->hold = 0; |
121
|
24772
|
|
|
|
|
state->bits = 0; |
122
|
24772
|
|
|
|
|
state->lencode = state->distcode = state->next = state->codes; |
123
|
24772
|
|
|
|
|
state->sane = 1; |
124
|
24772
|
|
|
|
|
state->back = -1; |
125
|
|
|
|
|
|
Tracev((stderr, "inflate: reset\n")); |
126
|
24772
|
|
|
|
|
return Z_OK; |
127
|
|
|
|
|
|
} |
128
|
|
|
|
|
|
|
129
|
24772
|
|
|
|
|
int ZEXPORT inflateReset( |
130
|
|
|
|
|
|
z_streamp strm) |
131
|
|
|
|
|
|
{ |
132
|
|
|
|
|
|
struct inflate_state FAR *state; |
133
|
|
|
|
|
|
|
134
|
24772
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
135
|
24772
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
136
|
24772
|
|
|
|
|
state->wsize = 0; |
137
|
24772
|
|
|
|
|
state->whave = 0; |
138
|
24772
|
|
|
|
|
state->wnext = 0; |
139
|
24772
|
|
|
|
|
return inflateResetKeep(strm); |
140
|
|
|
|
|
|
} |
141
|
|
|
|
|
|
|
142
|
19456
|
|
|
|
|
int ZEXPORT inflateReset2( |
143
|
|
|
|
|
|
z_streamp strm, |
144
|
|
|
|
|
|
int windowBits) |
145
|
|
|
|
|
|
{ |
146
|
|
|
|
|
|
int wrap; |
147
|
|
|
|
|
|
struct inflate_state FAR *state; |
148
|
|
|
|
|
|
|
149
|
|
|
|
|
|
/* get the state */ |
150
|
19456
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
151
|
19456
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
152
|
|
|
|
|
|
|
153
|
|
|
|
|
|
/* extract wrap request from windowBits parameter */ |
154
|
19456
|
|
|
|
|
if (windowBits < 0) { |
155
|
|
|
|
|
|
wrap = 0; |
156
|
19320
|
|
|
|
|
windowBits = -windowBits; |
157
|
|
|
|
|
|
} |
158
|
|
|
|
|
|
else { |
159
|
136
|
|
|
|
|
wrap = (windowBits >> 4) + 1; |
160
|
|
|
|
|
|
#ifdef GUNZIP |
161
|
136
|
|
|
|
|
if (windowBits < 48) |
162
|
136
|
|
|
|
|
windowBits &= 15; |
163
|
|
|
|
|
|
#endif |
164
|
|
|
|
|
|
} |
165
|
|
|
|
|
|
|
166
|
|
|
|
|
|
/* set number of window bits, free window if different */ |
167
|
19456
|
|
|
|
|
if (windowBits && (windowBits < 8 || windowBits > 15)) |
168
|
|
|
|
|
|
return Z_STREAM_ERROR; |
169
|
19456
|
|
|
|
|
if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { |
170
|
0
|
|
|
|
|
ZFREE(strm, state->window); |
171
|
0
|
|
|
|
|
state->window = Z_NULL; |
172
|
|
|
|
|
|
} |
173
|
|
|
|
|
|
|
174
|
|
|
|
|
|
/* update state and reset the rest of it */ |
175
|
19456
|
|
|
|
|
state->wrap = wrap; |
176
|
19456
|
|
|
|
|
state->wbits = (unsigned)windowBits; |
177
|
19456
|
|
|
|
|
return inflateReset(strm); |
178
|
|
|
|
|
|
} |
179
|
|
|
|
|
|
|
180
|
19456
|
|
|
|
|
int ZEXPORT inflateInit2_( |
181
|
|
|
|
|
|
z_streamp strm, |
182
|
|
|
|
|
|
int windowBits, |
183
|
|
|
|
|
|
const char *version, |
184
|
|
|
|
|
|
int stream_size) |
185
|
|
|
|
|
|
{ |
186
|
|
|
|
|
|
int ret; |
187
|
|
|
|
|
|
struct inflate_state FAR *state; |
188
|
|
|
|
|
|
|
189
|
38912
|
|
|
|
|
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || |
190
|
19456
|
|
|
|
|
stream_size != (int)(sizeof(z_stream))) |
191
|
|
|
|
|
|
return Z_VERSION_ERROR; |
192
|
19456
|
|
|
|
|
if (strm == Z_NULL) return Z_STREAM_ERROR; |
193
|
19456
|
|
|
|
|
strm->msg = Z_NULL; /* in case we return an error */ |
194
|
19456
|
|
|
|
|
if (strm->zalloc == (alloc_func)0) { |
195
|
|
|
|
|
|
#ifdef Z_SOLO |
196
|
|
|
|
|
|
return Z_STREAM_ERROR; |
197
|
|
|
|
|
|
#else |
198
|
|
|
|
|
|
strm->zalloc = zcalloc; |
199
|
|
|
|
|
|
strm->opaque = (voidpf)0; |
200
|
|
|
|
|
|
#endif |
201
|
|
|
|
|
|
} |
202
|
19456
|
|
|
|
|
if (strm->zfree == (free_func)0) |
203
|
|
|
|
|
|
#ifdef Z_SOLO |
204
|
|
|
|
|
|
return Z_STREAM_ERROR; |
205
|
|
|
|
|
|
#else |
206
|
|
|
|
|
|
strm->zfree = zcfree; |
207
|
|
|
|
|
|
#endif |
208
|
19456
|
|
|
|
|
state = (struct inflate_state FAR *) |
209
|
19456
|
|
|
|
|
ZALLOC(strm, 1, sizeof(struct inflate_state)); |
210
|
19456
|
|
|
|
|
if (state == Z_NULL) return Z_MEM_ERROR; |
211
|
|
|
|
|
|
Tracev((stderr, "inflate: allocated\n")); |
212
|
19456
|
|
|
|
|
strm->state = (struct internal_state FAR *)state; |
213
|
19456
|
|
|
|
|
state->window = Z_NULL; |
214
|
19456
|
|
|
|
|
ret = inflateReset2(strm, windowBits); |
215
|
19456
|
|
|
|
|
if (ret != Z_OK) { |
216
|
0
|
|
|
|
|
ZFREE(strm, state); |
217
|
0
|
|
|
|
|
strm->state = Z_NULL; |
218
|
|
|
|
|
|
} |
219
|
|
|
|
|
|
return ret; |
220
|
|
|
|
|
|
} |
221
|
|
|
|
|
|
|
222
|
0
|
|
|
|
|
int ZEXPORT inflateInit_( |
223
|
|
|
|
|
|
z_streamp strm, |
224
|
|
|
|
|
|
const char *version, |
225
|
|
|
|
|
|
int stream_size) |
226
|
|
|
|
|
|
{ |
227
|
0
|
|
|
|
|
return inflateInit2_(strm, DEF_WBITS, version, stream_size); |
228
|
|
|
|
|
|
} |
229
|
|
|
|
|
|
|
230
|
0
|
|
|
|
|
int ZEXPORT inflatePrime( |
231
|
|
|
|
|
|
z_streamp strm, |
232
|
|
|
|
|
|
int bits, |
233
|
|
|
|
|
|
int value) |
234
|
|
|
|
|
|
{ |
235
|
|
|
|
|
|
struct inflate_state FAR *state; |
236
|
|
|
|
|
|
|
237
|
0
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
238
|
0
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
239
|
0
|
|
|
|
|
if (bits < 0) { |
240
|
0
|
|
|
|
|
state->hold = 0; |
241
|
0
|
|
|
|
|
state->bits = 0; |
242
|
0
|
|
|
|
|
return Z_OK; |
243
|
|
|
|
|
|
} |
244
|
0
|
|
|
|
|
if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; |
245
|
0
|
|
|
|
|
value &= (1L << bits) - 1; |
246
|
0
|
|
|
|
|
state->hold += value << state->bits; |
247
|
0
|
|
|
|
|
state->bits += bits; |
248
|
0
|
|
|
|
|
return Z_OK; |
249
|
|
|
|
|
|
} |
250
|
|
|
|
|
|
|
251
|
|
|
|
|
|
/* |
252
|
|
|
|
|
|
Return state with length and distance decoding tables and index sizes set to |
253
|
|
|
|
|
|
fixed code decoding. Normally this returns fixed tables from inffixed.h. |
254
|
|
|
|
|
|
If BUILDFIXED is defined, then instead this routine builds the tables the |
255
|
|
|
|
|
|
first time it's called, and returns those tables the first time and |
256
|
|
|
|
|
|
thereafter. This reduces the size of the code by about 2K bytes, in |
257
|
|
|
|
|
|
exchange for a little execution time. However, BUILDFIXED should not be |
258
|
|
|
|
|
|
used for threaded applications, since the rewriting of the tables and virgin |
259
|
|
|
|
|
|
may not be thread-safe. |
260
|
|
|
|
|
|
*/ |
261
|
|
|
|
|
|
local void fixedtables( |
262
|
|
|
|
|
|
struct inflate_state FAR *state) |
263
|
|
|
|
|
|
{ |
264
|
|
|
|
|
|
#ifdef BUILDFIXED |
265
|
|
|
|
|
|
static int virgin = 1; |
266
|
|
|
|
|
|
static code *lenfix, *distfix; |
267
|
|
|
|
|
|
static code fixed[544]; |
268
|
|
|
|
|
|
|
269
|
|
|
|
|
|
/* build fixed huffman tables if first call (may not be thread safe) */ |
270
|
|
|
|
|
|
if (virgin) { |
271
|
|
|
|
|
|
unsigned sym, bits; |
272
|
|
|
|
|
|
static code *next; |
273
|
|
|
|
|
|
|
274
|
|
|
|
|
|
/* literal/length table */ |
275
|
|
|
|
|
|
sym = 0; |
276
|
|
|
|
|
|
while (sym < 144) state->lens[sym++] = 8; |
277
|
|
|
|
|
|
while (sym < 256) state->lens[sym++] = 9; |
278
|
|
|
|
|
|
while (sym < 280) state->lens[sym++] = 7; |
279
|
|
|
|
|
|
while (sym < 288) state->lens[sym++] = 8; |
280
|
|
|
|
|
|
next = fixed; |
281
|
|
|
|
|
|
lenfix = next; |
282
|
|
|
|
|
|
bits = 9; |
283
|
|
|
|
|
|
inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); |
284
|
|
|
|
|
|
|
285
|
|
|
|
|
|
/* distance table */ |
286
|
|
|
|
|
|
sym = 0; |
287
|
|
|
|
|
|
while (sym < 32) state->lens[sym++] = 5; |
288
|
|
|
|
|
|
distfix = next; |
289
|
|
|
|
|
|
bits = 5; |
290
|
|
|
|
|
|
inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); |
291
|
|
|
|
|
|
|
292
|
|
|
|
|
|
/* do this just once */ |
293
|
|
|
|
|
|
virgin = 0; |
294
|
|
|
|
|
|
} |
295
|
|
|
|
|
|
#else /* !BUILDFIXED */ |
296
|
|
|
|
|
|
# include "inffixed.h" |
297
|
|
|
|
|
|
#endif /* BUILDFIXED */ |
298
|
6678
|
|
|
|
|
state->lencode = lenfix; |
299
|
6678
|
|
|
|
|
state->lenbits = 9; |
300
|
6678
|
|
|
|
|
state->distcode = distfix; |
301
|
6678
|
|
|
|
|
state->distbits = 5; |
302
|
|
|
|
|
|
} |
303
|
|
|
|
|
|
|
304
|
|
|
|
|
|
#ifdef MAKEFIXED |
305
|
|
|
|
|
|
#include |
306
|
|
|
|
|
|
|
307
|
|
|
|
|
|
/* |
308
|
|
|
|
|
|
Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also |
309
|
|
|
|
|
|
defines BUILDFIXED, so the tables are built on the fly. makefixed() writes |
310
|
|
|
|
|
|
those tables to stdout, which would be piped to inffixed.h. A small program |
311
|
|
|
|
|
|
can simply call makefixed to do this: |
312
|
|
|
|
|
|
|
313
|
|
|
|
|
|
void makefixed(void); |
314
|
|
|
|
|
|
|
315
|
|
|
|
|
|
int main(void) |
316
|
|
|
|
|
|
{ |
317
|
|
|
|
|
|
makefixed(); |
318
|
|
|
|
|
|
return 0; |
319
|
|
|
|
|
|
} |
320
|
|
|
|
|
|
|
321
|
|
|
|
|
|
Then that can be linked with zlib built with MAKEFIXED defined and run: |
322
|
|
|
|
|
|
|
323
|
|
|
|
|
|
a.out > inffixed.h |
324
|
|
|
|
|
|
*/ |
325
|
|
|
|
|
|
void makefixed() |
326
|
|
|
|
|
|
{ |
327
|
|
|
|
|
|
unsigned low, size; |
328
|
|
|
|
|
|
struct inflate_state state; |
329
|
|
|
|
|
|
|
330
|
|
|
|
|
|
fixedtables(&state); |
331
|
|
|
|
|
|
puts(" /* inffixed.h -- table for decoding fixed codes"); |
332
|
|
|
|
|
|
puts(" * Generated automatically by makefixed()."); |
333
|
|
|
|
|
|
puts(" */"); |
334
|
|
|
|
|
|
puts(""); |
335
|
|
|
|
|
|
puts(" /* WARNING: this file should *not* be used by applications."); |
336
|
|
|
|
|
|
puts(" It is part of the implementation of this library and is"); |
337
|
|
|
|
|
|
puts(" subject to change. Applications should only use zlib.h."); |
338
|
|
|
|
|
|
puts(" */"); |
339
|
|
|
|
|
|
puts(""); |
340
|
|
|
|
|
|
size = 1U << 9; |
341
|
|
|
|
|
|
printf(" static const code lenfix[%u] = {", size); |
342
|
|
|
|
|
|
low = 0; |
343
|
|
|
|
|
|
for (;;) { |
344
|
|
|
|
|
|
if ((low % 7) == 0) printf("\n "); |
345
|
|
|
|
|
|
printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, |
346
|
|
|
|
|
|
state.lencode[low].bits, state.lencode[low].val); |
347
|
|
|
|
|
|
if (++low == size) break; |
348
|
|
|
|
|
|
putchar(','); |
349
|
|
|
|
|
|
} |
350
|
|
|
|
|
|
puts("\n };"); |
351
|
|
|
|
|
|
size = 1U << 5; |
352
|
|
|
|
|
|
printf("\n static const code distfix[%u] = {", size); |
353
|
|
|
|
|
|
low = 0; |
354
|
|
|
|
|
|
for (;;) { |
355
|
|
|
|
|
|
if ((low % 6) == 0) printf("\n "); |
356
|
|
|
|
|
|
printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, |
357
|
|
|
|
|
|
state.distcode[low].val); |
358
|
|
|
|
|
|
if (++low == size) break; |
359
|
|
|
|
|
|
putchar(','); |
360
|
|
|
|
|
|
} |
361
|
|
|
|
|
|
puts("\n };"); |
362
|
|
|
|
|
|
} |
363
|
|
|
|
|
|
#endif /* MAKEFIXED */ |
364
|
|
|
|
|
|
|
365
|
|
|
|
|
|
/* |
366
|
|
|
|
|
|
Update the window with the last wsize (normally 32K) bytes written before |
367
|
|
|
|
|
|
returning. If window does not exist yet, create it. This is only called |
368
|
|
|
|
|
|
when a window is already in use, or when output has been written during this |
369
|
|
|
|
|
|
inflate call, but the end of the deflate stream has not been reached yet. |
370
|
|
|
|
|
|
It is also called to create a window for dictionary data when a dictionary |
371
|
|
|
|
|
|
is loaded. |
372
|
|
|
|
|
|
|
373
|
|
|
|
|
|
Providing output buffers larger than 32K to inflate() should provide a speed |
374
|
|
|
|
|
|
advantage, since only the last 32K of output is copied to the sliding window |
375
|
|
|
|
|
|
upon return from inflate(), and since all distances after the first 32K of |
376
|
|
|
|
|
|
output will fall in the output data, making match copies simpler and faster. |
377
|
|
|
|
|
|
The advantage may be dependent on the size of the processor's data caches. |
378
|
|
|
|
|
|
*/ |
379
|
347980
|
|
|
|
|
local int updatewindow( |
380
|
|
|
|
|
|
z_streamp strm, |
381
|
|
|
|
|
|
const Bytef *end, |
382
|
|
|
|
|
|
unsigned copy) |
383
|
|
|
|
|
|
{ |
384
|
|
|
|
|
|
struct inflate_state FAR *state; |
385
|
|
|
|
|
|
unsigned dist; |
386
|
|
|
|
|
|
|
387
|
347980
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
388
|
|
|
|
|
|
|
389
|
|
|
|
|
|
/* if it hasn't been done already, allocate space for the window */ |
390
|
347980
|
|
|
|
|
if (state->window == Z_NULL) { |
391
|
14954
|
|
|
|
|
state->window = (unsigned char FAR *) |
392
|
14954
|
|
|
|
|
ZALLOC(strm, 1U << state->wbits, |
393
|
|
|
|
|
|
sizeof(unsigned char)); |
394
|
14954
|
|
|
|
|
if (state->window == Z_NULL) return 1; |
395
|
|
|
|
|
|
} |
396
|
|
|
|
|
|
|
397
|
|
|
|
|
|
/* if window not in use yet, initialize */ |
398
|
347980
|
|
|
|
|
if (state->wsize == 0) { |
399
|
15966
|
|
|
|
|
state->wsize = 1U << state->wbits; |
400
|
15966
|
|
|
|
|
state->wnext = 0; |
401
|
15966
|
|
|
|
|
state->whave = 0; |
402
|
|
|
|
|
|
} |
403
|
|
|
|
|
|
|
404
|
|
|
|
|
|
/* copy state->wsize or less output bytes into the circular window */ |
405
|
347980
|
|
|
|
|
if (copy >= state->wsize) { |
406
|
12
|
|
|
|
|
zmemcpy(state->window, end - state->wsize, state->wsize); |
407
|
12
|
|
|
|
|
state->wnext = 0; |
408
|
12
|
|
|
|
|
state->whave = state->wsize; |
409
|
|
|
|
|
|
} |
410
|
|
|
|
|
|
else { |
411
|
347968
|
|
|
|
|
dist = state->wsize - state->wnext; |
412
|
347968
|
|
|
|
|
if (dist > copy) dist = copy; |
413
|
347968
|
|
|
|
|
zmemcpy(state->window + state->wnext, end - copy, dist); |
414
|
347968
|
|
|
|
|
copy -= dist; |
415
|
347968
|
|
|
|
|
if (copy) { |
416
|
580
|
|
|
|
|
zmemcpy(state->window, end - copy, copy); |
417
|
580
|
|
|
|
|
state->wnext = copy; |
418
|
580
|
|
|
|
|
state->whave = state->wsize; |
419
|
|
|
|
|
|
} |
420
|
|
|
|
|
|
else { |
421
|
347388
|
|
|
|
|
state->wnext += dist; |
422
|
347388
|
|
|
|
|
if (state->wnext == state->wsize) state->wnext = 0; |
423
|
347388
|
|
|
|
|
if (state->whave < state->wsize) state->whave += dist; |
424
|
|
|
|
|
|
} |
425
|
|
|
|
|
|
} |
426
|
|
|
|
|
|
return 0; |
427
|
|
|
|
|
|
} |
428
|
|
|
|
|
|
|
429
|
|
|
|
|
|
/* Macros for inflate(): */ |
430
|
|
|
|
|
|
|
431
|
|
|
|
|
|
/* check function to use adler32() for zlib or crc32() for gzip */ |
432
|
|
|
|
|
|
#ifdef GUNZIP |
433
|
|
|
|
|
|
# define UPDATE(check, buf, len) \ |
434
|
|
|
|
|
|
(state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) |
435
|
|
|
|
|
|
#else |
436
|
|
|
|
|
|
# define UPDATE(check, buf, len) adler32(check, buf, len) |
437
|
|
|
|
|
|
#endif |
438
|
|
|
|
|
|
|
439
|
|
|
|
|
|
/* check macros for header crc */ |
440
|
|
|
|
|
|
#ifdef GUNZIP |
441
|
|
|
|
|
|
# define CRC2(check, word) \ |
442
|
|
|
|
|
|
do { \ |
443
|
|
|
|
|
|
hbuf[0] = (unsigned char)(word); \ |
444
|
|
|
|
|
|
hbuf[1] = (unsigned char)((word) >> 8); \ |
445
|
|
|
|
|
|
check = crc32(check, hbuf, 2); \ |
446
|
|
|
|
|
|
} while (0) |
447
|
|
|
|
|
|
|
448
|
|
|
|
|
|
# define CRC4(check, word) \ |
449
|
|
|
|
|
|
do { \ |
450
|
|
|
|
|
|
hbuf[0] = (unsigned char)(word); \ |
451
|
|
|
|
|
|
hbuf[1] = (unsigned char)((word) >> 8); \ |
452
|
|
|
|
|
|
hbuf[2] = (unsigned char)((word) >> 16); \ |
453
|
|
|
|
|
|
hbuf[3] = (unsigned char)((word) >> 24); \ |
454
|
|
|
|
|
|
check = crc32(check, hbuf, 4); \ |
455
|
|
|
|
|
|
} while (0) |
456
|
|
|
|
|
|
#endif |
457
|
|
|
|
|
|
|
458
|
|
|
|
|
|
/* Load registers with state in inflate() for speed */ |
459
|
|
|
|
|
|
#define LOAD() \ |
460
|
|
|
|
|
|
do { \ |
461
|
|
|
|
|
|
put = strm->next_out; \ |
462
|
|
|
|
|
|
left = strm->avail_out; \ |
463
|
|
|
|
|
|
next = strm->next_in; \ |
464
|
|
|
|
|
|
have = strm->avail_in; \ |
465
|
|
|
|
|
|
hold = state->hold; \ |
466
|
|
|
|
|
|
bits = state->bits; \ |
467
|
|
|
|
|
|
} while (0) |
468
|
|
|
|
|
|
|
469
|
|
|
|
|
|
/* Restore state from registers in inflate() */ |
470
|
|
|
|
|
|
#define RESTORE() \ |
471
|
|
|
|
|
|
do { \ |
472
|
|
|
|
|
|
strm->next_out = put; \ |
473
|
|
|
|
|
|
strm->avail_out = left; \ |
474
|
|
|
|
|
|
strm->next_in = next; \ |
475
|
|
|
|
|
|
strm->avail_in = have; \ |
476
|
|
|
|
|
|
state->hold = hold; \ |
477
|
|
|
|
|
|
state->bits = bits; \ |
478
|
|
|
|
|
|
} while (0) |
479
|
|
|
|
|
|
|
480
|
|
|
|
|
|
/* Clear the input bit accumulator */ |
481
|
|
|
|
|
|
#define INITBITS() \ |
482
|
|
|
|
|
|
do { \ |
483
|
|
|
|
|
|
hold = 0; \ |
484
|
|
|
|
|
|
bits = 0; \ |
485
|
|
|
|
|
|
} while (0) |
486
|
|
|
|
|
|
|
487
|
|
|
|
|
|
/* Get a byte of input into the bit accumulator, or return from inflate() |
488
|
|
|
|
|
|
if there is no input available. */ |
489
|
|
|
|
|
|
#define PULLBYTE() \ |
490
|
|
|
|
|
|
do { \ |
491
|
|
|
|
|
|
if (have == 0) goto inf_leave; \ |
492
|
|
|
|
|
|
have--; \ |
493
|
|
|
|
|
|
hold += (unsigned long)(*next++) << bits; \ |
494
|
|
|
|
|
|
bits += 8; \ |
495
|
|
|
|
|
|
} while (0) |
496
|
|
|
|
|
|
|
497
|
|
|
|
|
|
/* Assure that there are at least n bits in the bit accumulator. If there is |
498
|
|
|
|
|
|
not enough available input to do that, then return from inflate(). */ |
499
|
|
|
|
|
|
#define NEEDBITS(n) \ |
500
|
|
|
|
|
|
do { \ |
501
|
|
|
|
|
|
while (bits < (unsigned)(n)) \ |
502
|
|
|
|
|
|
PULLBYTE(); \ |
503
|
|
|
|
|
|
} while (0) |
504
|
|
|
|
|
|
|
505
|
|
|
|
|
|
/* Return the low n bits of the bit accumulator (n < 16) */ |
506
|
|
|
|
|
|
#define BITS(n) \ |
507
|
|
|
|
|
|
((unsigned)hold & ((1U << (n)) - 1)) |
508
|
|
|
|
|
|
|
509
|
|
|
|
|
|
/* Remove n bits from the bit accumulator */ |
510
|
|
|
|
|
|
#define DROPBITS(n) \ |
511
|
|
|
|
|
|
do { \ |
512
|
|
|
|
|
|
hold >>= (n); \ |
513
|
|
|
|
|
|
bits -= (unsigned)(n); \ |
514
|
|
|
|
|
|
} while (0) |
515
|
|
|
|
|
|
|
516
|
|
|
|
|
|
/* Remove zero to seven bits as needed to go to a byte boundary */ |
517
|
|
|
|
|
|
#define BYTEBITS() \ |
518
|
|
|
|
|
|
do { \ |
519
|
|
|
|
|
|
hold >>= bits & 7; \ |
520
|
|
|
|
|
|
bits -= bits & 7; \ |
521
|
|
|
|
|
|
} while (0) |
522
|
|
|
|
|
|
|
523
|
|
|
|
|
|
/* |
524
|
|
|
|
|
|
inflate() uses a state machine to process as much input data and generate as |
525
|
|
|
|
|
|
much output data as possible before returning. The state machine is |
526
|
|
|
|
|
|
structured roughly as follows: |
527
|
|
|
|
|
|
|
528
|
|
|
|
|
|
for (;;) switch (state) { |
529
|
|
|
|
|
|
... |
530
|
|
|
|
|
|
case STATEn: |
531
|
|
|
|
|
|
if (not enough input data or output space to make progress) |
532
|
|
|
|
|
|
return; |
533
|
|
|
|
|
|
... make progress ... |
534
|
|
|
|
|
|
state = STATEm; |
535
|
|
|
|
|
|
break; |
536
|
|
|
|
|
|
... |
537
|
|
|
|
|
|
} |
538
|
|
|
|
|
|
|
539
|
|
|
|
|
|
so when inflate() is called again, the same case is attempted again, and |
540
|
|
|
|
|
|
if the appropriate resources are provided, the machine proceeds to the |
541
|
|
|
|
|
|
next state. The NEEDBITS() macro is usually the way the state evaluates |
542
|
|
|
|
|
|
whether it can proceed or should return. NEEDBITS() does the return if |
543
|
|
|
|
|
|
the requested bits are not available. The typical use of the BITS macros |
544
|
|
|
|
|
|
is: |
545
|
|
|
|
|
|
|
546
|
|
|
|
|
|
NEEDBITS(n); |
547
|
|
|
|
|
|
... do something with BITS(n) ... |
548
|
|
|
|
|
|
DROPBITS(n); |
549
|
|
|
|
|
|
|
550
|
|
|
|
|
|
where NEEDBITS(n) either returns from inflate() if there isn't enough |
551
|
|
|
|
|
|
input left to load n bits into the accumulator, or it continues. BITS(n) |
552
|
|
|
|
|
|
gives the low n bits in the accumulator. When done, DROPBITS(n) drops |
553
|
|
|
|
|
|
the low n bits off the accumulator. INITBITS() clears the accumulator |
554
|
|
|
|
|
|
and sets the number of available bits to zero. BYTEBITS() discards just |
555
|
|
|
|
|
|
enough bits to put the accumulator on a byte boundary. After BYTEBITS() |
556
|
|
|
|
|
|
and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. |
557
|
|
|
|
|
|
|
558
|
|
|
|
|
|
NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return |
559
|
|
|
|
|
|
if there is no input available. The decoding of variable length codes uses |
560
|
|
|
|
|
|
PULLBYTE() directly in order to pull just enough bytes to decode the next |
561
|
|
|
|
|
|
code, and no more. |
562
|
|
|
|
|
|
|
563
|
|
|
|
|
|
Some states loop until they get enough input, making sure that enough |
564
|
|
|
|
|
|
state information is maintained to continue the loop where it left off |
565
|
|
|
|
|
|
if NEEDBITS() returns in the loop. For example, want, need, and keep |
566
|
|
|
|
|
|
would all have to actually be part of the saved state in case NEEDBITS() |
567
|
|
|
|
|
|
returns: |
568
|
|
|
|
|
|
|
569
|
|
|
|
|
|
case STATEw: |
570
|
|
|
|
|
|
while (want < need) { |
571
|
|
|
|
|
|
NEEDBITS(n); |
572
|
|
|
|
|
|
keep[want++] = BITS(n); |
573
|
|
|
|
|
|
DROPBITS(n); |
574
|
|
|
|
|
|
} |
575
|
|
|
|
|
|
state = STATEx; |
576
|
|
|
|
|
|
case STATEx: |
577
|
|
|
|
|
|
|
578
|
|
|
|
|
|
As shown above, if the next state is also the next case, then the break |
579
|
|
|
|
|
|
is omitted. |
580
|
|
|
|
|
|
|
581
|
|
|
|
|
|
A state may also return if there is not enough output space available to |
582
|
|
|
|
|
|
complete that state. Those states are copying stored data, writing a |
583
|
|
|
|
|
|
literal byte, and copying a matching string. |
584
|
|
|
|
|
|
|
585
|
|
|
|
|
|
When returning, a "goto inf_leave" is used to update the total counters, |
586
|
|
|
|
|
|
update the check value, and determine whether any progress has been made |
587
|
|
|
|
|
|
during that inflate() call in order to return the proper return code. |
588
|
|
|
|
|
|
Progress is defined as a change in either strm->avail_in or strm->avail_out. |
589
|
|
|
|
|
|
When there is a window, goto inf_leave will update the window with the last |
590
|
|
|
|
|
|
output written. If a goto inf_leave occurs in the middle of decompression |
591
|
|
|
|
|
|
and there is no window currently, goto inf_leave will create one and copy |
592
|
|
|
|
|
|
output to the window for the next call of inflate(). |
593
|
|
|
|
|
|
|
594
|
|
|
|
|
|
In this implementation, the flush parameter of inflate() only affects the |
595
|
|
|
|
|
|
return code (per zlib.h). inflate() always writes as much as possible to |
596
|
|
|
|
|
|
strm->next_out, given the space available and the provided input--the effect |
597
|
|
|
|
|
|
documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers |
598
|
|
|
|
|
|
the allocation of and copying into a sliding window until necessary, which |
599
|
|
|
|
|
|
provides the effect documented in zlib.h for Z_FINISH when the entire input |
600
|
|
|
|
|
|
stream available. So the only thing the flush parameter actually does is: |
601
|
|
|
|
|
|
when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it |
602
|
|
|
|
|
|
will return Z_BUF_ERROR if it has not reached the end of the stream. |
603
|
|
|
|
|
|
*/ |
604
|
|
|
|
|
|
|
605
|
449194
|
|
|
|
|
int ZEXPORT inflate( |
606
|
|
|
|
|
|
z_streamp strm, |
607
|
|
|
|
|
|
int flush) |
608
|
|
|
|
|
|
{ |
609
|
|
|
|
|
|
struct inflate_state FAR *state; |
610
|
|
|
|
|
|
z_const unsigned char FAR *next; /* next input */ |
611
|
|
|
|
|
|
unsigned char FAR *put; /* next output */ |
612
|
|
|
|
|
|
unsigned have, left; /* available input and output */ |
613
|
|
|
|
|
|
unsigned long hold; /* bit buffer */ |
614
|
|
|
|
|
|
unsigned bits; /* bits in bit buffer */ |
615
|
|
|
|
|
|
unsigned in, out; /* save starting available input and output */ |
616
|
|
|
|
|
|
unsigned copy; /* number of stored or match bytes to copy */ |
617
|
|
|
|
|
|
unsigned char FAR *from; /* where to copy match bytes from */ |
618
|
|
|
|
|
|
code here; /* current decoding table entry */ |
619
|
|
|
|
|
|
code last; /* parent table entry */ |
620
|
|
|
|
|
|
unsigned len; /* length to copy for repeats, bits to drop */ |
621
|
|
|
|
|
|
int ret; /* return code */ |
622
|
|
|
|
|
|
#ifdef GUNZIP |
623
|
|
|
|
|
|
unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ |
624
|
|
|
|
|
|
#endif |
625
|
|
|
|
|
|
static const unsigned short order[19] = /* permutation of code lengths */ |
626
|
|
|
|
|
|
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; |
627
|
|
|
|
|
|
|
628
|
898388
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || |
629
|
449194
|
|
|
|
|
(strm->next_in == Z_NULL && strm->avail_in != 0)) |
630
|
|
|
|
|
|
return Z_STREAM_ERROR; |
631
|
|
|
|
|
|
|
632
|
449194
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
633
|
449194
|
|
|
|
|
if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ |
634
|
449194
|
|
|
|
|
LOAD(); |
635
|
|
|
|
|
|
in = have; |
636
|
|
|
|
|
|
out = left; |
637
|
|
|
|
|
|
ret = Z_OK; |
638
|
|
|
|
|
|
for (;;) |
639
|
1771086
|
|
|
|
|
switch (state->mode) { |
640
|
|
|
|
|
|
case HEAD: |
641
|
21914
|
|
|
|
|
if (state->wrap == 0) { |
642
|
21720
|
|
|
|
|
state->mode = TYPEDO; |
643
|
21720
|
|
|
|
|
break; |
644
|
|
|
|
|
|
} |
645
|
328
|
|
|
|
|
NEEDBITS(16); |
646
|
|
|
|
|
|
#ifdef GUNZIP |
647
|
126
|
|
|
|
|
if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ |
648
|
6
|
|
|
|
|
state->check = crc32(0L, Z_NULL, 0); |
649
|
6
|
|
|
|
|
CRC2(state->check, hold); |
650
|
|
|
|
|
|
INITBITS(); |
651
|
6
|
|
|
|
|
state->mode = FLAGS; |
652
|
6
|
|
|
|
|
break; |
653
|
|
|
|
|
|
} |
654
|
120
|
|
|
|
|
state->flags = 0; /* expect zlib header */ |
655
|
120
|
|
|
|
|
if (state->head != Z_NULL) |
656
|
0
|
|
|
|
|
state->head->done = -1; |
657
|
238
|
|
|
|
|
if (!(state->wrap & 1) || /* check if zlib header allowed */ |
658
|
|
|
|
|
|
#else |
659
|
|
|
|
|
|
if ( |
660
|
|
|
|
|
|
#endif |
661
|
118
|
|
|
|
|
((BITS(8) << 8) + (hold >> 8)) % 31) { |
662
|
6
|
|
|
|
|
strm->msg = (char *)"incorrect header check"; |
663
|
6
|
|
|
|
|
state->mode = BAD; |
664
|
6
|
|
|
|
|
break; |
665
|
|
|
|
|
|
} |
666
|
114
|
|
|
|
|
if (BITS(4) != Z_DEFLATED) { |
667
|
0
|
|
|
|
|
strm->msg = (char *)"unknown compression method"; |
668
|
0
|
|
|
|
|
state->mode = BAD; |
669
|
0
|
|
|
|
|
break; |
670
|
|
|
|
|
|
} |
671
|
114
|
|
|
|
|
DROPBITS(4); |
672
|
114
|
|
|
|
|
len = BITS(4) + 8; |
673
|
114
|
|
|
|
|
if (state->wbits == 0) |
674
|
0
|
|
|
|
|
state->wbits = len; |
675
|
114
|
|
|
|
|
else if (len > state->wbits) { |
676
|
0
|
|
|
|
|
strm->msg = (char *)"invalid window size"; |
677
|
0
|
|
|
|
|
state->mode = BAD; |
678
|
0
|
|
|
|
|
break; |
679
|
|
|
|
|
|
} |
680
|
114
|
|
|
|
|
state->dmax = 1U << len; |
681
|
|
|
|
|
|
Tracev((stderr, "inflate: zlib header ok\n")); |
682
|
114
|
|
|
|
|
strm->adler = state->check = adler32(0L, Z_NULL, 0); |
683
|
114
|
|
|
|
|
state->mode = hold & 0x200 ? DICTID : TYPE; |
684
|
|
|
|
|
|
INITBITS(); |
685
|
114
|
|
|
|
|
break; |
686
|
|
|
|
|
|
#ifdef GUNZIP |
687
|
|
|
|
|
|
case FLAGS: |
688
|
12
|
|
|
|
|
NEEDBITS(16); |
689
|
6
|
|
|
|
|
state->flags = (int)(hold); |
690
|
6
|
|
|
|
|
if ((state->flags & 0xff) != Z_DEFLATED) { |
691
|
0
|
|
|
|
|
strm->msg = (char *)"unknown compression method"; |
692
|
0
|
|
|
|
|
state->mode = BAD; |
693
|
0
|
|
|
|
|
break; |
694
|
|
|
|
|
|
} |
695
|
6
|
|
|
|
|
if (state->flags & 0xe000) { |
696
|
0
|
|
|
|
|
strm->msg = (char *)"unknown header flags set"; |
697
|
0
|
|
|
|
|
state->mode = BAD; |
698
|
0
|
|
|
|
|
break; |
699
|
|
|
|
|
|
} |
700
|
6
|
|
|
|
|
if (state->head != Z_NULL) |
701
|
0
|
|
|
|
|
state->head->text = (int)((hold >> 8) & 1); |
702
|
6
|
|
|
|
|
if (state->flags & 0x0200) CRC2(state->check, hold); |
703
|
|
|
|
|
|
INITBITS(); |
704
|
6
|
|
|
|
|
state->mode = TIME; |
705
|
|
|
|
|
|
case TIME: |
706
|
24
|
|
|
|
|
NEEDBITS(32); |
707
|
6
|
|
|
|
|
if (state->head != Z_NULL) |
708
|
0
|
|
|
|
|
state->head->time = hold; |
709
|
6
|
|
|
|
|
if (state->flags & 0x0200) CRC4(state->check, hold); |
710
|
|
|
|
|
|
INITBITS(); |
711
|
6
|
|
|
|
|
state->mode = OS; |
712
|
|
|
|
|
|
case OS: |
713
|
12
|
|
|
|
|
NEEDBITS(16); |
714
|
6
|
|
|
|
|
if (state->head != Z_NULL) { |
715
|
0
|
|
|
|
|
state->head->xflags = (int)(hold & 0xff); |
716
|
0
|
|
|
|
|
state->head->os = (int)(hold >> 8); |
717
|
|
|
|
|
|
} |
718
|
6
|
|
|
|
|
if (state->flags & 0x0200) CRC2(state->check, hold); |
719
|
|
|
|
|
|
INITBITS(); |
720
|
6
|
|
|
|
|
state->mode = EXLEN; |
721
|
|
|
|
|
|
case EXLEN: |
722
|
6
|
|
|
|
|
if (state->flags & 0x0400) { |
723
|
0
|
|
|
|
|
NEEDBITS(16); |
724
|
0
|
|
|
|
|
state->length = (unsigned)(hold); |
725
|
0
|
|
|
|
|
if (state->head != Z_NULL) |
726
|
0
|
|
|
|
|
state->head->extra_len = (unsigned)hold; |
727
|
0
|
|
|
|
|
if (state->flags & 0x0200) CRC2(state->check, hold); |
728
|
|
|
|
|
|
INITBITS(); |
729
|
|
|
|
|
|
} |
730
|
6
|
|
|
|
|
else if (state->head != Z_NULL) |
731
|
0
|
|
|
|
|
state->head->extra = Z_NULL; |
732
|
6
|
|
|
|
|
state->mode = EXTRA; |
733
|
|
|
|
|
|
case EXTRA: |
734
|
6
|
|
|
|
|
if (state->flags & 0x0400) { |
735
|
0
|
|
|
|
|
copy = state->length; |
736
|
0
|
|
|
|
|
if (copy > have) copy = have; |
737
|
0
|
|
|
|
|
if (copy) { |
738
|
0
|
|
|
|
|
if (state->head != Z_NULL && |
739
|
0
|
|
|
|
|
state->head->extra != Z_NULL) { |
740
|
0
|
|
|
|
|
len = state->head->extra_len - state->length; |
741
|
0
|
|
|
|
|
zmemcpy(state->head->extra + len, next, |
742
|
0
|
|
|
|
|
len + copy > state->head->extra_max ? |
743
|
0
|
|
|
|
|
state->head->extra_max - len : copy); |
744
|
|
|
|
|
|
} |
745
|
0
|
|
|
|
|
if (state->flags & 0x0200) |
746
|
0
|
|
|
|
|
state->check = crc32(state->check, next, copy); |
747
|
0
|
|
|
|
|
have -= copy; |
748
|
0
|
|
|
|
|
next += copy; |
749
|
0
|
|
|
|
|
state->length -= copy; |
750
|
|
|
|
|
|
} |
751
|
0
|
|
|
|
|
if (state->length) goto inf_leave; |
752
|
|
|
|
|
|
} |
753
|
6
|
|
|
|
|
state->length = 0; |
754
|
6
|
|
|
|
|
state->mode = NAME; |
755
|
|
|
|
|
|
case NAME: |
756
|
6
|
|
|
|
|
if (state->flags & 0x0800) { |
757
|
0
|
|
|
|
|
if (have == 0) goto inf_leave; |
758
|
|
|
|
|
|
copy = 0; |
759
|
|
|
|
|
|
do { |
760
|
0
|
|
|
|
|
len = (unsigned)(next[copy++]); |
761
|
0
|
|
|
|
|
if (state->head != Z_NULL && |
762
|
0
|
|
|
|
|
state->head->name != Z_NULL && |
763
|
0
|
|
|
|
|
state->length < state->head->name_max) |
764
|
0
|
|
|
|
|
state->head->name[state->length++] = len; |
765
|
0
|
|
|
|
|
} while (len && copy < have); |
766
|
0
|
|
|
|
|
if (state->flags & 0x0200) |
767
|
0
|
|
|
|
|
state->check = crc32(state->check, next, copy); |
768
|
0
|
|
|
|
|
have -= copy; |
769
|
0
|
|
|
|
|
next += copy; |
770
|
0
|
|
|
|
|
if (len) goto inf_leave; |
771
|
|
|
|
|
|
} |
772
|
6
|
|
|
|
|
else if (state->head != Z_NULL) |
773
|
0
|
|
|
|
|
state->head->name = Z_NULL; |
774
|
6
|
|
|
|
|
state->length = 0; |
775
|
6
|
|
|
|
|
state->mode = COMMENT; |
776
|
|
|
|
|
|
case COMMENT: |
777
|
6
|
|
|
|
|
if (state->flags & 0x1000) { |
778
|
0
|
|
|
|
|
if (have == 0) goto inf_leave; |
779
|
|
|
|
|
|
copy = 0; |
780
|
|
|
|
|
|
do { |
781
|
0
|
|
|
|
|
len = (unsigned)(next[copy++]); |
782
|
0
|
|
|
|
|
if (state->head != Z_NULL && |
783
|
0
|
|
|
|
|
state->head->comment != Z_NULL && |
784
|
0
|
|
|
|
|
state->length < state->head->comm_max) |
785
|
0
|
|
|
|
|
state->head->comment[state->length++] = len; |
786
|
0
|
|
|
|
|
} while (len && copy < have); |
787
|
0
|
|
|
|
|
if (state->flags & 0x0200) |
788
|
0
|
|
|
|
|
state->check = crc32(state->check, next, copy); |
789
|
0
|
|
|
|
|
have -= copy; |
790
|
0
|
|
|
|
|
next += copy; |
791
|
0
|
|
|
|
|
if (len) goto inf_leave; |
792
|
|
|
|
|
|
} |
793
|
6
|
|
|
|
|
else if (state->head != Z_NULL) |
794
|
0
|
|
|
|
|
state->head->comment = Z_NULL; |
795
|
6
|
|
|
|
|
state->mode = HCRC; |
796
|
|
|
|
|
|
case HCRC: |
797
|
6
|
|
|
|
|
if (state->flags & 0x0200) { |
798
|
0
|
|
|
|
|
NEEDBITS(16); |
799
|
0
|
|
|
|
|
if (hold != (state->check & 0xffff)) { |
800
|
0
|
|
|
|
|
strm->msg = (char *)"header crc mismatch"; |
801
|
0
|
|
|
|
|
state->mode = BAD; |
802
|
0
|
|
|
|
|
break; |
803
|
|
|
|
|
|
} |
804
|
|
|
|
|
|
INITBITS(); |
805
|
|
|
|
|
|
} |
806
|
6
|
|
|
|
|
if (state->head != Z_NULL) { |
807
|
0
|
|
|
|
|
state->head->hcrc = (int)((state->flags >> 9) & 1); |
808
|
0
|
|
|
|
|
state->head->done = 1; |
809
|
|
|
|
|
|
} |
810
|
6
|
|
|
|
|
strm->adler = state->check = crc32(0L, Z_NULL, 0); |
811
|
6
|
|
|
|
|
state->mode = TYPE; |
812
|
6
|
|
|
|
|
break; |
813
|
|
|
|
|
|
#endif |
814
|
|
|
|
|
|
case DICTID: |
815
|
16
|
|
|
|
|
NEEDBITS(32); |
816
|
4
|
|
|
|
|
strm->adler = state->check = ZSWAP32(hold); |
817
|
|
|
|
|
|
INITBITS(); |
818
|
4
|
|
|
|
|
state->mode = DICT; |
819
|
|
|
|
|
|
case DICT: |
820
|
8
|
|
|
|
|
if (state->havedict == 0) { |
821
|
4
|
|
|
|
|
RESTORE(); |
822
|
4
|
|
|
|
|
return Z_NEED_DICT; |
823
|
|
|
|
|
|
} |
824
|
4
|
|
|
|
|
strm->adler = state->check = adler32(0L, Z_NULL, 0); |
825
|
4
|
|
|
|
|
state->mode = TYPE; |
826
|
|
|
|
|
|
case TYPE: |
827
|
16346
|
|
|
|
|
if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; |
828
|
|
|
|
|
|
case TYPEDO: |
829
|
38154
|
|
|
|
|
if (state->last) { |
830
|
16002
|
|
|
|
|
BYTEBITS(); |
831
|
16002
|
|
|
|
|
state->mode = CHECK; |
832
|
16002
|
|
|
|
|
break; |
833
|
|
|
|
|
|
} |
834
|
21960
|
|
|
|
|
NEEDBITS(3); |
835
|
22004
|
|
|
|
|
state->last = BITS(1); |
836
|
22004
|
|
|
|
|
DROPBITS(1); |
837
|
22004
|
|
|
|
|
switch (BITS(2)) { |
838
|
|
|
|
|
|
case 0: /* stored block */ |
839
|
|
|
|
|
|
Tracev((stderr, "inflate: stored block%s\n", |
840
|
|
|
|
|
|
state->last ? " (last)" : "")); |
841
|
1262
|
|
|
|
|
state->mode = STORED; |
842
|
1262
|
|
|
|
|
break; |
843
|
|
|
|
|
|
case 1: /* fixed block */ |
844
|
|
|
|
|
|
fixedtables(state); |
845
|
|
|
|
|
|
Tracev((stderr, "inflate: fixed codes block%s\n", |
846
|
|
|
|
|
|
state->last ? " (last)" : "")); |
847
|
6678
|
|
|
|
|
state->mode = LEN_; /* decode codes */ |
848
|
6678
|
|
|
|
|
if (flush == Z_TREES) { |
849
|
0
|
|
|
|
|
DROPBITS(2); |
850
|
0
|
|
|
|
|
goto inf_leave; |
851
|
|
|
|
|
|
} |
852
|
|
|
|
|
|
break; |
853
|
|
|
|
|
|
case 2: /* dynamic block */ |
854
|
|
|
|
|
|
Tracev((stderr, "inflate: dynamic codes block%s\n", |
855
|
|
|
|
|
|
state->last ? " (last)" : "")); |
856
|
13320
|
|
|
|
|
state->mode = TABLE; |
857
|
13320
|
|
|
|
|
break; |
858
|
|
|
|
|
|
case 3: |
859
|
744
|
|
|
|
|
strm->msg = (char *)"invalid block type"; |
860
|
744
|
|
|
|
|
state->mode = BAD; |
861
|
|
|
|
|
|
} |
862
|
22004
|
|
|
|
|
DROPBITS(2); |
863
|
22004
|
|
|
|
|
break; |
864
|
|
|
|
|
|
case STORED: |
865
|
1302
|
|
|
|
|
BYTEBITS(); /* go to byte boundary */ |
866
|
1302
|
|
|
|
|
NEEDBITS(32); |
867
|
1262
|
|
|
|
|
if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { |
868
|
1210
|
|
|
|
|
strm->msg = (char *)"invalid stored block lengths"; |
869
|
1210
|
|
|
|
|
state->mode = BAD; |
870
|
1210
|
|
|
|
|
break; |
871
|
|
|
|
|
|
} |
872
|
52
|
|
|
|
|
state->length = (unsigned)hold & 0xffff; |
873
|
|
|
|
|
|
Tracev((stderr, "inflate: stored length %u\n", |
874
|
|
|
|
|
|
state->length)); |
875
|
|
|
|
|
|
INITBITS(); |
876
|
52
|
|
|
|
|
state->mode = COPY_; |
877
|
52
|
|
|
|
|
if (flush == Z_TREES) goto inf_leave; |
878
|
|
|
|
|
|
case COPY_: |
879
|
52
|
|
|
|
|
state->mode = COPY; |
880
|
|
|
|
|
|
case COPY: |
881
|
300168
|
|
|
|
|
copy = state->length; |
882
|
300168
|
|
|
|
|
if (copy) { |
883
|
300116
|
|
|
|
|
if (copy > have) copy = have; |
884
|
300116
|
|
|
|
|
if (copy > left) copy = left; |
885
|
300116
|
|
|
|
|
if (copy == 0) goto inf_leave; |
886
|
100082
|
|
|
|
|
zmemcpy(put, next, copy); |
887
|
100082
|
|
|
|
|
have -= copy; |
888
|
100082
|
|
|
|
|
next += copy; |
889
|
100082
|
|
|
|
|
left -= copy; |
890
|
100082
|
|
|
|
|
put += copy; |
891
|
100082
|
|
|
|
|
state->length -= copy; |
892
|
100082
|
|
|
|
|
break; |
893
|
|
|
|
|
|
} |
894
|
|
|
|
|
|
Tracev((stderr, "inflate: stored end\n")); |
895
|
52
|
|
|
|
|
state->mode = TYPE; |
896
|
52
|
|
|
|
|
break; |
897
|
|
|
|
|
|
case TABLE: |
898
|
32684
|
|
|
|
|
NEEDBITS(14); |
899
|
13216
|
|
|
|
|
state->nlen = BITS(5) + 257; |
900
|
13216
|
|
|
|
|
DROPBITS(5); |
901
|
13216
|
|
|
|
|
state->ndist = BITS(5) + 1; |
902
|
13216
|
|
|
|
|
DROPBITS(5); |
903
|
13216
|
|
|
|
|
state->ncode = BITS(4) + 4; |
904
|
13216
|
|
|
|
|
DROPBITS(4); |
905
|
|
|
|
|
|
#ifndef PKZIP_BUG_WORKAROUND |
906
|
13216
|
|
|
|
|
if (state->nlen > 286 || state->ndist > 30) { |
907
|
0
|
|
|
|
|
strm->msg = (char *)"too many length or distance symbols"; |
908
|
0
|
|
|
|
|
state->mode = BAD; |
909
|
0
|
|
|
|
|
break; |
910
|
|
|
|
|
|
} |
911
|
|
|
|
|
|
#endif |
912
|
|
|
|
|
|
Tracev((stderr, "inflate: table sizes ok\n")); |
913
|
13216
|
|
|
|
|
state->have = 0; |
914
|
13216
|
|
|
|
|
state->mode = LENLENS; |
915
|
|
|
|
|
|
case LENLENS: |
916
|
266128
|
|
|
|
|
while (state->have < state->ncode) { |
917
|
96798
|
|
|
|
|
NEEDBITS(3); |
918
|
234572
|
|
|
|
|
state->lens[order[state->have++]] = (unsigned short)BITS(3); |
919
|
234572
|
|
|
|
|
DROPBITS(3); |
920
|
|
|
|
|
|
} |
921
|
26212
|
|
|
|
|
while (state->have < 19) |
922
|
13308
|
|
|
|
|
state->lens[order[state->have++]] = 0; |
923
|
12904
|
|
|
|
|
state->next = state->codes; |
924
|
12904
|
|
|
|
|
state->lencode = (const code FAR *)(state->next); |
925
|
12904
|
|
|
|
|
state->lenbits = 7; |
926
|
12904
|
|
|
|
|
ret = inflate_table(CODES, state->lens, 19, &(state->next), |
927
|
12904
|
|
|
|
|
&(state->lenbits), state->work); |
928
|
12904
|
|
|
|
|
if (ret) { |
929
|
38
|
|
|
|
|
strm->msg = (char *)"invalid code lengths set"; |
930
|
38
|
|
|
|
|
state->mode = BAD; |
931
|
38
|
|
|
|
|
break; |
932
|
|
|
|
|
|
} |
933
|
|
|
|
|
|
Tracev((stderr, "inflate: code lengths ok\n")); |
934
|
12866
|
|
|
|
|
state->have = 0; |
935
|
12866
|
|
|
|
|
state->mode = CODELENS; |
936
|
|
|
|
|
|
case CODELENS: |
937
|
613904
|
|
|
|
|
while (state->have < state->nlen + state->ndist) { |
938
|
|
|
|
|
|
for (;;) { |
939
|
792364
|
|
|
|
|
here = state->lencode[BITS(state->lenbits)]; |
940
|
792364
|
|
|
|
|
if ((unsigned)(here.bits) <= bits) break; |
941
|
249270
|
|
|
|
|
PULLBYTE(); |
942
|
190338
|
|
|
|
|
} |
943
|
543094
|
|
|
|
|
if (here.val < 16) { |
944
|
453912
|
|
|
|
|
DROPBITS(here.bits); |
945
|
453912
|
|
|
|
|
state->lens[state->have++] = here.val; |
946
|
|
|
|
|
|
} |
947
|
|
|
|
|
|
else { |
948
|
89182
|
|
|
|
|
if (here.val == 16) { |
949
|
178
|
|
|
|
|
NEEDBITS(here.bits + 2); |
950
|
752
|
|
|
|
|
DROPBITS(here.bits); |
951
|
752
|
|
|
|
|
if (state->have == 0) { |
952
|
0
|
|
|
|
|
strm->msg = (char *)"invalid bit length repeat"; |
953
|
0
|
|
|
|
|
state->mode = BAD; |
954
|
0
|
|
|
|
|
break; |
955
|
|
|
|
|
|
} |
956
|
752
|
|
|
|
|
len = state->lens[state->have - 1]; |
957
|
752
|
|
|
|
|
copy = 3 + BITS(2); |
958
|
752
|
|
|
|
|
DROPBITS(2); |
959
|
|
|
|
|
|
} |
960
|
88430
|
|
|
|
|
else if (here.val == 17) { |
961
|
1054
|
|
|
|
|
NEEDBITS(here.bits + 3); |
962
|
25516
|
|
|
|
|
DROPBITS(here.bits); |
963
|
|
|
|
|
|
len = 0; |
964
|
25516
|
|
|
|
|
copy = 3 + BITS(3); |
965
|
25516
|
|
|
|
|
DROPBITS(3); |
966
|
|
|
|
|
|
} |
967
|
|
|
|
|
|
else { |
968
|
62258
|
|
|
|
|
NEEDBITS(here.bits + 7); |
969
|
50302
|
|
|
|
|
DROPBITS(here.bits); |
970
|
|
|
|
|
|
len = 0; |
971
|
50302
|
|
|
|
|
copy = 11 + BITS(7); |
972
|
50302
|
|
|
|
|
DROPBITS(7); |
973
|
|
|
|
|
|
} |
974
|
76570
|
|
|
|
|
if (state->have + copy > state->nlen + state->ndist) { |
975
|
0
|
|
|
|
|
strm->msg = (char *)"invalid bit length repeat"; |
976
|
0
|
|
|
|
|
state->mode = BAD; |
977
|
0
|
|
|
|
|
break; |
978
|
|
|
|
|
|
} |
979
|
2971150
|
|
|
|
|
while (copy--) |
980
|
2894580
|
|
|
|
|
state->lens[state->have++] = (unsigned short)len; |
981
|
|
|
|
|
|
} |
982
|
|
|
|
|
|
} |
983
|
|
|
|
|
|
|
984
|
|
|
|
|
|
/* handle error breaks in while */ |
985
|
11878
|
|
|
|
|
if (state->mode == BAD) break; |
986
|
|
|
|
|
|
|
987
|
|
|
|
|
|
/* check for end-of-block code (better have one) */ |
988
|
11878
|
|
|
|
|
if (state->lens[256] == 0) { |
989
|
0
|
|
|
|
|
strm->msg = (char *)"invalid code -- missing end-of-block"; |
990
|
0
|
|
|
|
|
state->mode = BAD; |
991
|
0
|
|
|
|
|
break; |
992
|
|
|
|
|
|
} |
993
|
|
|
|
|
|
|
994
|
|
|
|
|
|
/* build code tables -- note: do not change the lenbits or distbits |
995
|
|
|
|
|
|
values here (9 and 6) without reading the comments in inftrees.h |
996
|
|
|
|
|
|
concerning the ENOUGH constants, which depend on those values */ |
997
|
11878
|
|
|
|
|
state->next = state->codes; |
998
|
11878
|
|
|
|
|
state->lencode = (const code FAR *)(state->next); |
999
|
11878
|
|
|
|
|
state->lenbits = 9; |
1000
|
11878
|
|
|
|
|
ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), |
1001
|
11878
|
|
|
|
|
&(state->lenbits), state->work); |
1002
|
11878
|
|
|
|
|
if (ret) { |
1003
|
0
|
|
|
|
|
strm->msg = (char *)"invalid literal/lengths set"; |
1004
|
0
|
|
|
|
|
state->mode = BAD; |
1005
|
0
|
|
|
|
|
break; |
1006
|
|
|
|
|
|
} |
1007
|
11878
|
|
|
|
|
state->distcode = (const code FAR *)(state->next); |
1008
|
11878
|
|
|
|
|
state->distbits = 6; |
1009
|
11878
|
|
|
|
|
ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, |
1010
|
11878
|
|
|
|
|
&(state->next), &(state->distbits), state->work); |
1011
|
11878
|
|
|
|
|
if (ret) { |
1012
|
0
|
|
|
|
|
strm->msg = (char *)"invalid distances set"; |
1013
|
0
|
|
|
|
|
state->mode = BAD; |
1014
|
0
|
|
|
|
|
break; |
1015
|
|
|
|
|
|
} |
1016
|
|
|
|
|
|
Tracev((stderr, "inflate: codes ok\n")); |
1017
|
11878
|
|
|
|
|
state->mode = LEN_; |
1018
|
11878
|
|
|
|
|
if (flush == Z_TREES) goto inf_leave; |
1019
|
|
|
|
|
|
case LEN_: |
1020
|
18556
|
|
|
|
|
state->mode = LEN; |
1021
|
|
|
|
|
|
case LEN: |
1022
|
790842
|
|
|
|
|
if (have >= 6 && left >= 258) { |
1023
|
77466
|
|
|
|
|
RESTORE(); |
1024
|
77466
|
|
|
|
|
inflate_fast(strm, out); |
1025
|
77466
|
|
|
|
|
LOAD(); |
1026
|
77466
|
|
|
|
|
if (state->mode == TYPE) |
1027
|
7134
|
|
|
|
|
state->back = -1; |
1028
|
|
|
|
|
|
break; |
1029
|
|
|
|
|
|
} |
1030
|
713376
|
|
|
|
|
state->back = 0; |
1031
|
|
|
|
|
|
for (;;) { |
1032
|
1038004
|
|
|
|
|
here = state->lencode[BITS(state->lenbits)]; |
1033
|
1038004
|
|
|
|
|
if ((unsigned)(here.bits) <= bits) break; |
1034
|
449182
|
|
|
|
|
PULLBYTE(); |
1035
|
324628
|
|
|
|
|
} |
1036
|
588822
|
|
|
|
|
if (here.op && (here.op & 0xf0) == 0) { |
1037
|
|
|
|
|
|
last = here; |
1038
|
|
|
|
|
|
for (;;) { |
1039
|
6912
|
|
|
|
|
here = state->lencode[last.val + |
1040
|
3456
|
|
|
|
|
(BITS(last.bits + last.op) >> last.bits)]; |
1041
|
3456
|
|
|
|
|
if ((unsigned)(last.bits + here.bits) <= bits) break; |
1042
|
474
|
|
|
|
|
PULLBYTE(); |
1043
|
474
|
|
|
|
|
} |
1044
|
2982
|
|
|
|
|
DROPBITS(last.bits); |
1045
|
2982
|
|
|
|
|
state->back += last.bits; |
1046
|
|
|
|
|
|
} |
1047
|
588822
|
|
|
|
|
DROPBITS(here.bits); |
1048
|
588822
|
|
|
|
|
state->back += here.bits; |
1049
|
588822
|
|
|
|
|
state->length = (unsigned)here.val; |
1050
|
588822
|
|
|
|
|
if ((int)(here.op) == 0) { |
1051
|
|
|
|
|
|
Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? |
1052
|
|
|
|
|
|
"inflate: literal '%c'\n" : |
1053
|
|
|
|
|
|
"inflate: literal 0x%02x\n", here.val)); |
1054
|
483934
|
|
|
|
|
state->mode = LIT; |
1055
|
483934
|
|
|
|
|
break; |
1056
|
|
|
|
|
|
} |
1057
|
104888
|
|
|
|
|
if (here.op & 32) { |
1058
|
|
|
|
|
|
Tracevv((stderr, "inflate: end of block\n")); |
1059
|
9040
|
|
|
|
|
state->back = -1; |
1060
|
9040
|
|
|
|
|
state->mode = TYPE; |
1061
|
9040
|
|
|
|
|
break; |
1062
|
|
|
|
|
|
} |
1063
|
95848
|
|
|
|
|
if (here.op & 64) { |
1064
|
0
|
|
|
|
|
strm->msg = (char *)"invalid literal/length code"; |
1065
|
0
|
|
|
|
|
state->mode = BAD; |
1066
|
0
|
|
|
|
|
break; |
1067
|
|
|
|
|
|
} |
1068
|
95848
|
|
|
|
|
state->extra = (unsigned)(here.op) & 15; |
1069
|
95848
|
|
|
|
|
state->mode = LENEXT; |
1070
|
|
|
|
|
|
case LENEXT: |
1071
|
95868
|
|
|
|
|
if (state->extra) { |
1072
|
4446
|
|
|
|
|
NEEDBITS(state->extra); |
1073
|
20140
|
|
|
|
|
state->length += BITS(state->extra); |
1074
|
20140
|
|
|
|
|
DROPBITS(state->extra); |
1075
|
20140
|
|
|
|
|
state->back += state->extra; |
1076
|
|
|
|
|
|
} |
1077
|
|
|
|
|
|
Tracevv((stderr, "inflate: length %u\n", state->length)); |
1078
|
95848
|
|
|
|
|
state->was = state->length; |
1079
|
95848
|
|
|
|
|
state->mode = DIST; |
1080
|
|
|
|
|
|
case DIST: |
1081
|
|
|
|
|
|
for (;;) { |
1082
|
137462
|
|
|
|
|
here = state->distcode[BITS(state->distbits)]; |
1083
|
137462
|
|
|
|
|
if ((unsigned)(here.bits) <= bits) break; |
1084
|
41618
|
|
|
|
|
PULLBYTE(); |
1085
|
41342
|
|
|
|
|
} |
1086
|
95844
|
|
|
|
|
if ((here.op & 0xf0) == 0) { |
1087
|
|
|
|
|
|
last = here; |
1088
|
|
|
|
|
|
for (;;) { |
1089
|
4700
|
|
|
|
|
here = state->distcode[last.val + |
1090
|
2350
|
|
|
|
|
(BITS(last.bits + last.op) >> last.bits)]; |
1091
|
2350
|
|
|
|
|
if ((unsigned)(last.bits + here.bits) <= bits) break; |
1092
|
494
|
|
|
|
|
PULLBYTE(); |
1093
|
494
|
|
|
|
|
} |
1094
|
1856
|
|
|
|
|
DROPBITS(last.bits); |
1095
|
1856
|
|
|
|
|
state->back += last.bits; |
1096
|
|
|
|
|
|
} |
1097
|
95844
|
|
|
|
|
DROPBITS(here.bits); |
1098
|
95844
|
|
|
|
|
state->back += here.bits; |
1099
|
95844
|
|
|
|
|
if (here.op & 64) { |
1100
|
0
|
|
|
|
|
strm->msg = (char *)"invalid distance code"; |
1101
|
0
|
|
|
|
|
state->mode = BAD; |
1102
|
0
|
|
|
|
|
break; |
1103
|
|
|
|
|
|
} |
1104
|
95844
|
|
|
|
|
state->offset = (unsigned)here.val; |
1105
|
95844
|
|
|
|
|
state->extra = (unsigned)(here.op) & 15; |
1106
|
95844
|
|
|
|
|
state->mode = DISTEXT; |
1107
|
|
|
|
|
|
case DISTEXT: |
1108
|
99620
|
|
|
|
|
if (state->extra) { |
1109
|
93426
|
|
|
|
|
NEEDBITS(state->extra); |
1110
|
85642
|
|
|
|
|
state->offset += BITS(state->extra); |
1111
|
85642
|
|
|
|
|
DROPBITS(state->extra); |
1112
|
85642
|
|
|
|
|
state->back += state->extra; |
1113
|
|
|
|
|
|
} |
1114
|
|
|
|
|
|
#ifdef INFLATE_STRICT |
1115
|
|
|
|
|
|
if (state->offset > state->dmax) { |
1116
|
|
|
|
|
|
strm->msg = (char *)"invalid distance too far back"; |
1117
|
|
|
|
|
|
state->mode = BAD; |
1118
|
|
|
|
|
|
break; |
1119
|
|
|
|
|
|
} |
1120
|
|
|
|
|
|
#endif |
1121
|
|
|
|
|
|
Tracevv((stderr, "inflate: distance %u\n", state->offset)); |
1122
|
95788
|
|
|
|
|
state->mode = MATCH; |
1123
|
|
|
|
|
|
case MATCH: |
1124
|
110880
|
|
|
|
|
if (left == 0) goto inf_leave; |
1125
|
106276
|
|
|
|
|
copy = out - left; |
1126
|
106276
|
|
|
|
|
if (state->offset > copy) { /* copy from window */ |
1127
|
43802
|
|
|
|
|
copy = state->offset - copy; |
1128
|
43802
|
|
|
|
|
if (copy > state->whave) { |
1129
|
6
|
|
|
|
|
if (state->sane) { |
1130
|
6
|
|
|
|
|
strm->msg = (char *)"invalid distance too far back"; |
1131
|
6
|
|
|
|
|
state->mode = BAD; |
1132
|
6
|
|
|
|
|
break; |
1133
|
|
|
|
|
|
} |
1134
|
|
|
|
|
|
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR |
1135
|
|
|
|
|
|
Trace((stderr, "inflate.c too far\n")); |
1136
|
|
|
|
|
|
copy -= state->whave; |
1137
|
|
|
|
|
|
if (copy > state->length) copy = state->length; |
1138
|
|
|
|
|
|
if (copy > left) copy = left; |
1139
|
|
|
|
|
|
left -= copy; |
1140
|
|
|
|
|
|
state->length -= copy; |
1141
|
|
|
|
|
|
do { |
1142
|
|
|
|
|
|
*put++ = 0; |
1143
|
|
|
|
|
|
} while (--copy); |
1144
|
|
|
|
|
|
if (state->length == 0) state->mode = LEN; |
1145
|
|
|
|
|
|
break; |
1146
|
|
|
|
|
|
#endif |
1147
|
|
|
|
|
|
} |
1148
|
43796
|
|
|
|
|
if (copy > state->wnext) { |
1149
|
10256
|
|
|
|
|
copy -= state->wnext; |
1150
|
10256
|
|
|
|
|
from = state->window + (state->wsize - copy); |
1151
|
|
|
|
|
|
} |
1152
|
|
|
|
|
|
else |
1153
|
33540
|
|
|
|
|
from = state->window + (state->wnext - copy); |
1154
|
43796
|
|
|
|
|
if (copy > state->length) copy = state->length; |
1155
|
|
|
|
|
|
} |
1156
|
|
|
|
|
|
else { /* copy from output */ |
1157
|
62474
|
|
|
|
|
from = put - state->offset; |
1158
|
62474
|
|
|
|
|
copy = state->length; |
1159
|
|
|
|
|
|
} |
1160
|
106270
|
|
|
|
|
if (copy > left) copy = left; |
1161
|
106270
|
|
|
|
|
left -= copy; |
1162
|
106270
|
|
|
|
|
state->length -= copy; |
1163
|
|
|
|
|
|
do { |
1164
|
2746122
|
|
|
|
|
*put++ = *from++; |
1165
|
2746122
|
|
|
|
|
} while (--copy); |
1166
|
106270
|
|
|
|
|
if (state->length == 0) state->mode = LEN; |
1167
|
|
|
|
|
|
break; |
1168
|
|
|
|
|
|
case LIT: |
1169
|
484218
|
|
|
|
|
if (left == 0) goto inf_leave; |
1170
|
483928
|
|
|
|
|
*put++ = (unsigned char)(state->length); |
1171
|
483928
|
|
|
|
|
left--; |
1172
|
483928
|
|
|
|
|
state->mode = LEN; |
1173
|
483928
|
|
|
|
|
break; |
1174
|
|
|
|
|
|
case CHECK: |
1175
|
16286
|
|
|
|
|
if (state->wrap) { |
1176
|
796
|
|
|
|
|
NEEDBITS(32); |
1177
|
128
|
|
|
|
|
out -= left; |
1178
|
128
|
|
|
|
|
strm->total_out += out; |
1179
|
128
|
|
|
|
|
state->total += out; |
1180
|
128
|
|
|
|
|
if (out) |
1181
|
80
|
|
|
|
|
strm->adler = state->check = |
1182
|
80
|
|
|
|
|
UPDATE(state->check, put - out, out); |
1183
|
|
|
|
|
|
out = left; |
1184
|
128
|
|
|
|
|
if (( |
1185
|
|
|
|
|
|
#ifdef GUNZIP |
1186
|
242
|
|
|
|
|
state->flags ? hold : |
1187
|
|
|
|
|
|
#endif |
1188
|
242
|
|
|
|
|
ZSWAP32(hold)) != state->check) { |
1189
|
8
|
|
|
|
|
strm->msg = (char *)"incorrect data check"; |
1190
|
8
|
|
|
|
|
state->mode = BAD; |
1191
|
8
|
|
|
|
|
break; |
1192
|
|
|
|
|
|
} |
1193
|
|
|
|
|
|
INITBITS(); |
1194
|
|
|
|
|
|
Tracev((stderr, "inflate: check matches trailer\n")); |
1195
|
|
|
|
|
|
} |
1196
|
|
|
|
|
|
#ifdef GUNZIP |
1197
|
15994
|
|
|
|
|
state->mode = LENGTH; |
1198
|
|
|
|
|
|
case LENGTH: |
1199
|
15994
|
|
|
|
|
if (state->wrap && state->flags) { |
1200
|
24
|
|
|
|
|
NEEDBITS(32); |
1201
|
6
|
|
|
|
|
if (hold != (state->total & 0xffffffffUL)) { |
1202
|
0
|
|
|
|
|
strm->msg = (char *)"incorrect length check"; |
1203
|
0
|
|
|
|
|
state->mode = BAD; |
1204
|
0
|
|
|
|
|
break; |
1205
|
|
|
|
|
|
} |
1206
|
|
|
|
|
|
INITBITS(); |
1207
|
|
|
|
|
|
Tracev((stderr, "inflate: length matches trailer\n")); |
1208
|
|
|
|
|
|
} |
1209
|
|
|
|
|
|
#endif |
1210
|
15994
|
|
|
|
|
state->mode = DONE; |
1211
|
|
|
|
|
|
case DONE: |
1212
|
|
|
|
|
|
ret = Z_STREAM_END; |
1213
|
|
|
|
|
|
goto inf_leave; |
1214
|
|
|
|
|
|
case BAD: |
1215
|
|
|
|
|
|
ret = Z_DATA_ERROR; |
1216
|
|
|
|
|
|
goto inf_leave; |
1217
|
|
|
|
|
|
case MEM: |
1218
|
|
|
|
|
|
return Z_MEM_ERROR; |
1219
|
|
|
|
|
|
case SYNC: |
1220
|
|
|
|
|
|
default: |
1221
|
0
|
|
|
|
|
return Z_STREAM_ERROR; |
1222
|
|
|
|
|
|
} |
1223
|
|
|
|
|
|
|
1224
|
|
|
|
|
|
/* |
1225
|
|
|
|
|
|
Return from inflate(), updating the total counts and the check value. |
1226
|
|
|
|
|
|
If there was no progress during the inflate() call, return a buffer |
1227
|
|
|
|
|
|
error. Call updatewindow() to create and/or update the window state. |
1228
|
|
|
|
|
|
Note: a memory error from inflate() is non-recoverable. |
1229
|
|
|
|
|
|
*/ |
1230
|
|
|
|
|
|
inf_leave: |
1231
|
449190
|
|
|
|
|
RESTORE(); |
1232
|
465152
|
|
|
|
|
if (state->wsize || (out != strm->avail_out && state->mode < BAD && |
1233
|
15962
|
|
|
|
|
(state->mode < CHECK || flush != Z_FINISH))) |
1234
|
347976
|
|
|
|
|
if (updatewindow(strm, strm->next_out, out - strm->avail_out)) { |
1235
|
0
|
|
|
|
|
state->mode = MEM; |
1236
|
0
|
|
|
|
|
return Z_MEM_ERROR; |
1237
|
|
|
|
|
|
} |
1238
|
449190
|
|
|
|
|
in -= strm->avail_in; |
1239
|
449190
|
|
|
|
|
out -= strm->avail_out; |
1240
|
449190
|
|
|
|
|
strm->total_in += in; |
1241
|
449190
|
|
|
|
|
strm->total_out += out; |
1242
|
449190
|
|
|
|
|
state->total += out; |
1243
|
449190
|
|
|
|
|
if (state->wrap && out) |
1244
|
101904
|
|
|
|
|
strm->adler = state->check = |
1245
|
101904
|
|
|
|
|
UPDATE(state->check, strm->next_out - out, out); |
1246
|
1347570
|
|
|
|
|
strm->data_type = state->bits + (state->last ? 64 : 0) + |
1247
|
898380
|
|
|
|
|
(state->mode == TYPE ? 128 : 0) + |
1248
|
449190
|
|
|
|
|
(state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); |
1249
|
449190
|
|
|
|
|
if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) |
1250
|
|
|
|
|
|
ret = Z_BUF_ERROR; |
1251
|
449190
|
|
|
|
|
return ret; |
1252
|
|
|
|
|
|
} |
1253
|
|
|
|
|
|
|
1254
|
19456
|
|
|
|
|
int ZEXPORT inflateEnd( |
1255
|
|
|
|
|
|
z_streamp strm) |
1256
|
|
|
|
|
|
{ |
1257
|
|
|
|
|
|
struct inflate_state FAR *state; |
1258
|
19456
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) |
1259
|
|
|
|
|
|
return Z_STREAM_ERROR; |
1260
|
19456
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
1261
|
19456
|
|
|
|
|
if (state->window != Z_NULL) ZFREE(strm, state->window); |
1262
|
19456
|
|
|
|
|
ZFREE(strm, strm->state); |
1263
|
19456
|
|
|
|
|
strm->state = Z_NULL; |
1264
|
|
|
|
|
|
Tracev((stderr, "inflate: end\n")); |
1265
|
19456
|
|
|
|
|
return Z_OK; |
1266
|
|
|
|
|
|
} |
1267
|
|
|
|
|
|
|
1268
|
0
|
|
|
|
|
int ZEXPORT inflateGetDictionary( |
1269
|
|
|
|
|
|
z_streamp strm, |
1270
|
|
|
|
|
|
Bytef *dictionary, |
1271
|
|
|
|
|
|
uInt *dictLength) |
1272
|
|
|
|
|
|
{ |
1273
|
|
|
|
|
|
struct inflate_state FAR *state; |
1274
|
|
|
|
|
|
|
1275
|
|
|
|
|
|
/* check state */ |
1276
|
0
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
1277
|
0
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
1278
|
|
|
|
|
|
|
1279
|
|
|
|
|
|
/* copy dictionary */ |
1280
|
0
|
|
|
|
|
if (state->whave && dictionary != Z_NULL) { |
1281
|
0
|
|
|
|
|
zmemcpy(dictionary, state->window + state->wnext, |
1282
|
0
|
|
|
|
|
state->whave - state->wnext); |
1283
|
0
|
|
|
|
|
zmemcpy(dictionary + state->whave - state->wnext, |
1284
|
0
|
|
|
|
|
state->window, state->wnext); |
1285
|
|
|
|
|
|
} |
1286
|
0
|
|
|
|
|
if (dictLength != Z_NULL) |
1287
|
0
|
|
|
|
|
*dictLength = state->whave; |
1288
|
|
|
|
|
|
return Z_OK; |
1289
|
|
|
|
|
|
} |
1290
|
|
|
|
|
|
|
1291
|
4
|
|
|
|
|
int ZEXPORT inflateSetDictionary( |
1292
|
|
|
|
|
|
z_streamp strm, |
1293
|
|
|
|
|
|
const Bytef *dictionary, |
1294
|
|
|
|
|
|
uInt dictLength) |
1295
|
|
|
|
|
|
{ |
1296
|
|
|
|
|
|
struct inflate_state FAR *state; |
1297
|
|
|
|
|
|
unsigned long dictid; |
1298
|
|
|
|
|
|
int ret; |
1299
|
|
|
|
|
|
|
1300
|
|
|
|
|
|
/* check state */ |
1301
|
4
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
1302
|
4
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
1303
|
4
|
|
|
|
|
if (state->wrap != 0 && state->mode != DICT) |
1304
|
|
|
|
|
|
return Z_STREAM_ERROR; |
1305
|
|
|
|
|
|
|
1306
|
|
|
|
|
|
/* check for correct dictionary identifier */ |
1307
|
4
|
|
|
|
|
if (state->mode == DICT) { |
1308
|
4
|
|
|
|
|
dictid = adler32(0L, Z_NULL, 0); |
1309
|
4
|
|
|
|
|
dictid = adler32(dictid, dictionary, dictLength); |
1310
|
4
|
|
|
|
|
if (dictid != state->check) |
1311
|
|
|
|
|
|
return Z_DATA_ERROR; |
1312
|
|
|
|
|
|
} |
1313
|
|
|
|
|
|
|
1314
|
|
|
|
|
|
/* copy dictionary to window using updatewindow(), which will amend the |
1315
|
|
|
|
|
|
existing dictionary if appropriate */ |
1316
|
4
|
|
|
|
|
ret = updatewindow(strm, dictionary + dictLength, dictLength); |
1317
|
4
|
|
|
|
|
if (ret) { |
1318
|
0
|
|
|
|
|
state->mode = MEM; |
1319
|
0
|
|
|
|
|
return Z_MEM_ERROR; |
1320
|
|
|
|
|
|
} |
1321
|
4
|
|
|
|
|
state->havedict = 1; |
1322
|
|
|
|
|
|
Tracev((stderr, "inflate: dictionary set\n")); |
1323
|
4
|
|
|
|
|
return Z_OK; |
1324
|
|
|
|
|
|
} |
1325
|
|
|
|
|
|
|
1326
|
0
|
|
|
|
|
int ZEXPORT inflateGetHeader( |
1327
|
|
|
|
|
|
z_streamp strm, |
1328
|
|
|
|
|
|
gz_headerp head) |
1329
|
|
|
|
|
|
{ |
1330
|
|
|
|
|
|
struct inflate_state FAR *state; |
1331
|
|
|
|
|
|
|
1332
|
|
|
|
|
|
/* check state */ |
1333
|
0
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
1334
|
0
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
1335
|
0
|
|
|
|
|
if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; |
1336
|
|
|
|
|
|
|
1337
|
|
|
|
|
|
/* save header structure */ |
1338
|
0
|
|
|
|
|
state->head = head; |
1339
|
0
|
|
|
|
|
head->done = 0; |
1340
|
0
|
|
|
|
|
return Z_OK; |
1341
|
|
|
|
|
|
} |
1342
|
|
|
|
|
|
|
1343
|
|
|
|
|
|
/* |
1344
|
|
|
|
|
|
Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found |
1345
|
|
|
|
|
|
or when out of input. When called, *have is the number of pattern bytes |
1346
|
|
|
|
|
|
found in order so far, in 0..3. On return *have is updated to the new |
1347
|
|
|
|
|
|
state. If on return *have equals four, then the pattern was found and the |
1348
|
|
|
|
|
|
return value is how many bytes were read including the last byte of the |
1349
|
|
|
|
|
|
pattern. If *have is less than four, then the pattern has not been found |
1350
|
|
|
|
|
|
yet and the return value is len. In the latter case, syncsearch() can be |
1351
|
|
|
|
|
|
called again with more data and the *have state. *have is initialized to |
1352
|
|
|
|
|
|
zero for the first call. |
1353
|
|
|
|
|
|
*/ |
1354
|
|
|
|
|
|
local unsigned syncsearch( |
1355
|
|
|
|
|
|
unsigned FAR *have, |
1356
|
|
|
|
|
|
const unsigned char FAR *buf, |
1357
|
|
|
|
|
|
unsigned len) |
1358
|
|
|
|
|
|
{ |
1359
|
|
|
|
|
|
unsigned got; |
1360
|
|
|
|
|
|
unsigned next; |
1361
|
|
|
|
|
|
|
1362
|
3068
|
|
|
|
|
got = *have; |
1363
|
|
|
|
|
|
next = 0; |
1364
|
6788
|
|
|
|
|
while (next < len && got < 4) { |
1365
|
3720
|
|
|
|
|
if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) |
1366
|
110
|
|
|
|
|
got++; |
1367
|
3610
|
|
|
|
|
else if (buf[next]) |
1368
|
|
|
|
|
|
got = 0; |
1369
|
|
|
|
|
|
else |
1370
|
44
|
|
|
|
|
got = 4 - got; |
1371
|
3720
|
|
|
|
|
next++; |
1372
|
|
|
|
|
|
} |
1373
|
3068
|
|
|
|
|
*have = got; |
1374
|
|
|
|
|
|
return next; |
1375
|
|
|
|
|
|
} |
1376
|
|
|
|
|
|
|
1377
|
3044
|
|
|
|
|
int ZEXPORT inflateSync( |
1378
|
|
|
|
|
|
z_streamp strm) |
1379
|
|
|
|
|
|
{ |
1380
|
|
|
|
|
|
unsigned len; /* number of bytes to look at or looked at */ |
1381
|
|
|
|
|
|
unsigned long in, out; /* temporary to save total_in and total_out */ |
1382
|
|
|
|
|
|
unsigned char buf[4]; /* to restore bit buffer to byte string */ |
1383
|
|
|
|
|
|
struct inflate_state FAR *state; |
1384
|
|
|
|
|
|
|
1385
|
|
|
|
|
|
/* check parameters */ |
1386
|
3044
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
1387
|
3044
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
1388
|
3044
|
|
|
|
|
if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; |
1389
|
|
|
|
|
|
|
1390
|
|
|
|
|
|
/* if first time, start search in bit buffer */ |
1391
|
3044
|
|
|
|
|
if (state->mode != SYNC) { |
1392
|
24
|
|
|
|
|
state->mode = SYNC; |
1393
|
24
|
|
|
|
|
state->hold <<= state->bits & 7; |
1394
|
24
|
|
|
|
|
state->bits -= state->bits & 7; |
1395
|
|
|
|
|
|
len = 0; |
1396
|
56
|
|
|
|
|
while (state->bits >= 8) { |
1397
|
8
|
|
|
|
|
buf[len++] = (unsigned char)(state->hold); |
1398
|
8
|
|
|
|
|
state->hold >>= 8; |
1399
|
8
|
|
|
|
|
state->bits -= 8; |
1400
|
|
|
|
|
|
} |
1401
|
24
|
|
|
|
|
state->have = 0; |
1402
|
|
|
|
|
|
syncsearch(&(state->have), buf, len); |
1403
|
|
|
|
|
|
} |
1404
|
|
|
|
|
|
|
1405
|
|
|
|
|
|
/* search available input */ |
1406
|
3044
|
|
|
|
|
len = syncsearch(&(state->have), strm->next_in, strm->avail_in); |
1407
|
3044
|
|
|
|
|
strm->avail_in -= len; |
1408
|
3044
|
|
|
|
|
strm->next_in += len; |
1409
|
3044
|
|
|
|
|
strm->total_in += len; |
1410
|
|
|
|
|
|
|
1411
|
|
|
|
|
|
/* return no joy or set up to restart inflate() on a new block */ |
1412
|
3044
|
|
|
|
|
if (state->have != 4) return Z_DATA_ERROR; |
1413
|
16
|
|
|
|
|
in = strm->total_in; out = strm->total_out; |
1414
|
16
|
|
|
|
|
inflateReset(strm); |
1415
|
16
|
|
|
|
|
strm->total_in = in; strm->total_out = out; |
1416
|
16
|
|
|
|
|
state->mode = TYPE; |
1417
|
16
|
|
|
|
|
return Z_OK; |
1418
|
|
|
|
|
|
} |
1419
|
|
|
|
|
|
|
1420
|
|
|
|
|
|
/* |
1421
|
|
|
|
|
|
Returns true if inflate is currently at the end of a block generated by |
1422
|
|
|
|
|
|
Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP |
1423
|
|
|
|
|
|
implementation to provide an additional safety check. PPP uses |
1424
|
|
|
|
|
|
Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored |
1425
|
|
|
|
|
|
block. When decompressing, PPP checks that at the end of input packet, |
1426
|
|
|
|
|
|
inflate is waiting for these length bytes. |
1427
|
|
|
|
|
|
*/ |
1428
|
0
|
|
|
|
|
int ZEXPORT inflateSyncPoint( |
1429
|
|
|
|
|
|
z_streamp strm) |
1430
|
|
|
|
|
|
{ |
1431
|
|
|
|
|
|
struct inflate_state FAR *state; |
1432
|
|
|
|
|
|
|
1433
|
0
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
1434
|
0
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
1435
|
0
|
|
|
|
|
return state->mode == STORED && state->bits == 0; |
1436
|
|
|
|
|
|
} |
1437
|
|
|
|
|
|
|
1438
|
0
|
|
|
|
|
int ZEXPORT inflateCopy( |
1439
|
|
|
|
|
|
z_streamp dest, |
1440
|
|
|
|
|
|
z_streamp source) |
1441
|
|
|
|
|
|
{ |
1442
|
|
|
|
|
|
struct inflate_state FAR *state; |
1443
|
|
|
|
|
|
struct inflate_state FAR *copy; |
1444
|
|
|
|
|
|
unsigned char FAR *window; |
1445
|
|
|
|
|
|
unsigned wsize; |
1446
|
|
|
|
|
|
|
1447
|
|
|
|
|
|
/* check input */ |
1448
|
0
|
|
|
|
|
if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || |
1449
|
0
|
|
|
|
|
source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) |
1450
|
|
|
|
|
|
return Z_STREAM_ERROR; |
1451
|
0
|
|
|
|
|
state = (struct inflate_state FAR *)source->state; |
1452
|
|
|
|
|
|
|
1453
|
|
|
|
|
|
/* allocate space */ |
1454
|
0
|
|
|
|
|
copy = (struct inflate_state FAR *) |
1455
|
0
|
|
|
|
|
ZALLOC(source, 1, sizeof(struct inflate_state)); |
1456
|
0
|
|
|
|
|
if (copy == Z_NULL) return Z_MEM_ERROR; |
1457
|
|
|
|
|
|
window = Z_NULL; |
1458
|
0
|
|
|
|
|
if (state->window != Z_NULL) { |
1459
|
0
|
|
|
|
|
window = (unsigned char FAR *) |
1460
|
0
|
|
|
|
|
ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); |
1461
|
0
|
|
|
|
|
if (window == Z_NULL) { |
1462
|
0
|
|
|
|
|
ZFREE(source, copy); |
1463
|
0
|
|
|
|
|
return Z_MEM_ERROR; |
1464
|
|
|
|
|
|
} |
1465
|
|
|
|
|
|
} |
1466
|
|
|
|
|
|
|
1467
|
|
|
|
|
|
/* copy state */ |
1468
|
0
|
|
|
|
|
zmemcpy((Bytef*)dest, (Bytef*)source, sizeof(z_stream)); |
1469
|
0
|
|
|
|
|
zmemcpy((Bytef*)copy, (Bytef*)state, sizeof(struct inflate_state)); |
1470
|
0
|
|
|
|
|
if (state->lencode >= state->codes && |
1471
|
0
|
|
|
|
|
state->lencode <= state->codes + ENOUGH - 1) { |
1472
|
0
|
|
|
|
|
copy->lencode = copy->codes + (state->lencode - state->codes); |
1473
|
0
|
|
|
|
|
copy->distcode = copy->codes + (state->distcode - state->codes); |
1474
|
|
|
|
|
|
} |
1475
|
0
|
|
|
|
|
copy->next = copy->codes + (state->next - state->codes); |
1476
|
0
|
|
|
|
|
if (window != Z_NULL) { |
1477
|
0
|
|
|
|
|
wsize = 1U << state->wbits; |
1478
|
0
|
|
|
|
|
zmemcpy(window, state->window, wsize); |
1479
|
|
|
|
|
|
} |
1480
|
0
|
|
|
|
|
copy->window = window; |
1481
|
0
|
|
|
|
|
dest->state = (struct internal_state FAR *)copy; |
1482
|
0
|
|
|
|
|
return Z_OK; |
1483
|
|
|
|
|
|
} |
1484
|
|
|
|
|
|
|
1485
|
0
|
|
|
|
|
int ZEXPORT inflateUndermine( |
1486
|
|
|
|
|
|
z_streamp strm, |
1487
|
|
|
|
|
|
int subvert) |
1488
|
|
|
|
|
|
{ |
1489
|
|
|
|
|
|
struct inflate_state FAR *state; |
1490
|
|
|
|
|
|
|
1491
|
0
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
1492
|
0
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
1493
|
0
|
|
|
|
|
state->sane = !subvert; |
1494
|
|
|
|
|
|
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR |
1495
|
|
|
|
|
|
return Z_OK; |
1496
|
|
|
|
|
|
#else |
1497
|
0
|
|
|
|
|
state->sane = 1; |
1498
|
0
|
|
|
|
|
return Z_DATA_ERROR; |
1499
|
|
|
|
|
|
#endif |
1500
|
|
|
|
|
|
} |
1501
|
|
|
|
|
|
|
1502
|
0
|
|
|
|
|
long ZEXPORT inflateMark( |
1503
|
|
|
|
|
|
z_streamp strm) |
1504
|
|
|
|
|
|
{ |
1505
|
|
|
|
|
|
struct inflate_state FAR *state; |
1506
|
|
|
|
|
|
|
1507
|
0
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; |
1508
|
0
|
|
|
|
|
state = (struct inflate_state FAR *)strm->state; |
1509
|
0
|
|
|
|
|
return ((long)(state->back) << 16) + |
1510
|
0
|
|
|
|
|
(state->mode == COPY ? state->length : |
1511
|
0
|
|
|
|
|
(state->mode == MATCH ? state->was - state->length : 0)); |
1512
|
|
|
|
|
|
} |