Fossil SCM

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

Keyboard Shortcuts

Open search /
Next entry (timeline) j
Previous entry (timeline) k
Open focused entry Enter
Show this help ?
Toggle theme Top nav button