zip man page on UnixWare

Man page or keyword search:  
man Server   3616 pages
apropos Keyword Search (all sections)
Output format
UnixWare logo
[printable version]

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 ar‐
       chive, 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 ar‐
       chive with a single command.  Compression ratios of 2:1 to 3:1 are com‐
       mon 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 ar‐
	      chives 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 ar‐
	      chive 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 ar‐
	      chive  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  ar‐
	      chives  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  ar‐
	      chive.   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 ar‐
       chive 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 ar‐
       chive  is deleted, making room for the next zip command to func‐
       tion.

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)
[top]
                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server UnixWare

List of man pages available for UnixWare

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net