2840 lines
84 KiB
Groff
2840 lines
84 KiB
Groff
.\" =========================================================================
|
|
.\" Copyright (c) 1990-2008 Info-ZIP. All rights reserved.
|
|
.\"
|
|
.\" See the accompanying file LICENSE, version 2007-Mar-4 or later
|
|
.\" (the contents of which are also included in zip.h) for terms of use.
|
|
.\" If, for some reason, all these files are missing, the Info-ZIP license
|
|
.\" also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
|
|
.\" ==========================================================================
|
|
.\"
|
|
.\" zip.1 by Mark Adler, Jean-loup Gailly and R. P. C. Rodgers
|
|
.\" updated by E. Gordon for Zip 3.0 (8 May 2005, 24 December 2006,
|
|
.\" 4 February 2007, 27 May 2007, 4 June 2007 by EG; 12 June 2007 by CS;
|
|
.\" 30 August 2007, 27 April 2008, 25 May 2008, 27 May 2008 by EG,
|
|
.\" 7 June 2008 by SMS and EG; 12 June 2008 by EG)
|
|
.\"
|
|
.TH ZIP 1L "16 June 2008 (v3.0)" Info-ZIP
|
|
.SH NAME
|
|
zip \- package and compress (archive) files
|
|
.SH SYNOPSIS
|
|
.B zip
|
|
.RB [\- aABcdDeEfFghjklLmoqrRSTuvVwXyz!@$ ]
|
|
[\-\-longoption ...]
|
|
.RB [\- b " path]"
|
|
.RB [\- n " suffixes]"
|
|
.RB [\- t " date]"
|
|
.RB [\- tt " date]"
|
|
[\fIzipfile\fR [\fIfile\fR \.\|.\|.]]
|
|
[\fB-xi\fR list]
|
|
.PP
|
|
.B zipcloak
|
|
(see separate man page)
|
|
.PP
|
|
.B zipnote
|
|
(see separate man page)
|
|
.PP
|
|
.B zipsplit
|
|
(see separate man page)
|
|
.PP
|
|
Note: Command line processing in
|
|
.I 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.
|
|
.SH DESCRIPTION
|
|
.I 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
|
|
.IR tar (1)
|
|
and
|
|
.IR compress (1)
|
|
and is compatible with PKZIP (Phil Katz's ZIP for MSDOS systems).
|
|
.LP
|
|
A companion program
|
|
.RI ( unzip (1L))
|
|
unpacks
|
|
.I zip
|
|
archives.
|
|
The
|
|
.I zip
|
|
and
|
|
.IR unzip (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
|
|
\fIzip\fP (with some exceptions, notably streamed archives,
|
|
but recent changes in the zip file standard may facilitate
|
|
better compatibility).
|
|
.I 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). \fIzip\fP also now supports \fBbzip2\fP compression
|
|
if the \fBbzip2\fP library is included when \fIzip\fP is compiled.
|
|
Note that PKUNZIP 1.10 cannot extract files produced by
|
|
PKZIP 2.04 or
|
|
\fIzip\ 3.0\fP. You must use PKUNZIP 2.04g or
|
|
\fIunzip\ 5.0p1\fP (or later versions) to extract them.
|
|
.PP
|
|
See the \fBEXAMPLES\fP section at the bottom of this page
|
|
for examples of some typical uses of \fIzip\fP.
|
|
.PP
|
|
\fBLarge\ Archives\ and\ Zip64.\fP
|
|
.I zip
|
|
automatically uses the Zip64 extensions when files larger than 4 GB are
|
|
added to an archive, an archive containing 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 \fB\-fz\-\fP can
|
|
be used to force \fIzip\fP 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 \fIunzip\ 6.0\fP or later, to extract files
|
|
using the Zip64 extensions.
|
|
.PP
|
|
In addition, streamed archives, entries encrypted with standard encryption,
|
|
or split archives created with the pause option may not be compatible 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 \fIzip\fP uses).
|
|
|
|
.PP
|
|
\fBMac OS X.\fP Though previous Mac versions had their own \fIzip\fP port,
|
|
\fIzip\fP supports Mac OS X as part of the Unix port and most Unix features
|
|
apply. 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 \fIzip\fP release.
|
|
|
|
.PP
|
|
For a brief help on \fIzip\fP and \fIunzip\fP,
|
|
run each without specifying any parameters on the command line.
|
|
|
|
.SH "USE"
|
|
.PP
|
|
The program is useful for packaging a set of files for distribution;
|
|
for archiving files;
|
|
and for saving disk space by temporarily
|
|
compressing unused files or directories.
|
|
.LP
|
|
The
|
|
.I zip
|
|
program puts one or more compressed files into a single
|
|
.I zip
|
|
archive,
|
|
along with information about the files
|
|
(name, path, date, time of last modification, protection,
|
|
and check information to verify file integrity).
|
|
An entire directory structure can be packed into a
|
|
.I zip
|
|
archive with a single command.
|
|
Compression ratios of 2:1 to 3:1 are common for text files.
|
|
.I zip
|
|
has one compression method (deflation) and can also store files without
|
|
compression. (If \fBbzip2\fP support is added, \fIzip\fP can also
|
|
compress using \fBbzip2\fP compression, but such entries require a
|
|
reasonably modern unzip to decompress. When \fBbzip2\fP compression
|
|
is selected, it replaces deflation as the default method.)
|
|
.I zip
|
|
automatically chooses the better of the two (deflation or store or, if
|
|
\fBbzip2\fP is selected, \fBbzip2\fP or store) for each file to be
|
|
compressed.
|
|
.LP
|
|
\fBCommand\ format.\fP The basic command format is
|
|
.IP
|
|
\fBzip\fR options archive inpath inpath ...
|
|
.LP
|
|
where \fBarchive\fR is a new or existing \fIzip\fR archive
|
|
and \fBinpath\fR is a directory or file path optionally including wildcards.
|
|
When given the name of an existing
|
|
.I zip
|
|
archive,
|
|
.I zip
|
|
will replace identically named entries in the
|
|
.I zip
|
|
archive (matching the relative names as stored in
|
|
the archive) or add entries for new names.
|
|
For example,
|
|
if
|
|
.I foo.zip
|
|
exists and contains
|
|
.I foo/file1
|
|
and
|
|
.IR foo/file2 ,
|
|
and the directory
|
|
.I foo
|
|
contains the files
|
|
.I foo/file1
|
|
and
|
|
.IR foo/file3 ,
|
|
then:
|
|
.IP
|
|
\fCzip -r foo.zip foo\fP
|
|
.LP
|
|
or more concisely
|
|
.IP
|
|
\fCzip -r foo foo\fP
|
|
.LP
|
|
will replace
|
|
.I foo/file1
|
|
in
|
|
.I foo.zip
|
|
and add
|
|
.I foo/file3
|
|
to
|
|
.IR foo.zip .
|
|
After this,
|
|
.I foo.zip
|
|
contains
|
|
.IR foo/file1 ,
|
|
.IR foo/file2 ,
|
|
and
|
|
.IR foo/file3 ,
|
|
with
|
|
.I foo/file2
|
|
unchanged from before.
|
|
.LP
|
|
So if before the zip command is executed \fIfoo.zip\fP has:
|
|
.IP
|
|
\fC foo/file1 foo/file2
|
|
.LP
|
|
and directory foo has:
|
|
.IP
|
|
\fC file1 file3\fP
|
|
.LP
|
|
then \fIfoo.zip\fP will have:
|
|
.IP
|
|
\fC foo/file1 foo/file2 foo/file3\fP
|
|
.LP
|
|
where \fIfoo/file1\fP is replaced and
|
|
\fIfoo/file3\fP is new.
|
|
.LP
|
|
\fB\-@\ file\ lists.\fP If a file list is specified as
|
|
\fB\-@\fP
|
|
[Not on MacOS],
|
|
.I zip
|
|
takes the list of input files from standard input instead of from
|
|
the command line. For example,
|
|
.IP
|
|
\fCzip -@ foo\fP
|
|
.LP
|
|
will store the files listed one per line on stdin in \fIfoo.zip\fP.
|
|
.LP
|
|
Under Unix,
|
|
this option can be used to powerful effect in conjunction with the
|
|
\fIfind\fP\ (1)
|
|
command.
|
|
For example,
|
|
to archive all the C source files in the current directory and
|
|
its subdirectories:
|
|
.IP
|
|
\fCfind . -name "*.[ch]" -print | zip source -@\fP
|
|
.LP
|
|
(note that the pattern must be quoted to keep the shell from expanding it).
|
|
.LP
|
|
\fBStreaming\ input\ and\ output.\fP
|
|
.I 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:
|
|
.IP
|
|
\fCzip -r - . | dd of=/dev/nrst0 obs=16k\fP
|
|
.LP
|
|
would write the zip output directly to a tape with the specified block size
|
|
for the purpose of backing up the current directory.
|
|
.LP
|
|
.I zip
|
|
also accepts a single dash ("-") as the name of a file to be compressed, in
|
|
which case it will read the file from standard input, allowing zip to take
|
|
input from another program. For example:
|
|
.IP
|
|
\fCtar cf - . | zip backup -\fP
|
|
.LP
|
|
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
|
|
.I zip
|
|
can take advantage of redundancy between files. The backup can be restored
|
|
using the command
|
|
.IP
|
|
\fCunzip -p backup | tar xf -\fP
|
|
.LP
|
|
When no zip file name is given and stdout is not a terminal,
|
|
.I zip
|
|
acts as a filter, compressing standard input to standard output.
|
|
For example,
|
|
.IP
|
|
\fCtar cf - . | zip | dd of=/dev/nrst0 obs=16k\fP
|
|
.LP
|
|
is equivalent to
|
|
.IP
|
|
\fCtar cf - . | zip - - | dd of=/dev/nrst0 obs=16k\fP
|
|
.LP
|
|
.I zip
|
|
archives created in this manner can be extracted with the program
|
|
.I funzip
|
|
which is provided in the
|
|
.I unzip
|
|
package, or by
|
|
.I gunzip
|
|
which is provided in the
|
|
.I gzip
|
|
package (but some
|
|
.I gunzip
|
|
may not support this if
|
|
.I zip
|
|
used the Zip64 extensions). For example:
|
|
.IP
|
|
\fPdd if=/dev/nrst0 ibs=16k | funzip | tar xvf -\fC
|
|
.LP
|
|
The stream can also be saved to a file and
|
|
.I unzip
|
|
used.
|
|
.LP
|
|
If Zip64 support for large files and archives is enabled and
|
|
\fIzip\fR is used as a filter, \fIzip\fR 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 \fB\-fz\-\fP can be used to prevent use of Zip64,
|
|
but \fIzip\fP will exit with an error if Zip64 was in fact needed.
|
|
\fIzip\ 3\fR and \fIunzip\ 6\fR and later can read archives with Zip64
|
|
entries. Also, \fIzip\fP removes the Zip64 extensions if not needed
|
|
when archive entries are copied (see the \fB\-U\fP (\fB\-\-copy\fP)
|
|
option).
|
|
.LP
|
|
When directing the output to another file, note that all options should be
|
|
before the redirection including \fB-x\fP. For example:
|
|
.IP
|
|
\fPzip archive "*.h" "*.c" -x donotinclude.h orthis.h > tofile\fC
|
|
.LP
|
|
\fBZip\ files.\fP When changing an existing
|
|
.I zip
|
|
archive,
|
|
.I 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.
|
|
.LP
|
|
If the name of the
|
|
.I zip
|
|
archive does not contain an extension, the extension
|
|
\fB.zip\fP
|
|
is added. If the name already contains an extension other than
|
|
\fB.zip\fP,
|
|
the existing extension is kept unchanged. However, split archives
|
|
(archives split over multiple files) require the \fB.zip\fP extension
|
|
on the last split.
|
|
.PP
|
|
\fBScanning\ and\ reading\ files.\fP
|
|
When \fIzip\fP starts, it scans for files to process (if needed). If
|
|
this scan takes longer than about 5 seconds, \fIzip\fP 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 updating an existing
|
|
archive, a space also appears between the existing file scan and the new
|
|
file scan.) The scanning files dots are not controlled by the \fB\-ds\fP
|
|
dot size option, but the dots are turned off by the \fB\-q\fP quiet option. The
|
|
\fB\-sf\fP show files option can be used to scan for files and get the list of
|
|
files scanned without actually processing them.
|
|
.LP
|
|
If \fIzip\fR is not able to read a file, it
|
|
issues a warning but
|
|
continues. See the \fB\-MM\fP option below for more on how \fIzip\fP 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.
|
|
.PP
|
|
\fBCommand\ modes.\fP \fIzip\fP now supports two distinct types of command
|
|
modes, \fBexternal\fP and \fBinternal\fP. The \fBexternal\fP modes
|
|
(add, update, and freshen) read files from the file system (as well as from an
|
|
existing archive) while the \fBinternal\fP modes (delete and copy) operate
|
|
exclusively on entries in an existing archive.
|
|
.LP
|
|
.TP
|
|
.BI add\ \ \ \ \ \
|
|
Update existing entries and add new files. If the archive does not exist
|
|
create it. This is the default mode.
|
|
.TP
|
|
.BI update\ \fP(\fB\-u\fP)
|
|
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.
|
|
.TP
|
|
.BI freshen\ \fP(\fB\-f\fP)
|
|
Update existing entries of an archive if newer on the file system.
|
|
Does not add new files to the archive.
|
|
.TP
|
|
.BI delete\ \fP(\fB\-d\fP)
|
|
Select entries in an existing archive and delete them.
|
|
.TP
|
|
.BI copy\ \fP(\fB\-U\fP)
|
|
Select entries in an existing archive and copy them to a new archive.
|
|
This new mode is similar to \fBupdate\fP but command line patterns
|
|
select entries in the existing archive rather than files from
|
|
the file system and it uses the \fB\-\-out\fP option to write the
|
|
resulting archive to a new file rather than update the existing
|
|
archive, leaving the original archive unchanged.
|
|
.LP
|
|
The new File Sync option (\fB\-FS\fP) is also considered a new mode,
|
|
though it is similar to \fBupdate\fP. 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 entries 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 \fB\-DF\fP for creating difference archives.
|
|
|
|
See each option description below for details and the \fBEXAMPLES\fP section
|
|
below for examples.
|
|
.PP
|
|
\fBSplit\ archives.\fP \fIzip\fP version 3.0 and later can create split
|
|
archives. A
|
|
\fBsplit archive\fP 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. Concatenating the pieces together will invalidate these offsets,
|
|
but \fIunzip\fP can usually deal with it. \fIzip\fP will usually refuse
|
|
to process such a spliced archive unless the \fB\-FF\fP fix option is
|
|
used to fix the offsets.)
|
|
.LP
|
|
One use of split archives is storing a large archive on multiple
|
|
removable media.
|
|
For a split archive with 20 split files the files are typically named (replace
|
|
ARCHIVE with the name of your archive) ARCHIVE.z01, ARCHIVE.z02, ..., ARCHIVE.z19,
|
|
ARCHIVE.zip. Note that the last file is the \fB.zip\fP file. In contrast,
|
|
\fBspanned archives\fP are the original multi-disk archive generally requiring
|
|
floppy disks and using volume labels to store disk numbers. \fIzip\fP 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.
|
|
.LP
|
|
Use \fB\-s\fP 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 \fB\-sp\fP option can be used to pause \fIzip\fP between
|
|
splits to allow changing removable media, for example, but read the descriptions
|
|
and warnings for both \fB\-s\fP and \fB\-sp\fP below.
|
|
.LP
|
|
Though \fIzip\fP does not update split archives, \fIzip\fP provides the new
|
|
option \fB\-O\fP (\fB\-\-output\-file\fP or \fB\-\-out\fP) to allow split archives
|
|
to be updated and saved in a new archive. For example,
|
|
.IP
|
|
\fCzip inarchive.zip foo.c bar.c \-\-out outarchive.zip\fP
|
|
.LP
|
|
reads archive \fBinarchive.zip\fP, even if split, adds the files \fBfoo.c\fP and
|
|
\fBbar.c\fP, and writes the resulting archive to \fBoutarchive.zip\fP. If
|
|
\fBinarchive.zip\fP is split then \fBoutarchive.zip\fP defaults to the same
|
|
split size. Be aware that if \fBoutarchive.zip\fP 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.
|
|
.PP
|
|
\fBUnicode.\fP 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 support wide characters, \fIzip\fP 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 represented in
|
|
the local character set, it's possible that some paths will be skipped during a
|
|
local character set directory scan. \fIzip\fP with Unicode support now can read
|
|
and store these paths. Note that Win 9x systems 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.
|
|
.PP
|
|
\fBCommand line format.\fP This version of
|
|
.I zip
|
|
has updated command line processing and support for long options.
|
|
.PP
|
|
Short options take the form
|
|
.IP
|
|
\fC-s[-][s[-]...][value][=value][\ value]\fP
|
|
.LP
|
|
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
|
|
.IP
|
|
\fC-s[-][value][=value][\ value]\ -s[-][value][=value][\ value]\ ...\fP
|
|
.LP
|
|
Short options in general take values either as part of the same
|
|
argument or as the following argument. An optional = is also supported.
|
|
So
|
|
.IP
|
|
\fC-ttmmddyyyy\fP
|
|
.LP
|
|
and
|
|
.IP
|
|
\fC-tt=mmddyyyy\fP
|
|
.LP
|
|
and
|
|
.IP
|
|
\fC-tt mmddyyyy\fP
|
|
.LP
|
|
all work. The \fB\-x\fP and \fB\-i\fP options accept lists of values
|
|
and use a slightly different format described below. See the
|
|
\fB\-x\fP and \fB\-i\fP options.
|
|
.PP
|
|
Long options take the form
|
|
.IP
|
|
\fC--longoption[-][=value][ value]\fP
|
|
.LP
|
|
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
|
|
.IP
|
|
\fC--before-date=mmddyyyy\fP
|
|
.LP
|
|
and
|
|
.IP
|
|
\fC--before-date mmddyyyy\fP
|
|
.LP
|
|
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 consider
|
|
a trailing dash, such as for the option \fB\-\-some\-option\fP using
|
|
\fB\-\-some\-\fP as the option, as part of the name rather
|
|
than a negating dash). This may be changed to force the last
|
|
dash in \fB\-\-some\-\fP to be negating in the future.
|
|
.SH "OPTIONS"
|
|
.TP
|
|
.PD 0
|
|
.BI \-a
|
|
.TP
|
|
.PD
|
|
.B \-\-ascii
|
|
[Systems using EBCDIC] Translate file to ASCII format.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-A
|
|
.TP
|
|
.PD
|
|
.B \-\-adjust-sfx
|
|
Adjust self-extracting executable archive.
|
|
A self-extracting executable archive is created by prepending
|
|
the SFX stub to an existing archive. The
|
|
.B \-A
|
|
option tells
|
|
.I zip
|
|
to adjust the entry offsets stored
|
|
in the archive to take into account this "preamble" data.
|
|
.LP
|
|
Note: self-extracting archives for the Amiga are a special case.
|
|
At present, only the Amiga port of \fIzip\fP 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.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-AC
|
|
.TP
|
|
.PD
|
|
.B \-\-archive-clear
|
|
[WIN32] Once archive is created (and tested if \fB\-T\fP is used,
|
|
which is recommended), clear the archive bits of files processed. WARNING:
|
|
Once the bits are cleared they are cleared. You may want to use the
|
|
\fB\-sf\fP show files option to store the list of files processed in case
|
|
the archive operation must be repeated. Also consider using
|
|
the \fB\-MM\fP must match option. Be sure to check out \fB\-DF\fP as a
|
|
possibly better way to do incremental backups.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-AS
|
|
.TP
|
|
.PD
|
|
.B \-\-archive-set
|
|
[WIN32] Only include files that have the archive bit set. Directories
|
|
are not stored when \fB\-AS\fP 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 \fB\-AC\fP, \fB\-AS\fP 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. Alternative
|
|
ways to create incremental backups are using \fB\-t\fP to use file dates,
|
|
though this won't catch old files copied to directories being archived,
|
|
and \fB\-DF\fP to create a differential archive.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-B
|
|
.TP
|
|
.PD
|
|
.B \-\-binary
|
|
[VM/CMS and MVS] force file to be read binary (default is text).
|
|
|
|
.TP
|
|
.B \-B\fRn
|
|
[TANDEM] set Edit/Enscribe formatting options with n defined as
|
|
.RS
|
|
bit 0: Don't add delimiter (Edit/Enscribe)
|
|
.RE
|
|
.RS
|
|
bit 1: Use LF rather than CR/LF as delimiter (Edit/Enscribe)
|
|
.RE
|
|
.RS
|
|
bit 2: Space fill record to maximum record length (Enscribe)
|
|
.RE
|
|
.RS
|
|
bit 3: Trim trailing space (Enscribe)
|
|
.RE
|
|
.RS
|
|
bit 8: Force 30K (Expand) large read for unstructured files
|
|
.RE
|
|
|
|
.TP
|
|
.PD 0
|
|
.BI \-b\ \fRpath
|
|
.TP
|
|
.PD
|
|
.B \-\-temp-path\ \fRpath
|
|
Use the specified
|
|
.I path
|
|
for the temporary
|
|
.I zip
|
|
archive. For example:
|
|
.RS
|
|
.IP
|
|
\fCzip -b /tmp stuff *\fP
|
|
.RE
|
|
.IP
|
|
will put the temporary
|
|
.I zip
|
|
archive in the directory
|
|
.IR /tmp ,
|
|
copying over
|
|
.I stuff.zip
|
|
to the current directory when done. This option 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 \fIzip\fP take additional time to copy
|
|
the archive file when done to the destination file system.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-c
|
|
.TP
|
|
.PD
|
|
.B \-\-entry-comments
|
|
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.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-C
|
|
.TP
|
|
.PD
|
|
.B \-\-preserve-case
|
|
[VMS] Preserve case all on VMS. Negating this option
|
|
(\fB\-C-\fP) downcases.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-C2
|
|
.TP
|
|
.PD
|
|
.BI \-\-preserve-case-2
|
|
[VMS] Preserve case ODS2 on VMS. Negating this option
|
|
(\fB\-C2-\fP) downcases.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-C5
|
|
.TP
|
|
.PD
|
|
.B \-\-preserve-case-5
|
|
[VMS] Preserve case ODS5 on VMS. Negating this option
|
|
(\fB\-C5-\fP) downcases.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-d
|
|
.TP
|
|
.PD
|
|
.B \-\-delete
|
|
Remove (delete) entries from a
|
|
.I zip
|
|
archive.
|
|
For example:
|
|
.RS
|
|
.IP
|
|
\fCzip -d foo foo/tom/junk foo/harry/\\* \\*.o\fP
|
|
.RE
|
|
.IP
|
|
will remove the entry
|
|
.IR foo/tom/junk ,
|
|
all of the files that start with
|
|
.IR foo/harry/ ,
|
|
and all of the files that end with
|
|
.B \&.o
|
|
(in any path).
|
|
Note that shell pathname expansion has been inhibited with backslashes,
|
|
so that
|
|
.I zip
|
|
can see the asterisks,
|
|
enabling
|
|
.I zip
|
|
to match on the contents of the
|
|
.I 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
|
|
.RS
|
|
.IP
|
|
\fCzip -d foo foo/tom/junk "foo/harry/*" "*.o"\fP
|
|
.RE
|
|
.IP
|
|
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.
|
|
.IP
|
|
Under MSDOS,
|
|
.B \-d
|
|
is case sensitive when it matches names in the
|
|
.I zip
|
|
archive.
|
|
This requires that file names be entered in upper case if they were
|
|
zipped by PKZIP on an MSDOS system. (We considered 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 \fBBar\fP and \fBbar\fP
|
|
as separate files in the archive.) But see the new option \fB\-ic\fP
|
|
to ignore case in the archive.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-db
|
|
.TP
|
|
.PD
|
|
.B \-\-display-bytes
|
|
Display running byte counts showing the bytes zipped and the bytes to go.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-dc
|
|
.TP
|
|
.PD
|
|
.B \-\-display-counts
|
|
Display running count of entries zipped and entries to go.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-dd
|
|
.TP
|
|
.PD
|
|
.B \-\-display-dots
|
|
Display dots while each entry is zipped (except on ports that have their own
|
|
progress indicator). See \fB-ds\fR below for setting dot size. The default is
|
|
a dot every 10 MB of input file processed. The \fB-v\fR option
|
|
also displays dots (previously at a much higher rate than this but now \fB\-v\fP
|
|
also defaults to 10 MB) and this rate is also controlled by \fB-ds\fR.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-df
|
|
.TP
|
|
.PD
|
|
.B \-\-datafork
|
|
[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.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-dg
|
|
.TP
|
|
.PD
|
|
.B \-\-display-globaldots
|
|
Display progress dots for the archive instead of for each file. The command
|
|
.RS
|
|
.IP
|
|
zip -qdgds 10m
|
|
.RE
|
|
.IP
|
|
will turn off most output except dots every 10 MB.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-ds\ \fRsize
|
|
.TP
|
|
.PD
|
|
.B \-\-dot-size\ \fRsize
|
|
Set amount of input file processed for each dot displayed. See \fB-dd\fR to
|
|
enable displaying dots. Setting this option implies \fB-dd\fR. Size is
|
|
in the format nm where n is a number and m is a multiplier. 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.
|
|
.IP
|
|
The \fB-v\fR 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.
|
|
.IP
|
|
This option does not control the dots from the "Scanning files" message as
|
|
\fIzip\fP scans for input files. The dot size for that is fixed at 2 seconds
|
|
or a fixed number of entries, whichever is longer.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-du
|
|
.TP
|
|
.PD
|
|
.B \-\-display-usize
|
|
Display the uncompressed size of each entry.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-dv
|
|
.TP
|
|
.PD
|
|
.B \-\-display-volume
|
|
Display the volume (disk) number each entry is being read from,
|
|
if reading an existing archive, and being written to.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-D
|
|
.TP
|
|
.PD
|
|
.B \-\-no-dir-entries
|
|
Do not create entries in the
|
|
.I 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:
|
|
.RS
|
|
.IP
|
|
ZIPOPT="-D"; export ZIPOPT
|
|
.RE
|
|
.IP
|
|
(The variable ZIPOPT can be used for any option, including \fB\-i\fP and \fB\-x\fP
|
|
using a new option format detailed below, and can include several options.) The option
|
|
.B \-D
|
|
is a shorthand
|
|
for
|
|
.B \-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.
|
|
.IP
|
|
This version of
|
|
.I zip
|
|
does allow
|
|
.B \-x
|
|
and
|
|
.B \-i
|
|
options in ZIPOPT if the form
|
|
.IP
|
|
\fC
|
|
.BR \-x \ file\ file\ ... \ @\fP
|
|
.IP
|
|
is used, where the @ (an argument that is just @) terminates
|
|
the list.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-DF
|
|
.TP
|
|
.PD
|
|
.B \-\-difference-archive
|
|
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 \fIzip\fP operation.
|
|
.IP
|
|
For example, if the existing archive was created using
|
|
.RS
|
|
.IP
|
|
\fCzip -r foofull .
|
|
.RE
|
|
.IP
|
|
from the \fIbar\fP directory, then the command
|
|
.RS
|
|
.IP
|
|
\fCzip -r foofull . -DF --out foonew
|
|
.RE
|
|
.IP
|
|
also from the \fIbar\fP directory creates the archive \fIfoonew\fP
|
|
with just the files not in \fIfoofull\fP and the files where
|
|
the size or file time of the files do not match those in \fIfoofull\fP.
|
|
|
|
Note that the timezone environment variable TZ should be set according 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 included.
|
|
|
|
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.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-e
|
|
.TP
|
|
.PD
|
|
.B \-\-encrypt
|
|
Encrypt the contents of the
|
|
.I 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,
|
|
.I zip
|
|
will exit with an error).
|
|
The password prompt is repeated to save the user from typing errors.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-E
|
|
.TP
|
|
.PD
|
|
.B \-\-longnames
|
|
[OS/2] Use the .LONGNAME Extended Attribute (if found) as filename.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-f
|
|
.TP
|
|
.PD
|
|
.B \-\-freshen
|
|
Replace (freshen) an existing entry in the
|
|
.I zip
|
|
archive only if it has been modified more recently than the
|
|
version already in the
|
|
.I zip
|
|
archive;
|
|
unlike the update option
|
|
.RB ( \-u )
|
|
this will not add files that are not already in the
|
|
.I zip
|
|
archive.
|
|
For example:
|
|
.RS
|
|
.IP
|
|
\fCzip -f foo\fP
|
|
.RE
|
|
.IP
|
|
This command should be run from the same directory from which the original
|
|
.I zip
|
|
command was run, since paths stored in
|
|
.I zip
|
|
archives are always relative.
|
|
.IP
|
|
Note that the timezone environment variable TZ should be set according to
|
|
the local timezone in order for the
|
|
\fB\-f\fP, \fB\-u\fP and \fB\-o\fP
|
|
options to work correctly.
|
|
.IP
|
|
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).
|
|
.IP
|
|
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.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-F
|
|
.TP
|
|
.B \-\-fix\ \ \ \ \ \
|
|
.TP
|
|
.B \-FF
|
|
.TP
|
|
.PD
|
|
.B \-\-fixfix\ \
|
|
Fix the
|
|
.I zip
|
|
archive. The \fB\-F\fP 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 \fIzip\fP will ignore
|
|
some problems. The resulting archive should be valid, but any
|
|
inconsistent entries will be left out.
|
|
.IP
|
|
When doubled as in
|
|
\fB\-FF\fP,
|
|
the archive is scanned from the beginning and \fIzip\fP scans for special
|
|
signatures to identify the limits between the archive members. The
|
|
single
|
|
.B \-F
|
|
is more reliable if the archive is not too much damaged, so try this
|
|
option first.
|
|
.IP
|
|
If the archive is too damaged or the end has been truncated, you
|
|
must use \fB\-FF\fP. This is a change from \fIzip\ 2.32\fP, where
|
|
the \fB\-F\fP option is able to read a truncated archive. The
|
|
\fB\-F\fP option now more reliably fixes archives with minor
|
|
damage and the \fB\-FF\fP option is needed to fix archives where
|
|
\fB\-F\fP might have been sufficient before.
|
|
.IP
|
|
Neither option will recover archives that have been incorrectly
|
|
transferred in ascii mode instead of binary. After the repair, the
|
|
.B \-t
|
|
option of
|
|
.I unzip
|
|
may show that some files have a bad CRC. Such files cannot be recovered;
|
|
you can remove them from the archive using the
|
|
.B \-d
|
|
option of
|
|
\fIzip\fP.
|
|
.IP
|
|
Note that \fB\-FF\fP 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 entries in the embedded
|
|
archive rather than the archive itself. Try \fB\-F\fP first as it
|
|
does not have this problem.
|
|
.IP
|
|
The format of the fix commands have changed. For example, to fix
|
|
the damaged archive \fIfoo.zip\fP,
|
|
.RS
|
|
.IP
|
|
\fCzip -F foo --out foofix
|
|
.RE
|
|
.IP
|
|
tries to read the entries normally, copying good entries to the
|
|
new archive \fIfoofix.zip\fP. If this doesn't work, as when the
|
|
archive is truncated, or if some entries you know are in the archive
|
|
are missed, then try
|
|
.RS
|
|
.IP
|
|
\fCzip -FF foo --out foofixfix
|
|
.RE
|
|
.IP
|
|
and compare the resulting archive to the archive created by \fB\-F\fP. The
|
|
\fB\-FF\fP option may create an inconsistent archive. Depending on
|
|
what is damaged, you can then use the \fB\-F\fP option to fix that archive.
|
|
.IP
|
|
A split archive with missing split files can be fixed using
|
|
\fB\-F\fP if you have the last split of the archive (the \fB\.zip\fP file).
|
|
If this file is missing, you must use \fB\-FF\fP to fix the archive,
|
|
which will prompt you for the splits you have.
|
|
.IP
|
|
Currently the fix options can't recover entries that have a bad checksum
|
|
or are otherwise damaged.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-FI
|
|
.TP
|
|
.PD
|
|
.B \-\-fifo
|
|
[Unix] Normally \fIzip\fP skips reading any FIFOs (named pipes) encountered, as
|
|
\fIzip\fP can hang if the FIFO is not being fed. This option tells \fIzip\fP to
|
|
read the contents of any FIFO it finds.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-FS
|
|
.TP
|
|
.PD
|
|
.B \-\-filesync
|
|
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 being 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 \fB\-FS\fP can be much faster than creating a new archive. Also
|
|
consider using \fB\-u\fP for updating an archive.
|
|
.IP
|
|
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.
|
|
.IP
|
|
Note that the timezone environment variable TZ should be set according 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.
|
|
.IP
|
|
This option deletes files from the archive. If you need to preserve
|
|
the original archive, make a copy of the archive first or use the
|
|
\fB\-\-out\fP 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.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-g
|
|
.TP
|
|
.PD
|
|
.B \-\-grow \ \ \ \ \ \
|
|
Grow (append to) the specified
|
|
.I zip
|
|
archive, instead of creating a new one. If this operation fails,
|
|
.I zip
|
|
attempts to restore the archive to its original state. If the restoration
|
|
fails, the archive might become corrupted. This option is ignored when
|
|
there's no existing archive or when at least one archive member must be
|
|
updated or deleted.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-h
|
|
.TP
|
|
.PD 0
|
|
.B \-?
|
|
.TP
|
|
.PD
|
|
.B \-\-help \ \ \ \ \ \
|
|
Display the
|
|
.I zip
|
|
help information (this also appears if
|
|
.I zip
|
|
is run with no arguments).
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-h2
|
|
.TP
|
|
.PD
|
|
.B \-\-more-help
|
|
Display extended help including more on command line format, pattern matching, and
|
|
more obscure options.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-i\ \fRfiles
|
|
.TP
|
|
.PD
|
|
.B \-\-include\ \fRfiles
|
|
Include only the specified files, as in:
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo . -i \\*.c\fP
|
|
.RE
|
|
.IP
|
|
which will include only the files that end in
|
|
.IR \& .c
|
|
in the current directory and its subdirectories. (Note for PKZIP
|
|
users: the equivalent command is
|
|
.RS
|
|
.IP
|
|
\fCpkzip -rP foo *.c\fP
|
|
.RE
|
|
.IP
|
|
PKZIP does not allow recursion in directories other than the current one.)
|
|
The backslash avoids the shell filename substitution, so that the
|
|
name matching is performed by
|
|
.I zip
|
|
at all directory 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
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo . -i *.c\fP
|
|
.RE
|
|
.IP
|
|
Examples are for Unix unless otherwise specified.] So to include dir,
|
|
a directory directly under the current directory, use
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo . -i dir/\\*
|
|
.RE
|
|
.IP
|
|
or
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo . -i "dir/*"
|
|
.RE
|
|
.IP
|
|
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
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo . -i dir/*
|
|
.RE
|
|
.IP
|
|
is used.] Note that currently the trailing / is needed
|
|
for directories (as in
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo . -i dir/
|
|
.RE
|
|
.IP
|
|
to include directory dir).
|
|
.IP
|
|
The long option form of the first example is
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo . --include \\*.c
|
|
.RE
|
|
.IP
|
|
and does the same thing as the short option form.
|
|
.IP
|
|
Though the command syntax used to require \fB-i\fR at
|
|
the end of the command line, this version actually
|
|
allows \fB\-i\fP (or \fB\-\-include\fP) anywhere. The
|
|
list of files terminates at the next argument starting
|
|
with \fB-\fR, the end of the command line, or the list
|
|
terminator \fB@\fR (an argument that is just @). So
|
|
the above can be given as
|
|
.RS
|
|
.IP
|
|
zip -i \\*.c @ -r foo .\fP
|
|
.RE
|
|
.IP
|
|
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
|
|
.RS
|
|
.IP
|
|
\fCzip -i\\*.c -r foo .\fP
|
|
.RE
|
|
.IP
|
|
(no space between option and value) or
|
|
.RS
|
|
.IP
|
|
\fCzip --include=\\*.c -r foo .\fP
|
|
.RE
|
|
.IP
|
|
as additional examples. The single value forms are
|
|
not recommended because they can be confusing and,
|
|
in particular, the \fB\-ifile\fP format can cause
|
|
problems if the first letter of \fBfile\fP combines with
|
|
\fBi\fP to form a two-letter option starting with
|
|
\fBi\fP. Use \fB\-sc\fP to see how your command line
|
|
will be parsed.
|
|
.IP
|
|
Also possible:
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo . -i@include.lst\fP
|
|
.RE
|
|
.IP
|
|
which will only include the files in the current directory and its
|
|
subdirectories that match the patterns in the file include.lst.
|
|
.IP
|
|
Files to \fB\-i\fR and \fB\-x\fR are patterns matching internal archive paths. See
|
|
\fB-R\fR for more on patterns.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-I
|
|
.TP
|
|
.PD
|
|
.B \-\-no-image
|
|
[Acorn RISC OS] Don't scan through Image files. When used, \fIzip\fP will not
|
|
consider Image files (eg. DOS partitions or Spark archives when SparkFS
|
|
is loaded) as directories but will store them as single files.
|
|
|
|
For example, if you have SparkFS loaded, zipping a Spark archive will result
|
|
in a zipfile containing a directory (and its content) while using the 'I'
|
|
option will result in a zipfile containing a Spark archive. Obviously this
|
|
second case will also be obtained (without the 'I' option) if SparkFS isn't
|
|
loaded.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-ic
|
|
.TP
|
|
.PD
|
|
.B \-\-ignore-case
|
|
[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 similar 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 \fB\-ic\fR option makes all matching case insensitive.
|
|
This can result in multiple archive entries matching a command line pattern.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-j
|
|
.TP
|
|
.PD
|
|
.B \-\-junk-paths
|
|
Store just the name of a saved file (junk the path), and do not store
|
|
directory names. By default,
|
|
.I zip
|
|
will store the full path (relative to the current directory).
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-jj
|
|
.TP
|
|
.PD
|
|
.B \-\-absolute-path
|
|
[MacOS] record Fullpath (+ Volname). The complete path including
|
|
volume will be stored. By default the relative path will be stored.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-J
|
|
.TP
|
|
.PD
|
|
.B \-\-junk-sfx
|
|
Strip any prepended data (e.g. a SFX stub) from the archive.
|
|
.TP
|
|
.PD 0
|
|
.B \-k
|
|
.TP
|
|
.PD
|
|
.B \-\-DOS-names
|
|
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.
|
|
.TP
|
|
.PD 0
|
|
.B \-l
|
|
.TP
|
|
.PD
|
|
.B \-\-to-crlf
|
|
Translate the Unix end-of-line character LF into the
|
|
MSDOS convention 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
|
|
\fBunzip -a\fP
|
|
on Unix will get back an exact copy of the original file,
|
|
to undo the effect of
|
|
\fBzip -l\fP. See \fB-ll\fR for how binary files are handled.
|
|
.TP
|
|
.PD 0
|
|
.B \-la
|
|
.TP
|
|
.PD
|
|
.B \-\-log-append
|
|
Append to existing logfile. Default is to overwrite.
|
|
.TP
|
|
.PD 0
|
|
.B \-lf\ \fPlogfilepath
|
|
.TP
|
|
.PD
|
|
.B \-\-logfile-path\ \fPlogfilepath
|
|
Open a logfile at the given path. By default any existing file at that location
|
|
is overwritten, but the \fB\-la\fP option will result in an existing file being
|
|
opened and the new log information appended to any existing information.
|
|
Only warnings and errors are written to the log unless the \fB\-li\fP option is
|
|
also given, then all information messages are also written to the log.
|
|
.TP
|
|
.PD 0
|
|
.B \-li
|
|
.TP
|
|
.PD
|
|
.B \-\-log-info
|
|
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.
|
|
.TP
|
|
.PD 0
|
|
.B \-ll
|
|
.TP
|
|
.PD
|
|
.B \-\-from-crlf
|
|
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 \fB-ll\fR detects binary in the first buffer
|
|
read from a file, \fIzip\fR 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 algorithm
|
|
is now being used for binary detection that should allow line end conversion
|
|
of text files in \fBUTF-8\fR and similar encodings.
|
|
.TP
|
|
.PD 0
|
|
.B \-L
|
|
.TP
|
|
.PD
|
|
.B \-\-license
|
|
Display the
|
|
.I zip
|
|
license.
|
|
.TP
|
|
.PD 0
|
|
.B \-m
|
|
.TP
|
|
.PD
|
|
.B \-\-move \ \ \
|
|
Move the specified files into the
|
|
.I zip
|
|
archive; actually,
|
|
this deletes the target directories/files after making the specified
|
|
.I zip
|
|
archive. If a directory becomes empty after removal of the files, the
|
|
directory is also removed. No deletions are done until
|
|
.I 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
|
|
.B \-T
|
|
to test the archive before removing all input files.
|
|
.TP
|
|
.PD 0
|
|
.B \-MM
|
|
.TP
|
|
.PD
|
|
.B \-\-must-match
|
|
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
|
|
.I zip
|
|
continues creating the archive, with missing or unreadable new files
|
|
being skipped and files already in the archive remaining unchanged.
|
|
After the archive is created, if any files were not readable
|
|
.I zip
|
|
returns the OPEN error code (18 on most systems) instead of the normal
|
|
success return (0 on most systems). With \fB\-MM\fP set,
|
|
.I 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 \fIzip\fR exits with an OPEN error
|
|
and no archive is created.
|
|
.IP
|
|
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 \fIzip\fR 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
|
|
.B \-MM
|
|
and just check the return code. Also \fB\-lf\fP could be useful.
|
|
.TP
|
|
.PD 0
|
|
.BI \-n\ \fRsuffixes
|
|
.TP
|
|
.PD
|
|
.B \-\-suffixes\ \fRsuffixes
|
|
Do not attempt to compress files named with the given
|
|
\fBsuffixes\fR.
|
|
Such files are simply stored (0% compression) in the output zip file,
|
|
so that
|
|
.I zip
|
|
doesn't waste its time trying to compress them.
|
|
The suffixes are separated by
|
|
either colons or semicolons. For example:
|
|
.RS
|
|
.IP
|
|
\fCzip -rn .Z:.zip:.tiff:.gif:.snd foo foo\fP
|
|
.RE
|
|
.IP
|
|
will copy everything from
|
|
.I foo
|
|
into
|
|
.IR foo.zip ,
|
|
but will store any files that end in
|
|
.IR .Z ,
|
|
.IR .zip ,
|
|
.IR .tiff ,
|
|
.IR .gif ,
|
|
or
|
|
.I .snd
|
|
without trying to compress them
|
|
(image and sound files often have their own specialized compression methods).
|
|
By default,
|
|
.I zip
|
|
does not compress files with extensions in the list
|
|
.I .Z:.zip:.zoo:.arc:.lzh:.arj.
|
|
Such files are stored directly in the output archive.
|
|
The environment variable ZIPOPT can be used to change the default options. For
|
|
example under Unix with csh:
|
|
.RS
|
|
.IP
|
|
setenv ZIPOPT "-n .gif:.zip"
|
|
.RE
|
|
.IP
|
|
To attempt compression on all files, use:
|
|
.RS
|
|
.IP
|
|
zip -n : foo
|
|
.RE
|
|
.IP
|
|
The maximum compression option
|
|
.B \-9
|
|
also attempts compression on all files regardless of extension.
|
|
.IP
|
|
On Acorn RISC OS systems the suffixes are actually filetypes (3 hex digit
|
|
format). By default, \fIzip\fP does not compress files with filetypes in the list
|
|
DDC:D96:68E (i.e. Archives, CFS files and PackDir files).
|
|
.TP
|
|
.PD 0
|
|
.B \-nw
|
|
.TP
|
|
.PD
|
|
.B \-\-no-wild
|
|
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 wildcard substitution is desired.
|
|
.TP
|
|
.PD 0
|
|
.B \-N
|
|
.TP
|
|
.PD
|
|
.B \-\-notes
|
|
[Amiga, MacOS] Save Amiga or MacOS filenotes as zipfile comments. They can be
|
|
restored by using the -N option of \fIunzip\fP. If -c is used also, you are
|
|
prompted for comments only for those files that do not have filenotes.
|
|
.TP
|
|
.PD 0
|
|
.B \-o
|
|
.TP
|
|
.PD
|
|
.B \-\-latest-time
|
|
Set the "last modified" time of the
|
|
.I zip
|
|
archive to the latest (oldest) "last modified" time
|
|
found among the entries in the
|
|
.I zip
|
|
archive.
|
|
This can be used without any other operations, if desired.
|
|
For example:
|
|
.IP
|
|
\fCzip -o foo\fP
|
|
.IP
|
|
will change the last modified time of
|
|
\fBfoo.zip\fP
|
|
to the latest time of the entries in
|
|
.BR foo.zip .
|
|
.TP
|
|
.PD 0
|
|
.B \-O \fPoutput-file
|
|
.TP
|
|
.PD
|
|
.B \-\-output-file \fPoutput-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 archive 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 \fB\-U\fP to copy entries from an existing archive to a new
|
|
archive. See the \fBEXAMPLES\fP section below.
|
|
|
|
Another use is converting \fIzip\fP files from one split size to another. For instance,
|
|
to convert an archive with 700 MB CD splits to one with 2 GB DVD splits, can use:
|
|
.RS
|
|
.IP
|
|
zip -s 2g cd-split.zip --out dvd-split.zip
|
|
.RE
|
|
.IP
|
|
which uses copy mode. See \fB\-U\fP below. Also:
|
|
.RS
|
|
.IP
|
|
zip -s 0 split.zip --out unsplit.zip
|
|
.RE
|
|
.IP
|
|
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 entries (which should
|
|
be compatible
|
|
with all unzips), except if standard encryption was used. For archives
|
|
with encrypted entries, \fIzipcloak\fP will decrypt the entries and convert
|
|
them to normal entries.
|
|
.TP
|
|
.PD 0
|
|
.B \-p
|
|
.TP
|
|
.PD
|
|
.B \-\-paths
|
|
Include relative file paths as part of the names of files stored in the archive.
|
|
This is the default. The \fB\-j\fP option junks the paths and just stores the
|
|
names of the files.
|
|
.TP
|
|
.PD 0
|
|
.B \-P\ \fRpassword
|
|
.TP
|
|
.PD
|
|
.B \-\-password\ \fRpassword
|
|
Use \fIpassword\fP to encrypt zipfile entries (if any). \fBTHIS IS
|
|
INSECURE!\fP 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 passwords.
|
|
(And where security is truly important, use strong encryption such as Pretty
|
|
Good Privacy instead of the relatively weak standard encryption provided by
|
|
zipfile utilities.)
|
|
.TP
|
|
.PD 0
|
|
.B \-q
|
|
.TP
|
|
.PD
|
|
.B \-\-quiet
|
|
Quiet mode;
|
|
eliminate informational messages and comment prompts.
|
|
(Useful, for example, in shell scripts and background tasks).
|
|
.TP
|
|
.PD 0
|
|
.BI \-Q\fRn
|
|
.TP
|
|
.PD
|
|
.B \-\-Q\-flag\ \fRn
|
|
[QDOS] store information about the file in the file header with n defined as
|
|
.RS
|
|
bit 0: Don't add headers for any file
|
|
.RE
|
|
.RS
|
|
bit 1: Add headers for all files
|
|
.RE
|
|
.RS
|
|
bit 2: Don't wait for interactive key press on exit
|
|
.RE
|
|
.TP
|
|
.PD 0
|
|
.B \-r
|
|
.TP
|
|
.PD
|
|
.B \-\-recurse\-paths
|
|
Travel the directory structure recursively;
|
|
for example:
|
|
.RS
|
|
.IP
|
|
zip -r foo.zip foo
|
|
.RE
|
|
.IP
|
|
or more concisely
|
|
.RS
|
|
.IP
|
|
zip -r foo foo
|
|
.RE
|
|
.IP
|
|
In this case, all the files and directories in
|
|
.B foo
|
|
are saved in a
|
|
.I zip
|
|
archive named \fBfoo.zip\fP,
|
|
including files with names starting with \fB"."\fP,
|
|
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
|
|
\fBfoo\fP
|
|
and its subdirectories, use the
|
|
\fB\-i\fP
|
|
option to specify the pattern of files to be included.
|
|
You should not use
|
|
\fB\-r\fP
|
|
with the name \fB".*"\fP,
|
|
since that matches \fB".."\fP
|
|
which will attempt to zip up the parent directory
|
|
(probably not what was intended).
|
|
.IP
|
|
Multiple source directories are allowed as in
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo foo1 foo2\fP
|
|
.RE
|
|
.IP
|
|
which first zips up \fBfoo1\fP and then \fBfoo2\fP, going down each directory.
|
|
.IP
|
|
Note that while wildcards to \fB-r\fR are typically resolved while recursing down
|
|
directories in the file system, any \fB-R\fN, \fB-x\fR, and \fB-i\fR wildcards
|
|
are applied to internal archive pathnames once the directories are scanned.
|
|
To have wildcards apply to files in subdirectories 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
|
|
\fIzip\fR see the wildcards and match files in subdirectories using them as
|
|
it recurses.
|
|
.TP
|
|
.PD 0
|
|
.B \-R
|
|
.TP
|
|
.PD
|
|
.B \-\-recurse\-patterns
|
|
Travel the directory structure recursively starting at the
|
|
current directory;
|
|
for example:
|
|
.RS
|
|
.IP
|
|
\fCzip -R foo "*.c"\fP
|
|
.RE
|
|
.IP
|
|
In this case, all the files matching \fB*.c\fP in the tree starting at the
|
|
current directory are stored into a
|
|
.I zip
|
|
archive named
|
|
\fBfoo.zip\fP.
|
|
Note that \fB*.c\fP will match \fBfile.c\fP, \fBa/file.c\fP
|
|
and \fBa/b/.c\fP. More than one pattern can be listed as separate
|
|
arguments.
|
|
Note for PKZIP users: the equivalent command is
|
|
.RS
|
|
.IP
|
|
\fCpkzip -rP foo *.c\fP
|
|
.RE
|
|
.IP
|
|
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 \fBfoo\fP and under it are directories \fBfoo1\fP and \fBfoo2\fP
|
|
and in \fBfoo1\fP is the file \fBbar.c\fP,
|
|
.RS
|
|
.IP
|
|
\fCzip -R foo/*\fP
|
|
.RE
|
|
.IP
|
|
will zip up \fBfoo\fP, \fBfoo/foo1\fP, \fBfoo/foo1/bar.c\fP, and \fBfoo/foo2\fP.
|
|
.RS
|
|
.IP
|
|
\fCzip -R */bar.c\fP
|
|
.RE
|
|
.IP
|
|
will zip up \fBfoo/foo1/bar.c\fP. See the note for \fB-r\fR on escaping wildcards.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-RE
|
|
.TP
|
|
.PD
|
|
.B \-\-regex
|
|
[WIN32] Before \fIzip\fP \fI3.0\fP, 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.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-s\ \fPsplitsize
|
|
.TP
|
|
.PD
|
|
.B \-\-split\-size\ \fPsplitsize
|
|
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 archive is smaller than the split size a
|
|
single-file archive is created.
|
|
|
|
Split archives are stored in numbered files. For example, if the output
|
|
archive is named \fBarchive\fP and three splits are required, the resulting
|
|
archive will be in the three files \fBarchive.z01\fP, \fBarchive.z02\fP, and
|
|
\fBarchive.zip\fP. Do not change the numbering 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
|
|
\fBk\fP (kilobytes), \fBm\fP (megabytes), \fBg\fP (gigabytes), or \fBt\fP
|
|
(terabytes). As 64k is the minimum split size, numbers without multipliers
|
|
default to megabytes. For example, to create a split archive called \fBfoo\fP
|
|
with the contents of the \fBbar\fP directory with splits of 670 MB that might
|
|
be useful for burning on CDs, the command:
|
|
.RS
|
|
.IP
|
|
zip -s 670m -r foo bar
|
|
.RE
|
|
.IP
|
|
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 being zipped when creating
|
|
split archives.
|
|
|
|
Using \fB\-s\fP without \fB\-sp\fP as above creates all the splits where
|
|
\fBfoo\fP 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 archives that are readable by
|
|
any unzip that supports split archives. See \fB\-sp\fP below for enabling
|
|
split pause mode which allows splits to be written directly to removable
|
|
media.
|
|
|
|
The option \fB\-sv\fP can be used to enable verbose splitting and provide details of
|
|
how the splitting is being done. The \fB\-sb\fP option can be used to ring the bell
|
|
when \fIzip\fP pauses for the next split destination.
|
|
|
|
Split archives cannot be updated, but see the \fB\-O\fP (\fB\-\-out\fP) 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 \fB\-s\fP option:
|
|
.RS
|
|
.IP
|
|
zip -s 0 split.zip --out single.zip
|
|
.RE
|
|
.IP
|
|
Also see \fB\-U\fP (\fB\-\-copy\fP) for more on using copy mode.
|
|
.TP
|
|
.PD 0
|
|
.B \-sb
|
|
.TP
|
|
.PD
|
|
.B \-\-split\-bell
|
|
If splitting and using split pause mode, ring the bell when \fIzip\fP pauses
|
|
for each split destination.
|
|
.TP
|
|
.PD 0
|
|
.B \-sc
|
|
.TP
|
|
.PD
|
|
.B \-\-show\-command
|
|
Show the command line starting \fIzip\fP as processed and exit. The new command parser
|
|
permutes the arguments, putting all options and any values associated with them
|
|
before any non-option arguments. 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 \fIzip\fP sees it, including any arguments from
|
|
the environment such as from the \fBZIPOPT\fP variable. Where allowed, options later
|
|
in the command line can override options earlier in the command line.
|
|
.TP
|
|
.PD 0
|
|
.B \-sf
|
|
.TP
|
|
.PD
|
|
.B \-\-show\-files
|
|
Show the files that would be operated on, then exit. For instance, if creating
|
|
a new archive, this will list the files that would be added. If the option is
|
|
negated, \fB\-sf\-\fP, output only to an open log file. Screen display is
|
|
not recommended for large lists.
|
|
.TP
|
|
.PD 0
|
|
.B \-so
|
|
.TP
|
|
.PD
|
|
.B \-\-show\-options
|
|
Show all available options supported by \fIzip\fP 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, required 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 options are available.
|
|
.TP
|
|
.PD 0
|
|
.B \-sp
|
|
.TP
|
|
.PD
|
|
.B \-\-split\-pause
|
|
If splitting is enabled with \fB\-s\fP, enable split pause mode. This
|
|
creates split archives as \fB\-s\fP does, but stream writing is used so each
|
|
split can be closed as soon as it is written and \fIzip\fP will pause between each
|
|
split to allow changing split destination or media.
|
|
|
|
Though this split mode allows writing splits directly to removable media, it
|
|
uses stream archive format that may not be readable by some unzips. Before
|
|
relying on splits created with \fB\-sp\fP, test a split archive with the unzip
|
|
you will be using.
|
|
|
|
To convert a stream split archive (created with \fB\-sp\fP) to a standard archive
|
|
see the \fB\-\-out\fP option.
|
|
.TP
|
|
.PD 0
|
|
.B \-su
|
|
.TP
|
|
.PD
|
|
.B \-\-show\-unicode
|
|
As \fB\-sf\fP, but also show Unicode version of the path if exists.
|
|
.TP
|
|
.PD 0
|
|
.B \-sU
|
|
.TP
|
|
.PD
|
|
.B \-\-show\-just\-unicode
|
|
As \fB\-sf\fP, but only show Unicode version of the path if exists, otherwise show
|
|
the standard version of the path.
|
|
.TP
|
|
.PD 0
|
|
.B \-sv
|
|
.TP
|
|
.PD
|
|
.B \-\-split\-verbose
|
|
Enable various verbose messages while splitting, showing how the splitting is being
|
|
done.
|
|
.TP
|
|
.PD 0
|
|
.B \-S
|
|
.TP
|
|
.PD
|
|
.B \-\-system-hidden
|
|
[MSDOS, OS/2, WIN32 and ATARI] Include system and hidden files.
|
|
.RS
|
|
[MacOS] Includes finder invisible files, which are ignored otherwise.
|
|
.RE
|
|
.TP
|
|
.PD 0
|
|
.BI \-t\ \fRmmddyyyy
|
|
.TP
|
|
.PD
|
|
.B \-\-from\-date\ \fRmmddyyyy
|
|
Do not operate on files modified prior to the specified date,
|
|
where
|
|
.B mm
|
|
is the month (00-12),
|
|
.B dd
|
|
is the day of the month (01-31),
|
|
and
|
|
.B yyyy
|
|
is the year.
|
|
The
|
|
.I ISO\ 8601
|
|
date format
|
|
.B yyyy\-mm\-dd
|
|
is also accepted.
|
|
For example:
|
|
.RS
|
|
.IP
|
|
\fCzip -rt 12071991 infamy foo\fP
|
|
|
|
\fCzip -rt 1991-12-07 infamy foo\fP
|
|
.RE
|
|
.IP
|
|
will add all the files in
|
|
.B foo
|
|
and its subdirectories that were last modified on or after 7 December 1991,
|
|
to the
|
|
.I zip
|
|
archive
|
|
.BR infamy.zip .
|
|
.TP
|
|
.PD 0
|
|
.BI \-tt\ \fRmmddyyyy
|
|
.TP
|
|
.PD
|
|
.B \-\-before\-date\ \fRmmddyyyy
|
|
Do not operate on files modified after or at the specified date,
|
|
where
|
|
.B mm
|
|
is the month (00-12),
|
|
.B dd
|
|
is the day of the month (01-31),
|
|
and
|
|
.B yyyy
|
|
is the year.
|
|
The
|
|
.I ISO\ 8601
|
|
date format
|
|
.B yyyy\-mm\-dd
|
|
is also accepted.
|
|
For example:
|
|
.RS
|
|
.IP
|
|
\fCzip -rtt 11301995 infamy foo\fP
|
|
|
|
\fCzip -rtt 1995-11-30 infamy foo\fP
|
|
.RE
|
|
.IP
|
|
will add all the files in
|
|
.B foo
|
|
and its subdirectories that were last modified before 30 November 1995,
|
|
to the
|
|
.I zip
|
|
archive
|
|
.BR infamy.zip .
|
|
.TP
|
|
.PD 0
|
|
.B \-T
|
|
.TP
|
|
.PD
|
|
.B \-\-test\ \ \ \
|
|
Test the integrity of the new zip file. If the check fails, the old zip file
|
|
is unchanged and (with the
|
|
.B -m
|
|
option) no input files are removed.
|
|
.TP
|
|
.PD 0
|
|
.B \-TT\ \fPcmd
|
|
.TP
|
|
.PD
|
|
.B \-\-unzip-command\ \fPcmd
|
|
Use command cmd instead of 'unzip -tqq' to test an archive when the \fB\-T\fP
|
|
option is used. On Unix, to use a copy of unzip in the current directory instead
|
|
of the standard system unzip, could use:
|
|
.IP
|
|
\fC zip archive file1 file2 -T -TT "./unzip -tqq"\fP
|
|
.IP
|
|
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).
|
|
.TP
|
|
.PD 0
|
|
.B \-u
|
|
.TP
|
|
.PD
|
|
.B \-\-update
|
|
Replace (update) an existing entry in the
|
|
.I zip
|
|
archive only if it has been modified more recently
|
|
than the version already in the
|
|
.I zip
|
|
archive.
|
|
For example:
|
|
.RS
|
|
.IP
|
|
\fCzip -u stuff *\fP
|
|
.RE
|
|
.IP
|
|
will add any new files in the current directory,
|
|
and update any files which have been modified since the
|
|
.I zip
|
|
archive
|
|
.I stuff.zip
|
|
was last created/modified (note that
|
|
.I zip
|
|
will not try to pack
|
|
.I stuff.zip
|
|
into itself when you do this).
|
|
.IP
|
|
Note that the
|
|
.B \-u
|
|
option with no input file arguments acts like the
|
|
.B \-f
|
|
(freshen) option.
|
|
.TP
|
|
.PD 0
|
|
.B \-U
|
|
.TP
|
|
.PD
|
|
.B \-\-copy\-entries
|
|
Copy entries from one archive to another. Requires the \fB\-\-out\fP
|
|
option to specify a different output file than the input archive. Copy
|
|
mode is the reverse of \fB\-d\fP delete. When delete is being used
|
|
with \fB\-\-out\fP, 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 \fB\-u\fP
|
|
update, input patterns on the command line are matched against archive
|
|
entries only and not the file system files. For instance,
|
|
.RS
|
|
.IP
|
|
\fCzip inarchive "*.c" --copy --out outarchive\fP
|
|
.RE
|
|
.IP
|
|
copies entries with names ending in \fB\.c\fP from \fBinarchive\fP
|
|
to \fBoutarchive\fP. The wildcard must be escaped on some systems
|
|
to prevent the shell from substituting names of files from the
|
|
file system which may have no relevance to the entries in the archive.
|
|
|
|
If no input files appear on the command line and \fB\-\-out\fP is
|
|
used, copy mode is assumed:
|
|
.RS
|
|
.IP
|
|
\fCzip inarchive --out outarchive\fP
|
|
.RE
|
|
.IP
|
|
This is useful for changing split size for instance. Encrypting
|
|
and decrypting entries is not yet supported using copy mode. Use
|
|
\fIzipcloak\fP for that.
|
|
.TP
|
|
.PD 0
|
|
.B \-UN\ \fRv
|
|
.TP
|
|
.PD
|
|
.B \-\-unicode\ \fRv
|
|
Determine what \fIzip\fP should do with Unicode file names.
|
|
\fIzip\ 3.0\fP, 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, \fIzip\fP 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 \fIzip\fP is
|
|
reading an archive, if an entry also has a Unicode path,
|
|
\fIzip\fP 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 \fIzip\fP 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
|
|
\fIzip\fP uses that. Values for \fBv\fP are
|
|
.RS
|
|
.IP
|
|
q \- quit if paths do not match
|
|
.IP
|
|
w \- warn, continue with standard path
|
|
.IP
|
|
i \- ignore, continue with standard path
|
|
.IP
|
|
n \- no Unicode, do not use Unicode paths
|
|
.RE
|
|
.IP
|
|
The default is to warn and continue.
|
|
|
|
Characters that are not valid in the current character set are
|
|
escaped as \fB#Uxxxx\fP and \fB#Lxxxxxx\fP, 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 Unicode character code. Setting \fB\-UN\fP to
|
|
.RS
|
|
.IP
|
|
e \- escape
|
|
.RE
|
|
.IP
|
|
as in
|
|
.RS
|
|
.IP
|
|
\fCzip archive -sU -UN=e\fP
|
|
.RE
|
|
.IP
|
|
forces \fIzip\fP to escape all characters that are not printable 7-bit
|
|
ASCII.
|
|
|
|
Normally \fIzip\fP 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
|
|
.RS
|
|
.IP
|
|
u \- UTF\-8
|
|
.RE
|
|
.IP
|
|
as in
|
|
.RS
|
|
.IP
|
|
\fCzip archive dir -r -UN=UTF8\fP
|
|
.RE
|
|
.IP
|
|
forces \fIzip\fP to store UTF\-8 as native in the archive. Note that
|
|
storing UTF\-8 directly is the default on Unix systems that support 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.
|
|
|
|
.TP
|
|
.PD 0
|
|
.B \-v
|
|
.TP
|
|
.PD
|
|
.B \-\-verbose
|
|
Verbose mode or print diagnostic version info.
|
|
.IP
|
|
Normally, when applied to real operations, this option enables the display of a
|
|
progress indicator during compression (see \fB-dd\fR for more on dots) and
|
|
requests verbose diagnostic info about zipfile structure oddities.
|
|
.IP
|
|
However, when
|
|
.B \-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 distribution 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
|
|
.I zip
|
|
executable).
|
|
.TP
|
|
.PD 0
|
|
.B \-V
|
|
.TP
|
|
.PD
|
|
.B \-\-VMS\-portable
|
|
[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.
|
|
.TP
|
|
.PD 0
|
|
.B \-VV
|
|
.TP
|
|
.PD
|
|
.B \-\-VMS\-specific
|
|
[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
|
|
unpacked on a non-VMS system, almost all files will appear corrupt.
|
|
.TP
|
|
.PD 0
|
|
.B \-w
|
|
.TP
|
|
.PD
|
|
.B \-\-VMS\-versions
|
|
[VMS] Append the version number of the files to the name,
|
|
including multiple versions of files. Default is to use only
|
|
the most recent version of a specified file.
|
|
.TP
|
|
.PD 0
|
|
.B \-ww
|
|
.TP
|
|
.PD
|
|
.B \-\-VMS\-dot\-versions
|
|
[VMS] Append the version number of the files to the name,
|
|
including multiple versions of files, using the \.nnn format.
|
|
Default is to use only the most recent version of a specified
|
|
file.
|
|
.TP
|
|
.PD 0
|
|
.BI \-ws
|
|
.TP
|
|
.PD
|
|
.B \-\-wild\-stop\-dirs
|
|
Wildcards match only at a directory level. Normally \fIzip\fP handles
|
|
paths as strings and given the paths
|
|
.RS
|
|
.IP
|
|
/foo/bar/dir/file1.c
|
|
.IP
|
|
/foo/bar/file2.c
|
|
.RE
|
|
.IP
|
|
an input pattern such as
|
|
.RS
|
|
.IP
|
|
/foo/bar/*
|
|
.RE
|
|
.IP
|
|
normally would match both paths, the * matching \fBdir/file1.c\fP
|
|
and \fBfile2.c\fP. Note that in the first case a directory
|
|
boundary (/) was crossed in the match. With \fB\-ws\fP no
|
|
directory bounds will be included in the match, making
|
|
wildcards local to a specific directory level. So, with
|
|
\fB\-ws\fP enabled, only the second path would be matched.
|
|
|
|
When using \fB\-ws\fP, use ** to match across directory boundaries as
|
|
* does normally.
|
|
.TP
|
|
.PD 0
|
|
.BI \-x\ \fRfiles
|
|
.TP
|
|
.PD
|
|
.B \-\-exclude\ \fRfiles
|
|
Explicitly exclude the specified files, as in:
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo foo -x \\*.o\fP
|
|
.RE
|
|
.IP
|
|
which will include the contents of
|
|
.B foo
|
|
in
|
|
.B foo.zip
|
|
while excluding all the files that end in
|
|
\fB.o\fP.
|
|
The backslash avoids the shell filename substitution, so that the
|
|
name matching is performed by
|
|
.I zip
|
|
at all directory levels.
|
|
.IP
|
|
Also possible:
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo foo -x@exclude.lst\fP
|
|
.RE
|
|
.IP
|
|
which will include the contents of
|
|
.B foo
|
|
in
|
|
.B foo.zip
|
|
while excluding all the files that match the patterns in the file
|
|
\fBexclude.lst\fP.
|
|
.IP
|
|
The long option forms of the above are
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo foo --exclude \\*.o\fP
|
|
.RE
|
|
.IP
|
|
and
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo foo --exclude @exclude.lst\fP
|
|
.RE
|
|
.IP
|
|
Multiple patterns can be specified, as in:
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo foo -x \\*.o \\*.c\fP
|
|
.RE
|
|
.IP
|
|
If there is no space between \fB\-x\fP and
|
|
the pattern, just one value is assumed (no list):
|
|
.RS
|
|
.IP
|
|
\fCzip -r foo foo -x\\*.o\fP
|
|
.RE
|
|
.IP
|
|
.IP
|
|
See \fB-i\fR for more on include and exclude.
|
|
.TP
|
|
.PD 0
|
|
.B \-X
|
|
.TP
|
|
.PD
|
|
.B \-\-no\-extra
|
|
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 \fIzip\fP 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 \fB\-X\fP, \fIzip\fP strips
|
|
all old fields and only includes the Unicode and Zip64 extra fields
|
|
(currently these two extra fields cannot be disabled).
|
|
|
|
Negating this option, \fB\-X\-\fP, includes all the default extra fields,
|
|
but also copies over any unrecognized extra fields.
|
|
.TP
|
|
.PD 0
|
|
.B \-y
|
|
.TP
|
|
.PD
|
|
.B \-\-symlinks
|
|
For UNIX and VMS (V8.3 and later), store symbolic links as such in the
|
|
.I 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 \fIzip\fP recurses the directory trees and accesses
|
|
files directly and by links.
|
|
.TP
|
|
.PD 0
|
|
.B \-z
|
|
.TP
|
|
.PD
|
|
.B \-\-archive\-comment
|
|
Prompt for a multi-line comment for the entire
|
|
.I 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:
|
|
.RS
|
|
.IP
|
|
\fCzip -z foo < foowhat\fP
|
|
.RE
|
|
.TP
|
|
.PD 0
|
|
.B \-Z\ \fRcm
|
|
.TP
|
|
.PD
|
|
.B \-\-compression\-method\ \fRcm
|
|
Set the default compression method. Currently the main methods supported
|
|
by \fIzip\fP are \fBstore\fP and \fBdeflate\fP. Compression method
|
|
can be set to:
|
|
|
|
\fBstore\fP \- Setting the compression method to \fBstore\fP forces
|
|
\fIzip\fP 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 \fB\-0\fP (compression level zero).
|
|
|
|
\fBdeflate\fP \- This is the default method for \fIzip\fP. If \fIzip\fP
|
|
determines that storing is better than deflation, the entry will be
|
|
stored instead.
|
|
|
|
\fBbzip2\fP \- If \fBbzip2\fP support is compiled in, this compression
|
|
method also becomes available. Only some modern unzips currently support
|
|
the \fBbzip2\fP compression method, so test the unzip you will be using
|
|
before relying on archives using this method (compression method 12).
|
|
|
|
For example, to add \fBbar.c\fP to archive \fBfoo\fP using \fBbzip2\fP
|
|
compression:
|
|
.RS
|
|
.IP
|
|
zip -Z bzip2 foo bar.c
|
|
.RE
|
|
.IP
|
|
The compression method can be abbreviated:
|
|
.RS
|
|
.IP
|
|
zip -Zb foo bar.c
|
|
.RE
|
|
.IP
|
|
.TP
|
|
.PD 0
|
|
.BI \-#
|
|
.TP
|
|
.PD
|
|
.B (\-0, \-1, \-2, \-3, \-4, \-5, \-6, \-7, \-8, \-9)
|
|
Regulate the speed of compression using the specified digit
|
|
.BR # ,
|
|
where
|
|
.B \-0
|
|
indicates no compression (store all files),
|
|
.B \-1
|
|
indicates the fastest compression speed (less compression)
|
|
and
|
|
.B \-9
|
|
indicates the slowest compression speed (optimal compression, ignores
|
|
the suffix list). The default compression level is
|
|
.BR \-6.
|
|
|
|
Though still being worked, the intention is this setting will control
|
|
compression speed for all compression methods. Currently only
|
|
deflation is controlled.
|
|
.TP
|
|
.PD 0
|
|
.B \-!
|
|
.TP
|
|
.PD
|
|
.B \-\-use\-privileges
|
|
[WIN32] Use priviliges (if granted) to obtain all aspects of WinNT security.
|
|
.TP
|
|
.PD 0
|
|
.B \-@
|
|
.TP
|
|
.PD
|
|
.B \-\-names\-stdin
|
|
Take the list of input files from standard input. Only one filename per line.
|
|
.TP
|
|
.PD 0
|
|
.B \-$
|
|
.TP
|
|
.PD
|
|
.B \-\-volume\-label
|
|
[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:
|
|
.RS
|
|
.IP
|
|
\fCzip -$ foo a: c:bar\fP
|
|
.RE
|
|
.IP
|
|
.SH "EXAMPLES"
|
|
The simplest example:
|
|
.IP
|
|
\fCzip stuff *\fP
|
|
.LP
|
|
creates the archive
|
|
.I stuff.zip
|
|
(assuming it does not exist)
|
|
and puts all the files in the current directory in it, in compressed form
|
|
(the
|
|
\fB\&.zip\fP
|
|
suffix is added automatically, unless the archive name contains
|
|
a dot already;
|
|
this allows the explicit specification of other suffixes).
|
|
.LP
|
|
Because of the way the shell on Unix does filename substitution,
|
|
files starting with "." are not included;
|
|
to include these as well:
|
|
.IP
|
|
\fCzip stuff .* *\fP
|
|
.LP
|
|
Even this will not include any subdirectories from the current directory.
|
|
.LP
|
|
To zip up an entire directory, the command:
|
|
.IP
|
|
\fCzip -r foo foo\fP
|
|
.LP
|
|
creates the archive
|
|
.IR foo.zip ,
|
|
containing all the files and directories in the directory
|
|
.I foo
|
|
that is contained within the current directory.
|
|
.LP
|
|
You may want to make a
|
|
.I zip
|
|
archive that contains the files in
|
|
.IR foo ,
|
|
without recording the directory name,
|
|
.IR foo .
|
|
You can use the
|
|
.B \-j
|
|
option to leave off the paths,
|
|
as in:
|
|
.IP
|
|
\fCzip -j foo foo/*\fP
|
|
.LP
|
|
If you are short on disk space,
|
|
you might not have enough room to hold both the original directory
|
|
and the corresponding compressed
|
|
.I zip
|
|
archive.
|
|
In this case, you can create the archive in steps using the
|
|
.B \-m
|
|
option.
|
|
If
|
|
.I foo
|
|
contains the subdirectories
|
|
.IR tom ,
|
|
.IR dick ,
|
|
and
|
|
.IR harry ,
|
|
you can:
|
|
.IP
|
|
\fCzip -rm foo foo/tom\fP
|
|
.br
|
|
\fCzip -rm foo foo/dick\fP
|
|
.br
|
|
\fCzip -rm foo foo/harry\fP
|
|
.LP
|
|
where the first command creates
|
|
.IR foo.zip ,
|
|
and the next two add to it.
|
|
At the completion of each
|
|
.I zip
|
|
command,
|
|
the last created archive is deleted,
|
|
making room for the next
|
|
.I zip
|
|
command to function.
|
|
|
|
|
|
|
|
.LP
|
|
Use \fB\-s\fP 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
|
|
.IP
|
|
\fCzip -s 2g -r split.zip foo\fP
|
|
.LP
|
|
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 split.zip at a little over 1\ GB.
|
|
.LP
|
|
The \fB\-sp\fP option can be used to pause \fIzip\fP between splits to allow changing
|
|
removable media, for example, but read the descriptions and warnings for both \fB\-s\fP
|
|
and \fB\-sp\fP below.
|
|
.LP
|
|
Though \fIzip\fP does not update split archives, \fIzip\fP provides the new option \fB\-O\fP
|
|
(\fB\-\-output\-file\fP) to allow split archives to be updated and saved in a new archive. For example,
|
|
.IP
|
|
\fCzip inarchive.zip foo.c bar.c \-\-out outarchive.zip\fP
|
|
.LP
|
|
reads archive \fBinarchive.zip\fP, even if split, adds the files \fBfoo.c\fP and
|
|
\fBbar.c\fP, and writes the resulting archive to \fBoutarchive.zip\fP. If
|
|
\fBinarchive.zip\fP is split then \fBoutarchive.zip\fP defaults
|
|
to the same split size. Be aware that \fBoutarchive.zip\fP and any split files
|
|
that are created with it are always overwritten without warning. This may be changed
|
|
in the future.
|
|
|
|
|
|
|
|
|
|
.SH "PATTERN MATCHING"
|
|
This section applies only to Unix.
|
|
Watch this space for details on MSDOS and VMS operation.
|
|
However, the special wildcard characters \fB*\fR and \fB[]\fR below apply
|
|
to at least MSDOS also.
|
|
.LP
|
|
The Unix shells (\fIsh\fP, \fIcsh\fP, \fIbash\fP, and others) normally
|
|
do filename substitution (also called "globbing") on command arguments.
|
|
Generally the special characters are:
|
|
.TP
|
|
.B ?
|
|
match any single character
|
|
.TP
|
|
.B *
|
|
match any number of characters (including none)
|
|
.TP
|
|
.B []
|
|
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 example:
|
|
.RS
|
|
.IP
|
|
\fCzip archive "*.[hc]"\fP
|
|
.RE
|
|
.IP
|
|
would archive all files in the current directory that end in
|
|
\fB.h\fP or \fB.c\fP.
|
|
|
|
Ranges of characters are supported:
|
|
.RS
|
|
.IP
|
|
\fCzip archive "[a\-f]*"\fP
|
|
.RE
|
|
.IP
|
|
would add to the archive all files starting with "a" through "f".
|
|
|
|
Negation is also supported, where any character in that position not in
|
|
the list matches. Negation is supported by adding \fB!\fP or \fB^\fP
|
|
to the beginning of the list:
|
|
.RS
|
|
.IP
|
|
\fCzip archive "*.[!o]"\fP
|
|
.RE
|
|
.IP
|
|
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.
|
|
|
|
.LP
|
|
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.
|
|
.LP
|
|
The
|
|
.I zip
|
|
program can do the same matching on names that are in the
|
|
.I zip
|
|
archive being modified or,
|
|
in the case of the
|
|
.B \-x
|
|
(exclude) or
|
|
.B \-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
|
|
.I 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
|
|
.I 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, unless this name matches one given
|
|
with the
|
|
.B \-x
|
|
option, or does not match any name given with the
|
|
.B \-i
|
|
option.
|
|
.LP
|
|
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 ("").
|
|
.LP
|
|
In general, use backslashes or double quotes for paths
|
|
that have wildcards to make
|
|
.I zip
|
|
do the pattern matching for file paths, and always for
|
|
paths and strings that have spaces or wildcards for
|
|
\fB\-\i\fP, \fB\-x\fP, \fB\-R\fP, \fB\-d\fP, and \fB\-U\fP
|
|
and anywhere \fIzip\fP needs to process the wildcards.
|
|
.SH "ENVIRONMENT"
|
|
.LP
|
|
The following environment variables are read and used by
|
|
.I zip
|
|
as described.
|
|
.TP
|
|
.B ZIPOPT\ \
|
|
contains default options that will be used when running
|
|
\fIzip\fR. The contents of this environment variable will get
|
|
added to the command line just after the \fBzip\fR command.
|
|
.TP
|
|
.B ZIP\ \ \ \ \
|
|
[Not on RISC OS and VMS] see ZIPOPT
|
|
.TP
|
|
.B Zip$Options
|
|
[RISC OS] see ZIPOPT
|
|
.TP
|
|
.B Zip$Exts
|
|
[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.
|
|
.TP
|
|
.B ZIP_OPTS
|
|
[VMS] see ZIPOPT
|
|
.SH "SEE ALSO"
|
|
compress(1),
|
|
shar(1L),
|
|
tar(1),
|
|
unzip(1L),
|
|
gzip(1L)
|
|
.SH DIAGNOSTICS
|
|
The exit status (or error level) approximates the exit codes defined by PKWARE
|
|
and takes on the following values, except under VMS:
|
|
.RS
|
|
.IP 0
|
|
normal; no errors or warnings detected.
|
|
.IP 2
|
|
unexpected end of zip file.
|
|
.IP 3
|
|
a generic error in the zipfile format was detected. Processing may have
|
|
completed successfully anyway; some broken zipfiles created by other
|
|
archivers have simple work-arounds.
|
|
.IP 4
|
|
\fIzip\fP was unable to allocate memory for one or more buffers during
|
|
program initialization.
|
|
.IP 5
|
|
a severe error in the zipfile format was detected. Processing probably
|
|
failed immediately.
|
|
.IP 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 \fIzipsplit\fP
|
|
.IP 7
|
|
invalid comment format
|
|
.IP 8
|
|
\fIzip\fP -T failed or out of memory
|
|
.IP 9
|
|
the user aborted \fIzip\fP prematurely with control-C (or similar)
|
|
.IP 10
|
|
\fIzip\fP encountered an error while using a temp file
|
|
.IP 11
|
|
read or seek error
|
|
.IP 12
|
|
\fIzip\fP has nothing to do
|
|
.IP 13
|
|
missing or empty zip file
|
|
.IP 14
|
|
error writing to a file
|
|
.IP 15
|
|
\fIzip\fP was unable to create a file to write to
|
|
.IP 16
|
|
bad command line parameters
|
|
.IP 18
|
|
\fIzip\fP could not open a specified file to read
|
|
.IP 19
|
|
\fIzip\fP was compiled with options not supported on this system
|
|
.RE
|
|
.PP
|
|
VMS interprets standard Unix (or PC) return values as other, scarier-looking
|
|
things, so \fIzip\fP instead maps them into VMS-style status codes. In
|
|
general, \fIzip\fP sets VMS Facility = 1955 (0x07A3), Code = 2* Unix_status,
|
|
and an appropriate Severity (as specified in ziperr.h). More details are
|
|
included in the VMS-specific documentation. See [.vms]NOTES.TXT and
|
|
[.vms]vms_msg_gen.c.
|
|
.PD
|
|
.SH BUGS
|
|
.I zip
|
|
3.0 is not compatible with PKUNZIP 1.10. Use
|
|
.I zip
|
|
1.1 to produce
|
|
.I zip
|
|
files which can be extracted by PKUNZIP 1.10.
|
|
.PP
|
|
.I zip
|
|
files produced by
|
|
.I zip
|
|
3.0 must not be
|
|
.I updated
|
|
by
|
|
.I 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
|
|
.I 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.
|
|
.LP
|
|
Under VMS,
|
|
not all of the odd file formats are treated properly.
|
|
Only stream-LF format
|
|
.I zip
|
|
files are expected to work with
|
|
.IR zip .
|
|
Others can be converted using Rahul Dhesi's BILF program.
|
|
This version of
|
|
.I zip
|
|
handles some of the conversion internally.
|
|
When using Kermit to transfer 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.
|
|
.LP
|
|
Under some older VMS versions, \fIzip\fP may hang for file
|
|
specifications that use DECnet syntax
|
|
.I foo::*.*.
|
|
.LP
|
|
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 programs such
|
|
as GNU tar are also affected by this bug.
|
|
.LP
|
|
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 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. Therefore the value reported by
|
|
.I zip
|
|
(which uses this 32-bit-mode size) differs from that reported by DIR.
|
|
.I 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.
|
|
.SH AUTHORS
|
|
Copyright (C) 1997-2008 Info-ZIP.
|
|
.LP
|
|
Currently distributed under the Info-ZIP license.
|
|
.LP
|
|
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.
|
|
.LP
|
|
Original copyright:
|
|
.LP
|
|
Permission is granted to any individual or institution to use, copy, or
|
|
redistribute this software so long as all of the original files are included,
|
|
that it is not sold for profit, and that this copyright notice
|
|
is retained.
|
|
.LP
|
|
LIKE ANYTHING ELSE THAT'S FREE, ZIP AND ITS ASSOCIATED UTILITIES ARE
|
|
PROVIDED AS IS AND COME WITH NO WARRANTY OF ANY KIND, EITHER EXPRESSED OR
|
|
IMPLIED. IN NO EVENT WILL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES
|
|
RESULTING FROM THE USE OF THIS SOFTWARE.
|
|
.LP
|
|
Please send bug reports and comments using the web page at:
|
|
.IR www.info-zip.org .
|
|
For bug reports, please include the version of
|
|
.IR zip
|
|
(see \fIzip\ \-h\fR),
|
|
the make options used to compile it (see \fIzip\ \-v\fR),
|
|
the machine and operating system in use,
|
|
and as much additional information as possible.
|
|
.SH ACKNOWLEDGEMENTS
|
|
Thanks to R. P. Byrne for his
|
|
.I 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
|
|
.I zip
|
|
file format, compression format, and .ZIP filename extension, and for
|
|
accepting minor changes to the file format; to Steve Burg for
|
|
clarifications 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
|
|
.I ftp
|
|
site for the Info-ZIP group to use; and most importantly, to the
|
|
Info-ZIP group itself (listed in the file
|
|
.IR infozip.who )
|
|
without whose tireless testing and bug-fixing efforts a portable
|
|
.I 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 and
|
|
updated by E. Gordon for \fIzip\fR 3.0.
|
|
.\" end of file
|