aixiao/denyhosts
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

更新libclamav库1.0.0版本

Browse Source
This commit is contained in:
aixiao
2023-01-14 18:28:39 +08:00
parent b879ee0b2e
commit 45fe15f472
8531 changed files with 1222046 additions and 177272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1122
clamav/libclamav/nsis/bzlib.c Normal file
View File

File diff suppressed because it is too large Load Diff

475
clamav/libclamav/nsis/bzlib_private.h Normal file
View File

@@ -0,0 +1,475 @@
/*-------------------------------------------------------------*/
/*--- Private header file for the library. ---*/
/*--- bzlib_private.h ---*/
/*-------------------------------------------------------------*/
/* ------------------------------------------------------------------
This file is part of bzip2/libbzip2, a program and library for
lossless, block-sorting data compression.
bzip2/libbzip2 version 1.0.4 of 20 December 2006
Copyright (C) 1996-2006 Julian Seward <jseward@bzip.org>
This file was modified for ClamAV by aCaB <acab@clamav.net>
This program is released under the terms of the license contained
in the file COPYING.bzip2.
------------------------------------------------------------------ */
#ifndef _BZLIB_PRIVATE_H
#define _BZLIB_PRIVATE_H
#if HAVE_CONFIG_H
#include "clamav-config.h"
#endif
#include <stdlib.h>
#ifndef BZ_NO_STDIO
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#endif
#include "nsis_bzlib.h"
/*-- General stuff. --*/
#define BZ_VERSION "1.0.4, 20-Dec-2006"
typedef char Char;
typedef unsigned char Bool;
typedef unsigned char UChar;
typedef int Int32;
typedef unsigned int UInt32;
typedef short Int16;
typedef unsigned short UInt16;
#define True ((Bool)1)
#define False ((Bool)0)
#ifndef __GNUC__
#define __inline__ /* */
#endif
/* aCaB */
/* #ifndef BZ_NO_STDIO */
/* extern void BZ2_bz__AssertH__fail ( int errcode ); */
/* #define AssertH(cond,errcode) \ */
/* { if (!(cond)) BZ2_bz__AssertH__fail ( errcode ); } */
/* #if BZ_DEBUG */
/* #define AssertD(cond,msg) \ */
/* { if (!(cond)) { \ */
/* fprintf ( stderr, \ */
/* "\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\ */
/* exit(1); \ */
/* }} */
/* #else */
/* #define AssertD(cond,msg) /\* *\/ */
/* #endif */
/* #define VPrintf0(zf) \ */
/* fprintf(stderr,zf) */
/* #define VPrintf1(zf,za1) \ */
/* fprintf(stderr,zf,za1) */
/* #define VPrintf2(zf,za1,za2) \ */
/* fprintf(stderr,zf,za1,za2) */
/* #define VPrintf3(zf,za1,za2,za3) \ */
/* fprintf(stderr,zf,za1,za2,za3) */
/* #define VPrintf4(zf,za1,za2,za3,za4) \ */
/* fprintf(stderr,zf,za1,za2,za3,za4) */
/* #define VPrintf5(zf,za1,za2,za3,za4,za5) \ */
/* fprintf(stderr,zf,za1,za2,za3,za4,za5) */
/* #else */
/* extern void bz_internal_error ( int errcode ); */
/* #define AssertH(cond,errcode) \ */
/* { if (!(cond)) bz_internal_error ( errcode ); } */
/* #define AssertD(cond,msg) do { } while (0) */
#define VPrintf0(zf) do { } while (0)
#define VPrintf1(zf,za1) do { } while (0)
#define VPrintf2(zf,za1,za2) do { } while (0)
#define VPrintf3(zf,za1,za2,za3) do { } while (0)
#define VPrintf4(zf,za1,za2,za3,za4) do { } while (0)
#define VPrintf5(zf,za1,za2,za3,za4,za5) do { } while (0)
/* #endif */
#define BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1)
#define BZFREE(ppp) (strm->bzfree)(strm->opaque,(ppp))
/*-- Header bytes. --*/
/* #define BZ_HDR_B 0x42 /\* 'B' *\/ */
/* #define BZ_HDR_Z 0x5a /\* 'Z' *\/ */
/* #define BZ_HDR_h 0x68 /\* 'h' *\/ */
/* #define BZ_HDR_0 0x30 /\* '0' *\/ */
/*-- Constants for the back end. --*/
#define BZ_MAX_ALPHA_SIZE 258
#define BZ_MAX_CODE_LEN 23
#define BZ_RUNA 0
#define BZ_RUNB 1
#define BZ_N_GROUPS 6
#define BZ_G_SIZE 50
#define BZ_N_ITERS 4
#define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE))
/*-- Stuff for randomising repetitive blocks. --*/
/* aCaB */
/* extern Int32 BZ2_rNums[512]; */
#define BZ_RAND_DECLS \
Int32 rNToGo; \
Int32 rTPos \
#define BZ_RAND_INIT_MASK \
s->rNToGo = 0; \
s->rTPos = 0 \
#define BZ_RAND_MASK ((s->rNToGo == 1) ? 1 : 0)
#define BZ_RAND_UPD_MASK \
if (s->rNToGo == 0) { \
s->rNToGo = BZ2_rNums[s->rTPos]; \
s->rTPos++; \
if (s->rTPos == 512) s->rTPos = 0; \
} \
s->rNToGo--;
/**/
/*-- Stuff for doing CRCs. --*/
/* aCaB
extern UInt32 BZ2_crc32Table[256];
#define BZ_INITIALISE_CRC(crcVar) \
{ \
crcVar = 0xffffffffL; \
}
#define BZ_FINALISE_CRC(crcVar) \
{ \
crcVar = ~(crcVar); \
}
#define BZ_UPDATE_CRC(crcVar,cha) \
{ \
crcVar = (crcVar << 8) ^ \
BZ2_crc32Table[(crcVar >> 24) ^ \
((UChar)cha)]; \
}
*/
/*-- States and modes for compression. --*/
#define BZ_M_IDLE 1
#define BZ_M_RUNNING 2
#define BZ_M_FLUSHING 3
#define BZ_M_FINISHING 4
#define BZ_S_OUTPUT 1
#define BZ_S_INPUT 2
#define BZ_N_RADIX 2
#define BZ_N_QSORT 12
#define BZ_N_SHELL 18
#define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2)
/*-- Structure holding all the compression-side stuff. --*/
typedef
struct {
/* pointer back to the struct nsis_bzstream */
nsis_bzstream* strm;
/* mode this stream is in, and whether inputting */
/* or outputting data */
Int32 mode;
Int32 state;
/* remembers avail_in when flush/finish requested */
UInt32 avail_in_expect;
/* for doing the block sorting */
UInt32* arr1;
UInt32* arr2;
UInt32* ftab;
Int32 origPtr;
/* aliases for arr1 and arr2 */
UInt32* ptr;
UChar* block;
UInt16* mtfv;
UChar* zbits;
/* for deciding when to use the fallback sorting algorithm */
Int32 workFactor;
/* run-length-encoding of the input */
UInt32 state_in_ch;
Int32 state_in_len;
BZ_RAND_DECLS;
/* input and output limits and current posns */
Int32 nblock;
Int32 nblockMAX;
Int32 numZ;
Int32 state_out_pos;
/* map of bytes used in block */
Int32 nInUse;
Bool inUse[256];
UChar unseqToSeq[256];
/* the buffer for bit stream creation */
UInt32 bsBuff;
Int32 bsLive;
/* block and combined CRCs */
UInt32 blockCRC;
UInt32 combinedCRC;
/* misc administratium */
Int32 verbosity;
Int32 blockNo;
Int32 blockSize100k;
/* stuff for coding the MTF values */
Int32 nMTF;
Int32 mtfFreq [BZ_MAX_ALPHA_SIZE];
UChar selector [BZ_MAX_SELECTORS];
UChar selectorMtf[BZ_MAX_SELECTORS];
UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 code [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 rfreq [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
/* second dimension: only 3 needed; 4 makes index calculations faster */
UInt32 len_pack[BZ_MAX_ALPHA_SIZE][4];
}
EState;
/*-- states for decompression. --*/
#define BZ_X_IDLE 1
#define BZ_X_OUTPUT 2
#define BZ_X_MAGIC_1 10
#define BZ_X_MAGIC_2 11
#define BZ_X_MAGIC_3 12
#define BZ_X_MAGIC_4 13
#define BZ_X_BLKHDR_1 14
#define BZ_X_BLKHDR_2 15
#define BZ_X_BLKHDR_3 16
#define BZ_X_BLKHDR_4 17
#define BZ_X_BLKHDR_5 18
#define BZ_X_BLKHDR_6 19
#define BZ_X_BCRC_1 20
#define BZ_X_BCRC_2 21
#define BZ_X_BCRC_3 22
#define BZ_X_BCRC_4 23
#define BZ_X_RANDBIT 24
#define BZ_X_ORIGPTR_1 25
#define BZ_X_ORIGPTR_2 26
#define BZ_X_ORIGPTR_3 27
#define BZ_X_MAPPING_1 28
#define BZ_X_MAPPING_2 29
#define BZ_X_SELECTOR_1 30
#define BZ_X_SELECTOR_2 31
#define BZ_X_SELECTOR_3 32
#define BZ_X_CODING_1 33
#define BZ_X_CODING_2 34
#define BZ_X_CODING_3 35
#define BZ_X_MTF_1 36
#define BZ_X_MTF_2 37
#define BZ_X_MTF_3 38
#define BZ_X_MTF_4 39
#define BZ_X_MTF_5 40
#define BZ_X_MTF_6 41
#define BZ_X_ENDHDR_2 42
#define BZ_X_ENDHDR_3 43
#define BZ_X_ENDHDR_4 44
#define BZ_X_ENDHDR_5 45
#define BZ_X_ENDHDR_6 46
#define BZ_X_CCRC_1 47
#define BZ_X_CCRC_2 48
#define BZ_X_CCRC_3 49
#define BZ_X_CCRC_4 50
/*-- Constants for the fast MTF decoder. --*/
#define MTFA_SIZE 4096
#define MTFL_SIZE 16
/*-- Structure holding all the decompression-side stuff. --*/
typedef
struct {
/* pointer back to the struct nsis_bzstream */
nsis_bzstream* strm;
/* state indicator for this stream */
Int32 state;
/* for doing the final run-length decoding */
UChar state_out_ch;
Int32 state_out_len;
Bool blockRandomised;
BZ_RAND_DECLS;
/* the buffer for bit stream reading */
UInt32 bsBuff;
Int32 bsLive;
/* misc administratium */
Int32 blockSize100k;
Bool smallDecompress;
Int32 currBlockNo;
Int32 verbosity;
/* for undoing the Burrows-Wheeler transform */
Int32 origPtr;
UInt32 tPos;
Int32 k0;
Int32 unzftab[256];
Int32 nblock_used;
Int32 cftab[257];
Int32 cftabCopy[257];
/* for undoing the Burrows-Wheeler transform (FAST) */
UInt32 *tt;
/* for undoing the Burrows-Wheeler transform (SMALL) */
UInt16 *ll16;
UChar *ll4;
/* stored and calculated CRCs */
UInt32 storedBlockCRC;
UInt32 storedCombinedCRC;
UInt32 calculatedBlockCRC;
UInt32 calculatedCombinedCRC;
/* map of bytes used in block */
Int32 nInUse;
Bool inUse[256];
Bool inUse16[16];
UChar seqToUnseq[256];
/* for decoding the MTF values */
UChar mtfa [MTFA_SIZE];
Int32 mtfbase[256 / MTFL_SIZE];
UChar selector [BZ_MAX_SELECTORS];
UChar selectorMtf[BZ_MAX_SELECTORS];
UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 limit [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 base [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 perm [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 minLens[BZ_N_GROUPS];
/* save area for scalars in the main decompress code */
Int32 save_i;
Int32 save_j;
Int32 save_t;
Int32 save_alphaSize;
Int32 save_nGroups;
Int32 save_nSelectors;
Int32 save_EOB;
Int32 save_groupNo;
Int32 save_groupPos;
Int32 save_nextSym;
Int32 save_nblockMAX;
Int32 save_nblock;
Int32 save_es;
Int32 save_N;
Int32 save_curr;
Int32 save_zt;
Int32 save_zn;
Int32 save_zvec;
Int32 save_zj;
Int32 save_gSel;
Int32 save_gMinlen;
Int32* save_gLimit;
Int32* save_gBase;
Int32* save_gPerm;
}
DState;
/*-- Macros for decompression. --*/
#define BZ_GET_FAST(cccc) \
/* c_tPos is unsigned, hence test < 0 is pointless. */ \
if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
s->tPos = s->tt[s->tPos]; \
cccc = (UChar)(s->tPos & 0xff); \
s->tPos >>= 8;
#define BZ_GET_FAST_C(cccc) \
/* c_tPos is unsigned, hence test < 0 is pointless. */ \
if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return True; \
c_tPos = c_tt[c_tPos]; \
cccc = (UChar)(c_tPos & 0xff); \
c_tPos >>= 8;
#define SET_LL4(i,n) \
{ if (((i) & 0x1) == 0) \
s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else \
s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4); \
}
#define GET_LL4(i) \
((((UInt32)(s->ll4[(i) >> 1])) >> (((i) << 2) & 0x4)) & 0xF)
#define SET_LL(i,n) \
{ s->ll16[i] = (UInt16)(n & 0x0000ffff); \
SET_LL4(i, n >> 16); \
}
#define GET_LL(i) \
(((UInt32)s->ll16[i]) | (GET_LL4(i) << 16))
#define BZ_GET_SMALL(cccc) \
/* c_tPos is unsigned, hence test < 0 is pointless. */ \
if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
cccc = indexIntoF ( s->tPos, s->cftab ); \
s->tPos = GET_LL(s->tPos);
#endif
/*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/
#ifdef BZ_NO_STDIO
#ifndef NULL
#define NULL 0
#endif
#endif
/*-------------------------------------------------------------*/
/*--- end bzlib_private.h ---*/
/*-------------------------------------------------------------*/

712
clamav/libclamav/nsis/infblock.c Normal file
View File

@@ -0,0 +1,712 @@
/*
* 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)
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 const 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 */
uIntf *v) /* 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 (!s->zs.fixed_built)
{
int _k; /* temporary variable */
uInt f = 0; /* number of hufts used in fixed_mem */
/* literal table */
for (_k = 0; _k < 288; _k++)
{
char v=8;
if (_k > 143)
{
if (_k < 256) v++;
else if (_k < 280) v--;
}
s->zs.lc[_k] = v;
}
huft_build(s->zs.lc, 288, 257, cplens, cplext, &s->zs.fixed_tl, &s->zs.fixed_bl, s->zs.fixed_mem, &f, s->zs.v);
/* distance table */
for (_k = 0; _k < 30; _k++) s->zs.lc[_k] = 5;
huft_build(s->zs.lc, 30, 0, cpdist, cpdext, &s->zs.fixed_td, &s->zs.fixed_bd, s->zs.fixed_mem, &f, s->zs.v);
/* done */
s->zs.fixed_built++;
}
/* s->sub.decode.t_codes.mode = CODES_START; */
s->sub.decode.t_codes.lbits = (Byte)s->zs.fixed_bl;
s->sub.decode.t_codes.dbits = (Byte)s->zs.fixed_bd;
s->sub.decode.t_codes.ltree = s->zs.fixed_tl;
s->sub.decode.t_codes.dtree = s->zs.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, s->zs.v);
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, s->zs.v);
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, s->zs.v);
}
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

264
clamav/libclamav/nsis/nsis_bzlib.h Normal file
View File

@@ -0,0 +1,264 @@
/*-------------------------------------------------------------*/
/*--- Public header file for the library. ---*/
/*--- bzlib.h ---*/
/*-------------------------------------------------------------*/
/* ------------------------------------------------------------------
This file is part of bzip2/libbzip2, a program and library for
lossless, block-sorting data compression.
bzip2/libbzip2 version 1.0.4 of 20 December 2006
Copyright (C) 1996-2006 Julian Seward <jseward@bzip.org>
This file was modified for ClamAV by aCaB <acab@clamav.net>
This program is released under the terms of the license contained
in the file COPYING.bzip2.
------------------------------------------------------------------ */
#ifndef _NSIS_BZLIB_H
#define _NSIS_BZLIB_H
#ifdef __cplusplus
extern "C" {
#endif
#define BZ_RUN 0
#define BZ_FLUSH 1
#define BZ_FINISH 2
#define BZ_OK 0
#define BZ_RUN_OK 1
#define BZ_FLUSH_OK 2
#define BZ_FINISH_OK 3
#define BZ_STREAM_END 4
#define BZ_SEQUENCE_ERROR (-1)
#define BZ_PARAM_ERROR (-2)
#define BZ_MEM_ERROR (-3)
#define BZ_DATA_ERROR (-4)
#define BZ_DATA_ERROR_MAGIC (-5)
#define BZ_IO_ERROR (-6)
#define BZ_UNEXPECTED_EOF (-7)
#define BZ_OUTBUFF_FULL (-8)
#define BZ_CONFIG_ERROR (-9)
typedef
struct {
unsigned char *next_in;
unsigned int avail_in;
unsigned int total_in_lo32;
unsigned int total_in_hi32;
unsigned char *next_out;
unsigned int avail_out;
unsigned int total_out_lo32;
unsigned int total_out_hi32;
void *state;
void *(*bzalloc)(void *,int,int);
void (*bzfree)(void *,void *);
void *opaque;
}
nsis_bzstream;
#ifndef BZ_IMPORT
#define BZ_EXPORT
#endif
#ifndef BZ_NO_STDIO
/* Need a definitition for FILE */
#include <stdio.h>
#endif
#define BZ_API(func) func
#define BZ_EXTERN extern
/*-- Core (low-level) library functions --*/
/* aCaB
BZ_EXTERN int BZ_API(BZ2_bzCompressInit) (
nsis_bzstream* strm,
int blockSize100k,
int verbosity,
int workFactor
);
BZ_EXTERN int BZ_API(BZ2_bzCompress) (
nsis_bzstream* strm,
int action
);
BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) (
nsis_bzstream* strm
);
*/
BZ_EXTERN int BZ_API(nsis_BZ2_bzDecompressInit) (
nsis_bzstream *strm,
int verbosity,
int small
);
BZ_EXTERN int BZ_API(nsis_BZ2_bzDecompress) (
nsis_bzstream* strm
);
BZ_EXTERN int BZ_API(nsis_BZ2_bzDecompressEnd) (
nsis_bzstream *strm
);
/*-- High(er) level library functions --*/
/* aCaB
#ifndef BZ_NO_STDIO
#define BZ_MAX_UNUSED 5000
typedef void BZFILE;
BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) (
int* bzerror,
FILE* f,
int verbosity,
int small,
void* unused,
int nUnused
);
BZ_EXTERN void BZ_API(BZ2_bzReadClose) (
int* bzerror,
BZFILE* b
);
BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) (
int* bzerror,
BZFILE* b,
void** unused,
int* nUnused
);
BZ_EXTERN int BZ_API(BZ2_bzRead) (
int* bzerror,
BZFILE* b,
void* buf,
int len
);
BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) (
int* bzerror,
FILE* f,
int blockSize100k,
int verbosity,
int workFactor
);
BZ_EXTERN void BZ_API(BZ2_bzWrite) (
int* bzerror,
BZFILE* b,
void* buf,
int len
);
BZ_EXTERN void BZ_API(BZ2_bzWriteClose) (
int* bzerror,
BZFILE* b,
int abandon,
unsigned int* nbytes_in,
unsigned int* nbytes_out
);
BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) (
int* bzerror,
BZFILE* b,
int abandon,
unsigned int* nbytes_in_lo32,
unsigned int* nbytes_in_hi32,
unsigned int* nbytes_out_lo32,
unsigned int* nbytes_out_hi32
);
#endif
*/
/*-- Utility functions --*/
/* aCaB
BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) (
char* dest,
unsigned int* destLen,
char* source,
unsigned int sourceLen,
int blockSize100k,
int verbosity,
int workFactor
);
BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) (
char* dest,
unsigned int* destLen,
char* source,
unsigned int sourceLen,
int small,
int verbosity
);
*/
/*--
Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp)
to support better zlib compatibility.
This code is not _officially_ part of libbzip2 (yet);
I haven't tested it, documented it, or considered the
threading-safeness of it.
If this code breaks, please contact both Yoshioka and me.
--*/
/* aCaB
BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) (
void
);
#ifndef BZ_NO_STDIO
BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) (
const char *path,
const char *mode
);
BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) (
int fd,
const char *mode
);
BZ_EXTERN int BZ_API(BZ2_bzread) (
BZFILE* b,
void* buf,
int len
);
BZ_EXTERN int BZ_API(BZ2_bzwrite) (
BZFILE* b,
void* buf,
int len
);
BZ_EXTERN int BZ_API(BZ2_bzflush) (
BZFILE* b
);
BZ_EXTERN void BZ_API(BZ2_bzclose) (
BZFILE* b
);
BZ_EXTERN const char * BZ_API(BZ2_bzerror) (
BZFILE *b,
int *errnum
);
#endif
*/
#ifdef __cplusplus
}
#endif
#endif
/*-------------------------------------------------------------*/
/*--- end bzlib.h ---*/
/*-------------------------------------------------------------*/

2
clamav/libclamav/nsis/nsis_zconf.h Normal file
View File

@@ -0,0 +1,2 @@
/* Avoid symbol collisions, just use the real thing */
#include <zconf.h>

238
clamav/libclamav/nsis/nsis_zlib.h Normal file
View File

@@ -0,0 +1,238 @@
/* 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;
#define FIXEDH 544 /* number of hufts used by fixed tables */
struct z_stuff {
char fixed_built;
inflate_huft fixed_mem[FIXEDH];
uInt fixed_bl;
uInt fixed_bd;
inflate_huft *fixed_tl;
inflate_huft *fixed_td;
uIntf v[288];
uIntf lc[288];
};
struct inflate_blocks_state {
/* acab */
struct z_stuff zs;
/* 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(z) \
{ \
(z)->blocks.zs.fixed_built = 0; \
(z)->blocks.zs.fixed_bl = 9; \
(z)->blocks.zs.fixed_bd = 5; \
inflateReset(z); \
}
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 */

74
clamav/libclamav/nsis/nsis_zutil.h Normal file
View File

@@ -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 */

576
clamav/libclamav/nsis/nulsft.c Normal file
View File

@@ -0,0 +1,576 @@
/*
* Copyright (C) 2007-2008 Sourcefire Inc.
*
* Authors: Alberto Wu
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*/
#if HAVE_CONFIG_H
#include "clamav-config.h"
#endif
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include "clamav.h"
#include "others.h"
#include "nsis_bzlib.h"
/* #include "zlib.h" */
#include "nsis_zlib.h"
#include "lzma_iface.h"
#include "matcher.h"
#include "scanners.h"
#include "nulsft.h" /* SHUT UP GCC -Wextra */
#include "fmap.h"
#define EC32(x) le32_to_host(x)
enum {
COMP_NOT_DETECTED,
COMP_BZIP2,
COMP_LZMA,
COMP_ZLIB,
COMP_NOCOMP
};
struct nsis_st {
size_t curpos;
int ofd;
int opened;
off_t off;
off_t fullsz;
char *dir;
uint32_t asz;
uint32_t hsz;
uint32_t fno;
uint8_t comp;
uint8_t solid;
uint8_t freecomp;
uint8_t eof;
struct stream_state nsis;
nsis_bzstream bz;
struct CLI_LZMA lz;
/* z_stream z; */
nsis_z_stream z;
const unsigned char *freeme;
fmap_t *map;
char ofn[1024];
};
#define LINESTR(x) #x
#define LINESTR2(x) LINESTR(x)
#define __AT__ " at "__FILE__ \
":" LINESTR2(__LINE__)
static int nsis_init(struct nsis_st *n)
{
switch (n->comp) {
case COMP_BZIP2:
memset(&n->bz, 0, sizeof(nsis_bzstream));
if (nsis_BZ2_bzDecompressInit(&n->bz, 0, 0) != BZ_OK)
return CL_EUNPACK;
n->freecomp = 1;
break;
case COMP_LZMA:
memset(&n->lz, 0, sizeof(struct CLI_LZMA));
if (cli_LzmaInit(&n->lz, 0xffffffffffffffffULL) != LZMA_RESULT_OK)
return CL_EUNPACK;
n->freecomp = 1;
break;
case COMP_ZLIB:
memset(&n->z, 0, sizeof(z_stream));
/* inflateInit2(&n->z, -MAX_WBITS); */
/* n->freecomp=1; */
nsis_inflateInit(&n->z);
n->freecomp = 0;
}
return CL_SUCCESS;
}
static void nsis_shutdown(struct nsis_st *n)
{
if (!n->freecomp)
return;
switch (n->comp) {
case COMP_BZIP2:
nsis_BZ2_bzDecompressEnd(&n->bz);
break;
case COMP_LZMA:
cli_LzmaShutdown(&n->lz);
break;
case COMP_ZLIB:
/* inflateEnd(&n->z); */
break;
}
n->freecomp = 0;
}
static int nsis_decomp(struct nsis_st *n)
{
int ret = CL_EFORMAT;
switch (n->comp) {
case COMP_BZIP2:
n->bz.avail_in = n->nsis.avail_in;
n->bz.next_in = n->nsis.next_in;
n->bz.avail_out = n->nsis.avail_out;
n->bz.next_out = n->nsis.next_out;
switch (nsis_BZ2_bzDecompress(&n->bz)) {
case BZ_OK:
ret = CL_SUCCESS;
break;
case BZ_STREAM_END:
ret = CL_BREAK;
}
n->nsis.avail_in = n->bz.avail_in;
n->nsis.next_in = n->bz.next_in;
n->nsis.avail_out = n->bz.avail_out;
n->nsis.next_out = n->bz.next_out;
break;
case COMP_LZMA:
n->lz.avail_in = n->nsis.avail_in;
n->lz.next_in = n->nsis.next_in;
n->lz.avail_out = n->nsis.avail_out;
n->lz.next_out = n->nsis.next_out;
switch (cli_LzmaDecode(&n->lz)) {
case LZMA_RESULT_OK:
ret = CL_SUCCESS;
break;
case LZMA_STREAM_END:
ret = CL_BREAK;
}
n->nsis.avail_in = n->lz.avail_in;
n->nsis.next_in = n->lz.next_in;
n->nsis.avail_out = n->lz.avail_out;
n->nsis.next_out = n->lz.next_out;
break;
case COMP_ZLIB:
n->z.avail_in = n->nsis.avail_in;
n->z.next_in = n->nsis.next_in;
n->z.avail_out = n->nsis.avail_out;
n->z.next_out = n->nsis.next_out;
/* switch (inflate(&n->z, Z_NO_FLUSH)) { */
switch (nsis_inflate(&n->z)) {
case Z_OK:
ret = CL_SUCCESS;
break;
case Z_STREAM_END:
ret = CL_BREAK;
}
n->nsis.avail_in = n->z.avail_in;
n->nsis.next_in = n->z.next_in;
n->nsis.avail_out = n->z.avail_out;
n->nsis.next_out = n->z.next_out;
break;
}
return ret;
}
static int nsis_unpack_next(struct nsis_st *n, cli_ctx *ctx)
{
const unsigned char *ibuf;
uint32_t size, loops;
int ret, gotsome = 0;
unsigned char obuf[BUFSIZ];
if (n->eof) {
cli_dbgmsg("NSIS: extraction complete\n");
return CL_BREAK;
}
if ((ret = cli_checklimits("NSIS", ctx, 0, 0, 0)) != CL_CLEAN)
return ret;
if (n->fno)
snprintf(n->ofn, 1023, "%s" PATHSEP "content.%.3u", n->dir, n->fno);
else
snprintf(n->ofn, 1023, "%s" PATHSEP "headers", n->dir);
n->fno++;
n->opened = 0;
if (!n->solid) {
if (fmap_readn(n->map, &size, n->curpos, 4) != 4) {
cli_dbgmsg("NSIS: reached EOF - extraction complete\n");
return CL_BREAK;
}
n->curpos += 4;
if (n->asz == 4) {
cli_dbgmsg("NSIS: reached CRC - extraction complete\n");
return CL_BREAK;
}
loops = EC32(size);
if (!(size = (loops & ~0x80000000))) {
cli_dbgmsg("NSIS: empty file found\n");
return CL_SUCCESS;
}
if (n->asz < 4 || size > n->asz - 4) {
cli_dbgmsg("NSIS: next file is outside the archive\n");
return CL_BREAK;
}
n->asz -= size + 4;
if ((ret = cli_checklimits("NSIS", ctx, size, 0, 0)) != CL_CLEAN) {
n->curpos += size;
return ret;
}
if (!(ibuf = fmap_need_off_once(n->map, n->curpos, size))) {
cli_dbgmsg("NSIS: cannot read %u bytes"__AT__
"\n",
size);
return CL_EREAD;
}
if ((n->ofd = open(n->ofn, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0600)) == -1) {
cli_errmsg("NSIS: unable to create output file %s - aborting.", n->ofn);
return CL_ECREAT;
}
n->opened = 1;
n->curpos += size;
if (loops == size) {
if (cli_writen(n->ofd, ibuf, size) != size) {
cli_dbgmsg("NSIS: cannot write output file"__AT__
"\n");
close(n->ofd);
return CL_EWRITE;
}
} else {
if ((ret = nsis_init(n)) != CL_SUCCESS) {
cli_dbgmsg("NSIS: decompressor init failed"__AT__
"\n");
close(n->ofd);
return ret;
}
n->nsis.avail_in = size;
n->nsis.next_in = (void *)ibuf;
n->nsis.next_out = obuf;
n->nsis.avail_out = BUFSIZ;
loops = 0;
while ((ret = nsis_decomp(n)) == CL_SUCCESS) {
if ((size = n->nsis.next_out - obuf) > 0) {
gotsome = 1;
if (cli_writen(n->ofd, obuf, size) != size) {
cli_dbgmsg("NSIS: cannot write output file"__AT__
"\n");
close(n->ofd);
nsis_shutdown(n);
return CL_EWRITE;
}
n->nsis.next_out = obuf;
n->nsis.avail_out = BUFSIZ;
loops = 0;
if ((ret = cli_checklimits("NSIS", ctx, size, 0, 0)) != CL_CLEAN) {
close(n->ofd);
nsis_shutdown(n);
return ret;
}
} else if (++loops > 20) {
cli_dbgmsg("NSIS: xs looping, breaking out"__AT__
"\n");
ret = CL_EFORMAT;
break;
}
}
nsis_shutdown(n);
if ((n->nsis.next_out - obuf) > 0) {
gotsome = 1;
if (cli_writen(n->ofd, obuf, (size_t)(n->nsis.next_out - obuf)) != (size_t)(n->nsis.next_out - obuf)) {
cli_dbgmsg("NSIS: cannot write output file"__AT__
"\n");
close(n->ofd);
return CL_EWRITE;
}
}
if (ret != CL_SUCCESS && ret != CL_BREAK) {
cli_dbgmsg("NSIS: bad stream"__AT__
"\n");
if (gotsome) {
ret = CL_SUCCESS;
} else {
ret = CL_EMAXSIZE;
close(n->ofd);
}
return ret;
}
}
return CL_SUCCESS;
} else {
if (!n->freeme) {
if ((ret = nsis_init(n)) != CL_SUCCESS) {
cli_dbgmsg("NSIS: decompressor init failed\n");
return ret;
}
if (!(n->freeme = fmap_need_off_once(n->map, n->curpos, n->asz))) {
cli_dbgmsg("NSIS: cannot read %u bytes"__AT__
"\n",
n->asz);
return CL_EREAD;
}
n->nsis.next_in = (void *)n->freeme;
n->nsis.avail_in = n->asz;
}
if (n->nsis.avail_in <= 4) {
cli_dbgmsg("NSIS: extraction complete\n");
return CL_BREAK;
}
n->nsis.next_out = obuf;
n->nsis.avail_out = 4;
loops = 0;
while ((ret = nsis_decomp(n)) == CL_SUCCESS) {
if (n->nsis.next_out - obuf == 4) break;
if (++loops > 20) {
cli_dbgmsg("NSIS: xs looping, breaking out"__AT__
"\n");
ret = CL_BREAK;
break;
}
}
if (ret != CL_SUCCESS) {
cli_dbgmsg("NSIS: bad stream"__AT__
"\n");
return CL_EFORMAT;
}
size = cli_readint32(obuf);
if ((ret = cli_checklimits("NSIS", ctx, size, 0, 0)) != CL_CLEAN) {
return ret;
}
if (size == 0) {
cli_dbgmsg("NSIS: Empty file found.\n");
return CL_SUCCESS;
}
n->nsis.next_out = obuf;
n->nsis.avail_out = MIN(BUFSIZ, size);
loops = 0;
if ((n->ofd = open(n->ofn, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0600)) == -1) {
cli_errmsg("NSIS: unable to create output file %s - aborting.", n->ofn);
return CL_ECREAT;
}
n->opened = 1;
while (size && (ret = nsis_decomp(n)) == CL_SUCCESS) {
unsigned int wsz;
if ((wsz = n->nsis.next_out - obuf) > 0) {
gotsome = 1;
if (cli_writen(n->ofd, obuf, wsz) != wsz) {
cli_dbgmsg("NSIS: cannot write output file"__AT__
"\n");
close(n->ofd);
return CL_EWRITE;
}
size -= wsz;
loops = 0;
n->nsis.next_out = obuf;
n->nsis.avail_out = MIN(size, BUFSIZ);
} else if (++loops > 20) {
cli_dbgmsg("NSIS: xs looping, breaking out"__AT__
"\n");
ret = CL_EFORMAT;
break;
}
}
if ((n->nsis.next_out - obuf) > 0) {
gotsome = 1;
if (cli_writen(n->ofd, obuf, (size_t)(n->nsis.next_out - obuf)) != (size_t)(n->nsis.next_out - obuf)) {
cli_dbgmsg("NSIS: cannot write output file"__AT__
"\n");
close(n->ofd);
return CL_EWRITE;
}
}
if (ret == CL_EFORMAT) {
cli_dbgmsg("NSIS: bad stream"__AT__
"\n");
if (!gotsome) {
close(n->ofd);
return CL_EMAXSIZE;
}
}
if (ret == CL_EFORMAT || ret == CL_BREAK) {
n->eof = 1;
} else if (ret != CL_SUCCESS) {
cli_dbgmsg("NSIS: bad stream"__AT__
"\n");
close(n->ofd);
return CL_EFORMAT;
}
return CL_SUCCESS;
}
}
static uint8_t nsis_detcomp(const char *b)
{
if (*b == '1') return COMP_BZIP2;
if ((cli_readint32(b) & ~0x80000000) == 0x5d) return COMP_LZMA;
return COMP_ZLIB;
}
static int nsis_headers(struct nsis_st *n, cli_ctx *ctx)
{
const char *buf;
uint32_t pos;
int i;
uint8_t comps[] = {0, 0, 0, 0}, trunc = 0;
if (!(buf = fmap_need_off_once(n->map, n->off, 0x1c)))
return CL_EREAD;
n->hsz = (uint32_t)cli_readint32(buf + 0x14);
n->asz = (uint32_t)cli_readint32(buf + 0x18);
n->fullsz = n->map->len;
cli_dbgmsg("NSIS: Header info - Flags=%x, Header size=%x, Archive size=%x\n", cli_readint32(buf), n->hsz, n->asz);
if (n->fullsz - n->off < (off_t)n->asz) {
cli_dbgmsg("NSIS: Possibly truncated file\n");
n->asz = n->fullsz - n->off;
trunc++;
} else if (n->fullsz - n->off != (off_t)n->asz) {
cli_dbgmsg("NSIS: Overlays found\n");
}
n->asz -= 0x1c;
buf += 0x1c;
/* Guess if solid */
for (i = 0, pos = 0; pos < n->asz - 4; i++) {
int32_t nextsz;
if (!(buf = fmap_need_ptr_once(n->map, (void *)buf, 4))) return CL_EREAD;
nextsz = cli_readint32(buf);
if (!i) n->comp = nsis_detcomp(buf);
buf += 4;
if (nextsz & 0x80000000) {
nextsz &= ~0x80000000;
if (!(buf = fmap_need_ptr_once(n->map, (void *)buf, 4))) return CL_EREAD;
comps[nsis_detcomp(buf)]++;
nextsz -= 4;
pos += 4;
buf += 4;
}
if ((pos += (4 + ((uint32_t)nextsz))) > n->asz) {
n->solid = 1;
break;
}
buf += nextsz;
}
if (trunc && i >= 2) n->solid = 0;
cli_dbgmsg("NSIS: solid compression%s detected\n", (n->solid) ? "" : " not");
/* Guess the compression method */
if (!n->solid) {
cli_dbgmsg("NSIS: bzip2 %u - lzma %u - zlib %u\n", comps[1], comps[2], comps[3]);
n->comp = (comps[1] < comps[2]) ? (comps[2] < comps[3] ? COMP_ZLIB : COMP_LZMA) : (comps[1] < comps[3] ? COMP_ZLIB : COMP_BZIP2);
}
n->curpos = n->off + 0x1c;
return nsis_unpack_next(n, ctx);
}
static int cli_nsis_unpack(struct nsis_st *n, cli_ctx *ctx)
{
return (n->fno) ? nsis_unpack_next(n, ctx) : nsis_headers(n, ctx);
}
int cli_scannulsft(cli_ctx *ctx, off_t offset)
{
int ret;
struct nsis_st nsist;
cli_dbgmsg("in scannulsft()\n");
memset(&nsist, 0, sizeof(struct nsis_st));
nsist.off = offset;
if (!(nsist.dir = cli_gentemp_with_prefix(ctx->sub_tmpdir, "nulsft-tmp")))
return CL_ETMPDIR;
if (mkdir(nsist.dir, 0700)) {
cli_dbgmsg("NSIS: Can't create temporary directory %s\n", nsist.dir);
free(nsist.dir);
return CL_ETMPDIR;
}
nsist.map = ctx->fmap;
if (ctx->engine->keeptmp) cli_dbgmsg("NSIS: Extracting files to %s\n", nsist.dir);
do {
ret = cli_nsis_unpack(&nsist, ctx);
if (ret == CL_SUCCESS && nsist.opened == 0) {
/* Don't scan a non-existent file */
continue;
}
if (ret == CL_SUCCESS) {
cli_dbgmsg("NSIS: Successully extracted file #%u\n", nsist.fno);
if (lseek(nsist.ofd, 0, SEEK_SET) == -1) {
cli_dbgmsg("NSIS: call to lseek() failed\n");
free(nsist.dir);
return CL_ESEEK;
}
if (nsist.fno == 1) {
ret = cli_scan_desc(nsist.ofd, ctx, CL_TYPE_ANY, false, NULL, AC_SCAN_VIR, NULL, NULL, LAYER_ATTRIBUTES_NONE); /// TODO: Extract file names
} else {
ret = cli_magic_scan_desc(nsist.ofd, nsist.ofn, ctx, NULL, LAYER_ATTRIBUTES_NONE); /// TODO: Extract file names
}
close(nsist.ofd);
if (!ctx->engine->keeptmp) {
if (cli_unlink(nsist.ofn)) {
ret = CL_EUNLINK;
}
}
} else if (ret == CL_EMAXSIZE) {
ret = nsist.solid ? CL_BREAK : CL_SUCCESS;
}
} while (ret == CL_SUCCESS);
if (ret == CL_BREAK)
ret = CL_CLEAN;
nsis_shutdown(&nsist);
if (!ctx->engine->keeptmp) {
cli_rmdirs(nsist.dir);
}
free(nsist.dir);
return ret;
}

26
clamav/libclamav/nsis/nulsft.h Normal file
View File

@@ -0,0 +1,26 @@
/*
* Copyright (C) 2007-2008 Sourcefire Inc.
*
* Authors: Alberto Wu
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*/
#ifndef __NSIS_H
#define __NSIS_H
#include "others.h"
int cli_scannulsft(cli_ctx *ctx, off_t offset);
#endif