zip



ZIP(1L)                                                                ZIP(1L)




NAME

       zip, zipcloak, zipnote, zipsplit - package and compress (archive) files


SYNOPSIS

       zip   [-aABcdDeEfFghjklLmoqrRSTuvVwXyz!@$]   [-b path]    [-n suffixes]
       [-t mmddyyyy] [-tt mmddyyyy] [ zipfile [ file1 file2 ...]] [-xi list]

       zipcloak [-dhL] [-b path] zipfile

       zipnote [-hwL] [-b path] zipfile

       zipsplit [-hiLpst] [-n size] [-b path] zipfile


DESCRIPTION

       zip  is  a compression and file packaging utility for Unix, VMS, MSDOS,
       OS/2, Windows NT, Minix, Atari and Macintosh, Amiga and Acorn RISC  OS.

       It  is  analogous to a combination of the UNIX commands tar(1) and com-
       press(1) and is compatible with PKZIP (Phil Katz’s ZIP for  MSDOS  sys-
       tems).

       A  companion  program  (unzip(1L)),  unpacks zip archives.  The zip and
       unzip(1L) programs can work with archives produced by PKZIP, and  PKZIP
       and PKUNZIP can work with archives produced by zip.  zip version 2.3 is
       compatible with PKZIP 2.04.  Note  that  PKUNZIP  1.10  cannot  extract
       files  produced by PKZIP 2.04 or zip 2.3. You must use PKUNZIP 2.04g or
       unzip 5.0p1 (or later versions) to extract them.

       For a brief help on zip and unzip,  run  each  without  specifying  any
       parameters on the command line.

       The  program  is  useful for packaging a set of files for distribution;
       for archiving files; and for saving disk space by temporarily compress-
       ing unused files or directories.

       The  zip  program  puts  one or more compressed files into a single zip
       archive, along with information about the files (name, path, date, time
       of  last modification, protection, and check information to verify file
       integrity).  An entire directory structure can be  packed  into  a  zip
       archive  with  a  single command.  Compression ratios of 2:1 to 3:1 are
       common for text files.  zip has one compression method (deflation)  and
       can  also  store  files without compression.  zip automatically chooses
       the better of the two for each file to be compressed.

       When given the name of an existing zip archive, zip will replace  iden-
       tically  named entries in the zip archive or add entries for new names.
       For example, if foo.zip exists and contains  foo/file1  and  foo/file2,
       and the directory foo contains the files foo/file1 and foo/file3, then:

              zip -r foo foo

       will replace foo/file1 in foo.zip and add foo/file3 to foo.zip.   After
       this,  foo.zip  contains  foo/file1,  foo/file2,  and  foo/file3,  with
       foo/file2 unchanged from before.

       If the file list is specified as -@, [Not on MacOS] zip takes the  list
       of  input  files  from  standard input.  Under UNIX, this option can be
       used to powerful effect in conjunction with the find(1)  command.   For
       example, to archive all the C source files in the current directory and
       its subdirectories:

              find . -name "*.[ch]" -print | zip source -@

       (note that the pattern must be quoted to keep the shell from  expanding
       it).  zip will also accept a single dash ("-") as the zip file name, in
       which case it will write the zip file to standard output, allowing  the
       output to be piped to another program. For example:

              zip -r - . | dd of=/dev/nrst0 obs=16k

       would  write the zip output directly to a tape with the specified block
       size for the purpose of backing up the current directory.

       zip also accepts a single dash ("-") as the name of a file to  be  com-
       pressed,  in  which  case  it  will  read the file from standard input,
       allowing zip to take input from another program. For example:

              tar cf - . | zip backup -

       would compress the output of the tar command for the purpose of backing
       up  the  current  directory. This generally produces better compression
       than the previous example using the -r option,  because  zip  can  take
       advantage of redundancy between files. The backup can be restored using
       the command

              unzip -p backup | tar xf -

       When no zip file name is given and stdout is not a terminal,  zip  acts
       as  a filter, compressing standard input to standard output.  For exam-
       ple,

              tar cf - . | zip | dd of=/dev/nrst0 obs=16k

       is equivalent to

              tar cf - . | zip - - | dd of=/dev/nrst0 obs=16k

       zip archives created in this manner can be extracted with  the  program
       funzip  which  is  provided in the unzip package, or by gunzip which is
       provided in the gzip package. For example:

       dd if=/dev/nrst0  ibs=16k | funzip | tar xvf -

       When changing an existing zip archive, zip will write a temporary  file
       with the new contents, and only replace the old one when the process of
       creating the new version has been completed without error.

       If the name of the zip archive  does  not  contain  an  extension,  the
       extension  .zip  is  added.  If  the name already contains an extension
       other than .zip the existing extension is kept unchanged.


OPTIONS

       -a     [Systems using EBCDIC] Translate file to ASCII format.

       -A     Adjust self-extracting executable  archive.   A  self-extracting
              executable  archive  is created by prepending the SFX stub to an
              existing archive. The -A option tells zip to  adjust  the  entry
              offsets  stored in the archive to take into account this "pream-
              ble" data.

       Note: self-extracting archives for the Amiga are a  special  case.   At
       present, only the Amiga port of Zip is capable of adjusting or updating
       these without corrupting them. -J can be used to remove the SFX stub if
       other updates need to be made.

       -B     [VM/CMS and MVS] force file to be read binary (default is text).

       -Bn    [TANDEM] set Edit/Enscribe formatting options with n defined as
              bit  0: Don’t add delimiter (Edit/Enscribe)
              bit 1: Use LF rather than CR/LF as delimiter (Edit/Enscribe)
              bit  2: Space fill record to maximum record length (Enscribe)
              bit  3: Trim trailing space (Enscribe)
              bit 8: Force 30K (Expand) large read for unstructured files

       -b path
              Use the specified path for the temporary zip archive. For  exam-
              ple:

                     zip -b /tmp stuff *

              will  put the temporary zip archive in the directory /tmp, copy-
              ing over stuff.zip to the  current  directory  when  done.  This
              option is only useful when updating an existing archive, and the
              file system containing this old archive  does  not  have  enough
              space to hold both old and new archives at the same time.

       -c     Add  one-line  comments for each file.  File operations (adding,
              updating) are done first, and the user is then  prompted  for  a
              one-line  comment  for each file.  Enter the comment followed by
              return, or just return for no comment.

       -d     Remove (delete) entries from a zip archive.  For example:

                     zip -d foo foo/tom/junk foo/harry/\* \*.o

              will remove the entry foo/tom/junk, all of the files that  start
              with  foo/harry/,  and all of the files that end with .o (in any
              path).  Note that shell pathname expansion  has  been  inhibited
              with  backslashes,  so  that zip can see the asterisks, enabling
              zip to match on the contents of the zip archive instead  of  the
              contents of the current directory.

              Under  MSDOS,  -d is case sensitive when it matches names in the
              zip archive.  This requires that file names be entered in  upper
              case if they were zipped by PKZIP on an MSDOS system.

       -df    [MacOS] Include only data-fork of files zipped into the archive.
              Good  for  exporting   files   to   foreign   operating-systems.
              Resource-forks will be ignored at all.

       -D     Do  not  create  entries  in  the  zip  archive for directories.
              Directory  entries  are  created  by  default  so   that   their
              attributes  can  be  saved  in the zip archive.  The environment
              variable ZIPOPT can be used to change the default  options.  For
              example under Unix with sh:

                     ZIPOPT="-D"; export ZIPOPT

              (The variable ZIPOPT can be used for any option except -i and -x
              and can include several options.) The option -D is  a  shorthand
              for  -x  "*/"  but  the  latter  cannot be set as default in the
              ZIPOPT environment variable.

       -e     Encrypt the contents of the zip archive using a  password  which
              is  entered  on  the terminal in response to a prompt (this will
              not be echoed; if standard error is not a  tty,  zip  will  exit
              with  an  error).   The  password prompt is repeated to save the
              user from typing errors.

       -E     [OS/2] Use the .LONGNAME Extended Attribute (if found) as  file-
              name.

       -f     Replace  (freshen)  an existing entry in the zip archive only if
              it has been modified more recently than the version  already  in
              the zip archive; unlike the update option (-u) this will not add
              files that are not already in the zip archive.  For example:

                     zip -f foo

              This command should be run from the same  directory  from  which
              the  original  zip  command  was  run, since paths stored in zip
              archives are always relative.

              Note that the timezone environment variable  TZ  should  be  set
              according  to the local timezone in order for the -f , -u and -o
              options to work correctly.

              The reasons behind this are somewhat subtle but have to do  with
              the  differences  between  the Unix-format file times (always in
              GMT) and most of the other operating systems (always local time)
              and  the  necessity  to  compare the two.  A typical TZ value is
              ‘‘MET-1MEST’’ (Middle European time  with  automatic  adjustment
              for ‘‘summertime’’ or Daylight Savings Time).

       -F     Fix the zip archive. This option can be used if some portions of
              the archive are missing. It is not guaranteed to  work,  so  you
              MUST make a backup of the original archive first.

              When  doubled  as  in  -FF the compressed sizes given inside the
              damaged archive are not trusted and zip scans for special signa-
              tures  to  identify  the limits between the archive members. The
              single -F is more reliable if the archive is not too  much  dam-
              aged,  for  example  if  it has only been truncated, so try this
              option first.

              Neither option will recover archives that have been  incorrectly
              transferred  in  ascii mode instead of binary. After the repair,
              the -t option of unzip may show that some files have a bad  CRC.
              Such  files  cannot  be  recovered; you can remove them from the
              archive using the -d option of zip.

       -g     Grow (append to) the specified zip archive, instead of  creating
              a  new one. If this operation fails, zip attempts to restore the
              archive to its original state. If  the  restoration  fails,  the
              archive  might  become  corrupted.  This  option is ignored when
              there’s no existing archive or when at least one archive  member
              must be updated or deleted.

       -h     Display  the  zip  help information (this also appears if zip is
              run with no arguments).

       -i files
              Include only the specified files, as in:

                     zip -r foo . -i \*.c

              which will include only the files that end in .c in the  current
              directory  and  its  subdirectories.  (Note for PKZIP users: the
              equivalent command is

                     pkzip -rP foo *.c

              PKZIP does not allow recursion in  directories  other  than  the
              current one.)  The backslash avoids the shell filename substitu-
              tion, so that the name matching  is  performed  by  zip  at  all
              directory levels.

              Also possible:

                     zip -r foo  . -i@include.lst

              which  will  only include the files in the current directory and
              its  subdirectories  that  match  the  patterns  in   the   file
              include.lst.

       -I     [Acorn  RISC OS] Don’t scan through Image files.  When used, zip
              will not consider Image  files  (eg.  DOS  partitions  or  Spark
              archives  when  SparkFS is loaded) as directories but will store
              them as single files.

              For example, if you have SparkFS loaded, zipping a Spark archive
              will  result  in  a zipfile containing a directory (and its con-
              tent) while using the ’I’ option will result in a  zipfile  con-
              taining a Spark archive. Obviously this second case will also be
              obtained (without the ’I’ option) if SparkFS isn’t loaded.

       -j     Store just the name of a saved file (junk the path), and do  not
              store  directory names. By default, zip will store the full path
              (relative to the current path).

       -jj    [MacOS] record Fullpath (+ Volname). The complete path including
              volume  will  be  stored.  By  default the relative path will be
              stored.

       -J     Strip any prepended data (e.g. a SFX stub) from the archive.

       -k     Attempt to convert the names and  paths  to  conform  to  MSDOS,
              store  only  the  MSDOS attribute (just the user write attribute
              from UNIX), and mark the entry as made under MSDOS (even  though
              it  was  not);  for compatibility with PKUNZIP under MSDOS which
              cannot handle certain names such as those with two dots.

       -l     Translate the Unix end-of-line character LF into the MSDOS  con-
              vention  CR  LF. This option should not be used on binary files.
              This option can be used on Unix if the zip file is intended  for
              PKUNZIP  under  MSDOS. If the input files already contain CR LF,
              this option adds an extra CR. This ensure that unzip -a on  Unix
              will  get  back  an exact copy of the original file, to undo the
              effect of zip -l.

       -ll    Translate the MSDOS end-of-line CR LF into Unix LF.  This option
              should  not be used on binary files.  This option can be used on
              MSDOS if the zip file is intended for unzip under Unix.

       -L     Display the zip license.

       -m     Move the specified files into the zip  archive;  actually,  this
              deletes  the target directories/files after making the specified
              zip archive. If a directory becomes empty after removal  of  the
              files,  the  directory  is  also  removed. No deletions are done
              until zip has created the archive without error.  This is useful
              for conserving disk space, but is potentially dangerous so it is
              recommended to use it in combination with -T to test the archive
              before removing all input files.

       -n suffixes
              Do  not attempt to compress files named with the given suffixes.
              Such files are simply stored (0% compression) in the output  zip
              file,  so  that  zip  doesn’t  waste its time trying to compress
              them.  The suffixes are separated  by  either  colons  or  semi-
              colons.  For example:

                     zip -rn .Z:.zip:.tiff:.gif:.snd  foo foo

              will  copy  everything from foo into foo.zip, but will store any
              files that end in .Z, .zip, .tiff, .gif, or .snd without  trying
              to  compress  them  (image  and sound files often have their own
              specialized compression methods).  By default, zip does not com-
              press      files     with     extensions     in     the     list
              .Z:.zip:.zoo:.arc:.lzh:.arj.  Such files are stored directly  in
              the output archive.  The environment variable ZIPOPT can be used
              to change the default options. For example under Unix with csh:

                     setenv ZIPOPT "-n .gif:.zip"

              To attempt compression on all files, use:

                     zip -n : foo

              The maximum compression option -9 also attempts  compression  on
              all files regardless of extension.

              On  Acorn RISC OS systems the suffixes are actually filetypes (3
              hex digit format). By default, zip does not compress files  with
              filetypes  in the list DDC:D96:68E (i.e. Archives, CFS files and
              PackDir files).

       -N     [Amiga, MacOS] Save Amiga or MacOS  filenotes  as  zipfile  com-
              ments.  They can be restored by using the -N option of unzip. If
              -c is used also, you are prompted for comments  only  for  those
              files that do not have filenotes.

       -o     Set  the  "last  modified" time of the zip archive to the latest
              (oldest) "last modified" time found among the entries in the zip
              archive.   This  can  be  used  without any other operations, if
              desired.  For example:

              zip -o foo

              will change the last modified time of foo.zip to the latest time
              of the entries in foo.zip.


       -P password
              use  password  to encrypt zipfile entries (if any).  THIS
              IS INSECURE!  Many multi-user operating  systems  provide
              ways  for any user to see the current command line of any
              other user; even on stand-alone systems there  is  always
              the  threat  of  over-the-shoulder  peeking.  Storing the
              plaintext password as part of a command line in an  auto-
              mated  script  is even worse.  Whenever possible, use the
              non-echoing, interactive prompt to enter passwords.  (And
              where  security is truly important, use strong encryption
              such as Pretty Good Privacy  instead  of  the  relatively
              weak  encryption provided by standard zipfile utilities.)

       -q     Quiet mode; eliminate informational messages and  comment
              prompts.   (Useful,  for  example,  in  shell scripts and
              background tasks).

       -Qn    [QDOS] store information  about  the  file  in  the  file
              header with n defined as
              bit  0: Don’t add headers for any file
              bit  1: Add headers for all files
              bit  2: Don’t wait for interactive key press on exit

       -r     Travel the directory structure recursively; for example:

                     zip -r foo foo

              In  this  case,  all the files and directories in foo are
              saved in a zip archive  named  foo.zip,  including  files
              with  names  starting  with ".", since the recursion does
              not use the shell’s file-name substitution mechanism.  If
              you  wish  to include only a specific subset of the files
              in directory foo  and  its  subdirectories,  use  the  -i
              option  to  specify  the pattern of files to be included.
              You should not use -r with  the  name  ".*",  since  that
              matches  ".."   which  will  attempt to zip up the parent
              directory (probably not what was intended).

       -R     Travel the directory structure  recursively  starting  at
              the current directory; for example:

                     zip -R foo ’*.c’

              In  this  case,  all  the  files matching *.c in the tree
              starting at the current directory are stored into  a  zip
              archive named foo.zip.  Note for PKZIP users: the equiva-
              lent command is

                     pkzip -rP foo *.c

       -S     [MSDOS, OS/2, WIN32 and ATARI] Include system and  hidden
              files.
              [MacOS]   Includes  finder  invisible  files,  which  are
              ignored otherwise.

       -t mmddyyyy
              Do not operate on files modified prior to  the  specified
              date,  where mm is the month (0-12), dd is the day of the
              month (1-31), and yyyy is the year.  The  ISO  8601  date
              format yyyy-mm-dd is also accepted.  For example:

                     zip -rt 12071991 infamy foo

                     zip -rt 1991-12-07 infamy foo

              will add all the files in foo and its subdirectories that
              were last modified on or after 7 December  1991,  to  the
              zip archive infamy.zip.

       -tt mmddyyyy
              Do  not  operate on files modified after or at the speci-
              fied date, where mm is the month (0-12), dd is the day of
              the  month  (1-31),  and  yyyy is the year.  The ISO 8601
              date format yyyy-mm-dd is also accepted.  For example:

                     zip -rtt 11301995 infamy foo

                     zip -rtt 1995-11-30 infamy foo

              will add all the files in foo and its subdirectories that
              were  last  modified  before the 30 November 1995, to the
              zip archive infamy.zip.

       -T     Test the integrity of the new  zip  file.  If  the  check
              fails,  the  old  zip  file is unchanged and (with the -m
              option) no input files are removed.

       -u     Replace (update) an existing entry  in  the  zip  archive
              only  if it has been modified more recently than the ver-
              sion already in the zip archive.  For example:

                     zip -u stuff *

              will add any new files  in  the  current  directory,  and
              update  any  files which have been modified since the zip
              archive stuff.zip was last  created/modified  (note  that
              zip  will  not try to pack stuff.zip into itself when you
              do this).

              Note that the -u option with no arguments acts  like  the
              -f (freshen) option.

       -v     Verbose mode or print diagnostic version info.

              Normally,  when  applied  to real operations, this option
              enables the display of a progress indicator  during  com-
              pression  and requests verbose diagnostic info about zip-
              file structure oddities.

              When -v is the only command line argument, and stdout  is
              not redirected to a file, a diagnostic screen is printed.
              In addition to the help screen header with program  name,
              version,  and release date, some pointers to the Info-ZIP
              home and distribution sites are  given.  Then,  it  shows
              information  about  the target environment (compiler type
              and version, OS version, compilation date and the enabled
              optional features used to create the zip executable.

       -V     [VMS]  Save  VMS  file  attributes.  zip archives created
              with this option will generally not be  usable  on  other
              systems.

       -w     [VMS] Append the version number of the files to the name,
              including multiple versions of files.  (default: use only
              the most recent version of a specified file).

       -x files
              Explicitly exclude the specified files, as in:

                     zip -r foo foo -x \*.o

              which  will  include the contents of foo in foo.zip while
              excluding all the files that end in  .o.   The  backslash
              avoids  the shell filename substitution, so that the name
              matching is performed by zip at all directory levels.

              Also possible:

                     zip -r foo foo -x@exclude.lst

              which will include the contents of foo in  foo.zip  while
              excluding  all  the  files that match the patterns in the
              file exclude.lst.

       -X     Do not save extra file attributes (Extended Attributes on
              OS/2, uid/gid and file times on Unix).

       -y     Store  symbolic links as such in the zip archive, instead
              of compressing and storing the file referred  to  by  the
              link (UNIX only).

       -z     Prompt  for  a  multi-line  comment  for  the  entire zip
              archive.  The comment is ended by a line containing  just
              a  period, or an end of file condition (^D on UNIX, ^Z on
              MSDOS, OS/2, and VAX/VMS).  The comment can be taken from
              a file:

                     zip -z foo < foowhat

       -#     Regulate  the  speed  of  compression using the specified
              digit #, where -0 indicates  no  compression  (store  all
              files), -1 indicates the fastest compression method (less
              compression) and -9  indicates  the  slowest  compression
              method  (optimal  compression,  ignores the suffix list).
              The default compression level is -6.

       -!     [WIN32] Use priviliges (if granted) to obtain all aspects
              of WinNT security.

       -@     Take  the  list  of input files from standard input. Only
              one filename per line.

       -$     [MSDOS, OS/2, WIN32] Include the volume label for the the
              drive  holding  the  first file to be compressed.  If you
              want to include only the volume label or to force a  spe-
              cific  drive,  use  the drive name as first file name, as
              in:

                     zip -$ foo a: c:bar



EXAMPLES

       The simplest example:

              zip stuff *

       creates the archive stuff.zip (assuming it does not  exist)  and
       puts all the files in the current directory in it, in compressed
       form (the  .zip  suffix  is  added  automatically,  unless  that
       archive  name  given  contains  a  dot  already; this allows the
       explicit specification of other suffixes).

       Because of the way the shell does filename  substitution,  files
       starting with "." are not included; to include these as well:

              zip stuff .* *

       Even  this  will not include any subdirectories from the current
       directory.

       To zip up an entire directory, the command:

              zip -r foo foo

       creates the archive foo.zip, containing all the files and direc-
       tories in the directory foo that is contained within the current
       directory.

       You may want to make a zip archive that contains  the  files  in
       foo, without recording the directory name, foo.  You can use the
       -j option to leave off the paths, as in:

              zip -j foo foo/*

       If you are short on disk space, you might not have  enough  room
       to  hold  both the original directory and the corresponding com-
       pressed zip archive.  In this case, you can create  the  archive
       in  steps  using the -m option.  If foo contains the subdirecto-
       ries tom, dick, and harry, you can:

              zip -rm foo foo/tom
              zip -rm foo foo/dick
              zip -rm foo foo/harry

       where the first command creates foo.zip, and the next two add to
       it.   At  the  completion  of each zip command, the last created
       archive is deleted, making room for  the  next  zip  command  to
       function.


PATTERN MATCHING

       This section applies only to UNIX.  Watch this space for details
       on MSDOS and VMS operation.

       The UNIX shells (sh(1) and csh(1)) do filename  substitution  on
       command arguments.  The special characters are:

       ?      match any single character

       *      match any number of characters (including none)

       []     match  any  character  in  the range indicated within the
              brackets (example: [a-f], [0-9]).

       When these characters are  encountered  (without  being  escaped
       with a backslash or quotes), the shell will look for files rela-
       tive to the current path that match the pattern, and replace the
       argument with a list of the names that matched.

       The  zip  program  can do the same matching on names that are in
       the zip archive being  modified  or,  in  the  case  of  the  -x
       (exclude)  or  -i  (include) options, on the list of files to be
       operated on, by using backslashes or quotes to  tell  the  shell
       not to do the name expansion.  In general, when zip encounters a
       name in the list of files to do, it first looks for the name  in
       the file system.  If it finds it, it then adds it to the list of
       files to do.  If it does not find it, it looks for the  name  in
       the zip archive being modified (if it exists), using the pattern
       matching characters  described  above,  if  present.   For  each
       match,  it  will  add  that name to the list of files to be pro-
       cessed, unless this name matches one given with the  -x  option,
       or does not match any name given with the -i option.

       The  pattern  matching  includes  the path, and so patterns like
       \*.o match names that end in ".o", no matter what the path  pre-
       fix  is.   Note  that  the  backslash must precede every special
       character (i.e. ?*[]), or the entire argument must  be  enclosed
       in double quotes ("").

       In  general,  use  backslash to make zip do the pattern matching
       with the -f (freshen) and -d  (delete)  options,  and  sometimes
       after  the  -x  (exclude)  option  when used with an appropriate
       operation (add, -u, -f, or -d).


ENVIRONMENT

       ZIPOPT contains default options that will be used  when  running
              zip

       ZIP    [Not on RISC OS and VMS] see ZIPOPT

       Zip$Options
              [RISC OS] see ZIPOPT

       Zip$Exts
              [RISC  OS] contains extensions separated by a : that will
              cause native filenames with one of the  specified  exten-
              sions  to  be  added  to  the  zip file with basename and
              extension swapped.  zip

       ZIP_OPTS
              [VMS] see ZIPOPT


SEE ALSO

       compress(1), shar(1L), tar(1), unzip(1L), gzip(1L)


DIAGNOSTICS

       The exit status (or error level)  approximates  the  exit  codes
       defined  by  PKWARE  and  takes  on the following values, except
       under VMS:

              0      normal; no errors or warnings detected.

              2      unexpected end of zip file.

              3      a  generic  error  in  the  zipfile   format   was
                     detected.   Processing may have completed success-
                     fully anyway;  some  broken  zipfiles  created  by
                     other archivers have simple work-arounds.

              4      zip  was unable to allocate memory for one or more
                     buffers during program initialization.

              5      a severe error in the zipfile format was detected.
                     Processing probably failed immediately.

              6      entry too large to be split with zipsplit

              7      invalid comment format

              8      zip -T failed or out of memory

              9      the  user  aborted  zip prematurely with control-C
                     (or similar)

              10     zip encountered an error while using a temp file

              11     read or seek error

              12     zip has nothing to do

              13     missing or empty zip file

              14     error writing to a file

              15     zip was unable to create a file to write to

              16     bad command line parameters

              18     zip could not open a specified file to read

       VMS interprets standard Unix (or PC)  return  values  as  other,
       scarier-looking  things, so zip instead maps them into VMS-style
       status codes.  The current mapping is as follows:   1  (success)
       for normal exit,
        and  (0x7fff000?  +  16*normal_zip_exit_status) for all errors,
       where the ‘?’ is 0 (warning) for zip value 12, 2 (error) for the
       zip  values  3, 6, 7, 9, 13, 16, 18, and 4 (fatal error) for the
       remaining ones.


BUGS

       zip 2.3 is not compatible with PKUNZIP 1.10. Use zip 1.1 to pro-
       duce zip files which can be extracted by PKUNZIP 1.10.

       zip  files produced by zip 2.3 must not be updated by zip 1.1 or
       PKZIP 1.10, if they contain encrypted members or  if  they  have
       been  produced  in  a  pipe or on a non-seekable device. The old
       versions of zip or PKZIP would create an archive with an  incor-
       rect  format.  The old versions can list the contents of the zip
       file but cannot extract it anyway (because of the  new  compres-
       sion  algorithm).   If you do not use encryption and use regular
       disk files, you do not have to care about this problem.

       Under VMS, not all of the odd file formats are treated properly.
       Only  stream-LF  format zip files are expected to work with zip.
       Others can be converted using Rahul Dhesi’s BILF program.   This
       version  of zip handles some of the conversion internally.  When
       using Kermit to transfer zip files from Vax to MSDOS, type  "set
       file  type  block"  on  the Vax.  When transfering from MSDOS to
       Vax, type "set file type fixed" on the Vax.  In both cases, type
       "set file type binary" on MSDOS.

       Under  VMS,  zip  hangs  for file specification that uses DECnet
       syntax foo::*.*.

       On OS/2, zip cannot match some names, such as those including an
       exclamation  mark or a hash sign.  This is a bug in OS/2 itself:
       the 32-bit DosFindFirst/Next don’t find such names.  Other  pro-
       grams such as GNU tar are also affected by this bug.

       Under  OS/2,  the amount of Extended Attributes displayed by DIR
       is (for compatibility) the amount returned by the 16-bit version
       of  DosQueryPathInfo().  Otherwise OS/2 1.3 and 2.0 would report
       different EA sizes when DIRing a file.  However,  the  structure
       layout  returned  by the 32-bit DosQueryPathInfo() is a bit dif-
       ferent, it uses extra padding bytes and link  pointers  (it’s  a
       linked  list) to have all fields on 4-byte boundaries for porta-
       bility  to  future  RISC  OS/2  versions.  Therefore  the  value
       reported  by zip (which uses this 32-bit-mode size) differs from
       that reported by DIR.  zip stores the 32-bit format  for  porta-
       bility,  even  the  16-bit MS-C-compiled version running on OS/2
       1.3, so even this one shows the 32-bit-mode size.


AUTHORS

       Copyright (C) 1990-1997 Mark Adler, Richard B. Wales,  Jean-loup
       Gailly,  Onno van der Linden, Kai Uwe Rommel, Igor Mandrichenko,
       John Bush and Paul Kienitz.  Permission is granted to any  indi-
       vidual  or  institution to use, copy, or redistribute this soft-
       ware so long as all of the original files are included, that  it
       is  not  sold  for  profit,  and  that  this copyright notice is
       retained.

       LIKE ANYTHING ELSE THAT’S FREE, ZIP AND ITS ASSOCIATED UTILITIES
       ARE PROVIDED AS IS AND COME WITH NO WARRANTY OF ANY KIND, EITHER
       EXPRESSED OR IMPLIED. IN NO EVENT WILL THE COPYRIGHT HOLDERS  BE
       LIABLE  FOR ANY DAMAGES RESULTING FROM THE USE OF THIS SOFTWARE.

       Please  send   bug   reports   and   comments   by   email   to:
       zip-bugs@lists.wku.edu.   For  bug  reports,  please include the
       version of zip (see zip-h ), the make options used to compile it
       see  zip-v  ),  the  machine and operating system in use, and as
       much additional information as possible.


ACKNOWLEDGEMENTS

       Thanks to R. P. Byrne for his Shrink.Pas program, which inspired
       this project, and from which the shrink algorithm was stolen; to
       Phil Katz for placing in the public domain the zip file  format,
       compression format, and .ZIP filename extension, and for accept-
       ing minor changes to the file format; to Steve Burg for clarifi-
       cations  on  the  deflate format; to Haruhiko Okumura and Leonid
       Broukhis for providing some useful  ideas  for  the  compression
       algorithm;  to  Keith  Petersen,  Rich Wales, Hunter Goatley and
       Mark Adler for providing a mailing list and  ftp  site  for  the
       Info-ZIP  group  to  use;  and most importantly, to the Info-ZIP
       group itself (listed in  the  file  infozip.who)  without  whose
       tireless testing and bug-fixing efforts a portable zip would not
       have been possible.  Finally we should thank (blame)  the  first
       Info-ZIP  moderator,  David Kirschbaum, for getting us into this
       mess in the first place.  The manual page was rewritten for UNIX
       by R. P. C. Rodgers.



Info-ZIP                     14 August 1999 (v2.3)                     ZIP(1L)

Man(1) output converted with man2html