The OpenNET Project / Index page

[ новости /+++ | форум | wiki | теги | ]

Интерактивная система просмотра системных руководств (man-ов)

 ТемаНаборКатегория 
 
 [Cписок руководств | Печать]

zip ()
  • >> zip (1) ( Solaris man: Команды и прикладные программы пользовательского уровня )
  • zip (1) ( Linux man: Команды и прикладные программы пользовательского уровня )
  • 
    NAME
         zip, zipcloak, zipnote,  zipsplit  -  package  and  compress
         (archive) files
    
    SYNOPSIS
         zip       [-AcdDeEfFghjklLmoqrRSTuvVwXyz@$]        [-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  pro-
         duced  by  zip.   zip  version  2.2 is compatible with PKZIP
         2.04.  Note that PKUNZIP 1.10 cannot extract files  produced
         by  PKZIP  2.04  or  zip  2.2. 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 specify-
         ing any parameters on the command line.
    
         The program is useful for packaging a set of files for  dis-
         tribution; 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 automati-
         cally 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 con-
         tains 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 -@, zip takes the  list  of
         input  files  from  standard input.  Under UNIX, this option
         can be used to  powerful  effect  in  conjunction  with  the
         find(1)  command.   For example, to archive all the C source
         files in the current directory and its subdirectories:
    
              find . -name "*.[ch]" -print | zip source -@
    
         (note that the pattern must be quoted to keep the shell from
         expanding  it).  zip will also accept a single dash ("-") as
         the zip file name, in which case it will write the zip  file
         to  standard  output,  allowing  the  output  to be piped to
         another program. For example:
    
              zip -r - . | dd of=/dev/nrst0 obs=16k
    
         would write the zip output  directly  to  a  tape  with  the
         specified  block  size  for  the  purpose  of backing up the
         current directory.
    
         zip also accepts a single dash ("-") as the name of  a  file
         to  be  compressed, in which case it will read the file from
         standard input, allowing zip to take input from another pro-
         gram. 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 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 tem-
         porary  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  exten-
         sion,  the extension .zip is added. If the name already con-
         tains an extension other than .zip the existing extension is
         kept unchanged.
    
    OPTIONS
         -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 "preamble" data.
    
         Note: self-extracting archives for the Amiga are  a  special
         case.   At present, only the Amiga port of Zip is capable of
         adjusting or updating these without corrupting them. -J  can
         be  used  to remove the SFX stub if other updates need to be
         made.
    
         -b 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  exam-
              ple:
    
                   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.
    
         -D   Do not create entries in the  zip  archive  for  direc-
              tories.   Directory  entries  are created by default so
              that their attributes can be saved in the zip  archive.
              The  environment  variable ZIPOPT can be used to change
              the default options. For example under Unix with sh:
    
                   ZIPOPT="-D"; export ZIPOPT
    
              (The variable ZIPOPT can be used for any option  except
              -i  and -x and can include several options.) The option
              -D is a shorthand for -x "*/" but the latter cannot  be
              set as default in the ZIPOPT environment variable.
    
         -e   Encrypt the contents of the zip archive using  a  pass-
              word  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.
    
         -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 com-
              pare 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 cor-
              rupted. 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 direc-
              tory  and its subdirectories that match the patterns in
              the file include.lst.
    
         -I   Don't scan through Image files. This option  is  avail-
              able  on  Acorn  RISC  OS only; 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).
    
         -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;  actu-
              ally,  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 "-n .gif:.zip"
    
              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   Save Amiga filenotes as zipfile comments. They  can  be
              restored  by  using the -N option of unzip. This option
              is available on the Amiga only. If -c is used also, you
              are  prompted for comments only for those files that do
              not have filenotes.
    
         -o   Set the "last modified" time of the zip archive to  the
              latest  (oldest)  "last  modified" time found among the
              entries in the zip archive.  This can be  used  without
              any other operations, if desired.  For example:
    
              zip -o foo
    
              will change the last modified time of  foo.zip  to  the
              latest time of the entries in foo.zip.
    
              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 ".", since the recursion  does
              not  use  the shell's file-name substitution mechanism.
              If you wish to include only a specific  subset  of  the
              files  in directory foo and its subdirectories, use the
              -i option  to  specify  the  pattern  of  files  to  be
              included.   You  should  not use -r with the name ".*",
              since that matches ".."  which will attempt to  zip  up
              the parent directory (probably not what was intended).
    
         -R   Travel the directory structure recursively starting  at
              the current directory; for example:
    
                   zip -R foo *.c
    
              In this case, all the files matching *.c  in  the  tree
              starting at the current directory are stored into a zip
              archive named  foo.zip.   Note  for  PKZIP  users:  the
              equivalent command is
    
                   pkzip -rP foo *.c
    
         -S   Include system and hidden files. This option is  effec-
              tive on some systems only; it is ignored on Unix.
    
         -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.  For example:
    
                   zip -rt 12071991 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 speci-
              fied  date, where mm is the month (0-12), dd is the day
              of the month (1-31), and yyyy is the year.   For  exam-
              ple:
                   zip -rtt 11301995 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   Save VMS file attributes. This option is  available  on
              VMS  only;  zip  archives created with this option will
              generally not be usable on other systems.
    
         -w   Append the version number of the  files  to  the  name,
              including  multiple  versions  of  files.   (VMS  only;
              default:  use only the most recent version of a  speci-
              fied 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 lev-
              els.
    
              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 < foowhat
    
         -#   Regulate the speed of compression using  the  specified
              digit  #,  where -0 indicates no compression (store all
              files), -1 indicates  the  fastest  compression  method
              (less   compression)   and  -9  indicates  the  slowest
              compression method (optimal  compression,  ignores  the
              suffix list). The default compression level is -6.
    
         -@   Take the list of input files from standard input.  Only
              one filename per line.
    
         -$   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
    
              This option is effective on some  systems  only  (MSDOS
              and OS/2); it is ignored on Unix.
    
    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 "." are not included; to include these
         as well:
    
              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 correspond-
         ing 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 ".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, use backslash to make zip do the pattern  match-
         ing with the -f (freshen) and -d (delete) options, and some-
         times after the  -x  (exclude)  option  when  used  with  an
         appropriate operation (add, -u, -f, or -d).
    
    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 success-
                   fully anyway;  some  broken  zipfiles  created  by
                   other archivers have simple work-arounds.
    
              4    zip was unable to allocate memory for one or  more
                   buffers during program initialization.
    
              5    a severe error in the zipfile format was detected.
                   Processing probably failed immediately.
    
              6    entry too large to be split with zipsplit
    
              7    invalid comment format
    
              8    zip -T failed or out of memory
    
              9    the user aborted zip  prematurely  with  control-C
                   (or similar)
    
              10   zip encountered an error while using a temp file
    
              11   read or seek error
    
              12   zip has nothing to do
    
              13   missing or empty zip file
    
              14   error writing to a file
    
              15   zip was unable to create a file to write to
    
              16   bad command line parameters
    
              18   zip could not open a specified file to read
    
         VMS interprets standard Unix (or PC) return values as other,
         scarier-looking  things,  so zip instead maps them into VMS-
         style status codes.  The current mapping is as follows:    1
         (success) for normal exit,
          and  (0x7fff000?  +  16*normal_zip_exit_status)   for   all
         errors,  where  the  `?'  is 0 (warning) for zip value 12, 2
         (error) for the zip values 3, 6, 7, 9, 13,  16,  18,  and  4
         (fatal error) for the remaining ones.
    
    BUGS
         zip 2.2 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.2 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 prop-
         erly.   Only stream-LF format zip files are expected to work
         with zip.  Others can be converted using Rahul Dhesi's  BILF
         program.  This version of zip handles some of the conversion
         internally.  When using Kermit to transfer  zip  files  from
         Vax  to  MSDOS, type "set file type block" on the Vax.  When
         transfering from MSDOS to Vax, type "set file type fixed" on
         the  Vax.   In  both  cases,  type "set file type binary" on
         MSDOS.
    
         Under VMS, zip hangs for file specification that uses DECnet
         syntax foo::*.*.
    
         On OS/2, zip cannot match some names, such as those  includ-
         ing  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.  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.
    
    AUTHORS
         Copyright (C) 1990-1997 Mark Adler, Richard B. Wales,  Jean-
         loup  Gailly, Onno van der Linden, Kai Uwe Rommel, Igor Man-
         drichenko,  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 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.
    
         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  com-
         pile  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  for-
         mat; 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 Peter-
         sen, 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 possi-
         ble.   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.
    
    
    
    


    Поиск по тексту MAN-ов: 




    Спонсоры:
    Слёрм
    Inferno Solutions
    Hosting by Ihor
    Хостинг:

    Закладки на сайте
    Проследить за страницей
    Created 1996-2019 by Maxim Chirkov
    Добавить, Поддержать, Вебмастеру