Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
ZIP(1L)								       ZIP(1L)

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

       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

       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-

       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 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 and add foo/file3 to	 After
       this,  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-

	      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.

       -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-

		     zip -b /tmp stuff *

	      will  put	the temporary zip archive in the directory /tmp, copy-
	      ing over 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-

       -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

       -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

       -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  foo foo

	      will  copy  everything from foo into, 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  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"

	      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 to the latest time
	      of the entries in

       -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,  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  Note for PKZIP users: the	equiva-
	      lent command is

		     pkzip -rP foo *.c

       -S     [MSDOS, OS/2, WIN32 and ATARI] Include system and	 hidden
	      [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

       -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

       -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	was last  created/modified  (note  that
	      zip  will	 not try to pack 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

       -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 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  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

		     zip -$ foo	a: c:bar

       The simplest example:

	      zip stuff	*

       creates the archive (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

       To zip up an entire directory, the command:

	      zip -r foo foo

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

       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,	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-

       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).

       ZIPOPT contains default options that will be used  when	running

       ZIP    [Not on RISC OS and VMS] see ZIPOPT

	      [RISC OS]	see ZIPOPT

	      [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

	      [VMS] see	ZIPOPT

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

       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.

       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.

       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


       Please  send   bug   reports   and   comments   by   email   to:	 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.

       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)


Want to link to this manual page? Use this URL:

home | help