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

FreeBSD Manual Pages


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

       zip - package and compress (archive) files

       zip  [-aABcdDeEfFghjklLmoqrRSTuvVwXyz!@$] [--longoption ...]  [-b path]
       [-n suffixes] [-t date] [-tt date] [zipfile [file ...]]	[-xi list]

       zipcloak	(see separate man page)

       zipnote (see separate man page)

       zipsplit	(see separate man page)

       Note:  Command line processing in zip has been changed to support  long
       options	and  handle all	options	and arguments more consistently.  Some
       old command lines that depend on	command	line  inconsistencies  may  no
       longer work.

       zip  is	a compression and file packaging utility for Unix, VMS,	MSDOS,
       OS/2, Windows 9x/NT/XP, Minix, Atari, Macintosh,	Amiga, and Acorn  RISC
       OS.   It	 is analogous to a combination of the Unix commands tar(1) and
       compress(1) and is compatible with PKZIP	(Phil  Katz's  ZIP  for	 MSDOS

       A  companion program (unzip(1L))	unpacks	zip archives.  The zip and un-
       zip(1L) programs	can work with archives produced	by  PKZIP  (supporting
       most PKZIP features up to PKZIP version 4.6), and PKZIP and PKUNZIP can
       work with archives produced  by	zip  (with  some  exceptions,  notably
       streamed	 archives, but recent changes in the zip file standard may fa-
       cilitate	better compatibility).	zip version  3.0  is  compatible  with
       PKZIP  2.04  and	 also supports the Zip64 extensions of PKZIP 4.5 which
       allow archives as well as files to exceed the previous 2	GB limit (4 GB
       in  some	 cases).  zip also now supports	bzip2 compression if the bzip2
       library is included when	zip is compiled.  Note that PKUNZIP 1.10  can-
       not extract files produced by PKZIP 2.04	or zip 3.0. You	must use PKUN-
       ZIP 2.04g or unzip 5.0p1	(or later versions) to extract them.

       See the EXAMPLES	section	at the bottom of this  page  for  examples  of
       some typical uses of zip.

       Large Archives and Zip64.   zip automatically uses the Zip64 extensions
       when files larger than 4	GB are added to	an archive,  an	 archive  con-
       taining	Zip64 entries is updated (if the resulting archive still needs
       Zip64), the size	of the archive will exceed 4 GB, or when the number of
       entries	in  the	archive	will exceed about 64K.	Zip64 is also used for
       archives	streamed from standard input as	the size of such archives  are
       not  known  in advance, but the option -fz- can be used to force	zip to
       create PKZIP 2 compatible archives (as long as Zip64 extensions are not
       needed).	  You must use a PKZIP 4.5 compatible unzip, such as unzip 6.0
       or later, to extract files using	the Zip64 extensions.

       In addition, streamed archives, entries encrypted with standard encryp-
       tion,  or  split	archives created with the pause	option may not be com-
       patible with PKZIP as data descriptors are used and PKZIP at  the  time
       of  this	 writing does not support data descriptors (but	recent changes
       in the PKWare published zip standard now	include	some support  for  the
       data descriptor format zip uses).

       Mac  OS	X.   Though  previous Mac versions had their own zip port, zip
       supports	Mac OS X as part of the	Unix port and most Unix	 features  ap-
       ply.   References  to  "MacOS"  below generally refer to	MacOS versions
       older than OS X.	 Support for some Mac OS features in the Unix Mac OS X
       port, such as resource forks, is	expected in the	next zip release.

       For  a brief help on zip	and unzip, run each without specifying any pa-
       rameters	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.  (If bzip2	support	is added,  zip
       can  also  compress using bzip2 compression, but	such entries require a
       reasonably modern unzip to decompress.  When bzip2 compression  is  se-
       lected,	it  replaces  deflation	as the default method.)	 zip automati-
       cally chooses the better	of the two (deflation or store or, if bzip2 is
       selected, bzip2 or store) for each file to be compressed.

       Command format.	The basic command format is

	      zip options archive inpath inpath	...

       where  archive  is a new	or existing zip	archive	and inpath is a	direc-
       tory or file path optionally including wildcards.  When given the  name
       of  an existing zip archive, zip	will replace identically named entries
       in the zip archive (matching the	relative names as stored  in  the  ar-
       chive)  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

       or more concisely

	      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.

       So if before the	zip command is executed	has:

	       foo/file1 foo/file2

       and directory foo has:

	       file1 file3

       then will have:

	       foo/file1 foo/file2 foo/file3

       where foo/file1 is replaced and foo/file3 is new.

       -@ file lists.	If  a file list	is specified as	-@ [Not	on MacOS], zip
       takes the list of input files from standard input instead of  from  the
       command line.  For example,

	      zip -@ foo

       will store the files listed one per line	on stdin in

       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

       Streaming input and output.  zip	will also accept a single  dash	 ("-")
       as the zip file name, in	which case it will write the zip file to stan-
       dard output, allowing the output	to be piped to	another	 program.  For

	      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, al-
       lowing 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  ad-
       vantage	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 (but some gunzip may not support  this  if
       zip used	the Zip64 extensions). For example:

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

       The stream can also be saved to a file and unzip	used.

       If  Zip64  support  for	large files and	archives is enabled and	zip is
       used as a filter, zip creates a Zip64 archive that requires a PKZIP 4.5
       or  later compatible unzip to read it.  This is to avoid	amgibuities in
       the zip file structure as defined in the	current	zip  standard  (PKWARE
       AppNote)	 where	the decision to	use Zip64 needs	to be made before data
       is written for the entry, but for a stream the size of the data is  not
       known at	that point.  If	the data is known to be	smaller	than 4 GB, the
       option -fz- can be used to prevent use of Zip64,	but zip	will exit with
       an  error if Zip64 was in fact needed.  zip 3 and unzip 6 and later can
       read archives with Zip64	entries.  Also,	zip removes the	 Zip64	exten-
       sions  if  not  needed  when  archive  entries  are  copied (see	the -U
       (--copy)	option).

       When directing the output to another file, note that all	options	should
       be before the redirection including -x.	For example:

	      zip archive "*.h"	"*.c" -x donotinclude.h	orthis.h > tofile

       Zip files.   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 er-

       If the name of the zip archive does not contain an extension,  the  ex-
       tension	.zip is	added. If the name already contains an extension other
       than .zip, the existing extension is kept  unchanged.   However,	 split
       archives	 (archives  split over multiple	files) require the .zip	exten-
       sion on the last	split.

       Scanning	and reading files.  When zip starts, it	 scans	for  files  to
       process	(if  needed).  If this scan takes longer than about 5 seconds,
       zip will	display	 a  "Scanning  files"  message	and  start  displaying
       progress	 dots  every  2	 seconds  or  every so many entries processed,
       whichever takes longer.	If there is more than 2	seconds	 between  dots
       it  could indicate that finding each file is taking time	and could mean
       a slow network connection for example.  (Actually the initial file scan
       is  a  two-step	process	where the directory scan is followed by	a sort
       and these two steps are separated with a	space in the dots.  If	updat-
       ing an existing archive,	a space	also appears between the existing file
       scan and	the new	file scan.)  The scanning  files  dots	are  not  con-
       trolled	by the -ds dot size option, but	the dots are turned off	by the
       -q quiet	option.	 The -sf show files option can be  used	 to  scan  for
       files  and  get	the  list of files scanned without actually processing

       If zip is not able to read a file, it issues a warning  but  continues.
       See  the	-MM option below for more on how zip handles patterns that are
       not matched and files that  are	not  readable.	 If  some  files  were
       skipped,	a warning is issued at the end of the zip operation noting how
       many files were read and	how many skipped.

       Command modes.  zip now supports	two distinct types of  command	modes,
       external	 and  internal.	 The external modes (add, update, and freshen)
       read files from the file	system (as well	as from	an  existing  archive)
       while  the  internal modes (delete and copy) operate exclusively	on en-
       tries in	an existing archive.

	      Update existing entries and add new files.  If the archive  does
	      not exist	create it.  This is the	default	mode.

       update (-u)
	      Update  existing entries if newer	on the file system and add new
	      files.  If the archive does not exist issue warning then	create
	      a	new archive.

       freshen (-f)
	      Update  existing entries of an archive if	newer on the file sys-
	      tem.  Does not add new files to the archive.

       delete (-d)
	      Select entries in	an existing archive and	delete them.

       copy (-U)
	      Select entries in	an existing archive and	copy them to a new ar-
	      chive.  This new mode is similar to update but command line pat-
	      terns select entries in the existing archive rather  than	 files
	      from  the	 file system and it uses the --out option to write the
	      resulting	archive	to a new file rather than update the  existing
	      archive, leaving the original archive unchanged.

       The new File Sync option	(-FS) is also considered a new mode, though it
       is similar to update.  This mode	 synchronizes  the  archive  with  the
       files  on  the OS, only replacing files in the archive if the file time
       or size of the OS file is different, adding new files, and deleting en-
       tries  from  the	archive	where there is no matching file.  As this mode
       can delete entries from the archive, consider making a backup  copy  of
       the archive.

       Also see	-DF for	creating difference archives.

       See  each option	description below for details and the EXAMPLES section
       below for examples.

       Split archives.	zip version 3.0	and later can create  split  archives.
       A  split	 archive  is a standard	zip archive split over multiple	files.
       (Note that split	archives are not just archives split in	to pieces,  as
       the  offsets of entries are now based on	the start of each split.  Con-
       catenating the pieces together will invalidate these offsets, but unzip
       can  usually  deal  with	it.  zip will usually refuse to	process	such a
       spliced archive unless the -FF fix option is used to fix	the offsets.)

       One use of split	archives is storing a large archive on multiple	remov-
       able media.  For	a split	archive	with 20	split files the	files are typ-
       ically named (replace ARCHIVE  with  the	 name  of  your	 archive)  AR-
       CHIVE.z01,  ARCHIVE.z02,	 ..., ARCHIVE.z19,	 Note that the
       last file is the	.zip file.  In	contrast,  spanned  archives  are  the
       original	 multi-disk archive generally requiring	floppy disks and using
       volume labels to	store disk numbers.  zip supports split	 archives  but
       not  spanned  archives,	though a procedure exists for converting split
       archives	of the right size to spanned archives.	The  reverse  is  also
       true,  where  each  file	of a spanned archive can be copied in order to
       files with the above names to create a split archive.

       Use -s to set the split size and	create a split archive.	 The  size  is
       given as	a number followed optionally by	one of k (kB), m (MB), g (GB),
       or t (TB) (the default is m).  The -sp option can be used to pause  zip
       between splits to allow changing	removable media, for example, but read
       the descriptions	and warnings for both -s and -sp below.

       Though zip does not update split	archives, zip provides the new	option
       -O  (--output-file  or --out) to	allow split archives to	be updated and
       saved in	a new archive.	For example,

	      zip	foo.c bar.c --out

       reads archive, even if split, adds	the  files  foo.c  and
       bar.c,  and  writes  the	resulting archive to  If inar- is split then defaults to the same split size.
       Be  aware  that	if and any split	files that are created
       with it already exist, these are	always overwritten as  needed  without
       warning.	 This may be changed in	the future.

       Unicode.	  Though the zip standard requires storing paths in an archive
       using a specific	character set, in practice zips	have stored  paths  in
       archives	in whatever the	local character	set is.	 This creates problems
       when an archive is created or updated on	a system using	one  character
       set  and	 then  extracted on another system using a different character
       set.  When compiled with	Unicode	support	enabled	on platforms that sup-
       port wide characters, zip now stores, in	addition to the	standard local
       path for	backward compatibility,	the UTF-8  translation	of  the	 path.
       This  provides  a common	universal character set	for storing paths that
       allows these paths to be	fully extracted	on other systems that  support
       Unicode and to match as close as	possible on systems that don't.

       On  Win32 systems where paths are internally stored as Unicode but rep-
       resented	in the local character set, it's possible that some paths will
       be  skipped during a local character set	directory scan.	 zip with Uni-
       code support now	can read and store these paths.	 Note that Win 9x sys-
       tems and	FAT file systems don't fully support Unicode.

       Be aware	that console windows on	Win32 and Unix,	for example, sometimes
       don't accurately	show all characters due	to how each  operating	system
       switches	 in character sets for display.	 However, directory navigation
       tools should show the correct paths if the needed fonts are loaded.

       Command line format.  This version of zip has updated command line pro-
       cessing and support for long options.

       Short options take the form

	      -s[-][s[-]...][value][=value][ value]

       where  s	 is  a one or two character short option.  A short option that
       takes a value is	last in	an argument and	anything after it is taken  as
       the  value.   If	 the option can	be negated and "-" immediately follows
       the option, the option is negated.  Short options can also be given  as
       separate	arguments

	      -s[-][value][=value][ value] -s[-][value][=value][ value]	...

       Short  options  in general take values either as	part of	the same argu-
       ment or as the following	argument.  An optional =  is  also  supported.





	      -tt mmddyyyy

       all  work.   The	 -x  and  -i  options accept lists of values and use a
       slightly	different format described below.  See the -x and -i options.

       Long options take the form

	      --longoption[-][=value][ value]

       where the option	starts with --,	has a multicharacter name, can include
       a  trailing  dash to negate the option (if the option supports it), and
       can have	a value	(option	argument) specified by preceeding  it  with  =
       (no spaces).  Values can	also follow the	argument.  So



	      --before-date mmddyyyy

       both work.

       Long option names can be	shortened to the shortest unique abbreviation.
       See the option descriptions below for which support long	 options.   To
       avoid confusion,	avoid abbreviating a negatable option with an embedded
       dash ("-") at the dash if you plan to negate it (the parser would  con-
       sider  a	 trailing  dash,  such	as  for	the option --some-option using
       --some- as the option, as part of  the  name  rather  than  a  negating
       dash).	This  may  be  changed to force	the last dash in --some- to be
       negating	in the future.

	      [Systems using EBCDIC] Translate file to ASCII format.

	      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.

	      [WIN32]	Once  archive  is  created  (and tested	if -T is used,
	      which is recommended), clear the	archive	 bits  of  files  pro-
	      cessed.	WARNING:  Once	the bits are cleared they are cleared.
	      You may want to use the -sf show files option to store the  list
	      of  files	 processed  in	case the archive operation must	be re-
	      peated.  Also consider using the -MM must	match option.  Be sure
	      to  check	 out  -DF  as  a possibly better way to	do incremental

	      [WIN32]  Only include files that have the	archive	bit set.   Di-
	      rectories	are not	stored when -AS	is used, though	by default the
	      paths of entries,	including directories, are stored as usual and
	      can be used by most unzips to recreate directories.

	      The  archive  bit	 is set	by the operating system	when a file is
	      modified and, if used with -AC, -AS can provide  an  incremental
	      backup  capability.   However, other applications	can modify the
	      archive bit and it may not be  a	reliable  indicator  of	 which
	      files  have  changed since the last archive operation.  Alterna-
	      tive ways	to create incremental backups are using	-t to use file
	      dates,  though  this won't catch old files copied	to directories
	      being archived, and -DF to create	a differential archive.

	      [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
       --temp-path 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  op-
	      tion  is	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.	It may also be
	      useful when streaming in some cases to avoid the need  for  data
	      descriptors.   Note  that	using this option may require zip take
	      additional time to copy the archive file when done to the	desti-
	      nation file system.

	      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.

	      [VMS]  Preserve case all on VMS.	 Negating  this	 option	 (-C-)

	      [VMS]   Preserve	case ODS2 on VMS.  Negating this option	(-C2-)

	      [VMS]  Preserve case ODS5	on VMS.	 Negating this	option	(-C5-)

	      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.   (The	 backslashes  are  not
	      used  on	MSDOS-based platforms.)	 Can also use quotes to	escape
	      the asterisks as in

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

	      Not escaping the asterisks on a system where the	shell  expands
	      wildcards	 could	result	in  the	asterisks being	converted to a
	      list of files in the current directory and  that	list  used  to
	      delete entries from the archive.

	      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.  (We con-
	      sidered making this case insensitive on systems where paths were
	      case  insensitive,  but  it  is possible the archive came	from a
	      system where case	does matter and	the archive could include both
	      Bar  and bar as separate files in	the archive.)  But see the new
	      option -ic to ignore case	in the archive.

	      Display running byte counts showing the  bytes  zipped  and  the
	      bytes to go.

	      Display running count of entries zipped and entries to go.

	      Display  dots  while  each entry is zipped (except on ports that
	      have their own progress indicator).  See -ds below  for  setting
	      dot  size.   The default is a dot	every 10 MB of input file pro-
	      cessed.  The -v option also displays dots	(previously at a  much
	      higher  rate  than  this	but now	-v also	defaults to 10 MB) and
	      this rate	is also	controlled by -ds.

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

	      Display progress dots for	the archive instead of for each	 file.
	      The command

			 zip -qdgds 10m

	      will turn	off most output	except dots every 10 MB.

       -ds size
       --dot-size size
	      Set  amount of input file	processed for each dot displayed.  See
	      -dd to enable displaying dots.  Setting this option implies -dd.
	      Size  is	in the format nm where n is a number and m is a	multi-
	      plier.  Currently	m can be k (KB), m (MB), g (GB), or t (TB), so
	      if n is 100 and m	is k, size would be 100k which is 100 KB.  The
	      default is 10 MB.

	      The -v option also displays dots and now defaults	to 10 MB also.
	      This  rate is also controlled by this option.  A size of 0 turns
	      dots off.

	      This option does not control the dots from the "Scanning	files"
	      message  as zip scans for	input files.  The dot size for that is
	      fixed at 2 seconds or a fixed number of  entries,	 whichever  is

	      Display the uncompressed size of each entry.

	      Display  the volume (disk) number	each entry is being read from,
	      if reading an existing archive, and being	written	to.

	      Do not create entries in the zip archive for  directories.   Di-
	      rectory  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,	 including  -i
	      and -x using a new option	format detailed	below, and can include
	      several options.)	The option -D is a shorthand for -x  "*/"  but
	      the  latter previously could not be set as default in the	ZIPOPT
	      environment variable as the contents  of	ZIPOPT	gets  inserted
	      near  the	beginning of the command line and the file list	had to
	      end at the end of	the line.

	      This version of zip does allow -x	and -i options	in  ZIPOPT  if
	      the form

	       -x file file ...	@

	      is used, where the @ (an argument	that is	just @)	terminates the

	      Create an	archive	that contains all new and changed files	 since
	      the  original  archive was created.  For this to work, the input
	      file list	and current directory must be the same as  during  the
	      original zip operation.

	      For example, if the existing archive was created using

		     zip -r foofull .

	      from the bar directory, then the command

		     zip -r foofull . -DF --out	foonew

	      also from	the bar	directory creates the archive foonew with just
	      the files	not in foofull and the files where the	size  or  file
	      time of the files	do not match those in foofull.

	      Note that	the timezone environment variable TZ should be set ac-
	      cording to the local timezone in order for this option  to  work
	      correctly.   A change in timezone	since the original archive was
	      created could result in no times matching	and  all  files	 being

	      A	possible approach to backing up	a directory might be to	create
	      a	normal archive of the contents of  the	directory  as  a  full
	      backup, then use this option to create incremental backups.

	      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.

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

	      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 ac-
	      cording to the local timezone in order for the -f, -u and	-o op-
	      tions 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).

	      The format is TTThhDDD, where TTT	is the time zone such as  MET,
	      hh  is  the  difference  between	GMT  and local time such as -1
	      above, and DDD is	the time zone when daylight savings time is in
	      effect.  Leave off the DDD if there is no	daylight savings time.
	      For the US Eastern time zone EST5EDT.

	      Fix the zip archive. The -F option can be	used if	some  portions
	      of  the  archive	are  missing, but requires a reasonably	intact
	      central directory.  The input archive is scanned as  usual,  but
	      zip  will	ignore some problems.  The resulting archive should be
	      valid, but any inconsistent entries will be left out.

	      When doubled as in -FF, the archive is scanned from  the	begin-
	      ning and zip scans for special signatures	to identify the	limits
	      between the archive members. The single -F is more  reliable  if
	      the archive is not too much damaged, so try this option first.

	      If the archive is	too damaged or the end has been	truncated, you
	      must use -FF.  This is a change from zip 2.32, where the -F  op-
	      tion  is	able  to  read a truncated archive.  The -F option now
	      more reliably fixes archives with	minor damage and the  -FF  op-
	      tion  is	needed to fix archives where -F	might have been	suffi-
	      cient before.

	      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.

	      Note that	-FF may	have trouble fixing archives that  include  an
	      embedded	zip  archive  that was stored (without compression) in
	      the archive and, depending on the	damage,	it may	find  the  en-
	      tries  in	 the  embedded archive rather than the archive itself.
	      Try -F first as it does not have this problem.

	      The format of the	fix commands have changed.   For  example,  to
	      fix the damaged archive,

		     zip -F foo	--out foofix

	      tries  to	read the entries normally, copying good	entries	to the
	      new archive  If this doesn't work, as	when  the  ar-
	      chive  is	 truncated, or if some entries you know	are in the ar-
	      chive are	missed,	then try

		     zip -FF foo --out foofixfix

	      and compare the resulting	archive	to the archive created by  -F.
	      The -FF option may create	an inconsistent	archive.  Depending on
	      what is damaged, you can then use	the -F option to fix that  ar-

	      A	 split	archive	with missing split files can be	fixed using -F
	      if you have the last split of the	archive	(the .zip  file).   If
	      this file	is missing, you	must use -FF to	fix the	archive, which
	      will prompt you for the splits you have.

	      Currently	the fix	options	can't recover entries that have	a  bad
	      checksum or are otherwise	damaged.

       --fifo [Unix]   Normally	 zip skips reading any FIFOs (named pipes) en-
	      countered, as zip	can hang if the	FIFO is	not being  fed.	  This
	      option tells zip to read the contents of any FIFO	it finds.

	      Synchronize the contents of an archive with the files on the OS.
	      Normally when an archive is updated, new	files  are  added  and
	      changed  files are updated but files that	no longer exist	on the
	      OS are not deleted from the archive.  This option	enables	a  new
	      mode that	checks entries in the archive against the file system.
	      If the file time and file	size of	the entry matches that of  the
	      OS file, the entry is copied from	the old	archive	instead	of be-
	      ing read from the	file system and	compressed.  If	 the  OS  file
	      has  changed, the	entry is read and compressed as	usual.	If the
	      entry in the archive does	not match a file on the	OS, the	 entry
	      is  deleted.   Enabling  this option should create archives that
	      are the same as new archives, but	 since	existing  entries  are
	      copied  instead of compressed, updating an existing archive with
	      -FS can be much faster than creating a new archive.   Also  con-
	      sider using -u for updating an archive.

	      For  this	option to work,	the archive should be updated from the
	      same directory it	was created in so the  relative	 paths	match.
	      If  few  files  are being	copied from the	old archive, it	may be
	      faster to	create a new archive instead.

	      Note that	the timezone environment variable TZ should be set ac-
	      cording  to  the local timezone in order for this	option to work
	      correctly.  A change in timezone since the original archive  was
	      created  could  result in	no times matching and recompression of
	      all files.

	      This option deletes files	from the archive.  If you need to pre-
	      serve  the original archive, make	a copy of the archive first or
	      use the --out option to output the  updated  archive  to	a  new
	      file.  Even though it may	be slower, creating a new archive with
	      a	new archive name is safer, avoids mismatches  between  archive
	      and OS paths, and	is preferred.

	      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.

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

	      Display  extended	 help  including  more on command line format,
	      pattern matching,	and more obscure options.

       -i files
       --include 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  di-
	      rectory  levels.	 [This	is  for	Unix and other systems where \
	      escapes the next character.  For other systems where  the	 shell
	      does not process * do not	use \ and the above is

		     zip -r foo	. -i *.c

	      Examples	are  for  Unix unless otherwise	specified.]  So	to in-
	      clude dir, a directory directly under the	current	directory, use

		     zip -r foo	. -i dir/\*


		     zip -r foo	. -i "dir/*"

	      to match paths such as dir/a and dir/b/file.c [on	ports  without
	      wildcard expansion in the	shell such as MSDOS and	Windows

		     zip -r foo	. -i dir/*

	      is  used.]  Note that currently the trailing / is	needed for di-
	      rectories	(as in

		     zip -r foo	. -i dir/

	      to include directory dir).

	      The long option form of the first	example	is

		     zip -r foo	. --include \*.c

	      and does the same	thing as the short option form.

	      Though the command syntax	used to	require	-i at the end  of  the
	      command  line,  this  version  actually allows -i	(or --include)
	      anywhere.	 The list of files terminates  at  the	next  argument
	      starting with -, the end of the command line, or the list	termi-
	      nator @ (an argument that	is just	@).  So	the above can be given

		     zip -i \*.c @ -r foo .

	      for  example.   There must be a space between the	option and the
	      first file of a list.  For just one file you can use the	single
	      value form

		     zip -i\*.c	-r foo .

	      (no space	between	option and value) or

		     zip --include=\*.c	-r foo .

	      as  additional  examples.	 The single value forms	are not	recom-
	      mended because they can be confusing  and,  in  particular,  the
	      -ifile  format  can  cause  problems if the first	letter of file
	      combines with i to form a	two-letter  option  starting  with  i.
	      Use -sc to see how your command line will	be parsed.

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

	      Files to -i and -x are patterns matching internal	archive	paths.
	      See -R for more on patterns.

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

	      [VMS,  WIN32]  Ignore  case when matching	archive	entries.  This
	      option is	only available on systems where	the case of  files  is
	      ignored.	On systems with	case-insensitive file systems, case is
	      normally ignored when matching files on the file system  but  is
	      not  ignored for -f (freshen), -d	(delete), -U (copy), and simi-
	      lar modes	when matching against archive  entries	(currently  -f
	      ignores case on VMS) because archive entries can be from systems
	      where case does matter and names that are	the  same  except  for
	      case can exist in	an archive.  The -ic option makes all matching
	      case insensitive.	 This can result in multiple  archive  entries
	      matching a command line pattern.

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

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

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

	      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.

	      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 is to ensure that unzip -a on
	      Unix will	get back an exact copy of the original file,  to  undo
	      the effect of zip	-l.  See -ll for how binary files are handled.

	      Append to	existing logfile.  Default is to overwrite.

       -lf logfilepath
       --logfile-path logfilepath
	      Open  a logfile at the given path.  By default any existing file
	      at that location is overwritten, but the -la option will	result
	      in an existing file being	opened and the new log information ap-
	      pended to	any existing information.  Only	 warnings  and	errors
	      are written to the log unless the	-li option is also given, then
	      all information messages are also	written	to the log.

	      Include information messages, such as file names	being  zipped,
	      in  the  log.   The default is to	only include the command line,
	      any warnings and errors, and the final status.

	      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.  If  the
	      file  is converted and the file is later determined to be	binary
	      a	warning	is issued and the file is probably corrupted.  In this
	      release  if  -ll	detects	binary in the first buffer read	from a
	      file, zip	now issues a warning and skips line end	conversion  on
	      the  file.   This	 check seems to	catch all binary files tested,
	      but the original check remains and if a converted	file is	 later
	      determined to be binary that warning is still issued.  A new al-
	      gorithm is now being used	for binary detection that should allow
	      line  end	 conversion  of	text files in UTF-8 and	similar	encod-

	      Display the zip license.

	      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 un-
	      til 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.

	      All  input  patterns  must match at least	one file and all input
	      files found must be readable.  Normally when  an	input  pattern
	      does  not	 match a file the "name	not matched" warning is	issued
	      and when an input	file has been found but	later  is  missing  or
	      not  readable  a	missing	or not readable	warning	is issued.  In
	      either case zip continues	creating the archive, with missing  or
	      unreadable  new files being skipped and files already in the ar-
	      chive remaining unchanged.  After	the archive is created,	if any
	      files  were  not readable	zip returns the	OPEN error code	(18 on
	      most systems) instead of the normal success return  (0  on  most
	      systems).	  With	-MM set, zip exits as soon as an input pattern
	      is not matched (whenever the "name not matched" warning would be
	      issued)  or  when	an input file is not readable.	In either case
	      zip exits	with an	OPEN error and no archive is created.

	      This option is useful when a known list of files is to be	zipped
	      so  any missing or unreadable files will result in an error.  It
	      is less useful when used with wildcards, but zip will still exit
	      with  an	error  if any input pattern doesn't match at least one
	      file and if any matched files are	unreadable.  If	 you  want  to
	      create  the  archive  anyway and only need to know if files were
	      skipped, don't use -MM and just check the	return code.  Also -lf
	      could be useful.

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

	      Do not perform internal wildcard processing (shell processing of
	      wildcards	 is  still  done by the	shell unless the arguments are
	      escaped).	 Useful	if a list of paths is being read and no	 wild-
	      card substitution	is desired.

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

	      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  de-
	      sired.  For example:

	      zip -o foo

	      will change the last modified time of to the latest time
	      of the entries in

       -O output-file
       --output-file output-file
	      Process the archive changes as usual, but	 instead  of  updating
	      the  existing  archive,  output  the new archive to output-file.
	      Useful for updating an archive without changing the existing ar-
	      chive  and  the  input archive must be a different file than the
	      output archive.

	      This option can be used to create	updated	 split	archives.   It
	      can  also	 be  used with -U to copy entries from an existing ar-
	      chive to a new archive.  See the EXAMPLES	section	below.

	      Another use is converting	zip files from one split size  to  an-
	      other.   For  instance,  to  convert  an	archive	with 700 MB CD
	      splits to	one with 2 GB DVD splits, can use:

		     zip -s 2g --out

	      which uses copy mode.  See -U below.  Also:

		     zip -s 0	--out

	      will convert a split archive to a	single-file archive.

	      Copy mode	will convert stream entries  (using  data  descriptors
	      and  which  should be compatible with most unzips) to normal en-
	      tries (which should be compatible	with all  unzips),  except  if
	      standard	encryption  was	used.  For archives with encrypted en-
	      tries, zipcloak will decrypt the entries	and  convert  them  to
	      normal entries.

	      Include relative file paths as part of the names of files	stored
	      in the archive.  This is the default.  The -j option  junks  the
	      paths and	just stores the	names of the files.

       -P password
       --password password
	      Use password to encrypt zipfile entries (if any).	 THIS IS INSE-
	      CURE!  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 automated script  is  even  worse.   Whenever
	      possible,	use the	non-echoing, interactive prompt	to enter pass-
	      words.  (And where security is truly important, use  strong  en-
	      cryption	such  as Pretty	Good Privacy instead of	the relatively
	      weak standard encryption provided	by zipfile utilities.)

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

       --Q-flag	n
	      [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

	      Travel the directory structure recursively; for example:

		     zip -r foo

	      or more concisely

		     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  (proba-
	      bly not what was intended).

	      Multiple source directories are allowed as in

		     zip -r foo	foo1 foo2

	      which  first  zips up foo1 and then foo2,	going down each	direc-

	      Note that	while wildcards	to -r are typically resolved while re-
	      cursing  down directories	in the file system, any	-R, -x,	and -i
	      wildcards	are applied to internal	archive	pathnames once the di-
	      rectories	are scanned.  To have wildcards	apply to files in sub-
	      directories when recursing on Unix and similar systems where the
	      shell does wildcard substitution,	either escape all wildcards or
	      put all arguments	with wildcards in quotes.  This	lets  zip  see
	      the wildcards and	match files in subdirectories using them as it

	      Travel the directory structure recursively starting at the  cur-
	      rent 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 that *.c will match file.c, a/file.c and a/b/.c.
	      More than	one pattern can	be listed as separate arguments.  Note
	      for PKZIP	users: the equivalent command is

		     pkzip -rP foo *.c

	      Patterns	are relative file paths	as they	appear in the archive,
	      or will after zipping, and can have optional wildcards in	 them.
	      For example, given the current directory is foo and under	it are
	      directories foo1 and foo2	and in foo1 is the file	bar.c,

		     zip -R foo/*

	      will zip up foo, foo/foo1, foo/foo1/bar.c, and foo/foo2.

		     zip -R */bar.c

	      will zip up foo/foo1/bar.c.  See the note	 for  -r  on  escaping

	      [WIN32]	Before	zip  3.0, regular expression list matching was
	      enabled by default on Windows platforms.	Because	 of  confusion
	      resulting	 from  the  need to escape "[" and "]" in names, it is
	      now off by default for Windows so	"[" and	"]"  are  just	normal
	      characters in names.  This option	enables	[] matching again.

       -s splitsize
       --split-size splitsize
	      Enable creating a	split archive and set the split	size.  A split
	      archive is an archive that could be split	over many  files.   As
	      the  archive  is created,	if the size of the archive reaches the
	      specified	split size, that split is closed and  the  next	 split
	      opened.	In  general  all splits	but the	last will be the split
	      size and the last	will be	whatever is left.  If the  entire  ar-
	      chive  is	 smaller  than the split size a	single-file archive is

	      Split archives are stored	in numbered files.   For  example,  if
	      the  output  archive  is	named archive and three	splits are re-
	      quired, the resulting archive will be in	the  three  files  ar-
	      chive.z01, archive.z02, and	Do not change the num-
	      bering of	these files or the archive will	 not  be  readable  as
	      these are	used to	determine the order the	splits are read.

	      Split  size  is  a  number  optionally followed by a multiplier.
	      Currently	the number must	be an  integer.	  The  multiplier  can
	      currently	be one of k (kilobytes), m (megabytes),	g (gigabytes),
	      or t (terabytes).	 As 64k	is the	minimum	 split	size,  numbers
	      without  multipliers default to megabytes.  For example, to cre-
	      ate a split archive called foo with the contents of the bar  di-
	      rectory  with  splits of 670 MB that might be useful for burning
	      on CDs, the command:

		     zip -s 670m -r foo	bar

	      could be used.

	      Currently	the old	splits of a split  archive  are	 not  excluded
	      from  a  new archive, but	they can be specifically excluded.  If
	      possible,	keep the input and output archives out of the path be-
	      ing zipped when creating split archives.

	      Using  -s	 without -sp as	above creates all the splits where foo
	      is being written,	in this	 case  the  current  directory.	  This
	      split  mode  updates the splits as the archive is	being created,
	      requiring	all splits to remain writable, but creates  split  ar-
	      chives  that  are	 readable by any unzip that supports split ar-
	      chives.  See -sp below for enabling split	pause mode  which  al-
	      lows splits to be	written	directly to removable media.

	      The  option -sv can be used to enable verbose splitting and pro-
	      vide details of how the splitting	is being done.	The -sb	option
	      can  be used to ring the bell when zip pauses for	the next split

	      Split archives cannot be updated,	but see	the -O (--out)	option
	      for  how a split archive can be updated as it is copied to a new
	      archive.	A split	archive	can also be converted into  a  single-
	      file archive using a split size of 0 or negating the -s option:

		     zip -s 0	--out

	      Also see -U (--copy) for more on using copy mode.

	      If  splitting and	using split pause mode,	ring the bell when zip
	      pauses for each split destination.

	      Show the command line starting zip as processed and  exit.   The
	      new  command  parser permutes the	arguments, putting all options
	      and any values associated	with them before any non-option	 argu-
	      ments.   This allows an option to	appear anywhere	in the command
	      line as long as any values that go with the option go  with  it.
	      This  option displays the	command	line as	zip sees it, including
	      any arguments from the environment such as from the ZIPOPT vari-
	      able.   Where  allowed,  options	later  in the command line can
	      override options earlier in the command line.

	      Show the files that would	be operated on,	then  exit.   For  in-
	      stance, if creating a new	archive, this will list	the files that
	      would be added.  If the option is	negated, -sf-, output only  to
	      an  open	log file.  Screen display is not recommended for large

	      Show all available options supported by zip as compiled  on  the
	      current  system.	 As  this  command  reads the option table, it
	      should include all options.  Each	line includes the short	option
	      (if  defined),  the  long	option (if defined), the format	of any
	      value that goes with the option, if the option can  be  negated,
	      and  a small description.	 The value format can be no value, re-
	      quired value, optional value,  single  character	value,	number
	      value,  or  a  list of values.  The output of this option	is not
	      intended to show how to use any option but only  show  what  op-
	      tions are	available.

	      If  splitting is enabled with -s,	enable split pause mode.  This
	      creates split archives as	-s does, but stream writing is used so
	      each  split  can be closed as soon as it is written and zip will
	      pause between each split to allow	changing split destination  or

	      Though  this split mode allows writing splits directly to	remov-
	      able media, it uses stream archive format	that may not be	 read-
	      able by some unzips.  Before relying on splits created with -sp,
	      test a split archive with	the unzip you will be using.

	      To convert a stream split	archive	(created with -sp) to a	 stan-
	      dard archive see the --out option.

	      As -sf, but also show Unicode version of the path	if exists.

	      As  -sf,	but  only  show	Unicode	version	of the path if exists,
	      otherwise	show the standard version of the path.

	      Enable various verbose messages while splitting, showing how the
	      splitting	is being done.

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

       -t mmddyyyy
       --from-date mmddyyyy
	      Do not operate on	files modified prior to	 the  specified	 date,
	      where  mm	 is  the  month	 (00-12),  dd  is the day of the month
	      (01-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
       --before-date mmddyyyy
	      Do not operate on	files modified after or	at the specified date,
	      where mm is the month (00-12),  dd  is  the  day	of  the	 month
	      (01-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  30 November 1995,	to the zip archive in-

	      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.

       -TT cmd
       --unzip-command cmd
	      Use command cmd instead of 'unzip	-tqq' to test an archive  when
	      the  -T  option is used.	On Unix, to use	a copy of unzip	in the
	      current directory	instead	of the standard	 system	 unzip,	 could

	       zip archive file1 file2 -T -TT "./unzip -tqq"

	      In  cmd,	{}  is	replaced by the	name of	the temporary archive,
	      otherwise	the name of the	archive	is appended to the end of  the
	      command.	The return code	is checked for success (0 on Unix).

	      Replace (update) an existing entry in the	zip archive only if it
	      has been modified	more recently than the version 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 input file arguments  acts  like
	      the -f (freshen) option.

	      Copy  entries  from  one archive to another.  Requires the --out
	      option to	specify	a different output file	 than  the  input  ar-
	      chive.   Copy  mode is the reverse of -d delete.	When delete is
	      being used with --out, the selected entries are deleted from the
	      archive  and  all	 other	entries	are copied to the new archive,
	      while copy mode selects the files	to include in the new archive.
	      Unlike -u	update,	input patterns on the command line are matched
	      against archive entries only and not the file system files.  For

		     zip inarchive "*.c" --copy	--out outarchive

	      copies  entries  with  names ending in .c	from inarchive to out-
	      archive.	The wildcard must be escaped on	some systems  to  pre-
	      vent  the	 shell	from substituting names	of files from the file
	      system which may have no relevance to the	 entries  in  the  ar-

	      If  no input files appear	on the command line and	--out is used,
	      copy mode	is assumed:

		     zip inarchive --out outarchive

	      This is useful for changing split	size for instance.  Encrypting
	      and  decrypting  entries	is  not	yet supported using copy mode.
	      Use zipcloak for that.

       -UN v
       --unicode v
	      Determine	what zip should	do with	Unicode	file names.   zip 3.0,
	      in  addition  to	the standard file path,	now includes the UTF-8
	      translation of the path if the entry path	is not entirely	 7-bit
	      ASCII.   When  an	entry is missing the Unicode path, zip reverts
	      back to the standard file	path.	The  problem  with  using  the
	      standard	path is	this path is in	the local character set	of the
	      zip that created the entry, which	may  contain  characters  that
	      are  not	valid  in  the	character set being used by the	unzip.
	      When zip is reading an archive, if an entry also has  a  Unicode
	      path, zip	now defaults to	using the Unicode path to recreate the
	      standard path using the current local character set.

	      This option can be used to determine what	 zip  should  do  with
	      this  path  if  there  is	a mismatch between the stored standard
	      path and the stored UTF-8	path (which can	happen if the standard
	      path  was	 updated).  In all cases, if there is a	mismatch it is
	      assumed that the standard	path is	 more  current	and  zip  uses
	      that.  Values for	v are

		     q - quit if paths do not match

		     w - warn, continue	with standard path

		     i - ignore, continue with standard	path

		     n - no Unicode, do	not use	Unicode	paths

	      The default is to	warn and continue.

	      Characters  that	are not	valid in the current character set are
	      escaped as #Uxxxx	and #Lxxxxxx, where x is  an  ASCII  character
	      for a hex	digit.	The first is used if a 16-bit character	number
	      is sufficient to represent the Unicode character and the	second
	      if  the character	needs more than	16 bits	to represent it's Uni-
	      code character code.  Setting -UN	to

		     e - escape

	      as in

		     zip archive -sU -UN=e

	      forces zip to escape all characters that are not printable 7-bit

	      Normally zip stores UTF-8	directly in the	standard path field on
	      systems where UTF-8 is the current character set and stores  the
	      UTF-8 in the new extra fields otherwise.	The option

		     u - UTF-8

	      as in

		     zip archive dir -r	-UN=UTF8

	      forces  zip  to store UTF-8 as native in the archive.  Note that
	      storing UTF-8 directly is	the default on Unix systems that  sup-
	      port  it.	  This option could be useful on Windows systems where
	      the escaped path is too large to be a valid path and  the	 UTF-8
	      version of the path is smaller, but native UTF-8 is not backward
	      compatible on Windows systems.

	      Verbose mode or print diagnostic version info.

	      Normally,	when applied to	real operations, this  option  enables
	      the  display of a	progress indicator during compression (see -dd
	      for more on dots)	and requests  verbose  diagnostic  info	 about
	      zipfile structure	oddities.

	      However,	when -v	is the only command line argument a diagnostic
	      screen is	printed	instead.  This should now work even if	stdout
	      is redirected to a file, allowing	easy saving of the information
	      for sending with bug reports to Info-ZIP.	  The  version	screen
	      provides	the help screen	header with program name, version, and
	      release date, some pointers to the Info-ZIP home	and  distribu-
	      tion  sites,  and	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).

	      [VMS]  Save VMS file attributes.	(Files are  truncated at EOF.)
	      When a -V	archive	is unpacked on a non-VMS  system,   some  file
	      types  (notably  Stream_LF  text	files	and  pure binary files
	      like fixed-512) should be	extracted intact.  Indexed  files  and
	      file  types  with	embedded record	sizes (notably variable-length
	      record types) will probably be seen as corrupt elsewhere.

	      [VMS] Save VMS file attributes, and  all allocated blocks	 in  a
	      file,   including	 any  data beyond EOF.	Useful for moving ill-
	      formed files  among  VMS systems.	  When a -VV  archive  is  un-
	      packed  on  a  non-VMS system, almost all	files will appear cor-

	      [VMS] Append the version number of the files to  the  name,  in-
	      cluding  multiple	versions of files.  Default is to use only the
	      most recent version of a specified file.

	      [VMS] Append the version number of the files to  the  name,  in-
	      cluding  multiple	versions of files, using the .nnn format.  De-
	      fault is to use only the most  recent  version  of  a  specified

	      Wildcards	match only at a	directory level.  Normally zip handles
	      paths as strings and given the paths



	      an input pattern such as


	      normally would match both	paths, the * matching dir/file1.c  and
	      file2.c.	 Note  that in the first case a	directory boundary (/)
	      was crossed in the match.	 With -ws no directory bounds will  be
	      included	in the match, making wildcards local to	a specific di-
	      rectory level.  So, with -ws enabled, only the second path would
	      be matched.

	      When using -ws, use ** to	match across directory boundaries as *
	      does normally.

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

		     zip -r foo	foo -x \*.o

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

	      Also possible:

		     zip -r foo	foo -x@exclude.lst

	      which  will include the contents of foo in while exclud-
	      ing all the files	that  match  the  patterns  in	the  file  ex-

	      The long option forms of the above are

		     zip -r foo	foo --exclude \*.o


		     zip -r foo	foo --exclude @exclude.lst

	      Multiple patterns	can be specified, as in:

		     zip -r foo	foo -x \*.o \*.c

	      If  there	is no space between -x and the pattern,	just one value
	      is assumed (no list):

		     zip -r foo	foo -x\*.o

	      See -i for more on include and exclude.

	      Do not save extra	file attributes	(Extended Attributes on	 OS/2,
	      uid/gid  and  file  times	 on  Unix).  The zip format uses extra
	      fields to	include	additional information for each	 entry.	  Some
	      extra fields are specific	to particular systems while others are
	      applicable to all	systems.  Normally when	zip reads entries from
	      an  existing archive, it reads the extra fields it knows,	strips
	      the rest,	and adds the extra fields applicable to	 that  system.
	      With -X, zip strips all old fields and only includes the Unicode
	      and Zip64	extra fields (currently	these two extra	fields	cannot
	      be disabled).

	      Negating	this  option,  -X-,  includes  all  the	 default extra
	      fields, but also copies over any unrecognized extra fields.

	      For UNIX and VMS (V8.3 and later), store symbolic	links as  such
	      in  the zip archive, instead of compressing and storing the file
	      referred to by the link.	This  can  avoid  multiple  copies  of
	      files  being  included in	the archive as zip recurses the	direc-
	      tory trees and accesses files directly and by links.

	      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 VMS).  The
	      comment can be taken from	a file:

		     zip -z foo	< foowhat

       -Z cm
       --compression-method cm
	      Set  the default compression method.  Currently the main methods
	      supported	by zip are store and deflate.  Compression method  can
	      be set to:

	      store  -	Setting	 the compression method	to store forces	zip to
	      store entries with no compression.   This	 is  generally	faster
	      than compressing entries,	but results in no space	savings.  This
	      is the same as using -0 (compression level zero).

	      deflate -	This is	the default method for zip.  If	zip determines
	      that  storing is better than deflation, the entry	will be	stored

	      bzip2 - If bzip2 support is compiled in, this compression	method
	      also  becomes available.	Only some modern unzips	currently sup-
	      port the bzip2 compression method, so test the unzip you will be
	      using  before relying on archives	using this method (compression
	      method 12).

	      For example, to add bar.c	to archive foo	using  bzip2  compres-

		     zip -Z bzip2 foo bar.c

	      The compression method can be abbreviated:

		     zip -Zb foo bar.c

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

	      Though  still  being  worked, the	intention is this setting will
	      control compression speed	for  all  compression  methods.	  Cur-
	      rently only deflation is controlled.

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

	      Take the list of input files from	standard input.	Only one file-
	      name per line.

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

		     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 the archive name contains	a  dot
       already;	this allows the	explicit specification of other	suffixes).

       Because	of the way the shell on	Unix 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	direc-

       To zip up an entire directory, the command:

	      zip -r foo foo

       creates	the  archive, containing all the files and directories
       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 compressed zip ar-
       chive.  In this case, you can create the	archive	in steps using the  -m
       option.	 If  foo contains the subdirectories tom, dick,	and harry, you

	      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 archive is
       deleted,	making room for	the next zip command to	function.

       Use -s to set the split size and	create a split archive.	 The  size  is
       given as	a number followed optionally by	one of k (kB), m (MB), g (GB),
       or t (TB).  The command

	      zip -s 2g	-r foo

       creates a split archive of the directory	foo with splits	no bigger than
       2 GB  each.   If	 foo  contained	5 GB of	contents and the contents were
       stored in the split archive without compression (to make	 this  example
       simple),	 this  would create three splits, split.z01 at 2 GB, split.z02
       at 2 GB,	and at a little over 1 GB.

       The -sp option can be used to pause zip between splits to allow	chang-
       ing  removable  media, for example, but read the	descriptions and warn-
       ings for	both -s	and -sp	below.

       Though zip does not update split	archives, zip provides the new	option
       -O (--output-file) to allow split archives to be	updated	and saved in a
       new archive.  For example,

	      zip	foo.c bar.c --out

       reads archive, even if split, adds	the  files  foo.c  and
       bar.c,  and  writes  the	resulting archive to  If inar- is split then defaults to the same split size.
       Be  aware that and any split files that are created with
       it are always overwritten without warning.  This	may be changed in  the

       This section applies only to Unix.  Watch this space for	details	on MS-
       DOS and VMS operation.  However,	the special wildcard characters	*  and
       [] below	apply to at least MSDOS	also.

       The  Unix  shells (sh, csh, bash, and others) normally do filename sub-
       stitution (also called "globbing") on command arguments.	 Generally 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]).	This form of wildcard matching	allows
	      a	 user  to specify a list of characters between square brackets
	      and if any of the	characters match the expression	matches.   For

		     zip archive "*.[hc]"

	      would  archive all files in the current directory	that end in .h
	      or .c.

	      Ranges of	characters are supported:

		     zip archive "[a-f]*"

	      would add	to the archive all files  starting  with  "a"  through

	      Negation is also supported, where	any character in that position
	      not in the list matches.	Negation is supported by adding	! or ^
	      to the beginning of the list:

		     zip archive "*.[!o]"

	      matches files that don't end in ".o".

	      On  WIN32, [] matching needs to be turned	on with	the -RE	option
	      to avoid the confusion that names	with [ or ] have caused.

       When these characters are encountered (without  being  escaped  with  a
       backslash  or  quotes),	the  shell will	look for files relative	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  (in-
       clude)  options,	on the list of files to	be operated on,	by using back-
       slashes 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 processed,  un-
       less  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 prefix	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	backslashes or double quotes for paths that have wild-
       cards to	make zip do the	pattern	matching for file  paths,  and	always
       for paths and strings that have spaces or wildcards for -i, -x, -R, -d,
       and -U and anywhere zip needs to	process	the wildcards.

       The following environment variables are read and	used  by  zip  as  de-

	      contains	default	 options  that	will be	used when running zip.
	      The contents of this environment variable	will get added to  the
	      command line just	after the zip command.

	      [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  extensions	to  be
	      added to the zip file with basename and extension	swapped.

	      [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.  Pro-
		     cessing may have completed	successfully anyway; some bro-
		     ken zipfiles created by other archivers have simple work-

	      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.	  Pro-
		     cessing probably failed immediately.

	      6	     entry  too	 large	to  be	processed (such	as input files
		     larger than 2 GB when not using Zip64 or trying  to  read
		     an	existing archive that is too large) or 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 simi-

	      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

	      19     zip  was compiled with options not	supported on this sys-

       VMS interprets standard Unix (or	PC) return values as  other,  scarier-
       looking	things,	 so zip	instead	maps them into VMS-style status	codes.
       In general, zip sets VMS	Facility = 1955	(0x07A3), Code = 2*  Unix_sta-
       tus,  and an appropriate	Severity (as specified in ziperr.h).  More de-
       tails  are   included   in   the	  VMS-specific	 documentation.	   See
       [.vms]NOTES.TXT and [.vms]vms_msg_gen.c.

       zip 3.0 is not compatible with PKUNZIP 1.10. Use	zip 1.1	to produce zip
       files which can be extracted by PKUNZIP 1.10.

       zip files produced by zip 3.0 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 incorrect format.  The old versions can
       list the	contents of the	zip file but cannot extract it anyway (because
       of  the	new  compression 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	trans-
       fer zip files from VMS to MSDOS,	type "set file	type  block"  on  VMS.
       When  transfering from MSDOS to VMS, type "set file type	fixed" on VMS.
       In both cases, type "set	file type binary" on MSDOS.

       Under some older	VMS versions, zip may  hang  for  file	specifications
       that use	DECnet syntax foo::*.*.

       On OS/2,	zip cannot match some names, such as those including an	excla-
       mation mark or a	hash sign.  This is a bug in OS/2 itself:  the	32-bit
       DosFindFirst/Next  don't	 find  such names.  Other programs 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 DosQuery-
       PathInfo(). 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 different,  it  uses	extra  padding
       bytes  and  link	 pointers  (it's  a linked list) to have all fields on
       4-byte boundaries for portability to future RISC	OS/2 versions.	There-
       fore  the value reported	by zip (which uses this	32-bit-mode size) dif-
       fers from that reported by DIR.	 zip  stores  the  32-bit  format  for
       portability, 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) 1997-2008 Info-ZIP.

       Currently distributed under the Info-ZIP	license.

       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.

       Original	copyright:

       Permission is granted to	any individual or institution to use, copy, or
       redistribute this software so long as all of the	original files are in-
       cluded, that it is not sold for profit, and that	this copyright	notice
       is retained.


       Please send bug reports and comments using the web page	at:	  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 pos-

       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  for-
       mat,  and  .ZIP	filename extension, and	for accepting minor changes to
       the file	format;	to Steve Burg for clarifications on the	 deflate  for-
       mat;  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  pos-
       sible.	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 and updated
       by E. Gordon for	zip 3.0.

Info-ZIP		      16 June 2008 (v3.0)		       ZIP(1L)


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

home | help