Subversion Repositories Kolibri OS

 

 

 

 

 

 

 

 

 

 

 

   /* zlib does not (yet?) provide Deflate64(tm) support */

 

   /* disable support for Deflate64(tm) */

   /* enable Deflate64(tm) support unless compiling for SFX stub */

 

 

 

 

 

 

 

 

   /* UnZip does not support merging both ports in a single executable. */

     /* conflicting choice requests -> we prefer the Win32 environment */

     /* native Win32 support was explicitly requested... */

     /* use the POSIX (Unix) emulation features by default... */

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

   /* DO NOT DEFINE DOS_OS2 HERE!  If Human68k is so much */

   /*  like MS-DOS and/or OS/2, create DOS_H68_OS2 macro. */

     /* enable MBCS support by default for this system */

     /* disable MBCS support when explicitely requested */

 

 

 

 

 

 

 

 

    /*

 

 

 

 /*---------------------------------------------------------------------------

 

 

 /*---------------------------------------------------------------------------

 

 

 

     /* We are compiling with non-WIDE memory model, int = 16 bits */

       /* Following required for 64k WSIZE of Deflate64 support */

   /* use a single LF delimiter so that writes to 101 text files work */

   /* USE_EF_UT_TIME is set in tandem.h */

 

 

 

 

   extern int open(), close(), read();

   extern int stat(), unlink(), jsys(), fcntl();

   extern long lseek(), dup(), creat();

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

   typedef Z_OFF_T zoff_t;

   typedef struct stat z_stat;

 

 

 

 

 

   typedef size_t extent;

     Z_OFF_T lseek();

       char *malloc();

   typedef unsigned int extent;

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

                             *  (should fit in 4096 bytes, usually) */

 

 

 

 

 

 

 

 

 

   /* For environments using 16-bit integers OUTBUFSIZ must be limited to

 

   typedef short  shrint;            /* short/int or "shrink int" (unshrink) */

     typedef short  shrint;

       typedef short shrint;

       typedef int  shrint;          /* for efficiency/speed, we hope... */

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

   /* Multi Byte Character Set */

   char *plastchar OF((ZCONST char *ptr, extent len));

 

 

   /* Any system without a special calloc function */

 

 

 

 

 

 

 

 

 

 

  /* 64-bit Large File Support */

 

 

 

    /* 64-bit stat functions */

 

    /* 64-bit fseeko */

 

    /* 64-bit ftello */

 

    /* 64-bit fopen */

 

 

 

 

    /* MS C (VC), MinGW GCC port and LCC-32 use the MS C Runtime lib */

 

      /* 64-bit stat functions */

 

      /* 64-bit lseek */

 

        /* Beginning with VS 8.0 (Visual Studio 2005, MSC 14), the Microsoft

        /* 64-bit fseeko */

        /* 64-bit ftello */

 

 

        /* Up-to-date versions of MinGW define the macro __MSVCRT_VERSION__

        /* 64-bit fseeko */

        /* 64-bit ftello */

 

        /* The version of the C runtime is lower than MSC 14 or unknown. */

 

        /* The newest MinGW port contains built-in extensions to the MSC rtl

       /* 64-bit fseeko */

       int zfseeko OF((FILE *, zoff_t, int));

 

       /* 64-bit ftello */

       zoff_t zftello OF((FILE *));

 

 

      /* 64-bit fopen */

 

 

    /* CYGWIN GCC Posix emulator on Windows

 

      /* 64-bit stat functions */

 

      /* 64-bit lseek */

 

      /* 64-bit fseeko */

 

      /* 64-bit ftello */

 

      /* 64-bit fopen */

 

    /* WATCOM C and Borland C provide their own C runtime libraries,

 

      /* 64-bit stat functions */

 

      /* 64-bit lseek */

 

      /* 64-bit fseeko */

      int zfseeko OF((FILE *, zoff_t, int));

 

      /* 64-bit ftello */

      zoff_t zftello OF((FILE *));

 

      /* 64-bit fopen */

 

      /* IBM C */

 

      /* 64-bit stat functions */

 

      /* 64-bit fseeko */

 

      /* 64-bit ftello */

 

      /* 64-bit fopen */

 

 

 

  /* No Large File Support */

 

 

    /* For these systems, implement "64bit file vs. 32bit prog" check  */

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  /* return codes for VMS-specific open_outfile() function */

 

 

 

 

 

 

 

 

 

 

 

 

                                  extra field blocks (BEOS, MAC, and others) */

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  typedef unsigned long long    z_uint8;

  typedef unsigned __int64      z_uint8;

     typedef unsigned int       z_uint4;

     typedef unsigned long      z_uint4;

     typedef unsigned short     z_uint4;

  typedef ulg                   z_uint4;

 

  typedef  z_uint8              zusz_t;     /* zipentry sizes & offsets */

  typedef  z_uint8              zucn_t;     /* archive entry counts */

  typedef  z_uint4              zuvl_t;     /* multivolume numbers */

  typedef  ulg                  zusz_t;     /* zipentry sizes & offsets */

  typedef  unsigned int         zucn_t;     /* archive entry counts */

  typedef  unsigned short       zuvl_t;     /* multivolume numbers */

 

     typedef unsigned short  uid_t;    /* TI SysV.3 */

     typedef unsigned short  gid_t;

     typedef unsigned int    uid_t;    /* SCO Xenix */

     typedef unsigned int    gid_t;

 

   typedef struct utimbuf ztimbuf;

   typedef struct ztimbuf {

       time_t actime;        /* new access time */

       time_t modtime;       /* new modification time */

   } ztimbuf;

 

typedef struct iztimes {

   time_t atime;             /* new access time */

   time_t mtime;             /* new modification time */

   time_t ctime;             /* used for creation time; NOT same as st_ctime */

} iztimes;

 

   typedef struct direntry {    /* head of system-specific struct holding */

       struct direntry *next;   /*  defered directory attributes info */

       char *fn;                /* filename of directory */

       char buf[1];             /* start of system-specific internal data */

   } direntry;

 

   typedef struct slinkentry {  /* info for deferred symlink creation */

       struct slinkentry *next; /* pointer to next entry in chain */

       extent targetlen;        /* length of target filespec */

       extent attriblen;        /* length of system-specific attrib data */

       char *target;            /* pointer to target filespec */

       char *fname;             /* pointer to name of link */

       char buf[1];             /* data/name/link buffer */

   } slinkentry;

 

typedef struct min_info {

    zoff_t offset;

    zusz_t compr_size;       /* compressed size (needed if extended header) */

    zusz_t uncompr_size;     /* uncompressed size (needed if extended header) */

    ulg crc;                 /* crc (needed if extended header) */

    zuvl_t diskstart;        /* no of volume where this entry starts */

    uch hostver;

    uch hostnum;

    unsigned file_attr;      /* local flavor, as used by creat(), chmod()... */

    unsigned encrypted : 1;  /* file encrypted: decrypt before uncompressing */

    unsigned ExtLocHdr : 1;  /* use time instead of CRC for decrypt check */

    unsigned textfile : 1;   /* file is text (according to zip) */

    unsigned textmode : 1;   /* file is to be extracted as text */

    unsigned lcflag : 1;     /* convert filename to lowercase */

    unsigned vollabel : 1;   /* "file" is an MS-DOS volume (disk) label */

    unsigned symlink : 1;    /* file is a symbolic link */

    unsigned HasUxAtt : 1;   /* crec ext_file_attr has Unix style mode bits */

    unsigned GPFIsUTF8: 1;   /* crec gen_purpose_flag UTF-8 bit 11 is set */

    char Far *cfilname;      /* central header version of filename */

} min_info;

 

typedef struct VMStimbuf {

    char *revdate;    /* (both roughly correspond to Unix modtime/st_mtime) */

    char *credate;

} VMStimbuf;

 

 

   union work {

     struct {                 /* unshrink(): */

       shrint *Parent;          /* pointer to (8192 * sizeof(shrint)) */

       uch *value;              /* pointer to 8KB char buffer */

       uch *Stack;              /* pointer to another 8KB char buffer */

     } shrink;

     uch *Slide;              /* explode(), inflate(), unreduce() */

   };

   union work {

     struct {                 /* unshrink(): */

       shrint Parent[HSIZE];    /* (8192 * sizeof(shrint)) == 16KB minimum */

       uch value[HSIZE];        /* 8KB */

       uch Stack[HSIZE];        /* 8KB */

     } shrink;                  /* total = 32KB minimum; 80KB on Cray/Alpha */

     uch Slide[WSIZE];        /* explode(), inflate(), unreduce() */

   };

 

 

 

 

   typedef uch   local_byte_hdr[ LREC_SIZE ];

 

   typedef uch   cdir_byte_hdr[ CREC_SIZE ];

 

   typedef uch   ec_byte_rec[ ECREC_SIZE+4 ];

 

   typedef uch   ec_byte_loc64[ ECLOC64_SIZE+4 ];

 

   typedef uch   ec_byte_rec64[ ECREC64_SIZE+4 ];

 

 

   typedef struct local_file_header {                 /* LOCAL */

       zusz_t csize;

       zusz_t ucsize;

       ulg last_mod_dos_datetime;

       ulg crc32;

       uch version_needed_to_extract[2];

       ush general_purpose_bit_flag;

       ush compression_method;

       ush filename_length;

       ush extra_field_length;

   } local_file_hdr;

 

   typedef struct central_directory_file_header {     /* CENTRAL */

       zusz_t csize;

       zusz_t ucsize;

       zusz_t relative_offset_local_header;

       ulg last_mod_dos_datetime;

       ulg crc32;

       ulg external_file_attributes;

       zuvl_t disk_number_start;

       ush internal_file_attributes;

       uch version_made_by[2];

       uch version_needed_to_extract[2];

       ush general_purpose_bit_flag;

       ush compression_method;

       ush filename_length;

       ush extra_field_length;

       ush file_comment_length;

   } cdir_file_hdr;

 

   typedef struct end_central_dir_record {            /* END CENTRAL */

       zusz_t size_central_directory;

       zusz_t offset_start_central_directory;

       zucn_t num_entries_centrl_dir_ths_disk;

       zucn_t total_entries_central_dir;

       zuvl_t number_this_disk;

       zuvl_t num_disk_start_cdir;

       int have_ecr64;                  /* valid Zip64 ecdir-record exists */

       int is_zip64_archive;            /* Zip64 ecdir-record is mandatory */

       ush zipfile_comment_length;

   } ecdir_rec;

 

 

 

struct huft {

    uch e;                /* number of extra bits or operation */

    uch b;                /* number of bits in this code or subcode */

    union {

        ush n;            /* literal, length base, or distance base */

        struct huft *t;   /* pointer to next level of table */

    } v;

 

 

typedef struct _APIDocStruct {

    char *compare;

    char *function;

    char *syntax;

    char *purpose;

} APIDocStruct;

 

 

 

 

 

 

 

 

 

 

 

   int    MAIN                   OF((int argc, char **argv));

   int    unzip                  OF((__GPRO__ int argc, char **argv));

   int    uz_opts                OF((__GPRO__ int *pargc, char ***pargv));

   int    usage                  OF((__GPRO__ int error));

 

 

int      process_zipfiles        OF((__GPRO));

void     free_G_buffers          OF((__GPRO));

int      process_cdir_file_hdr   OF((__GPRO));

int      process_local_file_hdr  OF((__GPRO));

int      getZip64Data            OF((__GPRO__ ZCONST uch *ef_buf,

                                     unsigned ef_len));

  int    getUnicodeData          OF((__GPRO__ ZCONST uch *ef_buf,

                                     unsigned ef_len));

unsigned ef_scan_for_izux        OF((ZCONST uch *ef_buf, unsigned ef_len,

                                     int ef_is_c, ulg dos_mdatetime,

                                     iztimes *z_utim, ulg *z_uidgid));

   zvoid *getRISCOSexfield       OF((ZCONST uch *ef_buf, unsigned ef_len));

 

 

 

   int   zi_opts                 OF((__GPRO__ int *pargc, char ***pargv));

void     zi_end_central          OF((__GPRO));

int      zipinfo                 OF((__GPRO));

 

 

int      list_files              OF((__GPRO));

   int   get_time_stamp          OF((__GPRO__  time_t *last_modtime,

                                     ulg *nmember));

int      ratio                   OF((zusz_t uc, zusz_t c));

void     fnprint                 OF((__GPRO));

 

 

 

int      open_input_file      OF((__GPRO));

int      open_outfile         OF((__GPRO));                    /* also vms.c */

void     undefer_input        OF((__GPRO));

void     defer_leftover_input OF((__GPRO));

unsigned readbuf              OF((__GPRO__ char *buf, register unsigned len));

int      readbyte             OF((__GPRO));

int      fillinbuf            OF((__GPRO));

int      seek_zipf            OF((__GPRO__ zoff_t abs_offset));

   int   flush                OF((__GPRO__ ulg size));  /* actually funzip.c */

   int   flush                OF((__GPRO__ uch *buf, ulg size, int unshrink));

void     handler              OF((int signal));

time_t   dos_to_unix_time     OF((ulg dos_datetime));

int      check_for_newer      OF((__GPRO__ char *filename)); /* os2,vmcms,vms */

int      do_string            OF((__GPRO__ unsigned int length, int option));

ush      makeword             OF((ZCONST uch *b));

ulg      makelong             OF((ZCONST uch *sig));

zusz_t   makeint64            OF((ZCONST uch *sig));

char    *fzofft               OF((__GPRO__ zoff_t val,

                                  ZCONST char *pre, ZCONST char *post));

   char *str2iso              OF((char *dst, ZCONST char *src));

   char *str2oem              OF((char *dst, ZCONST char *src));

   int   zstrnicmp            OF((register ZCONST char *s1,

                                  register ZCONST char *s2,

                                  register unsigned n));

   int   zstat                OF((ZCONST char *p, struct stat *s));

   zvoid *memset OF((register zvoid *, register int, register unsigned int));

   int    memcmp OF((register ZCONST zvoid*, register ZCONST zvoid *,

                     register unsigned int));

   zvoid *memcpy OF((register zvoid *, register ZCONST zvoid *,

                     register unsigned int));

   extent uzmbclen          OF((ZCONST unsigned char *ptr));

   unsigned char *uzmbschr  OF((ZCONST unsigned char *str, unsigned int c));

   unsigned char *uzmbsrchr OF((ZCONST unsigned char *str, unsigned int c));

   char *fLoadFarString       OF((__GPRO__ const char Far *sz));

   char *fLoadFarStringSmall  OF((__GPRO__ const char Far *sz));

   char *fLoadFarStringSmall2 OF((__GPRO__ const char Far *sz));

   #ifndef zfstrcpy

     char Far * Far zfstrcpy  OF((char Far *s1, const char Far *s2));

   #endif

   #if (!defined(SFX) && !defined(zfstrcmp))

     int Far zfstrcmp         OF((const char Far *s1, const char Far *s2));

   #endif

 

 

 

int    extract_or_test_files     OF((__GPRO));

  unsigned find_compr_idx        OF((unsigned compr_methodnum));

int    memextract                OF((__GPRO__ uch *tgt, ulg tgtsize,

                                     ZCONST uch *src, ulg srcsize));

int    memflush                  OF((__GPRO__ ZCONST uch *rawbuf, ulg size));

   uch   *extract_izvms_block    OF((__GPRO__ ZCONST uch *ebdata,

                                     unsigned size, unsigned *retlen,

                                     ZCONST uch *init, unsigned needlen));

char  *fnfilter                  OF((ZCONST char *raw, uch *space,

                                     extent size));

 

 

int    explode                   OF((__GPRO));                  /* explode.c */

int    huft_free                 OF((struct huft *t));          /* inflate.c */

int    huft_build                OF((__GPRO__ ZCONST unsigned *b, unsigned n,

                                     unsigned s, ZCONST ush *d, ZCONST uch *e,

                                     struct huft **t, unsigned *m));

   int    UZinflate              OF((__GPRO__ int is_defl64));  /* inflate.c */

   int    inflate                OF((__GPRO__ int is_defl64));  /* inflate.c */

   int    inflate_free           OF((__GPRO));                  /* inflate.c */

   int    unreduce               OF((__GPRO));                 /* unreduce.c */

   int    unshrink               OF((__GPRO));                 /* unshrink.c */

   int    UZbunzip2              OF((__GPRO));                  /* extract.c */

   void   bz_internal_error      OF((int bzerrcode));           /* ubz2err.c */

 

 

   void     setFileNotFound       OF((__GPRO));                     /* api.c */

   int      unzipToMemory         OF((__GPRO__ char *zip, char *file,

                                      UzpBuffer *retstr));          /* api.c */

   int      redirect_outfile      OF((__GPRO));                     /* api.c */

   int      writeToMemory         OF((__GPRO__ ZCONST uch *rawbuf,

                                      extent size));                /* api.c */

   int      close_redirect        OF((__GPRO));                     /* api.c */

   /* this obsolescent entry point kept for compatibility: */