OS/2 Professional/OS2PRO194.ISO/os2/packer/zip19/zip.doc

Text File | 1994-02-03 | 23.5 KB | 525 lines

ZIP(1)                   USER COMMANDS                     ZIP(1)

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

SYNOPSIS
     zip [ -cdeEfghjklmoqruwyz@ ] [ -b temppath ] [ -n suffixes ]
     [ -t mmddyy ] [ zipfile list ] [ -x list ]

     zipcloak [ -d ] [ -b path ] zipfile

     zipnote [ -w ] [ -b path ] zipfile

     zipsplit [ -ti ] [ -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.
     It is analogous to a combination of tar and compress and  is
     compatible with PKZIP (Phil Katz ZIP) for MSDOS systems.

     There is a companion to zip called unzip (of  course)  which
     you  should  be able to find the same place you got zip. zip
     and unzip can work with files produced by PKZIP under MSDOS,
     and PKZIP and PKUNZIP can work with files produced by zip.

     zip version 1.9 is compatible with pkzip 1.93a.   Note  that
     pkunzip 1.10 cannot extract files produced by pkzip 1.93a or
     zip 1.9b. You must use pkunzip 1.93a or unzip 5.0 to extract
     them.

     For a brief help on zip and unzip, run each without specify-
     ing any parameters on the command line.

     zip puts one or more compressed files  into  a  single  "zip
     file"  along with information about the files, including the
     name, path if requested, date and time last  modified,  pro-
     tection,  and  check  information  to verify the fidelity of
     each entry.  zip can also be used as a  filter,  compressing
     standard  input  to standard output.  zip can pack an entire
     directory structure in a zip file  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. It automatically chooses
     the better of the two for each file to be compressed.

     zip is useful for packaging a set of files to send to  some-
     one  or for distribution; for archiving or backing up files;
     and for saving disk space by temporarily compressing  unused
     files or directories.

HOW TO USE ZIP
     The simplest use of zip is as follows:

          zip stuff *

     This will create the file "stuff.zip" (assuming it does  not
     exist)  and  put  all  the files in the current directory in
     stuff.zip in a compressed form.  The .zip  suffix  is  added
     automatically,  unless  that  file name given contains a dot
     already.  This allows specifying suffixes other than ".zip".

     Because of the way the  shell  does  filename  substitution,
     files  that  start  with a "." are not included.  To include
     those as well, you can:

          zip stuff .* *

     Even this will not include any subdirectories  that  are  in
     the  current  directory.  To zip up an entire directory, the
     command:

          zip -r foo foo

     will create the file "foo.zip" containing all the files  and
     directories  in  the  directory "foo" that is in the current
     directory. (The first "foo" denotes the zip file, the second
     one  denotes  the  directory.)  The "r" option means recurse
     through the directory structure.   In  this  case,  all  the
     files  and directories in foo are zipped, including the ones
     that start with a ".", since the recursion does not use  the
     shell's  file-name substitution.  You should not use -r with
     the name ".*", since that matches ".." which will attempt to
     zip up the parent directory--probably not what was intended.

     You may want to make a zip file that contains the  files  in
     foo,  but  not  record the directory name, foo.  You can use
     the -j (junk path) option to leave off the path:

          zip -j foo foo/*

     The -y option (only under Unix) will store symbolic links as
     such in the zip file, instead of compressing and storing the
     file referred to in the link.

     You might be zipping to save disk space, in which  case  you
     could:

          zip -rm foo foo

     where the "m" option means "move".  This will delete foo and
     its  contents  after  making  foo.zip.  No deletions will be
     done until the zip  has  completed  with  no  errors.   This
     option  is  obviously more dangerous and should be used with
     care.

     If the zip file already exists, these commands will  replace
     existing  or  add new entries to the zip file.  For example,
     if you were really short on disk space, you might  not  have
     enough room simultaneously to hold the directory foo and the
     compressed foo.zip.  In this case, you could do it in steps.
     If  foo  contained  the subdirectories tom, dick, and harry,
     then you could:

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

     where the first command would create foo.zip, and  the  next
     two would add to it.  At the completion of each zip command,
     the directory just zipped would be deleted, making  room  in
     which the next zip command could work.

     zip will also accept a single dash ("-")  as  the  zip  file
     name,  in  which  case it will write the zip file to stdout,
     allowing the output to be  piped  to  another  program.  For
     example:

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

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

     zip also accepts a single dash ("-") as the name of  a  file
     to  be  compressed,  in which case it will read the zip file
     from stdin, allowing zip to take input from another program.
     For example:

          tar cf - . | zip backup -

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

          unzip -p backup | tar xf -

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

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

     is equivalent to

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

     Zip archives created in this manner can  be  extracted  with
     the  program  funzip which is provided in the unzip package.
     For example,

             dd if=/dev/nrst0 | funzip | tar xvf -

MODIFYING EXISTING ZIP FILES
     When given the name of an existing zip file with  the  above
     commands,  zip will replace identically named entries in the
     zip file 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.

     When changing an existing zip file, zip will  write  a  tem-
     porary  file with the new contents, and only replace the old
     one when the zip has completed with no errors. You  can  use
     the  -b  option  to specify a different path (usually a dif-
     ferent device) to put the temporary file in.  For example:

          zip -b /tmp stuff *

     will put the temporary zip file and the  temporary  compres-
     sion  files  in the directory "/tmp", copying over stuff.zip
     in the current directory when done.

     If you are only adding entries to a zip file, not replacing,
     and  the -g option is given, then zip grows (appends to) the
     file instead of copying it.  The danger of this is  that  if
     the  operation fails, the original zip file is corrupted and
     lost.

     There are two other ways to change or add entries in  a  zip
     file  that  are  restrictions of simple addition or replace-
     ment.  The first is -u (update) which will add  new  entries
     to  the zip file as before but will replace existing entries
     only if the modified date of the file is  more  recent  than
     the  date recorded for that name in the zip file.  For exam-
     ple:

          zip -u stuff *

     will add any new files in the current directory, and  update
     any  changed files in the zip file stuff.zip.  Note that zip
     will not try to pack stuff.zip into itself when you do this.
     zip will always exclude the zip file from the files on which
     to be operated.

     The second restriction is -f (freshen) which,  like  update,
     will  only  replace entries with newer files; unlike update,
     will not add files that are not already  in  the  zip  file.
     For  this  option, you may want to simply freshen all of the
     files that are in the specified zip file.  To  do  this  you
     would simply:

          zip -f foo

     Note that the -f option with no arguments freshens  all  the
     entries  in the zip file.  The same is true of -u, and hence
     "zip -u foo" and "zip -f foo" both do the same thing.

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

     Another restriction that can be used with adding,  updating,
     or  freshening is -t (time), which will not operate on files
     modified earlier than the specified date.  For example:

          zip -rt 120791 infamy foo

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

     Also, files can be explicitly excluded using the -x option:

          zip -r foo foo -x \*.o

     which will zip up the  contents  of  foo  into  foo.zip  but
     exclude  all the files that end in ".o".  Here the backslash
     causes zip to match file names that were found when foo  was
     searched.

     The last operation is -d (delete) which will remove  entries
     from a zip file.  An example might be:

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

     which 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 once  again,  the  shell
     expansion  has  been inhibited with backslashes, so that zip
     can see the asterisks. zip can then match on the contents of
     the  zip  file instead of the contents of the current direc-
     tory.

     Under MSDOS, -d is case sensitive when it matches  names  in
     the  zip  file.  This allows deleting names that were zipped
     on other systems, but requires that the names be entered  in
     upper  case  if they were zipped on an MSDOS system, so that
     the names can be found in the zip file and deleted.

MORE OPTIONS
     As mentioned before, zip will use the best of  two  methods:
     deflate or store.

     The option -0 will force zip to use store on all files.  For
     example:

          zip -r0 foo foo

     will zip up the directory foo into foo.zip using only store.

     The speed of deflation can also be controlled  with  options
     -1  (fastest  method  but  less  compression)  to  -9  (best
     compression but slower). The default value is -5. For  exam-
     ple:

          zip -r8 foo foo

     In nearly all cases, a file that is already compressed  can-
     not  be  compressed further by zip, or if it can, the effect
     is minimal.  The -n  option  prevents  zip  from  trying  to
     compress files that have 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 put everything in 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.) The default suf-
     fix list is ".Z:.zip;.zoo:.arc:.lzh:.arj".  The  environment
     variable  ZIPOPT  can  be  used  to change this default. For
     example under Unix with csh:

          setenv ZIPOPT "-n .gif:.zip"

     The variable ZIPOPT can be  used  for  any  option  and  can
     include several options.

     Under Unix and  under  OS/2  (if  files  from  an  HPFS  are
     stored),  zip  will  store  the  full  path (relative to the
     current path) and name of the file (or just the name  if  -j
     is   specified)   in  the  zip  file  along  with  the  Unix
     attributes, and it will mark the entry as made  under  Unix.
     If  the  zip  file is intended for PKUNZIP under MSDOS, then
     the -k (Katz) option should be used to  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
     wasn't).

     The -o (older) option will set the "last modified"  time  of
     the  zip  file  to  the  latest  "last modified" time of the
     entries in the zip file.  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.

     The -e and -c options operate on all files updated or  added
     to the zip file.  Encryption (-e) will prompt for a password
     on the terminal and will not echo  the  password  as  it  is
     typed (if stderr is not a TTY, zip will exit with an error).
     New zip entries will be encrypted using that password.   For
     added  peace of mind, you can use -ee, which will prompt for
     the password twice, checking  that  the  two  are  the  same
     before   using   it.  The  encryption  code  is  distributed
     separately, so the -e option may not be  available  in  your
     version.

     One-line comments can be added for each  file  with  the  -c
     option.   The  zip file operations (adding or updating) will
     be done first, and you will then be prompted for a  one-line
     comment  for each file.  You can then enter the comment fol-
     lowed by return, or just return for no comment.

     The -z option will prompt you for a multi-line  comment  for
     the  entire zip file.  This option can be used by itself, or
     in combination with other options.  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).   Since  -z
     reads  the lines from stdin, you can simply take the comment
     from a file:

          zip -z foo < foowhat

     The -q (quiet) option eliminates the informational  messages
     and  comment  prompts while zip is operating.  This might be
     used in shell scripts, for example, or if the zip  operation
     is  being  performed  as  a background task ("zip -q foo *.c
     &").

     zip can take a list of file names to operate on  from  stdin
     using  the -@ option.  In Unix, this option can be used with
     the find command to extend greatly the functionality of zip.
     For example, to zip up all the C source files in the current
     directory and its subdirectories, you can:

          find . -type f -name "*.[ch]" -print | zip source -@

     Note that the pattern must be quoted to keep the shell  from
     expanding it.

     Under VMS only, the -w option will append the version number
     of  the  files  to  the name and zip up multiple versions of
     files.  Without -w, zip will only use the most  recent  ver-
     sion of the specified file(s).

     The -l option translates 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".

     If zip is run with the -h option, or with no  arguments  and
     standard  output is a terminal, the license and the command-
     argument and option help is shown.  The -L option just shows
     the license.

ABOUT PATTERN MATCHING
     (Note: this section applies to Unix.  Watch this  space  for
     details on MSDOS and VMS operation.)

     The Unix shell (sh or csh)  does  filename  substitution  on
     command  arguments.   The  special  characters  are ?, which
     matches any single character; * which matches any number  of
     characters  (including none); and [] which matches any char-
     acter in the  range  inside  the  brackets  (like  [a-f]  or
     [0-9]).   When  these  characters  are  encountered (and not
     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.

     zip can do the same matching on names that are  in  the  zip
     file  being  modified  or,  in  the case of the -x (exclude)
     option, 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 will look for the
     name in the zip file being modified (if  it  exists),  using
     the  pattern  matching  characters  above, if any.  For each
     match, it will add that name to the list  of  files  to  do.
     After  -x  (exclude),  the  names are removed from the to-do
     list instead of added.

     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  spe-
     cial  character  (i.e. ?*[]), or the entire argument must be
     enclosed in double quotes ("").

     In general, using backslash  to  make  zip  do  the  pattern
     matching  is  used  with  the  -f  (freshen) and -d (delete)
     options, and sometimes after the -x  (exclude)  option  when
     used  with  any  operation  (add,  -u, -f, or -d).  zip will
     never use pattern matching to search the  file  system.   If
     zip has recursed into a directory, all files (and all direc-
     tories) in there are fair game.

COPYRIGHT
     Copyright (C) 1990-1992 Mark Adler, Richard B. Wales,  Jean-
     loup  Gailly, Kai Uwe Rommel and Igor Mandrichenko.  Permis-
     sion is granted to any individual  or  institution  to  use,
     copy,  or  redistribute  this software so long as all of the
     original files are included unmodified, that it is not  sold
     for profit, and that this copyright notice is retained.

ACKNOWLEDGEMENTS
     Thanks to R. P.  Byrne  for  his  Shrink.Pas  program  which
     inspired  this project; to Phil Katz for making the zip file
     format, compression format, and .zip filename extension  all
     public  domain;  to  Steve  Burg  and  Phil Katz for help on
     unclear points of the deflate format; to Keith Petersen  and
     Rich Wales 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
     INFO-ZIP moderator, David Kirschbaum  for  getting  us  into
     this mess in the first place.

SEE ALSO
     unzip(1), tar(1), compress(1)

BUGS
     WARNING: zip files produced by this version of zip must  not
     be  *updated*  by  zip  1.0 or pkzip 1.10 or pkzip 1.93a, if
     they contain encrypted members, or if they  have  been  pro-
     duced  in  a  pipe or on a non seekable device. The old ver-
     sions of zip or pkzip would destroy the zip  structure.  The
     old  versions can list the contents of the zip file but can-
     not extract it anyway (because of the new compression  algo-
     rithm).   If  you do not use encryption and use regular disk
     files, you do not have to care about this problem.

     zip 1.9 is compatible with  pkzip  1.93a,  except  when  two
     features  are used: encryption or zip file created in a pipe
     or on a non seekable device. pkzip versions above  2.0  will
     support such files, and unzip 5.0 already supports them.

     Without -y, when zip must compress a symbolic link to an non
     existing   file,  it  only  displays  a  warning  "name  not
     matched". A better warnign should be given.

     Under VMS, not all of the odd file formats are treated prop-
     erly.   Only  zip files of format stream-LF and fixed length
     512 are expected to work with zip.  Others can be  converted
     using  Rahul Dhesi's BILF program.  This version of zip does
     handle some of the conversion internally.  When using Kermit
     to transfer zip files from Vax to MSDOS, type "set file type
     block" on the Vax.  When transfering from MSDOS to Vax, type
     "set  file type fixed" on the Vax.  In both cases, type "set
     file type binary" on MSDOS.

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

     Under OS/2, the amount of External 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.  How-
     ever,  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.

     LIKE ANYTHING ELSE THAT'S FREE, ZIP AND ITS ASSOCIATED UTIL-
     ITIES  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.

     That having been said, please send any problems or  comments
     via email to the Internet address [e-mail].  For
     bug reports, please include the version  of  zip,  the  make
     options  you  used  to compile it, the machine and operating
     system you are using, and as much additional information  as
     possible.  Thank you for your support.