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