View Source: zip(1) - Waikato Linux Users Group

Edit PageHistory Diff Info LikePages
ZIP
!!!ZIP
NAME
SYNOPSIS
DESCRIPTION
OPTIONS
EXAMPLES
PATTERN MATCHING
ENVIRONMENT
SEE ALSO
DIAGNOSTICS
BUGS
AUTHORS
ACKNOWLEDGEMENTS
----
!!NAME


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


__zip__ [[__-aABcdDeEfFghjklLmoqrRSTuvVwXyz!@$__]
[[__-b path__] [[__-n suffixes__] [[__-t mmddyyyy__]
[[__-tt mmddyyyy__] ''[[ zipfile [[ file1 file2''
...'']]'' [[__-xi list__]


__zipcloak__ [[__-dhL__] [[__-b path__]
''zipfile''


__zipnote__ [[__-hwL__] [[__-b path__]
''zipfile''


__zipsplit__ [[__-hiLpst__] [[__-n size__] [[__-b
path__] ''zipfile''
!!DESCRIPTION


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


It is analogous to a combination of the UNIX commands
tar(1) and compress(1) and is compatible with
PKZIP (Phil Katz's ZIP for MSDOS systems).


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


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


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


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


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


zip -r foo foo


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


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


find . -name


(note that the pattern must be quoted to keep the shell from
expanding it). ''zip'' will also accept a single dash
(
''


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


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


''zip'' also accepts a single dash (
''


tar cf - . | zip backup -


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


unzip -p backup | tar xf -


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


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


is equivalent to


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


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


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


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


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


__-a__


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


__-A__


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


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


__-B__


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


__-Bn__


[[TANDEM] set Edit/Enscribe formatting options with n defined
as
bit 0: Don't add delimiter (Edit/Enscribe)


bit 1: Use LF rather than CR/LF as delimiter
(Edit/Enscribe)


bit 2: Space fill record to maximum record length
(Enscribe)


bit 3: Trim trailing space (Enscribe)


bit 8: Force 30K (Expand) large read for unstructured
files


__-b path__


Use the specified ''path'' for the temporary ''zip''
archive. For example:


zip -b /tmp stuff *


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


__-c__


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


__-d__


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


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


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


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


__-df__


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


__-D__


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


ZIPOPT=


(The variable ZIPOPT can be used for any option except
__-i__ and __-x__ and can include several options.)
The option __-D__ is a shorthand for __-x__
__


__-e__


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


__-E__


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


__-f__


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


zip -f foo


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


Note that the timezone environment variable TZ should be set
according to the local timezone in order for the __-f__ ,
__-u__ and __-o__ options to work
correctly.


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


__-F__


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


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


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


__-g__


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


__-h__


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


__-i files__


Include only the specified files, as in:


zip -r foo . -i *.c


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


pkzip -rP foo *.c


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


Also possible:


zip -r foo . -i@include.lst


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


__-I__


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


For example, if you have SparkFS loaded, zipping a Spark
archive will result in a zipfile containing a directory (and
its 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.


__-j__


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


__-jj__


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


__-J__


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


__-k__


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


__-l__


Translate the Unix end-of-line character LF into the MSDOS
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 ensure
that ''unzip -a'' on Unix will get back an exact copy of
the original file, to undo the effect of ''zip
-l.''


__-ll__


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


__-L__


Display the ''zip'' license.


__-m__


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


__-n suffixes__


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


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


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


setenv ZIPOPT


To attempt compression on all files, use:


zip -n : foo


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


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


__-N__


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


__-o__


Set the zip''
archive to the latest (oldest)
''zip'' archive. This
can be used without any other operations, if desired. For
example:


zip -o foo


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


__-P__ ''password''


use ''password'' to encrypt zipfile entries (if any).
__THIS IS INSECURE!__ Many multi-user operating systems
provide ways for any user to see the current command line of
any other user; even on stand-alone systems there is always
the threat of over-the-shoulder peeking. Storing the
plaintext password as part of a command line in an 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
encryption provided by standard zipfile
utilities.)


__-q__


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


__-Qn__


[[QDOS] store information about the file in the file header
with n defined as
bit 0: Don't add headers for any file


bit 1: Add headers for all files


bit 2: Don't wait for interactive key press on
exit


__-r__


Travel the directory structure recursively; for
example:


zip -r foo foo


In this case, all the files and directories in ''foo''
are saved in a ''zip'' archive named ''foo.zip'',
including files with names starting with
''foo'' and its
subdirectories, use the __-i__ option to specify the
pattern of files to be included. You should not use
__-r__ with the name
__


__-R__


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


zip -R foo '*.c'


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


pkzip -rP foo *.c


__-S__


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


__-t mmddyyyy__


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


zip -rt 12071991 infamy foo


zip -rt 1991-12-07 infamy foo


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


__-tt mmddyyyy__


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


zip -rtt 11301995 infamy foo


zip -rtt 1995-11-30 infamy foo


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


__-T__


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


__-u__


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


zip -u stuff *


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


Note that the __-u__ option with no arguments acts like
the __-f__ (freshen) option.


__-v__


Verbose mode or print diagnostic version info.


Normally, when applied to real operations, this option
enables the display of a progress indicator during
compression and requests verbose diagnostic info about
zipfile structure oddities.


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


__-V__


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


__-w__


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


__-x files__


Explicitly exclude the specified files, as in:


zip -r foo foo -x *.o


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


Also possible:


zip -r foo foo -x@exclude.lst


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


__-X__


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


__-y__


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


__-z__


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


zip -z foo


__-#__


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


__-!__


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


__-@__


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


__-$__


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


zip -$ foo a: c:bar
!!EXAMPLES


The simplest example:


zip stuff *


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


Because of the way the shell does filename substitution,
files starting with


zip stuff .* *


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


To zip up an entire directory, the command:


zip -r foo foo


creates the archive ''foo.zip'', containing all the files
and directories in the directory ''foo'' that is
contained within the current directory.


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


zip -j foo foo/*


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


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


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


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


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


__?__


match any single character


__*__


match any number of characters (including none)


__[[]__


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


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


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


The pattern matching includes the path, and so patterns like
*.o match names that end in


In general, use backslash to make ''zip'' do the pattern
matching with the __-f__ (freshen) and __-d__ (delete)
options, and sometimes after the __-x__ (exclude) option
when used with an appropriate operation (add, __-u__,
__-f__, or __-d__).
!!ENVIRONMENT


__ZIPOPT__


contains default options that will be used when running
''zip''


__ZIP__


[[Not on RISC OS and VMS] see ZIPOPT


__Zip$Options__


[[RISC OS] see ZIPOPT


__Zip$Exts__


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


__ZIP_OPTS__


[[VMS] see ZIPOPT
!!SEE ALSO


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


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


0


normal; no errors or warnings detected.


2


unexpected end of zip file.


3


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


4


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


5


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


6


entry too large to be split with
''zipsplit''


7


invalid comment format


8


''zip'' -T failed or out of memory


9


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


10


''zip'' encountered an error while using a temp
file


11


read or seek error


12


''zip'' has nothing to do


13


missing or empty zip file


14


error writing to a file


15


''zip'' was unable to create a file to write
to


16


bad command line parameters


18


''zip'' could not open a specified file to
read


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


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


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


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


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


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


Under OS/2, the amount of Extended Attributes displayed by
DIR is (for compatibility) the amount returned by the 16-bit
version of !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 ''zip''
(which uses this 32-bit-mode size) differs from that
reported by DIR. ''zip'' stores the 32-bit format for
portability, even the 16-bit MS-C-compiled version running
on OS/2 1.3, so even this one shows the 32-bit-mode
size.
!!AUTHORS


Copyright (C) 1990-1997 Mark Adler, Richard B. Wales,
Jean-loup Gailly, Onno van der Linden, Kai Uwe Rommel, Igor
Mandrichenko, John Bush and Paul Kienitz. Permission is
granted to any 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.


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


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


Thanks to R. P. Byrne for his ''Shrink.Pas'' program,
which inspired this project, and from which the shrink
algorithm was stolen; to Phil Katz for placing in the public
domain the ''zip'' file format, compression format, and
.ZIP filename extension, and for 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 ''ftp'' site for the
Info-ZIP group to use; and most importantly, to the Info-ZIP
group itself (listed in the file ''infozip.who'') without
whose tireless testing and bug-fixing efforts a portable
''zip'' would not have been possible. Finally we should
thank (blame) the first Info-ZIP moderator, David
Kirschbaum, for getting us into this mess in the first
place. The manual page was rewritten for UNIX by R. P. C.
Rodgers.
----
10 pages link to zip(1):
This page is a man page (or other imported legacy content). We are unable to automatically determine the license status of this page.
Last edited on Tuesday, June 4, 2002 12:23:04 am by "perry"
Edit PageHistory Diff Info LikePages