ReactOS 0.4.15-dev-8021-g7ce96fd
Classes | Macros | Enumerations | Functions
inflate.c File Reference
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include "winternl.h"
#include "zlib.h"
Include dependency graph for inflate.c:

Go to the source code of this file.

Classes

struct  code
 
struct  inflate_state
 

Macros

#define DEF_WBITS   MAX_WBITS
 
#define zmemcpy   memcpy
 
#define zmemzero(dest, len)   memset(dest, 0, len)
 
#define Assert(cond, msg)
 
#define Trace(x)
 
#define Tracev(x)
 
#define Tracevv(x)
 
#define Tracecv(c, x)
 
#define GUNZIP
 
#define ZALLOC(strm, items, size)    (*((strm)->zalloc))((strm)->opaque, (items), (size))
 
#define ZFREE(strm, addr)   (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
 
#define TRY_FREE(s, p)   {if (p) ZFREE(s, p);}
 
#define ZSWAP32(q)
 
#define BASE   65521U /* largest prime smaller than 65536 */
 
#define NMAX   5552
 
#define DO1(buf, i)   {adler += (buf)[i]; sum2 += adler;}
 
#define DO2(buf, i)   DO1(buf,i); DO1(buf,i+1);
 
#define DO4(buf, i)   DO2(buf,i); DO2(buf,i+2);
 
#define DO8(buf, i)   DO4(buf,i); DO4(buf,i+4);
 
#define DO16(buf)   DO8(buf,0); DO8(buf,8);
 
#define MOD(a)   a %= BASE
 
#define MOD28(a)   a %= BASE
 
#define MOD63(a)   a %= BASE
 
#define ENOUGH_LENS   852
 
#define ENOUGH_DISTS   592
 
#define ENOUGH   (ENOUGH_LENS+ENOUGH_DISTS)
 
#define MAXBITS   15
 
#define crc32(crc, buf, len)   RtlComputeCrc32(crc,buf,len)
 
#define UPDATE(check, buf, len)    (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
 
#define CRC2(check, word)
 
#define CRC4(check, word)
 
#define LOAD()
 
#define RESTORE()
 
#define INITBITS()
 
#define PULLBYTE()
 
#define NEEDBITS(n)
 
#define BITS(n)    ((unsigned)hold & ((1U << (n)) - 1))
 
#define DROPBITS(n)
 
#define BYTEBITS()
 

Enumerations

enum  codetype {
  CODES , LENS , DISTS , CODES ,
  LENS , DISTS , CODES , LENS ,
  DISTS
}
 
enum  inflate_mode {
  HEAD = 16180 , FLAGS , TIME , OS ,
  EXLEN , EXTRA , NAME , COMMENT ,
  HCRC , DICTID , DICT , TYPE ,
  TYPEDO , STORED , COPY_ , COPY ,
  TABLE , LENLENS , CODELENS , LEN_ ,
  LEN , LENEXT , DIST , DISTEXT ,
  MATCH , LIT , CHECK , LENGTH ,
  DONE , BAD , MEM , SYNC ,
  HEAD = 16180 , FLAGS , TIME , OS ,
  EXLEN , EXTRA , NAME , COMMENT ,
  HCRC , DICTID , DICT , TYPE ,
  TYPEDO , STORED , COPY_ , COPY ,
  TABLE , LENLENS , CODELENS , LEN_ ,
  LEN , LENEXT , DIST , DISTEXT ,
  MATCH , LIT , CHECK , LENGTH ,
  DONE , BAD , MEM , SYNC ,
  METHOD , FLAG , DICT4 , DICT3 ,
  DICT2 , DICT1 , DICT0 , BLOCKS ,
  CHECK4 , CHECK3 , CHECK2 , CHECK1 ,
  DONE , BAD , HEAD = 16180 , FLAGS ,
  TIME , OS , EXLEN , EXTRA ,
  NAME , COMMENT , HCRC , DICTID ,
  DICT , TYPE , TYPEDO , STORED ,
  COPY_ , COPY , TABLE , LENLENS ,
  CODELENS , LEN_ , LEN , LENEXT ,
  DIST , DISTEXT , MATCH , LIT ,
  CHECK , LENGTH , DONE , BAD ,
  MEM , SYNC
}
 

Functions

static uLong adler32 (uLong adler, const Bytef *buf, uInt len)
 
static void inflate_fast (z_streamp strm, unsigned start)
 
static int inflate_table (codetype type, unsigned short FAR *lens, unsigned codes, code FAR *FAR *table, unsigned FAR *bits, unsigned short FAR *work)
 
static int inflateStateCheck (z_streamp strm)
 
static int inflateResetKeep (z_streamp strm)
 
static int inflateReset (z_streamp strm)
 
static int inflateReset2 (z_streamp strm, int windowBits)
 
int inflateInit2 (z_streamp strm, int windowBits)
 
int inflateInit (z_streamp strm)
 
static void fixedtables (struct inflate_state FAR *state)
 
static int updatewindow (z_streamp strm, const Bytef *end, unsigned copy)
 
int inflate (z_streamp strm, int flush)
 
int inflateEnd (z_streamp strm)
 

Macro Definition Documentation

◆ Assert

#define Assert (   cond,
  msg 
)

Definition at line 41 of file inflate.c.

◆ BASE

#define BASE   65521U /* largest prime smaller than 65536 */

Definition at line 58 of file inflate.c.

◆ BITS

#define BITS (   n)     ((unsigned)hold & ((1U << (n)) - 1))

Definition at line 1158 of file inflate.c.

◆ BYTEBITS

#define BYTEBITS ( )
Value:
do { \
hold >>= bits & 7; \
bits -= bits & 7; \
} while (0)
bits
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929

Definition at line 1169 of file inflate.c.

◆ CRC2

#define CRC2 (   check,
  word 
)
Value:
do { \
hbuf[0] = (unsigned char)(word); \
hbuf[1] = (unsigned char)((word) >> 8); \
check = crc32(check, hbuf, 2); \
} while (0)
crc32
#define crc32(crc, buf, len)
Definition: inflate.c:1081
char
unsigned char
Definition: typeof.h:29
check
#define check(expected, result)
Definition: dplayx.c:32
word
const WCHAR * word
Definition: lex.c:36

Definition at line 1093 of file inflate.c.

◆ crc32

#define crc32 (   crc,
  buf,
  len 
)    RtlComputeCrc32(crc,buf,len)

Definition at line 1081 of file inflate.c.

◆ CRC4

#define CRC4 (   check,
  word 
)
Value:
do { \
hbuf[0] = (unsigned char)(word); \
hbuf[1] = (unsigned char)((word) >> 8); \
hbuf[2] = (unsigned char)((word) >> 16); \
hbuf[3] = (unsigned char)((word) >> 24); \
check = crc32(check, hbuf, 4); \
} while (0)

Definition at line 1100 of file inflate.c.

◆ DEF_WBITS

#define DEF_WBITS   MAX_WBITS

Definition at line 37 of file inflate.c.

◆ DO1

#define DO1 (   buf,
  i 
)    {adler += (buf)[i]; sum2 += adler;}

Definition at line 62 of file inflate.c.

◆ DO16

#define DO16 (   buf)    DO8(buf,0); DO8(buf,8);

Definition at line 66 of file inflate.c.

◆ DO2

#define DO2 (   buf,
  i 
)    DO1(buf,i); DO1(buf,i+1);

Definition at line 63 of file inflate.c.

◆ DO4

#define DO4 (   buf,
  i 
)    DO2(buf,i); DO2(buf,i+2);

Definition at line 64 of file inflate.c.

◆ DO8

#define DO8 (   buf,
  i 
)    DO4(buf,i); DO4(buf,i+4);

Definition at line 65 of file inflate.c.

◆ DROPBITS

#define DROPBITS (   n)
Value:
do { \
hold >>= (n); \
bits -= (unsigned)(n); \
} while (0)
n
GLdouble n
Definition: glext.h:7729
unsigned
static unsigned(__cdecl *hash_bstr)(bstr_t s)

Definition at line 1162 of file inflate.c.

◆ ENOUGH

#define ENOUGH   (ENOUGH_LENS+ENOUGH_DISTS)

Definition at line 147 of file inflate.c.

◆ ENOUGH_DISTS

#define ENOUGH_DISTS   592

Definition at line 146 of file inflate.c.

◆ ENOUGH_LENS

#define ENOUGH_LENS   852

Definition at line 145 of file inflate.c.

◆ GUNZIP

#define GUNZIP

Definition at line 47 of file inflate.c.

◆ INITBITS

#define INITBITS ( )
Value:
do { \
hold = 0; \
bits = 0; \
} while (0)

Definition at line 1133 of file inflate.c.

◆ LOAD

#define LOAD ( )
Value:
do { \
put = strm->next_out; \
left = strm->avail_out; \
next = strm->next_in; \
have = strm->avail_in; \
hold = state->hold; \
bits = state->bits; \
} while (0)
state
static int state
Definition: maze.c:121
left
GLint left
Definition: glext.h:7726
put
#define put(ret, state, sp, n)
Definition: match.c:105
next
static unsigned __int64 next
Definition: rand_nt.c:6

Definition at line 1111 of file inflate.c.

◆ MAXBITS

#define MAXBITS   15

Definition at line 531 of file inflate.c.

◆ MOD

#define MOD (   a)    a %= BASE

Definition at line 68 of file inflate.c.

◆ MOD28

#define MOD28 (   a)    a %= BASE

Definition at line 69 of file inflate.c.

◆ MOD63

#define MOD63 (   a)    a %= BASE

Definition at line 70 of file inflate.c.

◆ NEEDBITS

#define NEEDBITS (   n)
Value:
do { \
while (bits < (unsigned)(n)) \
PULLBYTE(); \
} while (0)

Definition at line 1151 of file inflate.c.

◆ NMAX

#define NMAX   5552

Definition at line 59 of file inflate.c.

◆ PULLBYTE

#define PULLBYTE ( )
Value:
do { \
if (have == 0) goto inf_leave; \
have--; \
hold += (unsigned long)(*next++) << bits; \
bits += 8; \
} while (0)
while
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))

Definition at line 1141 of file inflate.c.

◆ RESTORE

#define RESTORE ( )
Value:
do { \
strm->next_out = put; \
strm->avail_out = left; \
strm->next_in = next; \
strm->avail_in = have; \
state->hold = hold; \
state->bits = bits; \
} while (0)
bits
#define bits
Definition: infblock.c:15

Definition at line 1122 of file inflate.c.

◆ Trace

#define Trace (   x)

Definition at line 42 of file inflate.c.

◆ Tracecv

#define Tracecv (   c,
  x 
)

Definition at line 45 of file inflate.c.

◆ Tracev

#define Tracev (   x)

Definition at line 43 of file inflate.c.

◆ Tracevv

#define Tracevv (   x)

Definition at line 44 of file inflate.c.

◆ TRY_FREE

#define TRY_FREE (   s,
  p 
)    {if (p) ZFREE(s, p);}

Definition at line 52 of file inflate.c.

◆ UPDATE

#define UPDATE (   check,
  buf,
  len 
)     (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))

Definition at line 1085 of file inflate.c.

◆ ZALLOC

#define ZALLOC (   strm,
  items,
  size 
)     (*((strm)->zalloc))((strm)->opaque, (items), (size))

Definition at line 49 of file inflate.c.

◆ ZFREE

#define ZFREE (   strm,
  addr 
)    (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))

Definition at line 51 of file inflate.c.

◆ zmemcpy

#define zmemcpy   memcpy

Definition at line 38 of file inflate.c.

◆ zmemzero

#define zmemzero (   dest,
  len 
)    memset(dest, 0, len)

Definition at line 39 of file inflate.c.

◆ ZSWAP32

#define ZSWAP32 (   q)
Value:
((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
(((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
q
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063

Definition at line 55 of file inflate.c.

Enumeration Type Documentation

◆ codetype

enum codetype
Enumerator
CODES 
LENS 
DISTS 
CODES 
LENS 
DISTS 
CODES 
LENS 
DISTS 

Definition at line 150 of file inflate.c.

150 {
151 CODES,
152 LENS,
153 DISTS
154} codetype;
codetype
codetype
Definition: inflate.c:150
CODES
@ CODES
Definition: inflate.c:151
LENS
@ LENS
Definition: inflate.c:152
DISTS
@ DISTS
Definition: inflate.c:153

◆ inflate_mode

enum inflate_mode
Enumerator
HEAD 
FLAGS 
TIME 
OS 
EXLEN 
EXTRA 
NAME 
COMMENT 
HCRC 
DICTID 
DICT 
TYPE 
TYPEDO 
STORED 
COPY_ 
COPY 
TABLE 
LENLENS 
CODELENS 
LEN_ 
LEN 
LENEXT 
DIST 
DISTEXT 
MATCH 
LIT 
CHECK 
LENGTH 
DONE 
BAD 
MEM 
SYNC 
HEAD 
FLAGS 
TIME 
OS 
EXLEN 
EXTRA 
NAME 
COMMENT 
HCRC 
DICTID 
DICT 
TYPE 
TYPEDO 
STORED 
COPY_ 
COPY 
TABLE 
LENLENS 
CODELENS 
LEN_ 
LEN 
LENEXT 
DIST 
DISTEXT 
MATCH 
LIT 
CHECK 
LENGTH 
DONE 
BAD 
MEM 
SYNC 
METHOD 
FLAG 
DICT4 
DICT3 
DICT2 
DICT1 
DICT0 
BLOCKS 
CHECK4 
CHECK3 
CHECK2 
CHECK1 
DONE 
BAD 
HEAD 
FLAGS 
TIME 
OS 
EXLEN 
EXTRA 
NAME 
COMMENT 
HCRC 
DICTID 
DICT 
TYPE 
TYPEDO 
STORED 
COPY_ 
COPY 
TABLE 
LENLENS 
CODELENS 
LEN_ 
LEN 
LENEXT 
DIST 
DISTEXT 
MATCH 
LIT 
CHECK 
LENGTH 
DONE 
BAD 
MEM 
SYNC 

Definition at line 157 of file inflate.c.

157 {
158 HEAD = 16180, /* i: waiting for magic header */
159 FLAGS, /* i: waiting for method and flags (gzip) */
160 TIME, /* i: waiting for modification time (gzip) */
161 OS, /* i: waiting for extra flags and operating system (gzip) */
162 EXLEN, /* i: waiting for extra length (gzip) */
163 EXTRA, /* i: waiting for extra bytes (gzip) */
164 NAME, /* i: waiting for end of file name (gzip) */
165 COMMENT, /* i: waiting for end of comment (gzip) */
166 HCRC, /* i: waiting for header crc (gzip) */
167 DICTID, /* i: waiting for dictionary check value */
168 DICT, /* waiting for inflateSetDictionary() call */
169 TYPE, /* i: waiting for type bits, including last-flag bit */
170 TYPEDO, /* i: same, but skip check to exit inflate on new block */
171 STORED, /* i: waiting for stored size (length and complement) */
172 COPY_, /* i/o: same as COPY below, but only first time in */
173 COPY, /* i/o: waiting for input or output to copy stored block */
174 TABLE, /* i: waiting for dynamic block table lengths */
175 LENLENS, /* i: waiting for code length code lengths */
176 CODELENS, /* i: waiting for length/lit and distance code lengths */
177 LEN_, /* i: same as LEN below, but only first time in */
178 LEN, /* i: waiting for length/lit/eob code */
179 LENEXT, /* i: waiting for length extra bits */
180 DIST, /* i: waiting for distance code */
181 DISTEXT, /* i: waiting for distance extra bits */
182 MATCH, /* o: waiting for output space to copy string */
183 LIT, /* o: waiting for output space to write literal */
184 CHECK, /* i: waiting for 32-bit check value */
185 LENGTH, /* i: waiting for 32-bit length (gzip) */
186 DONE, /* finished check, done -- remain here until reset */
187 BAD, /* got a data error -- remain here until reset */
188 MEM, /* got an inflate() memory error -- remain here until reset */
189 SYNC /* looking for synchronization bytes to restart inflate() */
190} inflate_mode;
inflate_mode
inflate_mode
Definition: inflate.c:157
MATCH
@ MATCH
Definition: inflate.c:182
DICT
@ DICT
Definition: inflate.c:168
TABLE
@ TABLE
Definition: inflate.c:174
LENGTH
@ LENGTH
Definition: inflate.c:185
FLAGS
@ FLAGS
Definition: inflate.c:159
LIT
@ LIT
Definition: inflate.c:183
SYNC
@ SYNC
Definition: inflate.c:189
OS
@ OS
Definition: inflate.c:161
EXLEN
@ EXLEN
Definition: inflate.c:162
MEM
@ MEM
Definition: inflate.c:188
NAME
@ NAME
Definition: inflate.c:164
STORED
@ STORED
Definition: inflate.c:171
CODELENS
@ CODELENS
Definition: inflate.c:176
DICTID
@ DICTID
Definition: inflate.c:167
DONE
@ DONE
Definition: inflate.c:186
TYPEDO
@ TYPEDO
Definition: inflate.c:170
COMMENT
@ COMMENT
Definition: inflate.c:165
LENLENS
@ LENLENS
Definition: inflate.c:175
TYPE
@ TYPE
Definition: inflate.c:169
COPY
@ COPY
Definition: inflate.c:173
LEN_
@ LEN_
Definition: inflate.c:177
COPY_
@ COPY_
Definition: inflate.c:172
DIST
@ DIST
Definition: inflate.c:180
LENEXT
@ LENEXT
Definition: inflate.c:179
HCRC
@ HCRC
Definition: inflate.c:166
TIME
@ TIME
Definition: inflate.c:160
CHECK
@ CHECK
Definition: inflate.c:184
DISTEXT
@ DISTEXT
Definition: inflate.c:181
BAD
@ BAD
Definition: inflate.c:187
LEN
@ LEN
Definition: inflate.c:178
EXTRA
@ EXTRA
Definition: inflate.c:163
_HEAD
Definition: ntuser.h:180

Function Documentation

◆ adler32()

static uLong adler32 ( uLong  adler,
const Bytef *  buf,
uInt  len 
)
static

Definition at line 72 of file inflate.c.

73{
74 unsigned long sum2;
75 unsigned n;
76
77 /* split Adler-32 into component sums */
78 sum2 = (adler >> 16) & 0xffff;
79 adler &= 0xffff;
80
81 /* in case user likes doing a byte at a time, keep it fast */
82 if (len == 1) {
83 adler += buf[0];
84 if (adler >= BASE)
85 adler -= BASE;
86 sum2 += adler;
87 if (sum2 >= BASE)
88 sum2 -= BASE;
89 return adler | (sum2 << 16);
90 }
91
92 /* initial Adler-32 value (deferred check for len == 1 speed) */
93 if (buf == Z_NULL)
94 return 1L;
95
96 /* in case short lengths are provided, keep it somewhat fast */
97 if (len < 16) {
98 while (len--) {
99 adler += *buf++;
100 sum2 += adler;
101 }
102 if (adler >= BASE)
103 adler -= BASE;
104 MOD28(sum2); /* only added so many BASE's */
105 return adler | (sum2 << 16);
106 }
107
108 /* do length NMAX blocks -- requires just one modulo operation */
109 while (len >= NMAX) {
110 len -= NMAX;
111 n = NMAX / 16; /* NMAX is divisible by 16 */
112 do {
113 DO16(buf); /* 16 sums unrolled */
114 buf += 16;
115 } while (--n);
116 MOD(adler);
117 MOD(sum2);
118 }
119
120 /* do remaining bytes (less than NMAX, still just one modulo) */
121 if (len) { /* avoid modulos if none remaining */
122 while (len >= 16) {
123 len -= 16;
124 DO16(buf);
125 buf += 16;
126 }
127 while (len--) {
128 adler += *buf++;
129 sum2 += adler;
130 }
131 MOD(adler);
132 MOD(sum2);
133 }
134
135 /* return recombined sums */
136 return adler | (sum2 << 16);
137}
MOD28
#define MOD28(a)
Definition: inflate.c:69
NMAX
#define NMAX
Definition: inflate.c:59
DO16
#define DO16(buf)
Definition: inflate.c:66
BASE
#define BASE
Definition: inflate.c:58
MOD
#define MOD(a)
Definition: inflate.c:68
Z_NULL
#define Z_NULL
Definition: zlib.h:149
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
len
GLenum GLsizei len
Definition: glext.h:6722

Referenced by deflate(), deflateResetKeep(), deflateSetDictionary(), inflate(), inflateSetDictionary(), and read_buf().

◆ fixedtables()

static void fixedtables ( struct inflate_state FAR *  state)
static

Definition at line 924 of file inflate.c.

925{
926 static const code lenfix[512] = {
927 {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
928 {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
929 {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
930 {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
931 {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
932 {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
933 {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
934 {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
935 {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
936 {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
937 {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
938 {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
939 {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
940 {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
941 {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
942 {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
943 {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
944 {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
945 {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
946 {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
947 {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
948 {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
949 {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
950 {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
951 {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
952 {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
953 {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
954 {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
955 {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
956 {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
957 {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
958 {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
959 {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
960 {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
961 {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
962 {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
963 {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
964 {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
965 {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
966 {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
967 {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
968 {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
969 {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
970 {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
971 {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
972 {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
973 {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
974 {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
975 {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
976 {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
977 {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
978 {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
979 {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
980 {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
981 {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
982 {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
983 {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
984 {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
985 {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
986 {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
987 {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
988 {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
989 {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
990 {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
991 {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
992 {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
993 {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
994 {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
995 {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
996 {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
997 {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
998 {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
999 {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
1000 {0,9,255}
1001 };
1002
1003 static const code distfix[32] = {
1004 {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
1005 {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
1006 {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
1007 {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
1008 {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
1009 {22,5,193},{64,5,0}
1010 };
1011
1012 state->lencode = lenfix;
1013 state->lenbits = 9;
1014 state->distcode = distfix;
1015 state->distbits = 5;
1016}
code
Definition: inflate.c:139
distfix
static const code distfix[32]
Definition: inffixed.h:87
lenfix
static const code lenfix[512]
Definition: inffixed.h:10

Referenced by inflate().

◆ inflate()

int inflate ( z_streamp  strm,
int  flush 
)

Definition at line 1257 of file inflate.c.

1258{
1259 struct inflate_state FAR *state;
1260 z_const unsigned char FAR *next; /* next input */
1261 unsigned char FAR *put; /* next output */
1262 unsigned have, left; /* available input and output */
1263 unsigned long hold; /* bit buffer */
1264 unsigned bits; /* bits in bit buffer */
1265 unsigned in, out; /* save starting available input and output */
1266 unsigned copy; /* number of stored or match bytes to copy */
1267 unsigned char FAR *from; /* where to copy match bytes from */
1268 code here; /* current decoding table entry */
1269 code last; /* parent table entry */
1270 unsigned len; /* length to copy for repeats, bits to drop */
1271 int ret; /* return code */
1272#ifdef GUNZIP
1273 unsigned char hbuf[4]; /* buffer for gzip header crc calculation */
1274#endif
1275 static const unsigned short order[19] = /* permutation of code lengths */
1276 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
1277
1278 if (inflateStateCheck(strm) || strm->next_out == Z_NULL ||
1279 (strm->next_in == Z_NULL && strm->avail_in != 0))
1280 return Z_STREAM_ERROR;
1281
1282 state = (struct inflate_state FAR *)strm->state;
1283 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
1284 LOAD();
1285 in = have;
1286 out = left;
1287 ret = Z_OK;
1288 for (;;)
1289 switch (state->mode) {
1290 case HEAD:
1291 if (state->wrap == 0) {
1292 state->mode = TYPEDO;
1293 break;
1294 }
1295 NEEDBITS(16);
1296#ifdef GUNZIP
1297 if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
1298 if (state->wbits == 0)
1299 state->wbits = 15;
1300 state->check = crc32(0L, Z_NULL, 0);
1301 CRC2(state->check, hold);
1302 INITBITS();
1303 state->mode = FLAGS;
1304 break;
1305 }
1306 state->flags = 0; /* expect zlib header */
1307 if (state->head != Z_NULL)
1308 state->head->done = -1;
1309 if (!(state->wrap & 1) || /* check if zlib header allowed */
1310#else
1311 if (
1312#endif
1313 ((BITS(8) << 8) + (hold >> 8)) % 31) {
1314 strm->msg = (char *)"incorrect header check";
1315 state->mode = BAD;
1316 break;
1317 }
1318 if (BITS(4) != Z_DEFLATED) {
1319 strm->msg = (char *)"unknown compression method";
1320 state->mode = BAD;
1321 break;
1322 }
1323 DROPBITS(4);
1324 len = BITS(4) + 8;
1325 if (state->wbits == 0)
1326 state->wbits = len;
1327 if (len > 15 || len > state->wbits) {
1328 strm->msg = (char *)"invalid window size";
1329 state->mode = BAD;
1330 break;
1331 }
1332 state->dmax = 1U << len;
1333 Tracev((stderr, "inflate: zlib header ok\n"));
1334 strm->adler = state->check = adler32(0L, Z_NULL, 0);
1335 state->mode = hold & 0x200 ? DICTID : TYPE;
1336 INITBITS();
1337 break;
1338#ifdef GUNZIP
1339 case FLAGS:
1340 NEEDBITS(16);
1341 state->flags = (int)(hold);
1342 if ((state->flags & 0xff) != Z_DEFLATED) {
1343 strm->msg = (char *)"unknown compression method";
1344 state->mode = BAD;
1345 break;
1346 }
1347 if (state->flags & 0xe000) {
1348 strm->msg = (char *)"unknown header flags set";
1349 state->mode = BAD;
1350 break;
1351 }
1352 if (state->head != Z_NULL)
1353 state->head->text = (int)((hold >> 8) & 1);
1354 if ((state->flags & 0x0200) && (state->wrap & 4))
1355 CRC2(state->check, hold);
1356 INITBITS();
1357 state->mode = TIME;
1358 case TIME:
1359 NEEDBITS(32);
1360 if (state->head != Z_NULL)
1361 state->head->time = hold;
1362 if ((state->flags & 0x0200) && (state->wrap & 4))
1363 CRC4(state->check, hold);
1364 INITBITS();
1365 state->mode = OS;
1366 case OS:
1367 NEEDBITS(16);
1368 if (state->head != Z_NULL) {
1369 state->head->xflags = (int)(hold & 0xff);
1370 state->head->os = (int)(hold >> 8);
1371 }
1372 if ((state->flags & 0x0200) && (state->wrap & 4))
1373 CRC2(state->check, hold);
1374 INITBITS();
1375 state->mode = EXLEN;
1376 case EXLEN:
1377 if (state->flags & 0x0400) {
1378 NEEDBITS(16);
1379 state->length = (unsigned)(hold);
1380 if (state->head != Z_NULL)
1381 state->head->extra_len = (unsigned)hold;
1382 if ((state->flags & 0x0200) && (state->wrap & 4))
1383 CRC2(state->check, hold);
1384 INITBITS();
1385 }
1386 else if (state->head != Z_NULL)
1387 state->head->extra = Z_NULL;
1388 state->mode = EXTRA;
1389 case EXTRA:
1390 if (state->flags & 0x0400) {
1391 copy = state->length;
1392 if (copy > have) copy = have;
1393 if (copy) {
1394 if (state->head != Z_NULL &&
1395 state->head->extra != Z_NULL) {
1396 len = state->head->extra_len - state->length;
1397 zmemcpy(state->head->extra + len, next,
1398 len + copy > state->head->extra_max ?
1399 state->head->extra_max - len : copy);
1400 }
1401 if ((state->flags & 0x0200) && (state->wrap & 4))
1402 state->check = crc32(state->check, next, copy);
1403 have -= copy;
1404 next += copy;
1405 state->length -= copy;
1406 }
1407 if (state->length) goto inf_leave;
1408 }
1409 state->length = 0;
1410 state->mode = NAME;
1411 case NAME:
1412 if (state->flags & 0x0800) {
1413 if (have == 0) goto inf_leave;
1414 copy = 0;
1415 do {
1416 len = (unsigned)(next[copy++]);
1417 if (state->head != Z_NULL &&
1418 state->head->name != Z_NULL &&
1419 state->length < state->head->name_max)
1420 state->head->name[state->length++] = (Bytef)len;
1421 } while (len && copy < have);
1422 if ((state->flags & 0x0200) && (state->wrap & 4))
1423 state->check = crc32(state->check, next, copy);
1424 have -= copy;
1425 next += copy;
1426 if (len) goto inf_leave;
1427 }
1428 else if (state->head != Z_NULL)
1429 state->head->name = Z_NULL;
1430 state->length = 0;
1431 state->mode = COMMENT;
1432 case COMMENT:
1433 if (state->flags & 0x1000) {
1434 if (have == 0) goto inf_leave;
1435 copy = 0;
1436 do {
1437 len = (unsigned)(next[copy++]);
1438 if (state->head != Z_NULL &&
1439 state->head->comment != Z_NULL &&
1440 state->length < state->head->comm_max)
1441 state->head->comment[state->length++] = (Bytef)len;
1442 } while (len && copy < have);
1443 if ((state->flags & 0x0200) && (state->wrap & 4))
1444 state->check = crc32(state->check, next, copy);
1445 have -= copy;
1446 next += copy;
1447 if (len) goto inf_leave;
1448 }
1449 else if (state->head != Z_NULL)
1450 state->head->comment = Z_NULL;
1451 state->mode = HCRC;
1452 case HCRC:
1453 if (state->flags & 0x0200) {
1454 NEEDBITS(16);
1455 if ((state->wrap & 4) && hold != (state->check & 0xffff)) {
1456 strm->msg = (char *)"header crc mismatch";
1457 state->mode = BAD;
1458 break;
1459 }
1460 INITBITS();
1461 }
1462 if (state->head != Z_NULL) {
1463 state->head->hcrc = (int)((state->flags >> 9) & 1);
1464 state->head->done = 1;
1465 }
1466 strm->adler = state->check = crc32(0L, Z_NULL, 0);
1467 state->mode = TYPE;
1468 break;
1469#endif
1470 case DICTID:
1471 NEEDBITS(32);
1472 strm->adler = state->check = ZSWAP32(hold);
1473 INITBITS();
1474 state->mode = DICT;
1475 case DICT:
1476 if (state->havedict == 0) {
1477 RESTORE();
1478 return Z_NEED_DICT;
1479 }
1480 strm->adler = state->check = adler32(0L, Z_NULL, 0);
1481 state->mode = TYPE;
1482 case TYPE:
1483 if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
1484 case TYPEDO:
1485 if (state->last) {
1486 BYTEBITS();
1487 state->mode = CHECK;
1488 break;
1489 }
1490 NEEDBITS(3);
1491 state->last = BITS(1);
1492 DROPBITS(1);
1493 switch (BITS(2)) {
1494 case 0: /* stored block */
1495 Tracev((stderr, "inflate: stored block%s\n",
1496 state->last ? " (last)" : ""));
1497 state->mode = STORED;
1498 break;
1499 case 1: /* fixed block */
1500 fixedtables(state);
1501 Tracev((stderr, "inflate: fixed codes block%s\n",
1502 state->last ? " (last)" : ""));
1503 state->mode = LEN_; /* decode codes */
1504 if (flush == Z_TREES) {
1505 DROPBITS(2);
1506 goto inf_leave;
1507 }
1508 break;
1509 case 2: /* dynamic block */
1510 Tracev((stderr, "inflate: dynamic codes block%s\n",
1511 state->last ? " (last)" : ""));
1512 state->mode = TABLE;
1513 break;
1514 case 3:
1515 strm->msg = (char *)"invalid block type";
1516 state->mode = BAD;
1517 }
1518 DROPBITS(2);
1519 break;
1520 case STORED:
1521 BYTEBITS(); /* go to byte boundary */
1522 NEEDBITS(32);
1523 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
1524 strm->msg = (char *)"invalid stored block lengths";
1525 state->mode = BAD;
1526 break;
1527 }
1528 state->length = (unsigned)hold & 0xffff;
1529 Tracev((stderr, "inflate: stored length %u\n",
1530 state->length));
1531 INITBITS();
1532 state->mode = COPY_;
1533 if (flush == Z_TREES) goto inf_leave;
1534 case COPY_:
1535 state->mode = COPY;
1536 case COPY:
1537 copy = state->length;
1538 if (copy) {
1539 if (copy > have) copy = have;
1540 if (copy > left) copy = left;
1541 if (copy == 0) goto inf_leave;
1542 zmemcpy(put, next, copy);
1543 have -= copy;
1544 next += copy;
1545 left -= copy;
1546 put += copy;
1547 state->length -= copy;
1548 break;
1549 }
1550 Tracev((stderr, "inflate: stored end\n"));
1551 state->mode = TYPE;
1552 break;
1553 case TABLE:
1554 NEEDBITS(14);
1555 state->nlen = BITS(5) + 257;
1556 DROPBITS(5);
1557 state->ndist = BITS(5) + 1;
1558 DROPBITS(5);
1559 state->ncode = BITS(4) + 4;
1560 DROPBITS(4);
1561#ifndef PKZIP_BUG_WORKAROUND
1562 if (state->nlen > 286 || state->ndist > 30) {
1563 strm->msg = (char *)"too many length or distance symbols";
1564 state->mode = BAD;
1565 break;
1566 }
1567#endif
1568 Tracev((stderr, "inflate: table sizes ok\n"));
1569 state->have = 0;
1570 state->mode = LENLENS;
1571 case LENLENS:
1572 while (state->have < state->ncode) {
1573 NEEDBITS(3);
1574 state->lens[order[state->have++]] = (unsigned short)BITS(3);
1575 DROPBITS(3);
1576 }
1577 while (state->have < 19)
1578 state->lens[order[state->have++]] = 0;
1579 state->next = state->codes;
1580 state->lencode = (const code FAR *)(state->next);
1581 state->lenbits = 7;
1582 ret = inflate_table(CODES, state->lens, 19, &(state->next),
1583 &(state->lenbits), state->work);
1584 if (ret) {
1585 strm->msg = (char *)"invalid code lengths set";
1586 state->mode = BAD;
1587 break;
1588 }
1589 Tracev((stderr, "inflate: code lengths ok\n"));
1590 state->have = 0;
1591 state->mode = CODELENS;
1592 case CODELENS:
1593 while (state->have < state->nlen + state->ndist) {
1594 for (;;) {
1595 here = state->lencode[BITS(state->lenbits)];
1596 if ((unsigned)(here.bits) <= bits) break;
1597 PULLBYTE();
1598 }
1599 if (here.val < 16) {
1600 DROPBITS(here.bits);
1601 state->lens[state->have++] = here.val;
1602 }
1603 else {
1604 if (here.val == 16) {
1605 NEEDBITS(here.bits + 2);
1606 DROPBITS(here.bits);
1607 if (state->have == 0) {
1608 strm->msg = (char *)"invalid bit length repeat";
1609 state->mode = BAD;
1610 break;
1611 }
1612 len = state->lens[state->have - 1];
1613 copy = 3 + BITS(2);
1614 DROPBITS(2);
1615 }
1616 else if (here.val == 17) {
1617 NEEDBITS(here.bits + 3);
1618 DROPBITS(here.bits);
1619 len = 0;
1620 copy = 3 + BITS(3);
1621 DROPBITS(3);
1622 }
1623 else {
1624 NEEDBITS(here.bits + 7);
1625 DROPBITS(here.bits);
1626 len = 0;
1627 copy = 11 + BITS(7);
1628 DROPBITS(7);
1629 }
1630 if (state->have + copy > state->nlen + state->ndist) {
1631 strm->msg = (char *)"invalid bit length repeat";
1632 state->mode = BAD;
1633 break;
1634 }
1635 while (copy--)
1636 state->lens[state->have++] = (unsigned short)len;
1637 }
1638 }
1639
1640 /* handle error breaks in while */
1641 if (state->mode == BAD) break;
1642
1643 /* check for end-of-block code (better have one) */
1644 if (state->lens[256] == 0) {
1645 strm->msg = (char *)"invalid code -- missing end-of-block";
1646 state->mode = BAD;
1647 break;
1648 }
1649
1650 /* build code tables -- note: do not change the lenbits or distbits
1651 values here (9 and 6) without reading the comments in inftrees.h
1652 concerning the ENOUGH constants, which depend on those values */
1653 state->next = state->codes;
1654 state->lencode = (const code FAR *)(state->next);
1655 state->lenbits = 9;
1656 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1657 &(state->lenbits), state->work);
1658 if (ret) {
1659 strm->msg = (char *)"invalid literal/lengths set";
1660 state->mode = BAD;
1661 break;
1662 }
1663 state->distcode = (const code FAR *)(state->next);
1664 state->distbits = 6;
1665 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1666 &(state->next), &(state->distbits), state->work);
1667 if (ret) {
1668 strm->msg = (char *)"invalid distances set";
1669 state->mode = BAD;
1670 break;
1671 }
1672 Tracev((stderr, "inflate: codes ok\n"));
1673 state->mode = LEN_;
1674 if (flush == Z_TREES) goto inf_leave;
1675 case LEN_:
1676 state->mode = LEN;
1677 case LEN:
1678 if (have >= 6 && left >= 258) {
1679 RESTORE();
1680 inflate_fast(strm, out);
1681 LOAD();
1682 if (state->mode == TYPE)
1683 state->back = -1;
1684 break;
1685 }
1686 state->back = 0;
1687 for (;;) {
1688 here = state->lencode[BITS(state->lenbits)];
1689 if ((unsigned)(here.bits) <= bits) break;
1690 PULLBYTE();
1691 }
1692 if (here.op && (here.op & 0xf0) == 0) {
1693 last = here;
1694 for (;;) {
1695 here = state->lencode[last.val +
1696 (BITS(last.bits + last.op) >> last.bits)];
1697 if ((unsigned)(last.bits + here.bits) <= bits) break;
1698 PULLBYTE();
1699 }
1700 DROPBITS(last.bits);
1701 state->back += last.bits;
1702 }
1703 DROPBITS(here.bits);
1704 state->back += here.bits;
1705 state->length = (unsigned)here.val;
1706 if ((int)(here.op) == 0) {
1707 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
1708 "inflate: literal '%c'\n" :
1709 "inflate: literal 0x%02x\n", here.val));
1710 state->mode = LIT;
1711 break;
1712 }
1713 if (here.op & 32) {
1714 Tracevv((stderr, "inflate: end of block\n"));
1715 state->back = -1;
1716 state->mode = TYPE;
1717 break;
1718 }
1719 if (here.op & 64) {
1720 strm->msg = (char *)"invalid literal/length code";
1721 state->mode = BAD;
1722 break;
1723 }
1724 state->extra = (unsigned)(here.op) & 15;
1725 state->mode = LENEXT;
1726 case LENEXT:
1727 if (state->extra) {
1728 NEEDBITS(state->extra);
1729 state->length += BITS(state->extra);
1730 DROPBITS(state->extra);
1731 state->back += state->extra;
1732 }
1733 Tracevv((stderr, "inflate: length %u\n", state->length));
1734 state->was = state->length;
1735 state->mode = DIST;
1736 case DIST:
1737 for (;;) {
1738 here = state->distcode[BITS(state->distbits)];
1739 if ((unsigned)(here.bits) <= bits) break;
1740 PULLBYTE();
1741 }
1742 if ((here.op & 0xf0) == 0) {
1743 last = here;
1744 for (;;) {
1745 here = state->distcode[last.val +
1746 (BITS(last.bits + last.op) >> last.bits)];
1747 if ((unsigned)(last.bits + here.bits) <= bits) break;
1748 PULLBYTE();
1749 }
1750 DROPBITS(last.bits);
1751 state->back += last.bits;
1752 }
1753 DROPBITS(here.bits);
1754 state->back += here.bits;
1755 if (here.op & 64) {
1756 strm->msg = (char *)"invalid distance code";
1757 state->mode = BAD;
1758 break;
1759 }
1760 state->offset = (unsigned)here.val;
1761 state->extra = (unsigned)(here.op) & 15;
1762 state->mode = DISTEXT;
1763 case DISTEXT:
1764 if (state->extra) {
1765 NEEDBITS(state->extra);
1766 state->offset += BITS(state->extra);
1767 DROPBITS(state->extra);
1768 state->back += state->extra;
1769 }
1770#ifdef INFLATE_STRICT
1771 if (state->offset > state->dmax) {
1772 strm->msg = (char *)"invalid distance too far back";
1773 state->mode = BAD;
1774 break;
1775 }
1776#endif
1777 Tracevv((stderr, "inflate: distance %u\n", state->offset));
1778 state->mode = MATCH;
1779 case MATCH:
1780 if (left == 0) goto inf_leave;
1781 copy = out - left;
1782 if (state->offset > copy) { /* copy from window */
1783 copy = state->offset - copy;
1784 if (copy > state->whave) {
1785 if (state->sane) {
1786 strm->msg = (char *)"invalid distance too far back";
1787 state->mode = BAD;
1788 break;
1789 }
1790#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
1791 Trace((stderr, "inflate.c too far\n"));
1792 copy -= state->whave;
1793 if (copy > state->length) copy = state->length;
1794 if (copy > left) copy = left;
1795 left -= copy;
1796 state->length -= copy;
1797 do {
1798 *put++ = 0;
1799 } while (--copy);
1800 if (state->length == 0) state->mode = LEN;
1801 break;
1802#endif
1803 }
1804 if (copy > state->wnext) {
1805 copy -= state->wnext;
1806 from = state->window + (state->wsize - copy);
1807 }
1808 else
1809 from = state->window + (state->wnext - copy);
1810 if (copy > state->length) copy = state->length;
1811 }
1812 else { /* copy from output */
1813 from = put - state->offset;
1814 copy = state->length;
1815 }
1816 if (copy > left) copy = left;
1817 left -= copy;
1818 state->length -= copy;
1819 do {
1820 *put++ = *from++;
1821 } while (--copy);
1822 if (state->length == 0) state->mode = LEN;
1823 break;
1824 case LIT:
1825 if (left == 0) goto inf_leave;
1826 *put++ = (unsigned char)(state->length);
1827 left--;
1828 state->mode = LEN;
1829 break;
1830 case CHECK:
1831 if (state->wrap) {
1832 NEEDBITS(32);
1833 out -= left;
1834 strm->total_out += out;
1835 state->total += out;
1836 if ((state->wrap & 4) && out)
1837 strm->adler = state->check =
1838 UPDATE(state->check, put - out, out);
1839 out = left;
1840 if ((state->wrap & 4) && (
1841#ifdef GUNZIP
1842 state->flags ? hold :
1843#endif
1844 ZSWAP32(hold)) != state->check) {
1845 strm->msg = (char *)"incorrect data check";
1846 state->mode = BAD;
1847 break;
1848 }
1849 INITBITS();
1850 Tracev((stderr, "inflate: check matches trailer\n"));
1851 }
1852#ifdef GUNZIP
1853 state->mode = LENGTH;
1854 case LENGTH:
1855 if (state->wrap && state->flags) {
1856 NEEDBITS(32);
1857 if (hold != (state->total & 0xffffffffUL)) {
1858 strm->msg = (char *)"incorrect length check";
1859 state->mode = BAD;
1860 break;
1861 }
1862 INITBITS();
1863 Tracev((stderr, "inflate: length matches trailer\n"));
1864 }
1865#endif
1866 state->mode = DONE;
1867 case DONE:
1868 ret = Z_STREAM_END;
1869 goto inf_leave;
1870 case BAD:
1871 ret = Z_DATA_ERROR;
1872 goto inf_leave;
1873 case MEM:
1874 return Z_MEM_ERROR;
1875 case SYNC:
1876 default:
1877 return Z_STREAM_ERROR;
1878 }
1879
1880 /*
1881 Return from inflate(), updating the total counts and the check value.
1882 If there was no progress during the inflate() call, return a buffer
1883 error. Call updatewindow() to create and/or update the window state.
1884 Note: a memory error from inflate() is non-recoverable.
1885 */
1886 inf_leave:
1887 RESTORE();
1888 if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
1889 (state->mode < CHECK || flush != Z_FINISH)))
1890 if (updatewindow(strm, strm->next_out, out - strm->avail_out)) {
1891 state->mode = MEM;
1892 return Z_MEM_ERROR;
1893 }
1894 in -= strm->avail_in;
1895 out -= strm->avail_out;
1896 strm->total_in += in;
1897 strm->total_out += out;
1898 state->total += out;
1899 if ((state->wrap & 4) && out)
1900 strm->adler = state->check =
1901 UPDATE(state->check, strm->next_out - out, out);
1902 strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
1903 (state->mode == TYPE ? 128 : 0) +
1904 (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
1905 if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1906 ret = Z_BUF_ERROR;
1907 return ret;
1908}
copy
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
LOAD
#define LOAD()
Definition: inflate.c:1111
HEAD
@ HEAD
Definition: inflate.c:158
CRC2
#define CRC2(check, word)
Definition: inflate.c:1093
zmemcpy
#define zmemcpy
Definition: inflate.c:38
inflate_table
static int inflate_table(codetype type, unsigned short FAR *lens, unsigned codes, code FAR *FAR *table, unsigned FAR *bits, unsigned short FAR *work)
Definition: inflate.c:533
INITBITS
#define INITBITS()
Definition: inflate.c:1133
CRC4
#define CRC4(check, word)
Definition: inflate.c:1100
BITS
#define BITS(n)
Definition: inflate.c:1158
inflate_fast
static void inflate_fast(z_streamp strm, unsigned start)
Definition: inflate.c:274
UPDATE
#define UPDATE(check, buf, len)
Definition: inflate.c:1085
DROPBITS
#define DROPBITS(n)
Definition: inflate.c:1162
inflateStateCheck
static int inflateStateCheck(z_streamp strm)
Definition: inflate.c:802
Tracev
#define Tracev(x)
Definition: inflate.c:43
fixedtables
static void fixedtables(struct inflate_state FAR *state)
Definition: inflate.c:924
Trace
#define Trace(x)
Definition: inflate.c:42
BYTEBITS
#define BYTEBITS()
Definition: inflate.c:1169
ZSWAP32
#define ZSWAP32(q)
Definition: inflate.c:55
adler32
static uLong adler32(uLong adler, const Bytef *buf, uInt len)
Definition: inflate.c:72
NEEDBITS
#define NEEDBITS(n)
Definition: inflate.c:1151
PULLBYTE
#define PULLBYTE()
Definition: inflate.c:1141
Tracevv
#define Tracevv(x)
Definition: inflate.c:44
GUNZIP
#define GUNZIP
Definition: inflate.c:47
updatewindow
static int updatewindow(z_streamp strm, const Bytef *end, unsigned copy)
Definition: inflate.c:1032
RESTORE
#define RESTORE()
Definition: inflate.c:1122
Z_TREES
#define Z_TREES
Definition: zlib.h:111
Z_DEFLATED
#define Z_DEFLATED
Definition: zlib.h:146
Z_NEED_DICT
#define Z_NEED_DICT
Definition: zlib.h:116
Z_BUF_ERROR
#define Z_BUF_ERROR
Definition: zlib.h:121
Z_BLOCK
#define Z_BLOCK
Definition: zlib.h:110
Z_STREAM_END
#define Z_STREAM_END
Definition: zlib.h:115
Z_FINISH
#define Z_FINISH
Definition: zlib.h:109
Z_OK
#define Z_OK
Definition: zlib.h:114
z_const
#define z_const
Definition: zlib.h:35
Z_DATA_ERROR
#define Z_DATA_ERROR
Definition: zlib.h:119
Z_STREAM_ERROR
#define Z_STREAM_ERROR
Definition: zlib.h:118
Z_MEM_ERROR
#define Z_MEM_ERROR
Definition: zlib.h:120
Bytef
Byte FAR Bytef
Definition: zlib.h:41
FAR
#define FAR
Definition: zlib.h:34
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
short
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
TYPE
TYPE
Definition: eventcreate.c:652
in
GLuint in
Definition: glext.h:9616
order
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
stderr
#define stderr
Definition: stdio.h:100
if
if(dx< 0)
Definition: linetemp.h:194
last
static UINT UINT last
Definition: font.c:45
L
#define L(x)
Definition: ntvdm.h:50
out
static FILE * out
Definition: regtests2xml.c:44
flush
int flush
Definition: zlib.h:309
from
CardRegion * from
Definition: spigame.cpp:19
code::op
unsigned char op
Definition: inflate.c:140
code::bits
unsigned char bits
Definition: inflate.c:141
code::val
unsigned short val
Definition: inflate.c:142
inflate_state
Definition: inflate.c:194
inflate_state::have
unsigned have
Definition: inflate.c:229
inflate_state::hold
unsigned long hold
Definition: inflate.c:213
inflate_state::strm
z_streamp strm
Definition: inflate.c:195
ret
int ret
Definition: wcstombs-tests.c:31

Referenced by dwarf2_init_zsection(), ExtractZipImage(), gz_decomp(), gzip_read(), MSZipCodecUncompress(), test_boundsrect(), CMSZipCodec::Uncompress(), uncompress2(), unzReadCurrentFile(), and zlib_decompress().

◆ inflate_fast()

static void inflate_fast ( z_streamp  strm,
unsigned  start 
)
static

Definition at line 274 of file inflate.c.

275{
276 struct inflate_state FAR *state;
277 z_const unsigned char FAR *in; /* local strm->next_in */
278 z_const unsigned char FAR *last; /* have enough input while in < last */
279 unsigned char FAR *out; /* local strm->next_out */
280 unsigned char FAR *beg; /* inflate()'s initial strm->next_out */
281 unsigned char FAR *end; /* while out < end, enough space available */
282#ifdef INFLATE_STRICT
283 unsigned dmax; /* maximum distance from zlib header */
284#endif
285 unsigned wsize; /* window size or zero if not using window */
286 unsigned whave; /* valid bytes in the window */
287 unsigned wnext; /* window write index */
288 unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */
289 unsigned long hold; /* local strm->hold */
290 unsigned bits; /* local strm->bits */
291 code const FAR *lcode; /* local strm->lencode */
292 code const FAR *dcode; /* local strm->distcode */
293 unsigned lmask; /* mask for first level of length codes */
294 unsigned dmask; /* mask for first level of distance codes */
295 code here; /* retrieved table entry */
296 unsigned op; /* code bits, operation, extra bits, or */
297 /* window position, window bytes to copy */
298 unsigned len; /* match length, unused bytes */
299 unsigned dist; /* match distance */
300 unsigned char FAR *from; /* where to copy match from */
301
302 /* copy state to local variables */
303 state = (struct inflate_state FAR *)strm->state;
304 in = strm->next_in;
305 last = in + (strm->avail_in - 5);
306 out = strm->next_out;
307 beg = out - (start - strm->avail_out);
308 end = out + (strm->avail_out - 257);
309#ifdef INFLATE_STRICT
310 dmax = state->dmax;
311#endif
312 wsize = state->wsize;
313 whave = state->whave;
314 wnext = state->wnext;
315 window = state->window;
316 hold = state->hold;
317 bits = state->bits;
318 lcode = state->lencode;
319 dcode = state->distcode;
320 lmask = (1U << state->lenbits) - 1;
321 dmask = (1U << state->distbits) - 1;
322
323 /* decode literals and length/distances until end-of-block or not enough
324 input data or output space */
325 do {
326 if (bits < 15) {
327 hold += (unsigned long)(*in++) << bits;
328 bits += 8;
329 hold += (unsigned long)(*in++) << bits;
330 bits += 8;
331 }
332 here = lcode[hold & lmask];
333 dolen:
334 op = (unsigned)(here.bits);
335 hold >>= op;
336 bits -= op;
337 op = (unsigned)(here.op);
338 if (op == 0) { /* literal */
339 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
340 "inflate: literal '%c'\n" :
341 "inflate: literal 0x%02x\n", here.val));
342 *out++ = (unsigned char)(here.val);
343 }
344 else if (op & 16) { /* length base */
345 len = (unsigned)(here.val);
346 op &= 15; /* number of extra bits */
347 if (op) {
348 if (bits < op) {
349 hold += (unsigned long)(*in++) << bits;
350 bits += 8;
351 }
352 len += (unsigned)hold & ((1U << op) - 1);
353 hold >>= op;
354 bits -= op;
355 }
356 Tracevv((stderr, "inflate: length %u\n", len));
357 if (bits < 15) {
358 hold += (unsigned long)(*in++) << bits;
359 bits += 8;
360 hold += (unsigned long)(*in++) << bits;
361 bits += 8;
362 }
363 here = dcode[hold & dmask];
364 dodist:
365 op = (unsigned)(here.bits);
366 hold >>= op;
367 bits -= op;
368 op = (unsigned)(here.op);
369 if (op & 16) { /* distance base */
370 dist = (unsigned)(here.val);
371 op &= 15; /* number of extra bits */
372 if (bits < op) {
373 hold += (unsigned long)(*in++) << bits;
374 bits += 8;
375 if (bits < op) {
376 hold += (unsigned long)(*in++) << bits;
377 bits += 8;
378 }
379 }
380 dist += (unsigned)hold & ((1U << op) - 1);
381#ifdef INFLATE_STRICT
382 if (dist > dmax) {
383 strm->msg = (char *)"invalid distance too far back";
384 state->mode = BAD;
385 break;
386 }
387#endif
388 hold >>= op;
389 bits -= op;
390 Tracevv((stderr, "inflate: distance %u\n", dist));
391 op = (unsigned)(out - beg); /* max distance in output */
392 if (dist > op) { /* see if copy from window */
393 op = dist - op; /* distance back in window */
394 if (op > whave) {
395 if (state->sane) {
396 strm->msg =
397 (char *)"invalid distance too far back";
398 state->mode = BAD;
399 break;
400 }
401#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
402 if (len <= op - whave) {
403 do {
404 *out++ = 0;
405 } while (--len);
406 continue;
407 }
408 len -= op - whave;
409 do {
410 *out++ = 0;
411 } while (--op > whave);
412 if (op == 0) {
413 from = out - dist;
414 do {
415 *out++ = *from++;
416 } while (--len);
417 continue;
418 }
419#endif
420 }
421 from = window;
422 if (wnext == 0) { /* very common case */
423 from += wsize - op;
424 if (op < len) { /* some from window */
425 len -= op;
426 do {
427 *out++ = *from++;
428 } while (--op);
429 from = out - dist; /* rest from output */
430 }
431 }
432 else if (wnext < op) { /* wrap around window */
433 from += wsize + wnext - op;
434 op -= wnext;
435 if (op < len) { /* some from end of window */
436 len -= op;
437 do {
438 *out++ = *from++;
439 } while (--op);
440 from = window;
441 if (wnext < len) { /* some from start of window */
442 op = wnext;
443 len -= op;
444 do {
445 *out++ = *from++;
446 } while (--op);
447 from = out - dist; /* rest from output */
448 }
449 }
450 }
451 else { /* contiguous in window */
452 from += wnext - op;
453 if (op < len) { /* some from window */
454 len -= op;
455 do {
456 *out++ = *from++;
457 } while (--op);
458 from = out - dist; /* rest from output */
459 }
460 }
461 while (len > 2) {
462 *out++ = *from++;
463 *out++ = *from++;
464 *out++ = *from++;
465 len -= 3;
466 }
467 if (len) {
468 *out++ = *from++;
469 if (len > 1)
470 *out++ = *from++;
471 }
472 }
473 else {
474 from = out - dist; /* copy direct from output */
475 do { /* minimum length is three */
476 *out++ = *from++;
477 *out++ = *from++;
478 *out++ = *from++;
479 len -= 3;
480 } while (len > 2);
481 if (len) {
482 *out++ = *from++;
483 if (len > 1)
484 *out++ = *from++;
485 }
486 }
487 }
488 else if ((op & 64) == 0) { /* 2nd level distance code */
489 here = dcode[here.val + (hold & ((1U << op) - 1))];
490 goto dodist;
491 }
492 else {
493 strm->msg = (char *)"invalid distance code";
494 state->mode = BAD;
495 break;
496 }
497 }
498 else if ((op & 64) == 0) { /* 2nd level length code */
499 here = lcode[here.val + (hold & ((1U << op) - 1))];
500 goto dolen;
501 }
502 else if (op & 32) { /* end-of-block */
503 Tracevv((stderr, "inflate: end of block\n"));
504 state->mode = TYPE;
505 break;
506 }
507 else {
508 strm->msg = (char *)"invalid literal/length code";
509 state->mode = BAD;
510 break;
511 }
512 } while (in < last && out < end);
513
514 /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
515 len = bits >> 3;
516 in -= len;
517 bits -= len << 3;
518 hold &= (1U << bits) - 1;
519
520 /* update state and return */
521 strm->next_in = in;
522 strm->next_out = out;
523 strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
524 strm->avail_out = (unsigned)(out < end ?
525 257 + (end - out) : 257 - (out - end));
526 state->hold = hold;
527 state->bits = bits;
528 return;
529}
op
UINT op
Definition: effect.c:236
start
GLuint start
Definition: gl.h:1545
end
GLuint GLuint end
Definition: gl.h:1545
window
static IHTMLWindow2 * window
Definition: events.c:77
long
#define long
Definition: qsort.c:33
inflate_state::wnext
unsigned wnext
Definition: inflate.c:210
inflate_state::whave
unsigned whave
Definition: inflate.c:209
inflate_state::wsize
unsigned wsize
Definition: inflate.c:208
inflate_state::dmax
unsigned dmax
Definition: inflate.c:202

Referenced by inflate(), inflate_codes(), and inflateBack().

◆ inflate_table()

static int inflate_table ( codetype  type,
unsigned short FAR *  lens,
unsigned  codes,
code FAR *FAR *  table,
unsigned FAR *  bits,
unsigned short FAR *  work 
)
static

Definition at line 533 of file inflate.c.

535{
536 unsigned len; /* a code's length in bits */
537 unsigned sym; /* index of code symbols */
538 unsigned min, max; /* minimum and maximum code lengths */
539 unsigned root; /* number of index bits for root table */
540 unsigned curr; /* number of index bits for current table */
541 unsigned drop; /* code bits to drop for sub-table */
542 int left; /* number of prefix codes available */
543 unsigned used; /* code entries in table used */
544 unsigned huff; /* Huffman code */
545 unsigned incr; /* for incrementing code, index */
546 unsigned fill; /* index for replicating entries */
547 unsigned low; /* low bits for current root entry */
548 unsigned mask; /* mask for low root bits */
549 code here; /* table entry for duplication */
550 code FAR *next; /* next available space in table */
551 const unsigned short FAR *base; /* base value table to use */
552 const unsigned short FAR *extra; /* extra bits table to use */
553 unsigned match; /* use base and extra for symbol >= match */
554 unsigned short count[MAXBITS+1]; /* number of codes of each length */
555 unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
556 static const unsigned short lbase[31] = { /* Length codes 257..285 base */
557 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
558 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
559 static const unsigned short lext[31] = { /* Length codes 257..285 extra */
560 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
561 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202};
562 static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
563 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
564 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
565 8193, 12289, 16385, 24577, 0, 0};
566 static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
567 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
568 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
569 28, 28, 29, 29, 64, 64};
570
571 /*
572 Process a set of code lengths to create a canonical Huffman code. The
573 code lengths are lens[0..codes-1]. Each length corresponds to the
574 symbols 0..codes-1. The Huffman code is generated by first sorting the
575 symbols by length from short to long, and retaining the symbol order
576 for codes with equal lengths. Then the code starts with all zero bits
577 for the first code of the shortest length, and the codes are integer
578 increments for the same length, and zeros are appended as the length
579 increases. For the deflate format, these bits are stored backwards
580 from their more natural integer increment ordering, and so when the
581 decoding tables are built in the large loop below, the integer codes
582 are incremented backwards.
583
584 This routine assumes, but does not check, that all of the entries in
585 lens[] are in the range 0..MAXBITS. The caller must assure this.
586 1..MAXBITS is interpreted as that code length. zero means that that
587 symbol does not occur in this code.
588
589 The codes are sorted by computing a count of codes for each length,
590 creating from that a table of starting indices for each length in the
591 sorted table, and then entering the symbols in order in the sorted
592 table. The sorted table is work[], with that space being provided by
593 the caller.
594
595 The length counts are used for other purposes as well, i.e. finding
596 the minimum and maximum length codes, determining if there are any
597 codes at all, checking for a valid set of lengths, and looking ahead
598 at length counts to determine sub-table sizes when building the
599 decoding tables.
600 */
601
602 /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
603 for (len = 0; len <= MAXBITS; len++)
604 count[len] = 0;
605 for (sym = 0; sym < codes; sym++)
606 count[lens[sym]]++;
607
608 /* bound code lengths, force root to be within code lengths */
609 root = *bits;
610 for (max = MAXBITS; max >= 1; max--)
611 if (count[max] != 0) break;
612 if (root > max) root = max;
613 if (max == 0) { /* no symbols to code at all */
614 here.op = (unsigned char)64; /* invalid code marker */
615 here.bits = (unsigned char)1;
616 here.val = (unsigned short)0;
617 *(*table)++ = here; /* make a table to force an error */
618 *(*table)++ = here;
619 *bits = 1;
620 return 0; /* no symbols, but wait for decoding to report error */
621 }
622 for (min = 1; min < max; min++)
623 if (count[min] != 0) break;
624 if (root < min) root = min;
625
626 /* check for an over-subscribed or incomplete set of lengths */
627 left = 1;
628 for (len = 1; len <= MAXBITS; len++) {
629 left <<= 1;
630 left -= count[len];
631 if (left < 0) return -1; /* over-subscribed */
632 }
633 if (left > 0 && (type == CODES || max != 1))
634 return -1; /* incomplete set */
635
636 /* generate offsets into symbol table for each length for sorting */
637 offs[1] = 0;
638 for (len = 1; len < MAXBITS; len++)
639 offs[len + 1] = offs[len] + count[len];
640
641 /* sort symbols by length, by symbol order within each length */
642 for (sym = 0; sym < codes; sym++)
643 if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
644
645 /*
646 Create and fill in decoding tables. In this loop, the table being
647 filled is at next and has curr index bits. The code being used is huff
648 with length len. That code is converted to an index by dropping drop
649 bits off of the bottom. For codes where len is less than drop + curr,
650 those top drop + curr - len bits are incremented through all values to
651 fill the table with replicated entries.
652
653 root is the number of index bits for the root table. When len exceeds
654 root, sub-tables are created pointed to by the root entry with an index
655 of the low root bits of huff. This is saved in low to check for when a
656 new sub-table should be started. drop is zero when the root table is
657 being filled, and drop is root when sub-tables are being filled.
658
659 When a new sub-table is needed, it is necessary to look ahead in the
660 code lengths to determine what size sub-table is needed. The length
661 counts are used for this, and so count[] is decremented as codes are
662 entered in the tables.
663
664 used keeps track of how many table entries have been allocated from the
665 provided *table space. It is checked for LENS and DIST tables against
666 the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
667 the initial root table size constants. See the comments in inftrees.h
668 for more information.
669
670 sym increments through all symbols, and the loop terminates when
671 all codes of length max, i.e. all codes, have been processed. This
672 routine permits incomplete codes, so another loop after this one fills
673 in the rest of the decoding tables with invalid code markers.
674 */
675
676 /* set up for code type */
677 switch (type) {
678 case CODES:
679 base = extra = work; /* dummy value--not used */
680 match = 20;
681 break;
682 case LENS:
683 base = lbase;
684 extra = lext;
685 match = 257;
686 break;
687 default: /* DISTS */
688 base = dbase;
689 extra = dext;
690 match = 0;
691 }
692
693 /* initialize state for loop */
694 huff = 0; /* starting code */
695 sym = 0; /* starting code symbol */
696 len = min; /* starting code length */
697 next = *table; /* current table to fill in */
698 curr = root; /* current table index bits */
699 drop = 0; /* current bits to drop from code for index */
700 low = (unsigned)(-1); /* trigger new sub-table when len > root */
701 used = 1U << root; /* use root table entries */
702 mask = used - 1; /* mask for comparing low */
703
704 /* check available table space */
705 if ((type == LENS && used > ENOUGH_LENS) ||
706 (type == DISTS && used > ENOUGH_DISTS))
707 return 1;
708
709 /* process all codes and make table entries */
710 for (;;) {
711 /* create table entry */
712 here.bits = (unsigned char)(len - drop);
713 if (work[sym] + 1U < match) {
714 here.op = (unsigned char)0;
715 here.val = work[sym];
716 }
717 else if (work[sym] >= match) {
718 here.op = (unsigned char)(extra[work[sym] - match]);
719 here.val = base[work[sym] - match];
720 }
721 else {
722 here.op = (unsigned char)(32 + 64); /* end of block */
723 here.val = 0;
724 }
725
726 /* replicate for those indices with low len bits equal to huff */
727 incr = 1U << (len - drop);
728 fill = 1U << curr;
729 min = fill; /* save offset to next table */
730 do {
731 fill -= incr;
732 next[(huff >> drop) + fill] = here;
733 } while (fill != 0);
734
735 /* backwards increment the len-bit code huff */
736 incr = 1U << (len - 1);
737 while (huff & incr)
738 incr >>= 1;
739 if (incr != 0) {
740 huff &= incr - 1;
741 huff += incr;
742 }
743 else
744 huff = 0;
745
746 /* go to next symbol, update count, len */
747 sym++;
748 if (--(count[len]) == 0) {
749 if (len == max) break;
750 len = lens[work[sym]];
751 }
752
753 /* create new sub-table if needed */
754 if (len > root && (huff & mask) != low) {
755 /* if first time, transition to sub-tables */
756 if (drop == 0)
757 drop = root;
758
759 /* increment past last table */
760 next += min; /* here min is 1 << curr */
761
762 /* determine length of next table */
763 curr = len - drop;
764 left = (int)(1 << curr);
765 while (curr + drop < max) {
766 left -= count[curr + drop];
767 if (left <= 0) break;
768 curr++;
769 left <<= 1;
770 }
771
772 /* check for enough space */
773 used += 1U << curr;
774 if ((type == LENS && used > ENOUGH_LENS) ||
775 (type == DISTS && used > ENOUGH_DISTS))
776 return 1;
777
778 /* point entry in root table to sub-table */
779 low = huff & mask;
780 (*table)[low].op = (unsigned char)curr;
781 (*table)[low].bits = (unsigned char)root;
782 (*table)[low].val = (unsigned short)(next - *table);
783 }
784 }
785
786 /* fill in remaining table entry if code is incomplete (guaranteed to have
787 at most one remaining entry, since if the code is incomplete, the
788 maximum code length that was allowed to get this far is one bit) */
789 if (huff != 0) {
790 here.op = (unsigned char)64; /* invalid code marker */
791 here.bits = (unsigned char)(len - drop);
792 here.val = (unsigned short)0;
793 next[huff] = here;
794 }
795
796 /* set return parameters */
797 *table += used;
798 *bits = root;
799 return 0;
800}
fill
_STLP_MOVE_TO_STD_NAMESPACE void fill(_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
Definition: _algobase.h:449
used
static int used
Definition: adh-main.c:39
root
struct _root root
MAXBITS
#define MAXBITS
Definition: inflate.c:531
ENOUGH_LENS
#define ENOUGH_LENS
Definition: inflate.c:145
ENOUGH_DISTS
#define ENOUGH_DISTS
Definition: inflate.c:146
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
mask
GLenum GLint GLuint mask
Definition: glext.h:6028
extra
@ extra
Definition: id3.c:95
min
#define min(a, b)
Definition: monoChain.cc:55
_root
Definition: btrfs_drv.h:450
match
Definition: match.c:28
max
#define max(a, b)
Definition: svc.c:63

Referenced by fixedtables(), inflate(), and inflateBack().

◆ inflateEnd()

int inflateEnd ( z_streamp  strm)

Definition at line 1910 of file inflate.c.

1911{
1912 struct inflate_state FAR *state;
1913 if (inflateStateCheck(strm))
1914 return Z_STREAM_ERROR;
1915 state = (struct inflate_state FAR *)strm->state;
1916 if (state->window != Z_NULL) ZFREE(strm, state->window);
1917 ZFREE(strm, strm->state);
1918 strm->state = Z_NULL;
1919 Tracev((stderr, "inflate: end\n"));
1920 return Z_OK;
1921}
ZFREE
#define ZFREE(strm, addr)
Definition: inflate.c:51

Referenced by dwarf2_init_zsection(), ExtractZipImage(), gzclose_r(), gzip_destroy(), gzip_read(), MSZipCodecUncompress(), CMSZipCodec::Uncompress(), uncompress2(), unzCloseCurrentFile(), and zlib_decompress().

◆ inflateInit()

int inflateInit ( z_streamp  strm)

Definition at line 909 of file inflate.c.

910{
911 return inflateInit2(strm, DEF_WBITS);
912}
DEF_WBITS
#define DEF_WBITS
Definition: inflate.c:37
inflateInit2
#define inflateInit2(strm, windowBits)
Definition: zlib.h:1817

◆ inflateInit2()

int inflateInit2 ( z_streamp  strm,
int  windowBits 
)

Definition at line 887 of file inflate.c.

888{
889 int ret;
890 struct inflate_state FAR *state;
891
892 strm->msg = Z_NULL; /* in case we return an error */
893 state = (struct inflate_state FAR *)
894 ZALLOC(strm, 1, sizeof(struct inflate_state));
895 if (state == Z_NULL) return Z_MEM_ERROR;
896 Tracev((stderr, "inflate: allocated\n"));
897 strm->state = (struct internal_state FAR *)state;
898 state->strm = strm;
899 state->window = Z_NULL;
900 state->mode = HEAD; /* to pass state test in inflateReset2() */
901 ret = inflateReset2(strm, windowBits);
902 if (ret != Z_OK) {
903 ZFREE(strm, state);
904 strm->state = Z_NULL;
905 }
906 return ret;
907}
inflateReset2
static int inflateReset2(z_streamp strm, int windowBits)
Definition: inflate.c:851
ZALLOC
#define ZALLOC(strm, items, size)
Definition: inflate.c:49
windowBits
int windowBits
Definition: zlib.h:813
internal_state
Definition: inflate.c:30
internal_state::strm
z_streamp strm
Definition: deflate.h:101

◆ inflateReset()

static int inflateReset ( z_streamp  strm)
static

Definition at line 839 of file inflate.c.

840{
841 struct inflate_state FAR *state;
842
843 if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
844 state = (struct inflate_state FAR *)strm->state;
845 state->wsize = 0;
846 state->whave = 0;
847 state->wnext = 0;
848 return inflateResetKeep(strm);
849}
inflateResetKeep
static int inflateResetKeep(z_streamp strm)
Definition: inflate.c:815

Referenced by gz_look(), inflateReset2(), and inflateSync().

◆ inflateReset2()

static int inflateReset2 ( z_streamp  strm,
int  windowBits 
)
static

Definition at line 851 of file inflate.c.

852{
853 int wrap;
854 struct inflate_state FAR *state;
855
856 /* get the state */
857 if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
858 state = (struct inflate_state FAR *)strm->state;
859
860 /* extract wrap request from windowBits parameter */
861 if (windowBits < 0) {
862 wrap = 0;
863 windowBits = -windowBits;
864 }
865 else {
866 wrap = (windowBits >> 4) + 5;
867#ifdef GUNZIP
868 if (windowBits < 48)
869 windowBits &= 15;
870#endif
871 }
872
873 /* set number of window bits, free window if different */
874 if (windowBits && (windowBits < 8 || windowBits > 15))
875 return Z_STREAM_ERROR;
876 if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
877 ZFREE(strm, state->window);
878 state->window = Z_NULL;
879 }
880
881 /* update state and reset the rest of it */
882 state->wrap = wrap;
883 state->wbits = (unsigned)windowBits;
884 return inflateReset(strm);
885}
inflateReset
static int inflateReset(z_streamp strm)
Definition: inflate.c:839
wrap
#define wrap(journal, var)
Definition: recovery.c:207

Referenced by inflateInit2(), and inflateInit2_().

◆ inflateResetKeep()

static int inflateResetKeep ( z_streamp  strm)
static

Definition at line 815 of file inflate.c.

816{
817 struct inflate_state FAR *state;
818
819 if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
820 state = (struct inflate_state FAR *)strm->state;
821 strm->total_in = strm->total_out = state->total = 0;
822 strm->msg = Z_NULL;
823 if (state->wrap) /* to support ill-conceived Java test suite */
824 strm->adler = state->wrap & 1;
825 state->mode = HEAD;
826 state->last = 0;
827 state->havedict = 0;
828 state->dmax = 32768U;
829 state->head = Z_NULL;
830 state->hold = 0;
831 state->bits = 0;
832 state->lencode = state->distcode = state->next = state->codes;
833 state->sane = 1;
834 state->back = -1;
835 Tracev((stderr, "inflate: reset\n"));
836 return Z_OK;
837}

Referenced by inflateReset().

◆ inflateStateCheck()

static int inflateStateCheck ( z_streamp  strm)
static

Definition at line 802 of file inflate.c.

803{
804 struct inflate_state FAR *state;
805 if (strm == Z_NULL ||
806 strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
807 return 1;
808 state = (struct inflate_state FAR *)strm->state;
809 if (state == Z_NULL || state->strm != strm ||
810 state->mode < HEAD || state->mode > SYNC)
811 return 1;
812 return 0;
813}
free_func
void(* free_func)(voidpf opaque, voidpf address)
Definition: zlib.h:54
alloc_func
voidpf(* alloc_func)(voidpf opaque, uInt items, uInt size)
Definition: zlib.h:53

Referenced by inflate(), inflateCodesUsed(), inflateCopy(), inflateEnd(), inflateGetDictionary(), inflateGetHeader(), inflateMark(), inflatePrime(), inflateReset(), inflateReset2(), inflateResetKeep(), inflateSetDictionary(), inflateSync(), inflateSyncPoint(), inflateUndermine(), and inflateValidate().

◆ updatewindow()

static int updatewindow ( z_streamp  strm,
const Bytef *  end,
unsigned  copy 
)
static

Definition at line 1032 of file inflate.c.

1033{
1034 struct inflate_state FAR *state;
1035 unsigned dist;
1036
1037 state = (struct inflate_state FAR *)strm->state;
1038
1039 /* if it hasn't been done already, allocate space for the window */
1040 if (state->window == Z_NULL) {
1041 state->window = (unsigned char FAR *)
1042 ZALLOC(strm, 1U << state->wbits,
1043 sizeof(unsigned char));
1044 if (state->window == Z_NULL) return 1;
1045 }
1046
1047 /* if window not in use yet, initialize */
1048 if (state->wsize == 0) {
1049 state->wsize = 1U << state->wbits;
1050 state->wnext = 0;
1051 state->whave = 0;
1052 }
1053
1054 /* copy state->wsize or less output bytes into the circular window */
1055 if (copy >= state->wsize) {
1056 zmemcpy(state->window, end - state->wsize, state->wsize);
1057 state->wnext = 0;
1058 state->whave = state->wsize;
1059 }
1060 else {
1061 dist = state->wsize - state->wnext;
1062 if (dist > copy) dist = copy;
1063 zmemcpy(state->window + state->wnext, end - copy, dist);
1064 copy -= dist;
1065 if (copy) {
1066 zmemcpy(state->window, end - copy, copy);
1067 state->wnext = copy;
1068 state->whave = state->wsize;
1069 }
1070 else {
1071 state->wnext += dist;
1072 if (state->wnext == state->wsize) state->wnext = 0;
1073 if (state->whave < state->wsize) state->whave += dist;
1074 }
1075 }
1076 return 0;
1077}

Referenced by inflate(), and inflateSetDictionary().