mspack.h

Go to the documentation of this file.

/* libmspack -- a library for working with Microsoft compression formats.
 * (C) 2003-2019 Stuart Caie <kyzer@cabextract.org.uk>
 *
 * libmspack is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License (LGPL) version 2.1
 *
 * 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
#ifndef LIB_MSPACK_H
#define LIB_MSPACK_H 1
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <sys/types.h>
#include <stdlib.h>
 
#define MSPACK_SYS_SELFTEST(result)  do { \
  (result) = mspack_sys_selftest_internal(sizeof(off_t)); \
} while (0)
 
extern int mspack_sys_selftest_internal(int);
 
extern int mspack_version(int entity);
 
#define MSPACK_VER_LIBRARY   (0)
#define MSPACK_VER_SYSTEM    (1)
#define MSPACK_VER_MSCABD    (2)
#define MSPACK_VER_MSCABC    (3)
#define MSPACK_VER_MSCHMD    (4)
#define MSPACK_VER_MSCHMC    (5)
#define MSPACK_VER_MSLITD    (6)
#define MSPACK_VER_MSLITC    (7)
#define MSPACK_VER_MSHLPD    (8)
#define MSPACK_VER_MSHLPC    (9)
#define MSPACK_VER_MSSZDDD   (10)
#define MSPACK_VER_MSSZDDC   (11)
#define MSPACK_VER_MSKWAJD   (12)
#define MSPACK_VER_MSKWAJC   (13)
#define MSPACK_VER_MSOABD    (14)
#define MSPACK_VER_MSOABC    (15)
 
/* --- file I/O abstraction ------------------------------------------------ */
 
struct mspack_system {
  struct mspack_file * (*open)(struct mspack_system *self,
                               const char *filename,
                               int mode);
 
  void (*close)(struct mspack_file *file);
 
  int (*read)(struct mspack_file *file,
              void *buffer,
              int bytes);
 
  int (*write)(struct mspack_file *file,
               void *buffer,
               int bytes);
 
  int (*seek)(struct mspack_file *file,
              off_t offset,
              int mode);
 
  off_t (*tell)(struct mspack_file *file);
  
  void (*message)(struct mspack_file *file,
                  const char *format,
                  ...);
 
  void * (*alloc)(struct mspack_system *self,
                  size_t bytes);
  
  void (*free)(void *ptr);
 
  void (*copy)(void *src,
               void *dest,
               size_t bytes);
 
  void *null_ptr;
};
 
#define MSPACK_SYS_OPEN_READ   (0)
#define MSPACK_SYS_OPEN_WRITE  (1)
#define MSPACK_SYS_OPEN_UPDATE (2)
#define MSPACK_SYS_OPEN_APPEND (3)
 
#define MSPACK_SYS_SEEK_START  (0)
#define MSPACK_SYS_SEEK_CUR    (1)
#define MSPACK_SYS_SEEK_END    (2)
 
struct mspack_file {
  int dummy;
};
 
/* --- error codes --------------------------------------------------------- */
 
#define MSPACK_ERR_OK          (0)
#define MSPACK_ERR_ARGS        (1)
#define MSPACK_ERR_OPEN        (2)
#define MSPACK_ERR_READ        (3)
#define MSPACK_ERR_WRITE       (4)
#define MSPACK_ERR_SEEK        (5)
#define MSPACK_ERR_NOMEMORY    (6)
#define MSPACK_ERR_SIGNATURE   (7)
#define MSPACK_ERR_DATAFORMAT  (8)
#define MSPACK_ERR_CHECKSUM    (9)
#define MSPACK_ERR_CRUNCH      (10)
#define MSPACK_ERR_DECRUNCH    (11)
 
/* --- functions available in library -------------------------------------- */
 
extern struct mscab_compressor *
  mspack_create_cab_compressor(struct mspack_system *sys);
 
extern struct mscab_decompressor *
  mspack_create_cab_decompressor(struct mspack_system *sys);
 
extern void mspack_destroy_cab_compressor(struct mscab_compressor *self);
 
extern void mspack_destroy_cab_decompressor(struct mscab_decompressor *self);
 
 
extern struct mschm_compressor *
  mspack_create_chm_compressor(struct mspack_system *sys);
 
extern struct mschm_decompressor *
  mspack_create_chm_decompressor(struct mspack_system *sys);
 
extern void mspack_destroy_chm_compressor(struct mschm_compressor *self);
 
extern void mspack_destroy_chm_decompressor(struct mschm_decompressor *self);
 
 
extern struct mslit_compressor *
  mspack_create_lit_compressor(struct mspack_system *sys);
 
extern struct mslit_decompressor *
  mspack_create_lit_decompressor(struct mspack_system *sys);
 
extern void mspack_destroy_lit_compressor(struct mslit_compressor *self);
 
extern void mspack_destroy_lit_decompressor(struct mslit_decompressor *self);
 
 
extern struct mshlp_compressor *
  mspack_create_hlp_compressor(struct mspack_system *sys);
 
extern struct mshlp_decompressor *
  mspack_create_hlp_decompressor(struct mspack_system *sys);
 
extern void mspack_destroy_hlp_compressor(struct mshlp_compressor *self);
 
extern void mspack_destroy_hlp_decompressor(struct mshlp_decompressor *self);
 
 
extern struct msszdd_compressor *
  mspack_create_szdd_compressor(struct mspack_system *sys);
 
extern struct msszdd_decompressor *
  mspack_create_szdd_decompressor(struct mspack_system *sys);
 
extern void mspack_destroy_szdd_compressor(struct msszdd_compressor *self);
 
extern void mspack_destroy_szdd_decompressor(struct msszdd_decompressor *self);
 
 
extern struct mskwaj_compressor *
  mspack_create_kwaj_compressor(struct mspack_system *sys);
 
extern struct mskwaj_decompressor *
  mspack_create_kwaj_decompressor(struct mspack_system *sys);
 
extern void mspack_destroy_kwaj_compressor(struct mskwaj_compressor *self);
 
extern void mspack_destroy_kwaj_decompressor(struct mskwaj_decompressor *self);
 
 
extern struct msoab_compressor *
  mspack_create_oab_compressor(struct mspack_system *sys);
 
extern struct msoab_decompressor *
  mspack_create_oab_decompressor(struct mspack_system *sys);
 
extern void mspack_destroy_oab_compressor(struct msoab_compressor *self);
 
extern void mspack_destroy_oab_decompressor(struct msoab_decompressor *self);
 
 
/* --- support for .CAB (MS Cabinet) file format --------------------------- */
 
struct mscabd_cabinet {
  struct mscabd_cabinet *next;
 
  const char *filename;
  
  off_t base_offset;
 
  unsigned int length;
 
  struct mscabd_cabinet *prevcab;
 
  struct mscabd_cabinet *nextcab;
 
  char *prevname;
 
  char *nextname;
 
  char *previnfo;
 
  char *nextinfo;
 
  struct mscabd_file *files;
 
  struct mscabd_folder *folders;
 
  unsigned short set_id;
 
  unsigned short set_index;
 
  unsigned short header_resv;
 
  int flags;
};
 
#define MSCAB_HDR_RESV_OFFSET (0x28)
 
#define MSCAB_HDR_PREVCAB (0x01)
#define MSCAB_HDR_NEXTCAB (0x02)
#define MSCAB_HDR_RESV    (0x04)
 
struct mscabd_folder {
  struct mscabd_folder *next;
 
  int comp_type;
 
  unsigned int num_blocks;
};
 
#define MSCABD_COMP_METHOD(comp_type) ((comp_type) & 0x0F)
#define MSCABD_COMP_LEVEL(comp_type) (((comp_type) >> 8) & 0x1F)
 
#define MSCAB_COMP_NONE       (0)
#define MSCAB_COMP_MSZIP      (1)
#define MSCAB_COMP_QUANTUM    (2)
#define MSCAB_COMP_LZX        (3)
 
struct mscabd_file {
  struct mscabd_file *next;
 
  char *filename;
 
  unsigned int length;
 
  int attribs;
 
  char time_h;
  char time_m;
  char time_s;
 
  char date_d;
  char date_m;
  int date_y;
 
  struct mscabd_folder *folder;
 
  unsigned int offset;
};
 
#define MSCAB_ATTRIB_RDONLY   (0x01)
#define MSCAB_ATTRIB_HIDDEN   (0x02)
#define MSCAB_ATTRIB_SYSTEM   (0x04)
#define MSCAB_ATTRIB_ARCH     (0x20)
#define MSCAB_ATTRIB_EXEC     (0x40)
#define MSCAB_ATTRIB_UTF_NAME (0x80)
 
#define MSCABD_PARAM_SEARCHBUF (0)
#define MSCABD_PARAM_FIXMSZIP  (1)
#define MSCABD_PARAM_DECOMPBUF (2)
#define MSCABD_PARAM_SALVAGE   (3)
 
struct mscab_compressor {
  int dummy; 
};
 
struct mscab_decompressor {
  struct mscabd_cabinet * (*open) (struct mscab_decompressor *self,
                                   const char *filename);
 
  void (*close)(struct mscab_decompressor *self,
                struct mscabd_cabinet *cab);
 
  struct mscabd_cabinet * (*search) (struct mscab_decompressor *self,
                                     const char *filename);
 
  int (*append) (struct mscab_decompressor *self,
                 struct mscabd_cabinet *cab,
                 struct mscabd_cabinet *nextcab);
 
  int (*prepend) (struct mscab_decompressor *self,
                  struct mscabd_cabinet *cab,
                  struct mscabd_cabinet *prevcab);
 
  int (*extract)(struct mscab_decompressor *self,
                 struct mscabd_file *file,
                 const char *filename);
 
  int (*set_param)(struct mscab_decompressor *self,
                   int param,
                   int value);
 
  int (*last_error)(struct mscab_decompressor *self);
};
 
/* --- support for .CHM (HTMLHelp) file format ----------------------------- */
 
struct mschmc_file {
  int section;
 
  const char *filename;
 
  char *chm_filename;
 
  off_t length;
};
 
struct mschmd_section {
  struct mschmd_header *chm;
 
  unsigned int id;
};
 
struct mschmd_sec_uncompressed {
  struct mschmd_section base;
 
  off_t offset;
};
 
struct mschmd_sec_mscompressed {
  struct mschmd_section base;
 
  struct mschmd_file *content;
 
  struct mschmd_file *control;
 
  struct mschmd_file *rtable;
 
  struct mschmd_file *spaninfo;
};
 
struct mschmd_header {
  unsigned int version;
 
  unsigned int timestamp;
      
  unsigned int language;
 
  const char *filename;
 
  off_t length;
 
  struct mschmd_file *files;
 
  struct mschmd_file *sysfiles;
 
  struct mschmd_sec_uncompressed sec0;
 
  struct mschmd_sec_mscompressed sec1;
 
  off_t dir_offset;
 
  unsigned int num_chunks;
 
  unsigned int chunk_size;
 
  unsigned int density;
 
  unsigned int depth;
 
  unsigned int index_root;
 
  unsigned int first_pmgl;
 
  unsigned int last_pmgl;
 
  unsigned char **chunk_cache;
};
 
struct mschmd_file {
  struct mschmd_file *next;
 
  struct mschmd_section *section;
 
  off_t offset;
 
  off_t length;
 
  char *filename;
};
 
#define MSCHMC_ENDLIST   (0)
#define MSCHMC_UNCOMP    (1)
#define MSCHMC_MSCOMP    (2)
 
#define MSCHMC_PARAM_TIMESTAMP  (0)
#define MSCHMC_PARAM_LANGUAGE   (1)
#define MSCHMC_PARAM_LZXWINDOW  (2)
#define MSCHMC_PARAM_DENSITY    (3)
#define MSCHMC_PARAM_INDEX      (4)
 
struct mschm_compressor {
  int (*generate)(struct mschm_compressor *self,
                  struct mschmc_file file_list[],
                  const char *output_file);
 
  int (*use_temporary_file)(struct mschm_compressor *self,
                            int use_temp_file,
                            const char *temp_file);
  int (*set_param)(struct mschm_compressor *self,
                   int param,
                   int value);
 
  int (*last_error)(struct mschm_compressor *self);
};
 
struct mschm_decompressor {
  struct mschmd_header *(*open)(struct mschm_decompressor *self,
                                const char *filename);
 
  void (*close)(struct mschm_decompressor *self,
                struct mschmd_header *chm);
 
  int (*extract)(struct mschm_decompressor *self,
                 struct mschmd_file *file,
                 const char *filename);
 
  int (*last_error)(struct mschm_decompressor *self);
 
  struct mschmd_header *(*fast_open)(struct mschm_decompressor *self,
                                     const char *filename);
 
  int (*fast_find)(struct mschm_decompressor *self,
                   struct mschmd_header *chm,
                   const char *filename,
                   struct mschmd_file *f_ptr,
                   int f_size);
};
 
/* --- support for .LIT (EBook) file format -------------------------------- */
 
struct mslit_compressor {
  int dummy; 
};
 
struct mslit_decompressor {
  int dummy; 
};
 
 
/* --- support for .HLP (MS Help) file format ------------------------------ */
 
struct mshlp_compressor {
  int dummy; 
};
 
struct mshlp_decompressor {
  int dummy; 
};
 
 
/* --- support for SZDD file format ---------------------------------------- */
 
#define MSSZDDC_PARAM_MISSINGCHAR (0)
 
#define MSSZDD_FMT_NORMAL (0)
 
#define MSSZDD_FMT_QBASIC (1)
 
struct msszddd_header {
  int format;
 
  off_t length;
 
  char missing_char;
};
 
struct msszdd_compressor {
  int (*compress)(struct msszdd_compressor *self,
                  const char *input,
                  const char *output,
                  off_t length);
 
  int (*set_param)(struct msszdd_compressor *self,
                   int param,
                   int value);
 
  int (*last_error)(struct mschm_decompressor *self);
};
 
struct msszdd_decompressor {
  struct msszddd_header *(*open)(struct msszdd_decompressor *self,
                                 const char *filename);
 
  void (*close)(struct msszdd_decompressor *self,
                struct msszddd_header *szdd);
 
  int (*extract)(struct msszdd_decompressor *self,
                 struct msszddd_header *szdd,
                 const char *filename);
 
  int (*decompress)(struct msszdd_decompressor *self,
                    const char *input,
                    const char *output);
 
  int (*last_error)(struct msszdd_decompressor *self);
};
 
/* --- support for KWAJ file format ---------------------------------------- */
 
#define MSKWAJC_PARAM_COMP_TYPE  (0)
 
#define MSKWAJC_PARAM_INCLUDE_LENGTH (1)
 
#define MSKWAJ_COMP_NONE (0)
#define MSKWAJ_COMP_XOR (1)
#define MSKWAJ_COMP_SZDD (2)
#define MSKWAJ_COMP_LZH (3)
#define MSKWAJ_COMP_MSZIP (4)
 
#define MSKWAJ_HDR_HASLENGTH (0x01)
 
#define MSKWAJ_HDR_HASUNKNOWN1 (0x02)
 
#define MSKWAJ_HDR_HASUNKNOWN2 (0x04)
 
#define MSKWAJ_HDR_HASFILENAME (0x08)
 
#define MSKWAJ_HDR_HASFILEEXT (0x10)
 
#define MSKWAJ_HDR_HASEXTRATEXT (0x20)
 
struct mskwajd_header {
  unsigned short comp_type;
 
  off_t data_offset;
 
  int headers;
 
  off_t length;
 
  char *filename;
 
  char *extra;
 
  unsigned short extra_length;
};
 
struct mskwaj_compressor {
  int (*compress)(struct mskwaj_compressor *self,
                  const char *input,
                  const char *output,
                  off_t length);
 
  int (*set_param)(struct mskwaj_compressor *self,
                   int param,
                   int value);
 
 
  int (*set_filename)(struct mskwaj_compressor *self,
                      const char *filename);
 
  int (*set_extra_data)(struct mskwaj_compressor *self,
                        void *data,
                        size_t bytes);
 
  int (*last_error)(struct mschm_decompressor *self);
};
 
struct mskwaj_decompressor {
  struct mskwajd_header *(*open)(struct mskwaj_decompressor *self,
                                 const char *filename);
 
  void (*close)(struct mskwaj_decompressor *self,
                struct mskwajd_header *kwaj);
 
  int (*extract)(struct mskwaj_decompressor *self,
                 struct mskwajd_header *kwaj,
                 const char *filename);
 
  int (*decompress)(struct mskwaj_decompressor *self,
                    const char *input,
                    const char *output);
 
  int (*last_error)(struct mskwaj_decompressor *self);
};
 
/* --- support for .LZX (Offline Address Book) file format ----------------- */
 
struct msoab_compressor {
  int (*compress) (struct msoab_compressor *self,
                   const char *input,
                   const char *output);
 
  int (*compress_incremental) (struct msoab_compressor *self,
                               const char *input,
                               const char *base,
                               const char *output);
};
 
struct msoab_decompressor {
  int (*decompress) (struct msoab_decompressor *self,
                     const char *input,
                     const char *output);
 
  int (*decompress_incremental) (struct msoab_decompressor *self,
                                 const char *input,
                                 const char *base,
                                 const char *output);
 
  int (*set_param)(struct msoab_decompressor *self,
                   int param,
                   int value);
 
};
 
#define MSOABD_PARAM_DECOMPBUF (0)
 
#ifdef __cplusplus
}
#endif
 
#endif