1 /*

     2  * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  *

     8  *   - Redistributions of source code must retain the above copyright

     9  *     notice, this list of conditions and the following disclaimer.

    10  *

    11  *   - Redistributions in binary form must reproduce the above copyright

    12  *     notice, this list of conditions and the following disclaimer in the

    13  *     documentation and/or other materials provided with the distribution.

    14  *

    15  *   - Neither the name of Oracle nor the names of its

    16  *     contributors may be used to endorse or promote products derived

    17  *     from this software without specific prior written permission.

    18  *

    19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

    20  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

    21  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR

    23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

    27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

    28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

    29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    30  */

    31 

    32 /*

    33  * This source code is provided to illustrate the usage of a given feature

    34  * or technique and has been deliberately simplified. Additional steps

    35  * required for a production-quality application, such as security checks,

    36  * input validation and proper error handling, might not be present in

    37  * this sample code.

    38  */

    39 

    40 

    41 package com.sun.nio.zipfs;

    42 

    43 import java.io.BufferedOutputStream;

    44 import java.io.ByteArrayInputStream;

    45 import java.io.ByteArrayOutputStream;

    46 import java.io.EOFException;

    47 import java.io.File;

    48 import java.io.IOException;

    49 import java.io.InputStream;

    50 import java.io.OutputStream;

    51 import java.nio.ByteBuffer;

    52 import java.nio.MappedByteBuffer;

    53 import java.nio.channels.*;

    54 import java.nio.file.*;

    55 import java.nio.file.attribute.*;

    56 import java.nio.file.spi.*;

    57 import java.util.*;

    58 import java.util.concurrent.locks.ReadWriteLock;

    59 import java.util.concurrent.locks.ReentrantReadWriteLock;

    60 import java.util.regex.Pattern;

    61 import java.util.zip.CRC32;

    62 import java.util.zip.Inflater;

    63 import java.util.zip.Deflater;

    64 import java.util.zip.InflaterInputStream;

    65 import java.util.zip.DeflaterOutputStream;

    66 import java.util.zip.ZipException;

    67 import java.util.zip.ZipError;

    68 import static java.lang.Boolean.*;

    69 import static com.sun.nio.zipfs.ZipConstants.*;

    70 import static com.sun.nio.zipfs.ZipUtils.*;

    71 import static java.nio.file.StandardOpenOption.*;

    72 import static java.nio.file.StandardCopyOption.*;

    73 

    74 /**

    75  * A FileSystem built on a zip file

    76  *

    77  * @author Xueming Shen

    78  */

    79 

    80 public class ZipFileSystem extends FileSystem {

    81 

    82     private final ZipFileSystemProvider provider;

    83     private final ZipPath defaultdir;

    84     private boolean readOnly = false;

    85     private final Path zfpath;

    86     private final ZipCoder zc;

    87 

    88     // configurable by env map

    89     private final String  defaultDir;    // default dir for the file system

    90     private final String  nameEncoding;  // default encoding for name/comment

    91     private final boolean useTempFile;   // use a temp file for newOS, default

    92                                          // is to use BAOS for better performance

    93     private final boolean createNew;     // create a new zip if not exists

    94     private static final boolean isWindows =

    95         System.getProperty("os.name").startsWith("Windows");

    96 

    97     ZipFileSystem(ZipFileSystemProvider provider,

    98                   Path zfpath,

    99                   Map<String, ?> env)

   100         throws IOException

   101     {

   102         // configurable env setup

   103         this.createNew    = "true".equals(env.get("create"));

   104         this.nameEncoding = env.containsKey("encoding") ?

   105                             (String)env.get("encoding") : "UTF-8";

   106         this.useTempFile  = TRUE.equals(env.get("useTempFile"));

   107         this.defaultDir   = env.containsKey("default.dir") ?

   108                             (String)env.get("default.dir") : "/";

   109         if (this.defaultDir.charAt(0) != '/')

   110             throw new IllegalArgumentException("default dir should be absolute");

   111 

   112         this.provider = provider;

   113         this.zfpath = zfpath;

   114         if (Files.notExists(zfpath)) {

   115             if (createNew) {

   116                 try (OutputStream os = Files.newOutputStream(zfpath, CREATE_NEW, WRITE)) {

   117                     new END().write(os, 0);

   118                 }

   119             } else {

   120                 throw new FileSystemNotFoundException(zfpath.toString());

   121             }

   122         }

   123         // sm and existence check

   124         zfpath.getFileSystem().provider().checkAccess(zfpath, AccessMode.READ);

   125         if (!Files.isWritable(zfpath))

   126             this.readOnly = true;

   127         this.zc = ZipCoder.get(nameEncoding);

   128         this.defaultdir = new ZipPath(this, getBytes(defaultDir));

   129         this.ch = Files.newByteChannel(zfpath, READ);

   130         this.cen = initCEN();

   131     }

   132 

   133     @Override

   134     public FileSystemProvider provider() {

   135         return provider;

   136     }

   137 

   138     @Override

   139     public String getSeparator() {

   140         return "/";

   141     }

   142 

   143     @Override

   144     public boolean isOpen() {

   145         return isOpen;

   146     }

   147 

   148     @Override

   149     public boolean isReadOnly() {

   150         return readOnly;

   151     }

   152 

   153     private void checkWritable() throws IOException {

   154         if (readOnly)

   155             throw new ReadOnlyFileSystemException();

   156     }

   157 

   158     @Override

   159     public Iterable<Path> getRootDirectories() {

   160         ArrayList<Path> pathArr = new ArrayList<>();

   161         pathArr.add(new ZipPath(this, new byte[]{'/'}));

   162         return pathArr;

   163     }

   164 

   165     ZipPath getDefaultDir() {  // package private

   166         return defaultdir;

   167     }

   168 

   169     @Override

   170     public ZipPath getPath(String first, String... more) {

   171         String path;

   172         if (more.length == 0) {

   173             path = first;

   174         } else {

   175             StringBuilder sb = new StringBuilder();

   176             sb.append(first);

   177             for (String segment: more) {

   178                 if (segment.length() > 0) {

   179                     if (sb.length() > 0)

   180                         sb.append('/');

   181                     sb.append(segment);

   182                 }

   183             }

   184             path = sb.toString();

   185         }

   186         return new ZipPath(this, getBytes(path));

   187     }

   188 

   189     @Override

   190     public UserPrincipalLookupService getUserPrincipalLookupService() {

   191         throw new UnsupportedOperationException();

   192     }

   193 

   194     @Override

   195     public WatchService newWatchService() {

   196         throw new UnsupportedOperationException();

   197     }

   198 

   199     FileStore getFileStore(ZipPath path) {

   200         return new ZipFileStore(path);

   201     }

   202 

   203     @Override

   204     public Iterable<FileStore> getFileStores() {

   205         ArrayList<FileStore> list = new ArrayList<>(1);

   206         list.add(new ZipFileStore(new ZipPath(this, new byte[]{'/'})));

   207         return list;

   208     }

   209 

   210     private static final Set<String> supportedFileAttributeViews =

   211             Collections.unmodifiableSet(

   212                 new HashSet<String>(Arrays.asList("basic", "zip")));

   213 

   214     @Override

   215     public Set<String> supportedFileAttributeViews() {

   216         return supportedFileAttributeViews;

   217     }

   218 

   219     @Override

   220     public String toString() {

   221         return zfpath.toString();

   222     }

   223 

   224     Path getZipFile() {

   225         return zfpath;

   226     }

   227 

   228     private static final String GLOB_SYNTAX = "glob";

   229     private static final String REGEX_SYNTAX = "regex";

   230 

   231     @Override

   232     public PathMatcher getPathMatcher(String syntaxAndInput) {

   233         int pos = syntaxAndInput.indexOf(':');

   234         if (pos <= 0 || pos == syntaxAndInput.length()) {

   235             throw new IllegalArgumentException();

   236         }

   237         String syntax = syntaxAndInput.substring(0, pos);

   238         String input = syntaxAndInput.substring(pos + 1);

   239         String expr;

   240         if (syntax.equals(GLOB_SYNTAX)) {

   241             expr = toRegexPattern(input);

   242         } else {

   243             if (syntax.equals(REGEX_SYNTAX)) {

   244                 expr = input;

   245             } else {

   246                 throw new UnsupportedOperationException("Syntax '" + syntax +

   247                     "' not recognized");

   248             }

   249         }

   250         // return matcher

   251         final Pattern pattern = Pattern.compile(expr);

   252         return new PathMatcher() {

   253             @Override

   254             public boolean matches(Path path) {

   255                 return pattern.matcher(path.toString()).matches();

   256             }

   257         };

   258     }

   259 

   260     @Override

   261     public void close() throws IOException {

   262         beginWrite();

   263         try {

   264             if (!isOpen)

   265                 return;

   266             isOpen = false;             // set closed

   267         } finally {

   268             endWrite();

   269         }

   270         if (!streams.isEmpty()) {       // unlock and close all remaining streams

   271             Set<InputStream> copy = new HashSet<>(streams);

   272             for (InputStream is: copy)

   273                 is.close();

   274         }

   275         beginWrite();                   // lock and sync

   276         try {

   277             sync();

   278             ch.close();                 // close the ch just in case no update

   279         } finally {                     // and sync dose not close the ch

   280             endWrite();

   281         }

   282 

   283         synchronized (inflaters) {

   284             for (Inflater inf : inflaters)

   285                 inf.end();

   286         }

   287         synchronized (deflaters) {

   288             for (Deflater def : deflaters)

   289                 def.end();

   290         }

   291 

   292         IOException ioe = null;

   293         synchronized (tmppaths) {

   294             for (Path p: tmppaths) {

   295                 try {

   296                     Files.deleteIfExists(p);

   297                 } catch (IOException x) {

   298                     if (ioe == null)

   299                         ioe = x;

   300                     else

   301                         ioe.addSuppressed(x);

   302                 }

   303             }

   304         }

   305         provider.removeFileSystem(zfpath, this);

   306         if (ioe != null)

   307            throw ioe;

   308     }

   309 

   310     ZipFileAttributes getFileAttributes(byte[] path)

   311         throws IOException

   312     {

   313         Entry e;

   314         beginRead();

   315         try {

   316             ensureOpen();

   317             e = getEntry0(path);

   318             if (e == null) {

   319                 IndexNode inode = getInode(path);

   320                 if (inode == null)

   321                     return null;

   322                 e = new Entry(inode.name);       // pseudo directory

   323                 e.method = METHOD_STORED;        // STORED for dir

   324                 e.mtime = e.atime = e.ctime = -1;// -1 for all times

   325             }

   326         } finally {

   327             endRead();

   328         }

   329         return new ZipFileAttributes(e);

   330     }

   331 

   332     void setTimes(byte[] path, FileTime mtime, FileTime atime, FileTime ctime)

   333         throws IOException

   334     {

   335         checkWritable();

   336         beginWrite();

   337         try {

   338             ensureOpen();

   339             Entry e = getEntry0(path);    // ensureOpen checked

   340             if (e == null)

   341                 throw new NoSuchFileException(getString(path));

   342             if (e.type == Entry.CEN)

   343                 e.type = Entry.COPY;      // copy e

   344             if (mtime != null)

   345                 e.mtime = mtime.toMillis();

   346             if (atime != null)

   347                 e.atime = atime.toMillis();

   348             if (ctime != null)

   349                 e.ctime = ctime.toMillis();

   350             update(e);

   351         } finally {

   352             endWrite();

   353         }

   354     }

   355 

   356     boolean exists(byte[] path)

   357         throws IOException

   358     {

   359         beginRead();

   360         try {

   361             ensureOpen();

   362             return getInode(path) != null;

   363         } finally {

   364             endRead();

   365         }

   366     }

   367 

   368     boolean isDirectory(byte[] path)

   369         throws IOException

   370     {

   371         beginRead();

   372         try {

   373             IndexNode n = getInode(path);

   374             return n != null && n.isDir();

   375         } finally {

   376             endRead();

   377         }

   378     }

   379 

   380     private ZipPath toZipPath(byte[] path) {

   381         // make it absolute

   382         byte[] p = new byte[path.length + 1];

   383         p[0] = '/';

   384         System.arraycopy(path, 0, p, 1, path.length);

   385         return new ZipPath(this, p);

   386     }

   387 

   388     // returns the list of child paths of "path"

   389     Iterator<Path> iteratorOf(byte[] path,

   390                               DirectoryStream.Filter<? super Path> filter)

   391         throws IOException

   392     {

   393         beginWrite();    // iteration of inodes needs exclusive lock

   394         try {

   395             ensureOpen();

   396             IndexNode inode = getInode(path);

   397             if (inode == null)

   398                 throw new NotDirectoryException(getString(path));

   399             List<Path> list = new ArrayList<>();

   400             IndexNode child = inode.child;

   401             while (child != null) {

   402                 ZipPath zp = toZipPath(child.name);

   403                 if (filter == null || filter.accept(zp))

   404                     list.add(zp);

   405                 child = child.sibling;

   406             }

   407             return list.iterator();

   408         } finally {

   409             endWrite();

   410         }

   411     }

   412 

   413     void createDirectory(byte[] dir, FileAttribute<?>... attrs)

   414         throws IOException

   415     {

   416         checkWritable();

   417         dir = toDirectoryPath(dir);

   418         beginWrite();

   419         try {

   420             ensureOpen();

   421             if (dir.length == 0 || exists(dir))  // root dir, or exiting dir

   422                 throw new FileAlreadyExistsException(getString(dir));

   423             checkParents(dir);

   424             Entry e = new Entry(dir, Entry.NEW);

   425             e.method = METHOD_STORED;            // STORED for dir

   426             update(e);

   427         } finally {

   428             endWrite();

   429         }

   430     }

   431 

   432     void copyFile(boolean deletesrc, byte[]src, byte[] dst, CopyOption... options)

   433         throws IOException

   434     {

   435         checkWritable();

   436         if (Arrays.equals(src, dst))

   437             return;    // do nothing, src and dst are the same

   438 

   439         beginWrite();

   440         try {

   441             ensureOpen();

   442             Entry eSrc = getEntry0(src);  // ensureOpen checked

   443             if (eSrc == null)

   444                 throw new NoSuchFileException(getString(src));

   445             if (eSrc.isDir()) {    // spec says to create dst dir

   446                 createDirectory(dst);

   447                 return;

   448             }

   449             boolean hasReplace = false;

   450             boolean hasCopyAttrs = false;

   451             for (CopyOption opt : options) {

   452                 if (opt == REPLACE_EXISTING)

   453                     hasReplace = true;

   454                 else if (opt == COPY_ATTRIBUTES)

   455                     hasCopyAttrs = true;

   456             }

   457             Entry eDst = getEntry0(dst);

   458             if (eDst != null) {

   459                 if (!hasReplace)

   460                     throw new FileAlreadyExistsException(getString(dst));

   461             } else {

   462                 checkParents(dst);

   463             }

   464             Entry u = new Entry(eSrc, Entry.COPY);    // copy eSrc entry

   465             u.name(dst);                              // change name

   466             if (eSrc.type == Entry.NEW || eSrc.type == Entry.FILECH)

   467             {

   468                 u.type = eSrc.type;    // make it the same type

   469                 if (deletesrc) {       // if it's a "rename", take the data

   470                     u.bytes = eSrc.bytes;

   471                     u.file = eSrc.file;

   472                 } else {               // if it's not "rename", copy the data

   473                     if (eSrc.bytes != null)

   474                         u.bytes = Arrays.copyOf(eSrc.bytes, eSrc.bytes.length);

   475                     else if (eSrc.file != null) {

   476                         u.file = getTempPathForEntry(null);

   477                         Files.copy(eSrc.file, u.file, REPLACE_EXISTING);

   478                     }

   479                 }

   480             }

   481             if (!hasCopyAttrs)

   482                 u.mtime = u.atime= u.ctime = System.currentTimeMillis();

   483             update(u);

   484             if (deletesrc)

   485                 updateDelete(eSrc);

   486         } finally {

   487             endWrite();

   488         }

   489     }

   490 

   491     // Returns an output stream for writing the contents into the specified

   492     // entry.

   493     OutputStream newOutputStream(byte[] path, OpenOption... options)

   494         throws IOException

   495     {

   496         checkWritable();

   497         boolean hasCreateNew = false;

   498         boolean hasCreate = false;

   499         boolean hasAppend = false;

   500         for (OpenOption opt: options) {

   501             if (opt == READ)

   502                 throw new IllegalArgumentException("READ not allowed");

   503             if (opt == CREATE_NEW)

   504                 hasCreateNew = true;

   505             if (opt == CREATE)

   506                 hasCreate = true;

   507             if (opt == APPEND)

   508                 hasAppend = true;

   509         }

   510         beginRead();                 // only need a readlock, the "update()" will

   511         try {                        // try to obtain a writelock when the os is

   512             ensureOpen();            // being closed.

   513             Entry e = getEntry0(path);

   514             if (e != null) {

   515                 if (e.isDir() || hasCreateNew)

   516                     throw new FileAlreadyExistsException(getString(path));

   517                 if (hasAppend) {

   518                     InputStream is = getInputStream(e);

   519                     OutputStream os = getOutputStream(new Entry(e, Entry.NEW));

   520                     copyStream(is, os);

   521                     is.close();

   522                     return os;

   523                 }

   524                 return getOutputStream(new Entry(e, Entry.NEW));

   525             } else {

   526                 if (!hasCreate && !hasCreateNew)

   527                     throw new NoSuchFileException(getString(path));

   528                 checkParents(path);

   529                 return getOutputStream(new Entry(path, Entry.NEW));

   530             }

   531         } finally {

   532             endRead();

   533         }

   534     }

   535 

   536     // Returns an input stream for reading the contents of the specified

   537     // file entry.

   538     InputStream newInputStream(byte[] path) throws IOException {

   539         beginRead();

   540         try {

   541             ensureOpen();

   542             Entry e = getEntry0(path);

   543             if (e == null)

   544                 throw new NoSuchFileException(getString(path));

   545             if (e.isDir())

   546                 throw new FileSystemException(getString(path), "is a directory", null);

   547             return getInputStream(e);

   548         } finally {

   549             endRead();

   550         }

   551     }

   552 

   553     private void checkOptions(Set<? extends OpenOption> options) {

   554         // check for options of null type and option is an intance of StandardOpenOption

   555         for (OpenOption option : options) {

   556             if (option == null)

   557                 throw new NullPointerException();

   558             if (!(option instanceof StandardOpenOption))

   559                 throw new IllegalArgumentException();

   560         }

   561     }

   562 

   563     // Returns a Writable/ReadByteChannel for now. Might consdier to use

   564     // newFileChannel() instead, which dump the entry data into a regular

   565     // file on the default file system and create a FileChannel on top of

   566     // it.

   567     SeekableByteChannel newByteChannel(byte[] path,

   568                                        Set<? extends OpenOption> options,

   569                                        FileAttribute<?>... attrs)

   570         throws IOException

   571     {

   572         checkOptions(options);

   573         if (options.contains(StandardOpenOption.WRITE) ||

   574             options.contains(StandardOpenOption.APPEND)) {

   575             checkWritable();

   576             beginRead();

   577             try {

   578                 final WritableByteChannel wbc = Channels.newChannel(

   579                     newOutputStream(path, options.toArray(new OpenOption[0])));

   580                 long leftover = 0;

   581                 if (options.contains(StandardOpenOption.APPEND)) {

   582                     Entry e = getEntry0(path);

   583                     if (e != null && e.size >= 0)

   584                         leftover = e.size;

   585                 }

   586                 final long offset = leftover;

   587                 return new SeekableByteChannel() {

   588                     long written = offset;

   589                     public boolean isOpen() {

   590                         return wbc.isOpen();

   591                     }

   592 

   593                     public long position() throws IOException {

   594                         return written;

   595                     }

   596 

   597                     public SeekableByteChannel position(long pos)

   598                         throws IOException

   599                     {

   600                         throw new UnsupportedOperationException();

   601                     }

   602 

   603                     public int read(ByteBuffer dst) throws IOException {

   604                         throw new UnsupportedOperationException();

   605                     }

   606 

   607                     public SeekableByteChannel truncate(long size)

   608                         throws IOException

   609                     {

   610                         throw new UnsupportedOperationException();

   611                     }

   612 

   613                     public int write(ByteBuffer src) throws IOException {

   614                         int n = wbc.write(src);

   615                         written += n;

   616                         return n;

   617                     }

   618 

   619                     public long size() throws IOException {

   620                         return written;

   621                     }

   622 

   623                     public void close() throws IOException {

   624                         wbc.close();

   625                     }

   626                 };

   627             } finally {

   628                 endRead();

   629             }

   630         } else {

   631             beginRead();

   632             try {

   633                 ensureOpen();

   634                 Entry e = getEntry0(path);

   635                 if (e == null || e.isDir())

   636                     throw new NoSuchFileException(getString(path));

   637                 final ReadableByteChannel rbc =

   638                     Channels.newChannel(getInputStream(e));

   639                 final long size = e.size;

   640                 return new SeekableByteChannel() {

   641                     long read = 0;

   642                     public boolean isOpen() {

   643                         return rbc.isOpen();

   644                     }

   645 

   646                     public long position() throws IOException {

   647                         return read;

   648                     }

   649 

   650                     public SeekableByteChannel position(long pos)

   651                         throws IOException

   652                     {

   653                         throw new UnsupportedOperationException();

   654                     }

   655 

   656                     public int read(ByteBuffer dst) throws IOException {

   657                         int n = rbc.read(dst);

   658                         if (n > 0) {

   659                             read += n;

   660                         }

   661                         return n;

   662                     }

   663 

   664                     public SeekableByteChannel truncate(long size)

   665                     throws IOException

   666                     {

   667                         throw new NonWritableChannelException();

   668                     }

   669 

   670                     public int write (ByteBuffer src) throws IOException {

   671                         throw new NonWritableChannelException();

   672                     }

   673 

   674                     public long size() throws IOException {

   675                         return size;

   676                     }

   677 

   678                     public void close() throws IOException {

   679                         rbc.close();

   680                     }

   681                 };

   682             } finally {

   683                 endRead();

   684             }

   685         }

   686     }

   687 

   688     // Returns a FileChannel of the specified entry.

   689     //

   690     // This implementation creates a temporary file on the default file system,

   691     // copy the entry data into it if the entry exists, and then create a

   692     // FileChannel on top of it.

   693     FileChannel newFileChannel(byte[] path,

   694                                Set<? extends OpenOption> options,

   695                                FileAttribute<?>... attrs)

   696         throws IOException

   697     {

   698         checkOptions(options);

   699         final  boolean forWrite = (options.contains(StandardOpenOption.WRITE) ||

   700                                    options.contains(StandardOpenOption.APPEND));

   701         beginRead();

   702         try {

   703             ensureOpen();

   704             Entry e = getEntry0(path);

   705             if (forWrite) {

   706                 checkWritable();

   707                 if (e == null) {

   708                 if (!options.contains(StandardOpenOption.CREATE_NEW))

   709                     throw new NoSuchFileException(getString(path));

   710                 } else {

   711                     if (options.contains(StandardOpenOption.CREATE_NEW))

   712                         throw new FileAlreadyExistsException(getString(path));

   713                     if (e.isDir())

   714                         throw new FileAlreadyExistsException("directory <"

   715                             + getString(path) + "> exists");

   716                 }

   717                 options.remove(StandardOpenOption.CREATE_NEW); // for tmpfile

   718             } else if (e == null || e.isDir()) {

   719                 throw new NoSuchFileException(getString(path));

   720             }

   721 

   722             final boolean isFCH = (e != null && e.type == Entry.FILECH);

   723             final Path tmpfile = isFCH ? e.file : getTempPathForEntry(path);

   724             final FileChannel fch = tmpfile.getFileSystem()

   725                                            .provider()

   726                                            .newFileChannel(tmpfile, options, attrs);

   727             final Entry u = isFCH ? e : new Entry(path, tmpfile, Entry.FILECH);

   728             if (forWrite) {

   729                 u.flag = FLAG_DATADESCR;

   730                 u.method = METHOD_DEFLATED;

   731             }

   732             // is there a better way to hook into the FileChannel's close method?

   733             return new FileChannel() {

   734                 public int write(ByteBuffer src) throws IOException {

   735                     return fch.write(src);

   736                 }

   737                 public long write(ByteBuffer[] srcs, int offset, int length)

   738                     throws IOException

   739                 {

   740                     return fch.write(srcs, offset, length);

   741                 }

   742                 public long position() throws IOException {

   743                     return fch.position();

   744                 }

   745                 public FileChannel position(long newPosition)

   746                     throws IOException

   747                 {

   748                     fch.position(newPosition);

   749                     return this;

   750                 }

   751                 public long size() throws IOException {

   752                     return fch.size();

   753                 }

   754                 public FileChannel truncate(long size)

   755                     throws IOException

   756                 {

   757                     fch.truncate(size);

   758                     return this;

   759                 }

   760                 public void force(boolean metaData)

   761                     throws IOException

   762                 {

   763                     fch.force(metaData);

   764                 }

   765                 public long transferTo(long position, long count,

   766                                        WritableByteChannel target)

   767                     throws IOException

   768                 {

   769                     return fch.transferTo(position, count, target);

   770                 }

   771                 public long transferFrom(ReadableByteChannel src,

   772                                          long position, long count)

   773                     throws IOException

   774                 {

   775                     return fch.transferFrom(src, position, count);

   776                 }

   777                 public int read(ByteBuffer dst) throws IOException {

   778                     return fch.read(dst);

   779                 }

   780                 public int read(ByteBuffer dst, long position)

   781                     throws IOException

   782                 {

   783                     return fch.read(dst, position);

   784                 }

   785                 public long read(ByteBuffer[] dsts, int offset, int length)

   786                     throws IOException

   787                 {

   788                     return fch.read(dsts, offset, length);

   789                 }

   790                 public int write(ByteBuffer src, long position)

   791                     throws IOException

   792                     {

   793                    return fch.write(src, position);

   794                 }

   795                 public MappedByteBuffer map(MapMode mode,

   796                                             long position, long size)

   797                     throws IOException

   798                 {

   799                     throw new UnsupportedOperationException();

   800                 }

   801                 public FileLock lock(long position, long size, boolean shared)

   802                     throws IOException

   803                 {

   804                     return fch.lock(position, size, shared);

   805                 }

   806                 public FileLock tryLock(long position, long size, boolean shared)

   807                     throws IOException

   808                 {

   809                     return fch.tryLock(position, size, shared);

   810                 }

   811                 protected void implCloseChannel() throws IOException {

   812                     fch.close();

   813                     if (forWrite) {

   814                         u.mtime = System.currentTimeMillis();

   815                         u.size = Files.size(u.file);

   816 

   817                         update(u);

   818                     } else {

   819                         if (!isFCH)    // if this is a new fch for reading

   820                             removeTempPathForEntry(tmpfile);

   821                     }

   822                }

   823             };

   824         } finally {

   825             endRead();

   826         }

   827     }

   828 

   829     // the outstanding input streams that need to be closed

   830     private Set<InputStream> streams =

   831         Collections.synchronizedSet(new HashSet<InputStream>());

   832 

   833     // the ex-channel and ex-path that need to close when their outstanding

   834     // input streams are all closed by the obtainers.

   835     private Set<ExChannelCloser> exChClosers = new HashSet<>();

   836 

   837     private Set<Path> tmppaths = Collections.synchronizedSet(new HashSet<Path>());

   838     private Path getTempPathForEntry(byte[] path) throws IOException {

   839         Path tmpPath = createTempFileInSameDirectoryAs(zfpath);

   840         if (path != null) {

   841             Entry e = getEntry0(path);

   842             if (e != null) {

   843                 try (InputStream is = newInputStream(path)) {

   844                     Files.copy(is, tmpPath, REPLACE_EXISTING);

   845                 }

   846             }

   847         }

   848         return tmpPath;

   849     }

   850 

   851     private void removeTempPathForEntry(Path path) throws IOException {

   852         Files.delete(path);

   853         tmppaths.remove(path);

   854     }

   855 

   856     // check if all parents really exit. ZIP spec does not require

   857     // the existence of any "parent directory".

   858     private void checkParents(byte[] path) throws IOException {

   859         beginRead();

   860         try {

   861             while ((path = getParent(path)) != null && path.length != 0) {

   862                 if (!inodes.containsKey(IndexNode.keyOf(path))) {

   863                     throw new NoSuchFileException(getString(path));

   864                 }

   865             }

   866         } finally {

   867             endRead();

   868         }

   869     }

   870 

   871     private static byte[] ROOTPATH = new byte[0];

   872     private static byte[] getParent(byte[] path) {

   873         int off = path.length - 1;

   874         if (off > 0 && path[off] == '/')  // isDirectory

   875             off--;

   876         while (off > 0 && path[off] != '/') { off--; }

   877         if (off <= 0)

   878             return ROOTPATH;

   879         return Arrays.copyOf(path, off + 1);

   880     }

   881 

   882     private final void beginWrite() {

   883         rwlock.writeLock().lock();

   884     }

   885 

   886     private final void endWrite() {

   887         rwlock.writeLock().unlock();

   888     }

   889 

   890     private final void beginRead() {

   891         rwlock.readLock().lock();

   892     }

   893 

   894     private final void endRead() {

   895         rwlock.readLock().unlock();

   896     }

   897 

   898     ///////////////////////////////////////////////////////////////////

   899 

   900     private volatile boolean isOpen = true;

   901     private final SeekableByteChannel ch; // channel to the zipfile

   902     final byte[]  cen;     // CEN & ENDHDR

   903     private END  end;

   904     private long locpos;   // position of first LOC header (usually 0)

   905 

   906     private final ReadWriteLock rwlock = new ReentrantReadWriteLock();

   907 

   908     // name -> pos (in cen), IndexNode itself can be used as a "key"

   909     private LinkedHashMap<IndexNode, IndexNode> inodes;

   910 

   911     final byte[] getBytes(String name) {

   912         return zc.getBytes(name);

   913     }

   914 

   915     final String getString(byte[] name) {

   916         return zc.toString(name);

   917     }

   918 

   919     protected void finalize() throws IOException {

   920         close();

   921     }

   922 

   923     private long getDataPos(Entry e) throws IOException {

   924         if (e.locoff == -1) {

   925             Entry e2 = getEntry0(e.name);

   926             if (e2 == null)

   927                 throw new ZipException("invalid loc for entry <" + e.name + ">");

   928             e.locoff = e2.locoff;

   929         }

   930         byte[] buf = new byte[LOCHDR];

   931         if (readFullyAt(buf, 0, buf.length, e.locoff) != buf.length)

   932             throw new ZipException("invalid loc for entry <" + e.name + ">");

   933         return locpos + e.locoff + LOCHDR + LOCNAM(buf) + LOCEXT(buf);

   934     }

   935 

   936     // Reads len bytes of data from the specified offset into buf.

   937     // Returns the total number of bytes read.

   938     // Each/every byte read from here (except the cen, which is mapped).

   939     final long readFullyAt(byte[] buf, int off, long len, long pos)

   940         throws IOException

   941     {

   942         ByteBuffer bb = ByteBuffer.wrap(buf);

   943         bb.position(off);

   944         bb.limit((int)(off + len));

   945         return readFullyAt(bb, pos);

   946     }

   947 

   948     private final long readFullyAt(ByteBuffer bb, long pos)

   949         throws IOException

   950     {

   951         synchronized(ch) {

   952             return ch.position(pos).read(bb);

   953         }

   954     }

   955 

   956     // Searches for end of central directory (END) header. The contents of

   957     // the END header will be read and placed in endbuf. Returns the file

   958     // position of the END header, otherwise returns -1 if the END header

   959     // was not found or an error occurred.

   960     private END findEND() throws IOException

   961     {

   962         byte[] buf = new byte[READBLOCKSZ];

   963         long ziplen = ch.size();

   964         long minHDR = (ziplen - END_MAXLEN) > 0 ? ziplen - END_MAXLEN : 0;

   965         long minPos = minHDR - (buf.length - ENDHDR);

   966 

   967         for (long pos = ziplen - buf.length; pos >= minPos; pos -= (buf.length - ENDHDR))

   968         {

   969             int off = 0;

   970             if (pos < 0) {

   971                 // Pretend there are some NUL bytes before start of file

   972                 off = (int)-pos;

   973                 Arrays.fill(buf, 0, off, (byte)0);

   974             }

   975             int len = buf.length - off;

   976             if (readFullyAt(buf, off, len, pos + off) != len)

   977                 zerror("zip END header not found");

   978 

   979             // Now scan the block backwards for END header signature

   980             for (int i = buf.length - ENDHDR; i >= 0; i--) {

   981                 if (buf[i+0] == (byte)'P'    &&

   982                     buf[i+1] == (byte)'K'    &&

   983                     buf[i+2] == (byte)'\005' &&

   984                     buf[i+3] == (byte)'\006' &&

   985                     (pos + i + ENDHDR + ENDCOM(buf, i) == ziplen)) {

   986                     // Found END header

   987                     buf = Arrays.copyOfRange(buf, i, i + ENDHDR);

   988                     END end = new END();

   989                     end.endsub = ENDSUB(buf);

   990                     end.centot = ENDTOT(buf);

   991                     end.cenlen = ENDSIZ(buf);

   992                     end.cenoff = ENDOFF(buf);

   993                     end.comlen = ENDCOM(buf);

   994                     end.endpos = pos + i;

   995                     if (end.cenlen == ZIP64_MINVAL ||

   996                         end.cenoff == ZIP64_MINVAL ||

   997                         end.centot == ZIP64_MINVAL32)

   998                     {

   999                         // need to find the zip64 end;

  1000                         byte[] loc64 = new byte[ZIP64_LOCHDR];

  1001                         if (readFullyAt(loc64, 0, loc64.length, end.endpos - ZIP64_LOCHDR)

  1002                             != loc64.length) {

  1003                             return end;

  1004                         }

  1005                         long end64pos = ZIP64_LOCOFF(loc64);

  1006                         byte[] end64buf = new byte[ZIP64_ENDHDR];

  1007                         if (readFullyAt(end64buf, 0, end64buf.length, end64pos)

  1008                             != end64buf.length) {

  1009                             return end;

  1010                         }

  1011                         // end64 found, re-calcualte everything.

  1012                         end.cenlen = ZIP64_ENDSIZ(end64buf);

  1013                         end.cenoff = ZIP64_ENDOFF(end64buf);

  1014                         end.centot = (int)ZIP64_ENDTOT(end64buf); // assume total < 2g

  1015                         end.endpos = end64pos;

  1016                     }

  1017                     return end;

  1018                 }

  1019             }

  1020         }

  1021         zerror("zip END header not found");

  1022         return null; //make compiler happy

  1023     }

  1024 

  1025     // Reads zip file central directory. Returns the file position of first

  1026     // CEN header, otherwise returns -1 if an error occurred. If zip->msg != NULL

  1027     // then the error was a zip format error and zip->msg has the error text.

  1028     // Always pass in -1 for knownTotal; it's used for a recursive call.

  1029     private byte[] initCEN() throws IOException {

  1030         end = findEND();

  1031         if (end.endpos == 0) {

  1032             inodes = new LinkedHashMap<>(10);

  1033             locpos = 0;

  1034             buildNodeTree();

  1035             return null;         // only END header present

  1036         }

  1037         if (end.cenlen > end.endpos)

  1038             zerror("invalid END header (bad central directory size)");

  1039         long cenpos = end.endpos - end.cenlen;     // position of CEN table

  1040 

  1041         // Get position of first local file (LOC) header, taking into

  1042         // account that there may be a stub prefixed to the zip file.

  1043         locpos = cenpos - end.cenoff;

  1044         if (locpos < 0)

  1045             zerror("invalid END header (bad central directory offset)");

  1046 

  1047         // read in the CEN and END

  1048         byte[] cen = new byte[(int)(end.cenlen + ENDHDR)];

  1049         if (readFullyAt(cen, 0, cen.length, cenpos) != end.cenlen + ENDHDR) {

  1050             zerror("read CEN tables failed");

  1051         }

  1052         // Iterate through the entries in the central directory

  1053         inodes = new LinkedHashMap<>(end.centot + 1);

  1054         int pos = 0;

  1055         int limit = cen.length - ENDHDR;

  1056         while (pos < limit) {

  1057             if (CENSIG(cen, pos) != CENSIG)

  1058                 zerror("invalid CEN header (bad signature)");

  1059             int method = CENHOW(cen, pos);

  1060             int nlen   = CENNAM(cen, pos);

  1061             int elen   = CENEXT(cen, pos);

  1062             int clen   = CENCOM(cen, pos);

  1063             if ((CENFLG(cen, pos) & 1) != 0)

  1064                 zerror("invalid CEN header (encrypted entry)");

  1065             if (method != METHOD_STORED && method != METHOD_DEFLATED)

  1066                 zerror("invalid CEN header (unsupported compression method: " + method + ")");

  1067             if (pos + CENHDR + nlen > limit)

  1068                 zerror("invalid CEN header (bad header size)");

  1069             byte[] name = Arrays.copyOfRange(cen, pos + CENHDR, pos + CENHDR + nlen);

  1070             IndexNode inode = new IndexNode(name, pos);

  1071             inodes.put(inode, inode);

  1072             // skip ext and comment

  1073             pos += (CENHDR + nlen + elen + clen);

  1074         }

  1075         if (pos + ENDHDR != cen.length) {

  1076             zerror("invalid CEN header (bad header size)");

  1077         }

  1078         buildNodeTree();

  1079         return cen;

  1080     }

  1081 

  1082     private void ensureOpen() throws IOException {

  1083         if (!isOpen)

  1084             throw new ClosedFileSystemException();

  1085     }

  1086 

  1087     // Creates a new empty temporary file in the same directory as the

  1088     // specified file.  A variant of Files.createTempFile.

  1089     private Path createTempFileInSameDirectoryAs(Path path)

  1090         throws IOException

  1091     {

  1092         Path parent = path.toAbsolutePath().getParent();

  1093         Path dir = (parent == null) ? path.getFileSystem().getPath(".") : parent;

  1094         Path tmpPath = Files.createTempFile(dir, "zipfstmp", null);

  1095         tmppaths.add(tmpPath);

  1096         return tmpPath;

  1097     }

  1098 

  1099     ////////////////////update & sync //////////////////////////////////////

  1100 

  1101     private boolean hasUpdate = false;

  1102 

  1103     // shared key. consumer guarantees the "writeLock" before use it.

  1104     private final IndexNode LOOKUPKEY = IndexNode.keyOf(null);

  1105 

  1106     private void updateDelete(IndexNode inode) {

  1107         beginWrite();

  1108         try {

  1109             removeFromTree(inode);

  1110             inodes.remove(inode);

  1111             hasUpdate = true;

  1112         } finally {

  1113              endWrite();

  1114         }

  1115     }

  1116 

  1117     private void update(Entry e) {

  1118         beginWrite();

  1119         try {

  1120             IndexNode old = inodes.put(e, e);

  1121             if (old != null) {

  1122                 removeFromTree(old);

  1123             }

  1124             if (e.type == Entry.NEW || e.type == Entry.FILECH || e.type == Entry.COPY) {

  1125                 IndexNode parent = inodes.get(LOOKUPKEY.as(getParent(e.name)));

  1126                 e.sibling = parent.child;

  1127                 parent.child = e;

  1128             }

  1129             hasUpdate = true;

  1130         } finally {

  1131             endWrite();

  1132         }

  1133     }

  1134