mirror of https://github.com/Cisco-Talos/clamav
aCaB
18 years ago
parent
d9844083b5
commit
84f4e2bbc0
@ -0,0 +1,21 @@ |
||||
zlib/libpng license |
||||
------------------- |
||||
|
||||
This software is provided 'as-is', without any express or implied warranty. In |
||||
no event will the authors be held liable for any damages arising from the use |
||||
of this software. |
||||
|
||||
Permission is granted to anyone to use this software for any purpose, including |
||||
commercial applications, and to alter it and redistribute it freely, subject to |
||||
the following restrictions: |
||||
|
||||
1. The origin of this software must not be misrepresented; you must not |
||||
claim that you wrote the original software. If you use this software in |
||||
a product, an acknowledgment in the product documentation would be |
||||
appreciated but is not required. |
||||
|
||||
2. Altered source versions must be plainly marked as such, and must not be |
||||
misrepresented as being the original software. |
||||
|
||||
3. This notice may not be removed or altered from any source distribution. |
||||
|
||||
@ -0,0 +1,715 @@ |
||||
/*
|
||||
* This file is a part of the zlib compression module for NSIS. |
||||
*
|
||||
* Copyright and license information can be found below. |
||||
* Modifications Copyright (C) 1999-2007 Nullsoft and Contributors |
||||
*
|
||||
* The original zlib source code is available at |
||||
* http://www.zlib.net/
|
||||
*
|
||||
* This software is provided 'as-is', without any express or implied |
||||
* warranty. |
||||
*/ |
||||
|
||||
/*
|
||||
* Copyright (C) 1995-1998 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in COPYING.nsis |
||||
*/ |
||||
|
||||
#include "nsis_zutil.h" |
||||
#include <string.h> |
||||
|
||||
#ifndef min |
||||
# define min(x,y) ((x<y)?x:y) |
||||
#endif |
||||
|
||||
/* defines for inflate input/output */ |
||||
/* update pointers and return */ |
||||
#define UPDBITS {s->bitb=b;s->bitk=k;} |
||||
#define UPDIN {z->avail_in=n;z->next_in=p;} |
||||
#define UPDOUT {s->write=q;} |
||||
#define UPDATE {UPDBITS UPDIN UPDOUT} |
||||
#define LEAVE(r) {UPDATE inflate_flush(z); return r;} |
||||
|
||||
/* get bytes and bits */ |
||||
#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;} |
||||
|
||||
|
||||
#define NEEDBYTE {if(!n)LEAVE(Z_OK)} |
||||
#define NEXTBYTE (n--,*p++) |
||||
#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}} |
||||
|
||||
#define DUMPBITS(j) {b>>=(j);k-=(j);} |
||||
/* output bytes */ |
||||
#define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q) |
||||
#define LOADOUT {q=s->write;m=(uInt)WAVAIL;} |
||||
#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}} |
||||
#define FLUSH {UPDOUT inflate_flush(z); LOADOUT} |
||||
#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE(Z_OK)}}} |
||||
#define OUTBYTE(a) {*q++=(Byte)(a);m--;} |
||||
/* load local pointers */ |
||||
#define LOAD {LOADIN LOADOUT} |
||||
|
||||
#define LAST (s->last == DRY) |
||||
|
||||
#define FIXEDH 544 /* number of hufts used by fixed tables */ |
||||
|
||||
|
||||
|
||||
typedef struct inflate_blocks_state FAR inflate_blocks_statef; |
||||
#define exop word.what.Exop |
||||
#define bits word.what.Bits |
||||
|
||||
/* And'ing with mask[n] masks the lower n bits */ |
||||
local unsigned short inflate_mask[17] = { |
||||
0x0000, |
||||
0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, |
||||
0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff |
||||
}; /* use to reduce .data #define INFLATE_MASK(x, n) (x & (~((unsigned short) 0xFFFF << n))) */ |
||||
local const char border[] = { /* Order of the bit length code lengths */ |
||||
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; |
||||
|
||||
/* Tables for deflate from PKZIP's appnote.txt. */ |
||||
local const unsigned short cplens[31] = { /* Copy lengths for literal codes 257..285 */ |
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, |
||||
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; |
||||
/* see note #13 above about 258 */ |
||||
local const unsigned short cplext[31] = { /* Extra bits for literal codes 257..285 */ |
||||
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, |
||||
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112}; /* 112==invalid */ |
||||
local const unsigned short cpdist[30] = { /* Copy offsets for distance codes 0..29 */ |
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, |
||||
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, |
||||
8193, 12289, 16385, 24577}; |
||||
local const unsigned short cpdext[30] = { /* Extra bits for distance codes */ |
||||
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, |
||||
7, 7, 8, 8, 9, 9, 10, 10, 11, 11, |
||||
12, 12, 13, 13}; |
||||
|
||||
/* build fixed tables only once--keep them here */ |
||||
local char fixed_built = 0; |
||||
local inflate_huft fixed_mem[FIXEDH]; |
||||
local uInt fixed_bl=9; |
||||
local uInt fixed_bd=5; |
||||
local inflate_huft *fixed_tl; |
||||
local inflate_huft *fixed_td; |
||||
|
||||
/* copy as much as possible from the sliding window to the output area */ |
||||
local void ZEXPORT inflate_flush(nsis_z_streamp z) |
||||
{ |
||||
inflate_blocks_statef *s = &z->blocks; |
||||
uInt n; |
||||
Bytef *q; |
||||
|
||||
/* local copies of source and destination pointers */ |
||||
q = s->read; |
||||
|
||||
again: |
||||
/* compute number of bytes to copy as far as end of window */ |
||||
n = (uInt)((q <= s->write ? s->write : s->end) - q); |
||||
n = min(n, z->avail_out); |
||||
|
||||
/* update counters */ |
||||
z->avail_out -= n; |
||||
/* z->total_out += n; */ |
||||
|
||||
/* copy as far as end of window */ |
||||
zmemcpy(z->next_out, q, n); |
||||
z->next_out += n; |
||||
q += n; |
||||
|
||||
/* see if more to copy at beginning of window */ |
||||
if (q == s->end) |
||||
{ |
||||
/* wrap pointers */ |
||||
q = s->window; |
||||
if (s->write == s->end) |
||||
s->write = s->window; |
||||
|
||||
/* do the same for the beginning of the window */ |
||||
goto again; |
||||
} |
||||
|
||||
/* update pointers */ |
||||
s->read = q; |
||||
} |
||||
|
||||
#define BMAX 15 /* maximum bit length of any code */ |
||||
|
||||
local int ZEXPORT huft_build( |
||||
uIntf *b, /* code lengths in bits (all assumed <= BMAX) */ |
||||
uInt n, /* number of codes (assumed <= 288) */ |
||||
uInt s, /* number of simple-valued codes (0..s-1) */ |
||||
const unsigned short *d, /* list of base values for non-simple codes */ |
||||
const unsigned short *e, /* list of extra bits for non-simple codes */ |
||||
inflate_huft * FAR *t, /* result: starting table */ |
||||
uIntf *m, /* maximum lookup bits, returns actual */ |
||||
inflate_huft *hp, /* space for trees */ |
||||
uInt *hn) /* working area: values in order of bit length */ |
||||
{ |
||||
static uIntf v[288]; /* work area for huft_build */ |
||||
uInt a; /* counter for codes of length k */ |
||||
uInt c[BMAX+1]; /* bit length count table */ |
||||
uInt f; /* i repeats in table every f entries */ |
||||
int g; /* maximum code length */ |
||||
int h; /* table level */ |
||||
uInt i; /* counter, current code */ |
||||
uInt j; /* counter */ |
||||
int k; /* number of bits in current code */ |
||||
int l; /* bits per table (returned in m) */ |
||||
uIntf *p; /* pointer into c[], b[], or v[] */ |
||||
inflate_huft *q; /* points to current table */ |
||||
struct inflate_huft_s r; /* table entry for structure assignment */ |
||||
inflate_huft *u[BMAX]; /* table stack */ |
||||
int w; /* bits before this table == (l * h) */ |
||||
uInt x[BMAX+1]; /* bit offsets, then code stack */ |
||||
uIntf *xp; /* pointer into x */ |
||||
int y; /* number of dummy codes added */ |
||||
uInt z; /* number of entries in current table */ |
||||
|
||||
|
||||
/* Generate counts for each bit length */ |
||||
p=c; |
||||
y=16; while (y--) *p++ = 0; |
||||
p = b; |
||||
i = n; |
||||
do { |
||||
c[*p++]++; /* assume all entries <= BMAX */ |
||||
} while (--i); |
||||
if (c[0] == n) /* null input--all zero length codes */ |
||||
{ |
||||
*t = (inflate_huft *)Z_NULL; |
||||
*m = 0; |
||||
return Z_OK; |
||||
} |
||||
|
||||
|
||||
/* Find minimum and maximum length, bound *m by those */ |
||||
l = *m; |
||||
for (j = 1; j <= BMAX; j++) |
||||
if (c[j]) |
||||
break; |
||||
k = j; /* minimum code length */ |
||||
if ((uInt)l < j) |
||||
l = j; |
||||
for (i = BMAX; i; i--) |
||||
if (c[i]) |
||||
break; |
||||
g = i; /* maximum code length */ |
||||
if ((uInt)l > i) |
||||
l = i; |
||||
*m = l; |
||||
|
||||
|
||||
/* Adjust last length count to fill out codes, if needed */ |
||||
for (y = 1 << j; j < i; j++, y <<= 1) |
||||
if ((y -= c[j]) < 0) |
||||
return Z_DATA_ERROR; |
||||
if ((y -= c[i]) < 0) |
||||
return Z_DATA_ERROR; |
||||
c[i] += y; |
||||
|
||||
|
||||
/* Generate starting offsets into the value table for each length */ |
||||
x[1] = j = 0; |
||||
p = c + 1; xp = x + 2; |
||||
while (--i) { /* note that i == g from above */ |
||||
*xp++ = (j += *p++); |
||||
} |
||||
|
||||
|
||||
/* Make a table of values in order of bit lengths */ |
||||
p = b; i = 0; |
||||
do { |
||||
if ((j = *p++) != 0) |
||||
v[x[j]++] = i; |
||||
} while (++i < n); |
||||
n = x[g]; /* set n to length of v */ |
||||
|
||||
|
||||
/* Generate the Huffman codes and for each, make the table entries */ |
||||
x[0] = i = 0; /* first Huffman code is zero */ |
||||
p = v; /* grab values in bit order */ |
||||
h = -1; /* no tables yet--level -1 */ |
||||
w = -l; /* bits decoded == (l * h) */ |
||||
u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */ |
||||
q = (inflate_huft *)Z_NULL; /* ditto */ |
||||
z = 0; /* ditto */ |
||||
|
||||
r.base = 0; |
||||
|
||||
/* go through the bit lengths (k already is bits in shortest code) */ |
||||
for (; k <= g; k++) |
||||
{ |
||||
a = c[k]; |
||||
while (a--) |
||||
{ |
||||
int nextw=w; |
||||
/* here i is the Huffman code of length k bits for value *p */ |
||||
/* make tables up to required level */ |
||||
while (k > (nextw=w + l)) |
||||
{ |
||||
h++; |
||||
|
||||
/* compute minimum size table less than or equal to l bits */ |
||||
z = g - nextw; |
||||
z = z > (uInt)l ? (uInt)l : z; /* table size upper limit */ |
||||
if ((f = 1 << (j = k - nextw)) > a + 1) /* try a k-w bit table */ |
||||
{ /* too few codes for k-w bit table */ |
||||
f -= a + 1; /* deduct codes from patterns left */ |
||||
xp = c + k; |
||||
if (j < z) |
||||
while (++j < z && (f <<= 1) > *++xp) /* try smaller tables up to z bits */ |
||||
{ |
||||
f -= *xp; /* else deduct codes from patterns */ |
||||
} |
||||
} |
||||
z = 1 << j; /* table entries for j-bit table */ |
||||
|
||||
/* allocate new table */ |
||||
if (*hn + z > MANY) /* (note: doesn't matter for fixed) */ |
||||
return Z_MEM_ERROR; /* not enough memory */ |
||||
u[h] = q = hp + *hn; |
||||
*hn += z; |
||||
|
||||
/* connect to last table, if there is one */ |
||||
if (h) |
||||
{ |
||||
x[h] = i; /* save pattern for backing up */ |
||||
r.bits = (Byte)l; /* bits to dump before this table */ |
||||
r.exop = (Byte)j; /* bits in this table */ |
||||
j = i >> w; |
||||
r.base = (uInt)(q - u[h-1] - j); /* offset to this table */ |
||||
u[h-1][j] = r; /* connect to last table */ |
||||
} |
||||
else |
||||
*t = q; /* first table is returned result */ |
||||
w=nextw; /* previous table always l bits */ |
||||
} |
||||
|
||||
/* set up table entry in r */ |
||||
r.bits = (Byte)(k - w); |
||||
if (p >= v + n) |
||||
r.exop = 128 + 64; /* out of values--invalid code */ |
||||
else if (*p < s) |
||||
{ |
||||
r.exop = (Byte)(*p < 256 ? 0 : 32 + 64); /* 256 is end-of-block */ |
||||
r.base = *p++; /* simple code is just the value */ |
||||
} |
||||
else |
||||
{ |
||||
r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */ |
||||
r.base = d[*p++ - s]; |
||||
} |
||||
|
||||
/* fill code-like entries with r */ |
||||
f = 1 << (k - w); |
||||
for (j = i >> w; j < z; j += f) |
||||
q[j] = r; |
||||
|
||||
/* backwards increment the k-bit code i */ |
||||
for (j = 1 << (k - 1); i & j; j >>= 1) |
||||
i ^= j; |
||||
i ^= j; |
||||
|
||||
/* backup over finished tables */ |
||||
while ((i & ((1 << w) - 1)) != x[h]) |
||||
{ |
||||
h--; /* don't need to update q */ |
||||
w -= l; |
||||
} |
||||
} |
||||
} |
||||
|
||||
|
||||
/* Return Z_BUF_ERROR if we were given an incomplete table */ |
||||
return (y != 0 && g != 1) ? Z_BUF_ERROR : Z_OK; |
||||
} |
||||
|
||||
int ZEXPORT nsis_inflate(nsis_z_streamp z) |
||||
{ |
||||
inflate_blocks_statef *s = &z->blocks; |
||||
inflate_codes_statef *c = &s->sub.decode.t_codes; /* codes state */ |
||||
|
||||
/* lousy two bytes saved by doing this */ |
||||
struct |
||||
{ |
||||
uInt t; /* temporary storage */ |
||||
uLong b; /* bit buffer */ |
||||
uInt k; /* bits in bit buffer */ |
||||
Bytef *p; /* input data pointer */ |
||||
uInt n; /* bytes available there */ |
||||
Bytef *q; /* output window write pointer */ |
||||
uInt m; /* bytes to end of window or read pointer */ |
||||
|
||||
/* CODES variables */ |
||||
|
||||
inflate_huft *j; /* temporary pointer */ |
||||
uInt e; /* extra bits or operation */ |
||||
Bytef *f; /* pointer to copy strings from */ |
||||
} _state; |
||||
|
||||
#define t _state.t |
||||
#define b _state.b |
||||
#define k _state.k |
||||
#define p _state.p |
||||
#define n _state.n |
||||
#define q _state.q |
||||
#define m _state.m |
||||
|
||||
/* copy input/output information to locals (UPDATE macro restores) */ |
||||
LOAD |
||||
|
||||
/* process input based on current state */ |
||||
for (;;) switch (s->mode) |
||||
{ |
||||
case TYPE: |
||||
NEEDBITS(3) |
||||
t = (uInt)b & 7; |
||||
DUMPBITS(3) |
||||
s->last = (t & 1) ? DRY : TYPE; |
||||
switch (t >> 1) |
||||
{ |
||||
case 0: /* stored */ |
||||
Tracev((stderr, "inflate: stored block%s\n", |
||||
LAST ? " (last)" : "")); |
||||
DUMPBITS(k&7) |
||||
s->mode = LENS; /* get length of stored block */ |
||||
break; |
||||
case 1: /* fixed */ |
||||
Tracev((stderr, "inflate: fixed codes block%s\n", |
||||
LAST ? " (last)" : "")); |
||||
{ |
||||
if (!fixed_built) |
||||
{ |
||||
int _k; /* temporary variable */ |
||||
uInt f = 0; /* number of hufts used in fixed_mem */ |
||||
static uIntf lc[288]; /* length list for huft_build */ |
||||
|
||||
/* literal table */ |
||||
for (_k = 0; _k < 288; _k++) |
||||
{ |
||||
char v=8; |
||||
if (_k > 143) |
||||
{ |
||||
if (_k < 256) v++; |
||||
else if (_k < 280) v--; |
||||
} |
||||
lc[_k] = v; |
||||
} |
||||
|
||||
huft_build(lc, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, fixed_mem, &f); |
||||
|
||||
/* distance table */ |
||||
for (_k = 0; _k < 30; _k++) lc[_k] = 5; |
||||
|
||||
huft_build(lc, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, fixed_mem, &f); |
||||
|
||||
/* done */ |
||||
fixed_built++; |
||||
} |
||||
|
||||
/* s->sub.decode.t_codes.mode = CODES_START; */ |
||||
s->sub.decode.t_codes.lbits = (Byte)fixed_bl; |
||||
s->sub.decode.t_codes.dbits = (Byte)fixed_bd; |
||||
s->sub.decode.t_codes.ltree = fixed_tl; |
||||
s->sub.decode.t_codes.dtree = fixed_td; |
||||
} |
||||
s->mode = CODES_START; |
||||
break; |
||||
case 2: /* dynamic */ |
||||
Tracev((stderr, "inflate: dynamic codes block%s\n", |
||||
LAST ? " (last)" : "")); |
||||
s->mode = TABLE; |
||||
break; |
||||
case 3: /* illegal */ |
||||
/* the only illegal value possible is 3 because we check only 2 bits */ |
||||
goto bad; |
||||
} |
||||
break; |
||||
case LENS: |
||||
NEEDBITS(16) |
||||
s->sub.left = (uInt)b & 0xffff; |
||||
b = k = 0; /* dump bits */ |
||||
Tracev((stderr, "inflate: stored length %u\n", s->sub.left)); |
||||
s->mode = s->sub.left ? STORED : (inflate_mode)s->last; |
||||
break; |
||||
case STORED: |
||||
{ |
||||
uInt mn; |
||||
|
||||
if (n == 0) |
||||
LEAVE(Z_OK) |
||||
NEEDOUT |
||||
mn = min(m, n); |
||||
t = min(s->sub.left, mn); |
||||
zmemcpy(q, p, t); |
||||
p += t; n -= t; |
||||
q += t; m -= t; |
||||
if (!(s->sub.left -= t)) |
||||
s->mode = (inflate_mode)s->last; |
||||
break; |
||||
} |
||||
case TABLE: |
||||
NEEDBITS(14) |
||||
s->sub.trees.table = t = (uInt)b & 0x3fff; |
||||
if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) |
||||
{ |
||||
s->mode = NZ_BAD; |
||||
LEAVE(Z_DATA_ERROR); |
||||
} |
||||
/* t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f); */ |
||||
DUMPBITS(14) |
||||
s->sub.trees.index = 0; |
||||
Tracev((stderr, "inflate: table sizes ok\n")); |
||||
s->mode = BTREE; |
||||
case BTREE: |
||||
while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10)) |
||||
{ |
||||
NEEDBITS(3) |
||||
s->sub.trees.t_blens[(int)border[s->sub.trees.index++]] = (uInt)b & 7; |
||||
DUMPBITS(3) |
||||
} |
||||
while (s->sub.trees.index < 19) |
||||
s->sub.trees.t_blens[(int)border[s->sub.trees.index++]] = 0; |
||||
s->sub.trees.bb = 7; |
||||
|
||||
{ |
||||
uInt hn = 0; /* hufts used in space */ |
||||
|
||||
t = huft_build(s->sub.trees.t_blens, 19, 19, Z_NULL, Z_NULL, |
||||
&s->sub.trees.tb, &s->sub.trees.bb, s->hufts, &hn); |
||||
if (t != Z_OK || !s->sub.trees.bb) |
||||
{ |
||||
s->mode = NZ_BAD; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
s->sub.trees.index = 0; |
||||
Tracev((stderr, "inflate: bits tree ok\n")); |
||||
s->mode = DTREE; |
||||
case DTREE: |
||||
while (t = s->sub.trees.table, |
||||
s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)) |
||||
{ |
||||
inflate_huft *h; |
||||
uInt i, j, d; |
||||
|
||||
t = s->sub.trees.bb; |
||||
NEEDBITS(t) |
||||
h = s->sub.trees.tb + ((uInt)b & (uInt)inflate_mask[t]); |
||||
t = h->bits; |
||||
d = h->base; |
||||
if (d < 16) |
||||
{ |
||||
DUMPBITS(t) |
||||
s->sub.trees.t_blens[s->sub.trees.index++] = d; |
||||
} |
||||
else /* d == 16..18 */ |
||||
{ |
||||
if (d == 18) |
||||
{ |
||||
i=7; |
||||
j=11; |
||||
} |
||||
else |
||||
{ |
||||
i=d-14; |
||||
j=3; |
||||
} |
||||
NEEDBITS(t+i) |
||||
DUMPBITS(t) |
||||
j += (uInt)b & (uInt)inflate_mask[i]; |
||||
DUMPBITS(i) |
||||
i = s->sub.trees.index; |
||||
t = s->sub.trees.table; |
||||
if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || |
||||
(d == 16 && i < 1)) |
||||
{ |
||||
s->mode = NZ_BAD; |
||||
LEAVE(Z_DATA_ERROR); |
||||
} |
||||
d = d == 16 ? s->sub.trees.t_blens[i - 1] : 0; |
||||
do { |
||||
s->sub.trees.t_blens[i++] = d; |
||||
} while (--j); |
||||
s->sub.trees.index = i; |
||||
} |
||||
} |
||||
s->sub.trees.tb = Z_NULL; |
||||
{ |
||||
uInt hn = 0; /* hufts used in space */ |
||||
uInt bl, bd; |
||||
inflate_huft *tl, *td; |
||||
int nl,nd; |
||||
t = s->sub.trees.table; |
||||
|
||||
nl = 257 + (t & 0x1f); |
||||
nd = 1 + ((t >> 5) & 0x1f); |
||||
bl = 9; /* must be <= 9 for lookahead assumptions */ |
||||
bd = 6; /* must be <= 9 for lookahead assumptions */ |
||||
|
||||
t = huft_build(s->sub.trees.t_blens, nl, 257, cplens, cplext, &tl, &bl, s->hufts, &hn); |
||||
if (bl == 0) t = Z_DATA_ERROR; |
||||
if (t == Z_OK) |
||||
{ |
||||
/* build distance tree */ |
||||
t = huft_build(s->sub.trees.t_blens + nl, nd, 0, cpdist, cpdext, &td, &bd, s->hufts, &hn); |
||||
} |
||||
if (t != Z_OK || (bd == 0 && nl > 257)) |
||||
{ |
||||
s->mode = NZ_BAD; |
||||
LEAVE(Z_DATA_ERROR); |
||||
} |
||||
Tracev((stderr, "inflate: trees ok\n")); |
||||
|
||||
/* s->sub.decode.t_codes.mode = CODES_START; */ |
||||
s->sub.decode.t_codes.lbits = (Byte)bl; |
||||
s->sub.decode.t_codes.dbits = (Byte)bd; |
||||
s->sub.decode.t_codes.ltree = tl; |
||||
s->sub.decode.t_codes.dtree = td; |
||||
} |
||||
s->mode = CODES_START; |
||||
|
||||
#define j (_state.j) |
||||
#define e (_state.e) |
||||
#define f (_state.f) |
||||
|
||||
/* waiting for "i:"=input, "o:"=output, "x:"=nothing */ |
||||
|
||||
case CODES_START: /* x: set up for LEN */ |
||||
c->sub.code.need = c->lbits; |
||||
c->sub.code.tree = c->ltree; |
||||
s->mode = CODES_LEN; |
||||
case CODES_LEN: /* i: get length/literal/eob next */ |
||||
t = c->sub.code.need; |
||||
NEEDBITS(t) |
||||
j = c->sub.code.tree + ((uInt)b & (uInt)inflate_mask[t]); |
||||
DUMPBITS(j->bits) |
||||
e = (uInt)(j->exop); |
||||
if (e == 0) /* literal */ |
||||
{ |
||||
c->sub.lit = j->base; |
||||
s->mode = CODES_LIT; |
||||
break; |
||||
} |
||||
if (e & 16) /* length */ |
||||
{ |
||||
c->sub.copy.get = e & 15; |
||||
c->len = j->base; |
||||
s->mode = CODES_LENEXT; |
||||
break; |
||||
} |
||||
if ((e & 64) == 0) /* next table */ |
||||
{ |
||||
c->sub.code.need = e; |
||||
c->sub.code.tree = j + j->base; |
||||
break; |
||||
} |
||||
if (e & 32) /* end of block */ |
||||
{ |
||||
s->mode = CODES_WASH; |
||||
break; |
||||
} |
||||
goto bad; |
||||
case CODES_LENEXT: /* i: getting length extra (have base) */ |
||||
t = c->sub.copy.get; |
||||
NEEDBITS(t) |
||||
c->len += (uInt)b & (uInt)inflate_mask[t]; |
||||
DUMPBITS(t) |
||||
c->sub.code.need = c->dbits; |
||||
c->sub.code.tree = c->dtree; |
||||
s->mode = CODES_DIST; |
||||
case CODES_DIST: /* i: get distance next */ |
||||
t = c->sub.code.need; |
||||
NEEDBITS(t) |
||||
j = c->sub.code.tree + ((uInt)b & (uInt)inflate_mask[t]); |
||||
DUMPBITS(j->bits) |
||||
e = (uInt)(j->exop); |
||||
if (e & 16) /* distance */ |
||||
{ |
||||
c->sub.copy.get = e & 15; |
||||
c->sub.copy.dist = j->base; |
||||
s->mode = CODES_DISTEXT; |
||||
break; |
||||
} |
||||
if ((e & 64) == 0) /* next table */ |
||||
{ |
||||
c->sub.code.need = e; |
||||
c->sub.code.tree = j + j->base; |
||||
break; |
||||
} |
||||
goto bad; /* invalid code */ |
||||
case CODES_DISTEXT: /* i: getting distance extra */ |
||||
t = c->sub.copy.get; |
||||
NEEDBITS(t) |
||||
c->sub.copy.dist += (uInt)b & (uInt)inflate_mask[t]; |
||||
DUMPBITS(t) |
||||
s->mode = CODES_COPY; |
||||
case CODES_COPY: /* o: copying bytes in window, waiting for space */ |
||||
f = (uInt)(q - s->window) < c->sub.copy.dist ? |
||||
s->end - (c->sub.copy.dist - (q - s->window)) : |
||||
q - c->sub.copy.dist; |
||||
|
||||
while (c->len) |
||||
{ |
||||
NEEDOUT |
||||
OUTBYTE(*f++) |
||||
if (f == s->end) |
||||
f = s->window; |
||||
c->len--; |
||||
} |
||||
s->mode = CODES_START; |
||||
break; |
||||
case CODES_LIT: /* o: got literal, waiting for output space */ |
||||
NEEDOUT |
||||
OUTBYTE(c->sub.lit) |
||||
s->mode = CODES_START; |
||||
break; |
||||
case CODES_WASH: /* o: got eob, possibly more output */ |
||||
if (k > 7) /* return unused byte, if any */ |
||||
{ |
||||
k -= 8; |
||||
n++; |
||||
p--; /* can always return one */ |
||||
} |
||||
/* flushing will be done in DRY */ |
||||
|
||||
#undef j |
||||
#undef e |
||||
#undef f |
||||
|
||||
case DRY: |
||||
FLUSH |
||||
if (s->write != s->read) |
||||
LEAVE(Z_OK) |
||||
if (s->mode == CODES_WASH) |
||||
{ |
||||
Tracev((stderr, "inflate: codes end, %lu total out\n", |
||||
z->total_out + (q >= s->read ? q - s->read : |
||||
(s->end - s->read) + (q - s->window)))); |
||||
} |
||||
/* DRY if last, TYPE if not */ |
||||
s->mode = (inflate_mode)s->last; |
||||
if (s->mode == TYPE) |
||||
break; |
||||
LEAVE(Z_STREAM_END) |
||||
/*case BAD:
|
||||
r = Z_DATA_ERROR; |
||||
LEAVE |
||||
*/ |
||||
default: /* we'll call Z_STREAM_ERROR if BAD anyway */ |
||||
bad: |
||||
s->mode = NZ_BAD; |
||||
LEAVE(Z_STREAM_ERROR) |
||||
} |
||||
} |
||||
|
||||
#undef t |
||||
#undef b |
||||
#undef k |
||||
#undef p |
||||
#undef n |
||||
#undef q |
||||
#undef m |
||||
@ -0,0 +1,58 @@ |
||||
/* zconf.h -- configuration of the zlib compression library
|
||||
* Copyright (C) 1995-1998 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in COPYING.nsis. |
||||
*/ |
||||
|
||||
/* @(#) $Id: ZCONF.H,v 1.3 2007/01/13 17:28:23 kichik Exp $ */ |
||||
|
||||
#ifndef _ZCONF_H |
||||
#define _ZCONF_H |
||||
|
||||
|
||||
#define MAX_MEM_LEVEL 9 |
||||
|
||||
/* Maximum value for windowBits in deflateInit2 and inflateInit2.
|
||||
* WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files |
||||
* created by gzip. (Files created by minigzip can still be extracted by |
||||
* gzip.) |
||||
*/ |
||||
#ifndef MAX_WBITS |
||||
# define MAX_WBITS 15 /* 32K LZ77 window */ |
||||
#endif |
||||
|
||||
#define OF(args) args |
||||
|
||||
|
||||
#ifndef ZEXPORT |
||||
# define ZEXPORT |
||||
#endif |
||||
#ifndef ZEXPORTVA |
||||
# define ZEXPORTVA |
||||
#endif |
||||
#ifndef ZEXTERN |
||||
# define ZEXTERN extern |
||||
#endif |
||||
|
||||
#ifndef FAR |
||||
# define FAR |
||||
#endif |
||||
|
||||
typedef unsigned char Byte; /* 8 bits */ |
||||
typedef unsigned int uInt; /* 16 bits or more */ |
||||
typedef unsigned long uLong; /* 32 bits or more */ |
||||
|
||||
typedef Byte FAR Bytef; |
||||
typedef char FAR charf; |
||||
typedef int FAR intf; |
||||
typedef uInt FAR uIntf; |
||||
typedef uLong FAR uLongf; |
||||
|
||||
typedef void FAR *voidpf; |
||||
typedef void *voidp; |
||||
|
||||
#ifndef z_off_t |
||||
# define z_off_t long |
||||
#endif |
||||
|
||||
|
||||
#endif /* _ZCONF_H */ |
||||
@ -0,0 +1,217 @@ |
||||
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
||||
version 1.1.3, July 9th, 1998 |
||||
|
||||
Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler |
||||
|
||||
This software is provided 'as-is', without any express or implied |
||||
warranty. In no event will the authors be held liable for any damages |
||||
arising from the use of this software. |
||||
|
||||
Permission is granted to anyone to use this software for any purpose, |
||||
including commercial applications, and to alter it and redistribute it |
||||
freely, subject to the following restrictions: |
||||
|
||||
1. The origin of this software must not be misrepresented; you must not |
||||
claim that you wrote the original software. If you use this software |
||||
in a product, an acknowledgment in the product documentation would be |
||||
appreciated but is not required. |
||||
2. Altered source versions must be plainly marked as such, and must not be |
||||
misrepresented as being the original software. |
||||
3. This notice may not be removed or altered from any source distribution. |
||||
|
||||
Jean-loup Gailly Mark Adler |
||||
jloup@gzip.org madler@alumni.caltech.edu |
||||
|
||||
|
||||
*/ |
||||
|
||||
#ifndef _NSIS_ZLIB_H |
||||
#define _NSIS_ZLIB_H |
||||
|
||||
#include "nsis_zconf.h" |
||||
#include "nsis_zutil.h" |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
|
||||
typedef struct inflate_huft_s FAR inflate_huft; |
||||
|
||||
|
||||
|
||||
typedef enum { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */ |
||||
CODES_START, /* x: set up for LEN */ |
||||
CODES_LEN, /* i: get length/literal/eob next */ |
||||
CODES_LENEXT, /* i: getting length extra (have base) */ |
||||
CODES_DIST, /* i: get distance next */ |
||||
CODES_DISTEXT, /* i: getting distance extra */ |
||||
CODES_COPY, /* o: copying bytes in window, waiting for space */ |
||||
CODES_LIT, /* o: got literal, waiting for output space */ |
||||
CODES_WASH, /* o: got eob, possibly still output waiting */ |
||||
/* CODES_END, x: got eob and all data flushed */ |
||||
/* CODES_BADCODE, x: got error */ |
||||
|
||||
TYPE, /* get type bits (3, including end bit) */ |
||||
LENS, /* get lengths for stored */ |
||||
STORED, /* processing stored block */ |
||||
TABLE, /* get table lengths */ |
||||
BTREE, /* get bit lengths tree for a dynamic block */ |
||||
DTREE, /* get length, distance trees for a dynamic block */ |
||||
CODES, /* processing fixed or dynamic block */ |
||||
DRY, /* output remaining window bytes */ |
||||
DONE, /* finished last block, done */ |
||||
NZ_BAD /* got a data error--stuck here */ |
||||
} inflate_mode; |
||||
|
||||
/* inflate codes private state */ |
||||
struct inflate_codes_state { |
||||
|
||||
/* mode */ |
||||
/* inflate_mode mode; current inflate_codes mode */ |
||||
|
||||
/* mode dependent information */ |
||||
uInt len; |
||||
union { |
||||
struct { |
||||
inflate_huft *tree; /* pointer into tree */ |
||||
uInt need; /* bits needed */ |
||||
} code; /* if LEN or DIST, where in tree */ |
||||
uInt lit; /* if LIT, literal */ |
||||
struct { |
||||
uInt get; /* bits to get for extra */ |
||||
uInt dist; /* distance back to copy from */ |
||||
} copy; /* if EXT or COPY, where and how much */ |
||||
} sub; /* submode */ |
||||
|
||||
/* mode independent information */ |
||||
Byte lbits; /* ltree bits decoded per branch */ |
||||
Byte dbits; /* dtree bits decoder per branch */ |
||||
inflate_huft *ltree; /* literal/length/eob tree */ |
||||
inflate_huft *dtree; /* distance tree */ |
||||
|
||||
}; |
||||
|
||||
struct inflate_huft_s { |
||||
union { |
||||
struct { |
||||
Byte Exop; /* number of extra bits or operation */ |
||||
Byte Bits; /* number of bits in this code or subcode */ |
||||
} what; |
||||
} word; |
||||
unsigned short base; /* literal, length base, distance base,
|
||||
or table offset */ |
||||
}; |
||||
|
||||
#define MANY 1440 |
||||
|
||||
typedef struct inflate_codes_state inflate_codes_statef; |
||||
|
||||
struct inflate_blocks_state { |
||||
|
||||
/* mode */ |
||||
inflate_mode mode; /* current inflate_block mode */ |
||||
|
||||
/* mode dependent information */ |
||||
union { |
||||
uInt left; /* if STORED, bytes left to copy */ |
||||
struct { |
||||
uInt table; /* table lengths (14 bits) */ |
||||
uInt index; /* index into blens (or border) */ |
||||
uIntf t_blens[258+31+31]; /* bit lengths of codes */ |
||||
uInt bb; /* bit length tree depth */ |
||||
inflate_huft *tb; /* bit length decoding tree */ |
||||
} trees; /* if DTREE, decoding info for trees */ |
||||
struct { |
||||
inflate_codes_statef t_codes; |
||||
} decode; /* if CODES, current state */ |
||||
} sub; /* submode */ |
||||
|
||||
uInt last; /* DRY if this block is the last block, TYPE otherwise */ |
||||
|
||||
/* mode independent information */ |
||||
uInt bitk; /* bits in bit buffer */ |
||||
uLong bitb; /* bit buffer */ |
||||
inflate_huft hufts[MANY]; /* single malloc for tree space */ |
||||
Bytef window[1 << MAX_WBITS]; /* sliding window */ |
||||
Bytef *end; /* one byte after sliding window */ |
||||
Bytef *read; /* window read pointer */ |
||||
Bytef *write; /* window write pointer */ |
||||
uLong check; /* check on output */ |
||||
|
||||
}; |
||||
|
||||
typedef struct nsis_z_stream_s { |
||||
Bytef *next_in; /* next input byte */ |
||||
uInt avail_in; /* number of bytes available at next_in */ |
||||
uLong total_in; /* total nb of input bytes read so far */ |
||||
|
||||
Bytef *next_out; /* next output byte should be put there */ |
||||
uInt avail_out; /* remaining free space at next_out */ |
||||
|
||||
/* char *msg; last error message, NULL if no error */ |
||||
/* struct internal_state FAR *state; not visible by applications */ |
||||
struct inflate_blocks_state blocks; |
||||
|
||||
} nsis_z_stream; |
||||
|
||||
typedef nsis_z_stream FAR *nsis_z_streamp; |
||||
|
||||
|
||||
#define Z_NO_FLUSH 0 |
||||
#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ |
||||
#define Z_SYNC_FLUSH 2 |
||||
#define Z_FULL_FLUSH 3 |
||||
#define Z_FINISH 4 |
||||
/* Allowed flush values; see deflate() below for details */ |
||||
|
||||
#define Z_OK 0 |
||||
#define Z_STREAM_END 1 |
||||
#define Z_NEED_DICT 2 |
||||
#define Z_ERRNO (-1) |
||||
|
||||
/* EXEHEAD doesn't need a specific return code, just < 0 */ |
||||
#define Z_STREAM_ERROR (-2) |
||||
#define Z_DATA_ERROR (-3) |
||||
#define Z_MEM_ERROR (-4) |
||||
#define Z_BUF_ERROR (-5) |
||||
#define Z_VERSION_ERROR (-6) |
||||
|
||||
/* Return codes for the compression/decompression functions. Negative
|
||||
* values are errors, positive values are used for special but normal events. |
||||
*/ |
||||
|
||||
#define Z_NO_COMPRESSION 0 |
||||
#define Z_BEST_SPEED 1 |
||||
#define Z_BEST_COMPRESSION 9 |
||||
#define Z_DEFAULT_COMPRESSION (-1) |
||||
/* compression levels */ |
||||
|
||||
#define Z_FILTERED 1 |
||||
#define Z_HUFFMAN_ONLY 2 |
||||
#define Z_DEFAULT_STRATEGY 0 |
||||
/* compression strategy; see deflateInit2() below for details */ |
||||
|
||||
/* Possible values of the data_type field */ |
||||
|
||||
#define Z_DEFLATED 8 |
||||
/* The deflate compression method (the only one supported in this version) */ |
||||
|
||||
#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ |
||||
|
||||
|
||||
#define nsis_inflateInit(x) inflateReset(x) |
||||
int ZEXPORT nsis_inflate(nsis_z_streamp z); |
||||
#define inflateReset(z) \ |
||||
{ \
|
||||
(z)->blocks.mode = TYPE; \
|
||||
(z)->blocks.bitk = (z)->blocks.bitb = 0; \
|
||||
(z)->blocks.read = (z)->blocks.write = (z)->blocks.window; \
|
||||
(z)->blocks.end = (z)->blocks.window + (1 << DEF_WBITS); \
|
||||
} |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* _ZLIB_H */ |
||||
@ -0,0 +1,74 @@ |
||||
/*
|
||||
* This file is a part of the zlib compression module for NSIS. |
||||
*
|
||||
* Copyright and license information can be found below. |
||||
* Modifications Copyright (C) 1999-2007 Nullsoft and Contributors |
||||
*
|
||||
* The original zlib source code is available at |
||||
* http://www.zlib.net/
|
||||
*
|
||||
* This software is provided 'as-is', without any express or implied |
||||
* warranty. |
||||
*/ |
||||
|
||||
/* zutil.h -- internal interface and configuration of the compression library
|
||||
* Copyright (C) 1995-1998 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in COPYING.nsis. |
||||
*/ |
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is |
||||
subject to change. Applications should only use zlib.h. |
||||
*/ |
||||
|
||||
/* @(#) $Id: ZUTIL.H,v 1.6 2007/01/25 18:07:40 kichik Exp $ */ |
||||
|
||||
#ifndef _Z_UTIL_H |
||||
#define _Z_UTIL_H |
||||
|
||||
#include "nsis_zlib.h" |
||||
|
||||
#ifndef local |
||||
# define local static |
||||
#endif |
||||
|
||||
typedef unsigned char uch; |
||||
typedef uch FAR uchf; |
||||
typedef unsigned short ush; |
||||
typedef ush FAR ushf; |
||||
typedef unsigned long ulg; |
||||
|
||||
#ifndef DEF_WBITS |
||||
# define DEF_WBITS MAX_WBITS |
||||
#endif |
||||
/* default windowBits for decompression. MAX_WBITS is for compression only */ |
||||
|
||||
#define DEF_MEM_LEVEL MAX_MEM_LEVEL |
||||
|
||||
#define STORED_BLOCK 0 |
||||
#define STATIC_TREES 1 |
||||
#define DYN_TREES 2 |
||||
/* The three kinds of block type */ |
||||
|
||||
#define MIN_MATCH 3 |
||||
#define MAX_MATCH 258 |
||||
/* The minimum and maximum match lengths */ |
||||
|
||||
#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ |
||||
|
||||
|
||||
#define zmemcpy memcpy |
||||
|
||||
#define Assert(cond,msg) |
||||
#define Trace(x) |
||||
#define Tracev(x) |
||||
#define Tracevv(x) |
||||
#define Tracec(c,x) |
||||
#define Tracecv(c,x) |
||||
|
||||
#define ZALLOC(strm, items, size) malloc((items)*(size)) |
||||
#define ZFREE(strm, addr) { if (addr) free(addr); } |
||||
#define TRY_FREE(s, p) { ZFREE(s, p); } |
||||
#define ERR_RETURN(strm,err) return (err) |
||||
|
||||
#endif /* _Z_UTIL_H */ |
||||
Loading…
Reference in new issue