text: /*
   * This file includes code from libmspack adapted for libclamav by
   * tkojm@clamav.net
   *
   * Copyright (C) 2003-2004 Stuart Caie
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License version 2.1 as published by the Free Software Foundation.
   *
   * This library 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
   * Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
   * USA
   */
  
  #ifndef __MSPACK_H
  #define __MSPACK_H
  
  #include <sys/types.h>
  #include "cab.h"
  
  
  /***************************************************************************
   *			 MS-ZIP decompression definitions                  *
   ***************************************************************************/
  
  #define MSZIP_FRAME_SIZE          (32768) /* size of LZ history window */
  #define MSZIP_MAX_HUFFBITS        (16)    /* maximum huffman code length */
  #define MSZIP_LITERAL_MAXSYMBOLS  (288)   /* literal/length huffman tree */
  #define MSZIP_LITERAL_TABLEBITS   (9)
  #define MSZIP_DISTANCE_MAXSYMBOLS (32)    /* distance huffman tree */
  #define MSZIP_DISTANCE_TABLEBITS  (6)
  
  /* if there are less direct lookup entries than symbols, the longer
   * code pointers will be <= maxsymbols. This must not happen, or we
   * will decode entries badly */
  #if (1 << MSZIP_LITERAL_TABLEBITS) < (MSZIP_LITERAL_MAXSYMBOLS * 2)
  # define MSZIP_LITERAL_TABLESIZE (MSZIP_LITERAL_MAXSYMBOLS * 4)
  #else
  # define MSZIP_LITERAL_TABLESIZE ((1 << MSZIP_LITERAL_TABLEBITS) + \
  				  (MSZIP_LITERAL_MAXSYMBOLS * 2))
  #endif
  
  #if (1 << MSZIP_DISTANCE_TABLEBITS) < (MSZIP_DISTANCE_MAXSYMBOLS * 2)
  # define MSZIP_DISTANCE_TABLESIZE (MSZIP_DISTANCE_MAXSYMBOLS * 4)
  #else
  # define MSZIP_DISTANCE_TABLESIZE ((1 << MSZIP_DISTANCE_TABLEBITS) + \
  				  (MSZIP_DISTANCE_MAXSYMBOLS * 2))
  #endif
  
  struct mszip_stream {
    int fd;		    /* input file descriptor */
    int ofd;                  /* output file descriptor */
    unsigned char wflag;	    /* write flag */
  
    unsigned int window_posn;             /* offset within window  */
  
    /* inflate() will call this whenever the window should be emptied. */
    int (*flush_window)(struct mszip_stream *, unsigned int);
  
    int error, repair_mode, bytes_output, input_end;
  
    /* I/O buffering */
    unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end;
    unsigned int bit_buffer, bits_left, inbuf_size;
  
    /* huffman code lengths */
    unsigned char  LITERAL_len[MSZIP_LITERAL_MAXSYMBOLS];
    unsigned char  DISTANCE_len[MSZIP_DISTANCE_MAXSYMBOLS];
  
    /* huffman decoding tables */
    unsigned short LITERAL_table [MSZIP_LITERAL_TABLESIZE];
    unsigned short DISTANCE_table[MSZIP_DISTANCE_TABLESIZE];
  
    /* 32kb history window */
    unsigned char window[MSZIP_FRAME_SIZE];
  
    /* cabinet related stuff */
    struct cab_file *file;
    int (*read)(struct cab_file *, unsigned char *, int);
  };
  
  struct mszip_stream *mszip_init(int fd,
  				  int ofd,
  				  int input_buffer_size,
  				  int repair_mode,
  				  struct cab_file *file,
  			          int (*read)(struct cab_file *, unsigned char *, int));
  
  extern int mszip_decompress(struct mszip_stream *zip, off_t out_bytes);
  
  void mszip_free(struct mszip_stream *zip);
  
  
  /***************************************************************************
   *			 Quantum decompression definitions                 *
   ***************************************************************************/
  
  /* Quantum compression / decompression definitions */
  
  #define QTM_FRAME_SIZE (32768)
  
  struct qtm_modelsym {
    unsigned short sym, cumfreq;
  };
  
  struct qtm_model {
    int shiftsleft, entries;
    struct qtm_modelsym *syms;
  };
  
  struct qtm_stream {
    int fd;                   /* input file descriptor */
    int ofd;                  /* output file descriptor */
    unsigned char wflag;	    /* write flag */
  
    unsigned char *window;          /* decoding window                         */
    unsigned int window_size;       /* window size                             */
    unsigned int window_posn;       /* decompression offset within window      */
    unsigned int frame_start;       /* start of current frame within window    */
  
    unsigned short H, L, C;         /* high/low/current: arith coding state    */
    unsigned char header_read;      /* have we started decoding a new frame?   */
  
    int error;
  
    /* I/O buffers */
    unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end;
    unsigned int  bit_buffer, inbuf_size;
    unsigned char bits_left;
  
    /* data tables */
    unsigned int  position_base[42];
    unsigned char extra_bits[42], length_base[27], length_extra[27];
  
    /* four literal models, each representing 64 symbols
     * model0 for literals from   0 to  63 (selector = 0)
     * model1 for literals from  64 to 127 (selector = 1)
     * model2 for literals from 128 to 191 (selector = 2)
     * model3 for literals from 129 to 255 (selector = 3) */
    struct qtm_model model0, model1, model2, model3;
  
    /* three match models.
     * model4 for match with fixed length of 3 bytes
     * model5 for match with fixed length of 4 bytes
     * model6 for variable length match, encoded with model6len model */
    struct qtm_model model4, model5, model6, model6len;
  
    /* selector model. 0-6 to say literal (0,1,2,3) or match (4,5,6) */
    struct qtm_model model7;
  
    /* symbol arrays for all models */
    struct qtm_modelsym m0sym[64 + 1];
    struct qtm_modelsym m1sym[64 + 1];
    struct qtm_modelsym m2sym[64 + 1];
    struct qtm_modelsym m3sym[64 + 1];
    struct qtm_modelsym m4sym[24 + 1];
    struct qtm_modelsym m5sym[36 + 1];
    struct qtm_modelsym m6sym[42 + 1], m6lsym[27 + 1];
    struct qtm_modelsym m7sym[7 + 1];
  
    /* cabinet related stuff */
    struct cab_file *file;
    int (*read)(struct cab_file *, unsigned char *, int);
  
  };
  
  extern struct qtm_stream *qtm_init(int fd,
  				     int ofd,
  				     int window_bits,
  				     int input_buffer_size,
  				     struct cab_file *file,
  				     int (*read)(struct cab_file *, unsigned char *, int));
  
  extern int qtm_decompress(struct qtm_stream *qtm, off_t out_bytes);
  
  void qtm_free(struct qtm_stream *qtm);
  
  /***************************************************************************
   *			 LZX decompression definitions                     *
   ***************************************************************************/
  
  /* some constants defined by the LZX specification */
  #define LZX_MIN_MATCH                (2)
  #define LZX_MAX_MATCH                (257)
  #define LZX_NUM_CHARS                (256)
  #define LZX_BLOCKTYPE_INVALID        (0)   /* also blocktypes 4-7 invalid */
  #define LZX_BLOCKTYPE_VERBATIM       (1)
  #define LZX_BLOCKTYPE_ALIGNED        (2)
  #define LZX_BLOCKTYPE_UNCOMPRESSED   (3)
  #define LZX_PRETREE_NUM_ELEMENTS     (20)
  #define LZX_ALIGNED_NUM_ELEMENTS     (8)   /* aligned offset tree #elements */
  #define LZX_NUM_PRIMARY_LENGTHS      (7)   /* this one missing from spec! */
  #define LZX_NUM_SECONDARY_LENGTHS    (249) /* length tree #elements */
  
  /* LZX huffman defines: tweak tablebits as desired */
  #define LZX_PRETREE_MAXSYMBOLS  (LZX_PRETREE_NUM_ELEMENTS)
  #define LZX_PRETREE_TABLEBITS   (6)
  #define LZX_MAINTREE_MAXSYMBOLS (LZX_NUM_CHARS + 50*8)
  #define LZX_MAINTREE_TABLEBITS  (12)
  #define LZX_LENGTH_MAXSYMBOLS   (LZX_NUM_SECONDARY_LENGTHS+1)
  #define LZX_LENGTH_TABLEBITS    (12)
  #define LZX_ALIGNED_MAXSYMBOLS  (LZX_ALIGNED_NUM_ELEMENTS)
  #define LZX_ALIGNED_TABLEBITS   (7)
  #define LZX_LENTABLE_SAFETY (64)  /* table decoding overruns are allowed */
  
  #define LZX_FRAME_SIZE (32768) /* the size of a frame in LZX */
  
  struct lzx_stream {
    int fd;			  /* input file descriptor                   */
    int ofd;			  /* output file descriptor                  */
    unsigned char wflag;		  /* write flag */
  
    off_t   offset;                 /* number of bytes actually output         */
    off_t   length;                 /* overall decompressed length of stream   */
  
    unsigned char *window;          /* decoding window                         */
    unsigned int   window_size;     /* window size                             */
    unsigned int   window_posn;     /* decompression offset within window      */
    unsigned int   frame_posn;      /* current frame offset within in window   */
    unsigned int   frame;           /* the number of 32kb frames processed     */
    unsigned int   reset_interval;  /* which frame do we reset the compressor? */
  
    unsigned int   R0, R1, R2;      /* for the LRU offset system               */
    unsigned int   block_length;    /* uncompressed length of this LZX block   */
    unsigned int   block_remaining; /* uncompressed bytes still left to decode */
  
    signed int     intel_filesize;  /* magic header value used for transform   */
    signed int     intel_curpos;    /* current offset in transform space       */
  
    unsigned char  intel_started;   /* has intel E8 decoding started?          */
    unsigned char  block_type;      /* type of the current block               */
    unsigned char  header_read;     /* have we started decoding at all yet?    */
    unsigned char  posn_slots;      /* how many posn slots in stream?          */
    unsigned char  input_end;       /* have we reached the end of input?       */
  
    int error;
  
    /* I/O buffering */
    unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end;
    unsigned int  bit_buffer, bits_left, inbuf_size;
  
    /* huffman code lengths */
    unsigned char PRETREE_len  [LZX_PRETREE_MAXSYMBOLS  + LZX_LENTABLE_SAFETY];
    unsigned char MAINTREE_len [LZX_MAINTREE_MAXSYMBOLS + LZX_LENTABLE_SAFETY];
    unsigned char LENGTH_len   [LZX_LENGTH_MAXSYMBOLS   + LZX_LENTABLE_SAFETY];
    unsigned char ALIGNED_len  [LZX_ALIGNED_MAXSYMBOLS  + LZX_LENTABLE_SAFETY];
  
    /* huffman decoding tables */
    unsigned short PRETREE_table [(1 << LZX_PRETREE_TABLEBITS) +
  				(LZX_PRETREE_MAXSYMBOLS * 2)];
    unsigned short MAINTREE_table[(1 << LZX_MAINTREE_TABLEBITS) +
  				(LZX_MAINTREE_MAXSYMBOLS * 2)];
    unsigned short LENGTH_table  [(1 << LZX_LENGTH_TABLEBITS) +
  				(LZX_LENGTH_MAXSYMBOLS * 2)];
    unsigned short ALIGNED_table [(1 << LZX_ALIGNED_TABLEBITS) +
  				(LZX_ALIGNED_MAXSYMBOLS * 2)];
  
    unsigned int  position_base[51];
    unsigned char extra_bits[51];
  
    /* this is used purely for doing the intel E8 transform */
    unsigned char  e8_buf[LZX_FRAME_SIZE];
  
    /* cabinet related stuff */
    struct cab_file *file;
    int (*read)(struct cab_file *, unsigned char *, int);
  };
  
  struct lzx_stream *lzx_init(int fd,
  			      int ofd,
  			      int window_bits,
  			      int reset_interval,
  			      int input_buffer_size,
  			      off_t output_length,
  			      struct cab_file *file,
  			      int (*read)(struct cab_file *, unsigned char *, int));
  
  extern void lzx_set_output_length(struct lzx_stream *lzx,
  				   off_t output_length);
  
  extern int lzx_decompress(struct lzx_stream *lzx, off_t out_bytes);
  
  void lzx_free(struct lzx_stream *lzx);
  
  #endif
  