1 /*

     2  * Copyright (c) 2009, 2011, 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.*;

    44 import java.net.URI;

    45 import java.nio.channels.*;

    46 import java.nio.file.*;

    47 import java.nio.file.DirectoryStream.Filter;

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

    49 import java.util.*;

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

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

    52 

    53 

    54 /**

    55  *

    56  * @author  Xueming Shen, Rajendra Gutupalli,Jaya Hangal

    57  */

    58 

    59 public class ZipPath implements Path {

    60 

    61     private final ZipFileSystem zfs;

    62     private final byte[] path;

    63     private volatile int[] offsets;

    64     private int hashcode = 0;  // cached hashcode (created lazily)

    65 

    66     ZipPath(ZipFileSystem zfs, byte[] path) {

    67         this(zfs, path, false);

    68     }

    69 

    70     ZipPath(ZipFileSystem zfs, byte[] path, boolean normalized)

    71     {

    72         this.zfs = zfs;

    73         if (normalized)

    74             this.path = path;

    75         else

    76             this.path = normalize(path);

    77     }

    78 

    79     @Override

    80     public ZipPath getRoot() {

    81         if (this.isAbsolute())

    82             return new ZipPath(zfs, new byte[]{path[0]});

    83         else

    84             return null;

    85     }

    86 

    87     @Override

    88     public Path getFileName() {

    89         initOffsets();

    90         int count = offsets.length;

    91         if (count == 0)

    92             return null;  // no elements so no name

    93         if (count == 1 && path[0] != '/')

    94             return this;

    95         int lastOffset = offsets[count-1];

    96         int len = path.length - lastOffset;

    97         byte[] result = new byte[len];

    98         System.arraycopy(path, lastOffset, result, 0, len);

    99         return new ZipPath(zfs, result);

   100     }

   101 

   102     @Override

   103     public ZipPath getParent() {

   104         initOffsets();

   105         int count = offsets.length;

   106         if (count == 0)    // no elements so no parent

   107             return null;

   108         int len = offsets[count-1] - 1;

   109         if (len <= 0)      // parent is root only (may be null)

   110             return getRoot();

   111         byte[] result = new byte[len];

   112         System.arraycopy(path, 0, result, 0, len);

   113         return new ZipPath(zfs, result);

   114     }

   115 

   116     @Override

   117     public int getNameCount() {

   118         initOffsets();

   119         return offsets.length;

   120     }

   121 

   122     @Override

   123     public ZipPath getName(int index) {

   124         initOffsets();

   125         if (index < 0 || index >= offsets.length)

   126             throw new IllegalArgumentException();

   127         int begin = offsets[index];

   128         int len;

   129         if (index == (offsets.length-1))

   130             len = path.length - begin;

   131         else

   132             len = offsets[index+1] - begin - 1;

   133         // construct result

   134         byte[] result = new byte[len];

   135         System.arraycopy(path, begin, result, 0, len);

   136         return new ZipPath(zfs, result);

   137     }

   138 

   139     @Override

   140     public ZipPath subpath(int beginIndex, int endIndex) {

   141         initOffsets();

   142         if (beginIndex < 0 ||

   143             beginIndex >=  offsets.length ||

   144             endIndex > offsets.length ||

   145             beginIndex >= endIndex)

   146             throw new IllegalArgumentException();

   147 

   148         // starting offset and length

   149         int begin = offsets[beginIndex];

   150         int len;

   151         if (endIndex == offsets.length)

   152             len = path.length - begin;

   153         else

   154             len = offsets[endIndex] - begin - 1;

   155         // construct result

   156         byte[] result = new byte[len];

   157         System.arraycopy(path, begin, result, 0, len);

   158         return new ZipPath(zfs, result);

   159     }

   160 

   161     @Override

   162     public ZipPath toRealPath(LinkOption... options) throws IOException {

   163         ZipPath realPath = new ZipPath(zfs, getResolvedPath()).toAbsolutePath();

   164         realPath.checkAccess();

   165         return realPath;

   166     }

   167 

   168     boolean isHidden() {

   169         return false;

   170     }

   171 

   172     @Override

   173     public ZipPath toAbsolutePath() {

   174         if (isAbsolute()) {

   175             return this;

   176         } else {

   177             //add / bofore the existing path

   178             byte[] defaultdir = zfs.getDefaultDir().path;

   179             int defaultlen = defaultdir.length;

   180             boolean endsWith = (defaultdir[defaultlen - 1] == '/');

   181             byte[] t = null;

   182             if (endsWith)

   183                 t = new byte[defaultlen + path.length];

   184             else

   185                 t = new byte[defaultlen + 1 + path.length];

   186             System.arraycopy(defaultdir, 0, t, 0, defaultlen);

   187             if (!endsWith)

   188                 t[defaultlen++] = '/';

   189             System.arraycopy(path, 0, t, defaultlen, path.length);

   190             return new ZipPath(zfs, t, true);  // normalized

   191         }

   192     }

   193 

   194     @Override

   195     public URI toUri() {

   196         try {

   197             return new URI("jar",

   198                            zfs.getZipFile().toUri() +

   199                            "!" +

   200                            zfs.getString(toAbsolutePath().path),

   201                            null);

   202         } catch (Exception ex) {

   203             throw new AssertionError(ex);

   204         }

   205     }

   206 

   207     private boolean equalsNameAt(ZipPath other, int index) {

   208         int mbegin = offsets[index];

   209         int mlen = 0;

   210         if (index == (offsets.length-1))

   211             mlen = path.length - mbegin;

   212         else

   213             mlen = offsets[index + 1] - mbegin - 1;

   214         int obegin = other.offsets[index];

   215         int olen = 0;

   216         if (index == (other.offsets.length - 1))

   217             olen = other.path.length - obegin;

   218         else

   219             olen = other.offsets[index + 1] - obegin - 1;

   220         if (mlen != olen)

   221             return false;

   222         int n = 0;

   223         while(n < mlen) {

   224             if (path[mbegin + n] != other.path[obegin + n])

   225                 return false;

   226             n++;

   227         }

   228         return true;

   229     }

   230 

   231     @Override

   232     public Path relativize(Path other) {

   233         final ZipPath o = checkPath(other);

   234         if (o.equals(this))

   235             return new ZipPath(getFileSystem(), new byte[0], true);

   236         if (/* this.getFileSystem() != o.getFileSystem() || */

   237             this.isAbsolute() != o.isAbsolute()) {

   238             throw new IllegalArgumentException();

   239         }

   240         int mc = this.getNameCount();

   241         int oc = o.getNameCount();

   242         int n = Math.min(mc, oc);

   243         int i = 0;

   244         while (i < n) {

   245             if (!equalsNameAt(o, i))

   246                 break;

   247             i++;

   248         }

   249         int dotdots = mc - i;

   250         int len = dotdots * 3 - 1;

   251         if (i < oc)

   252             len += (o.path.length - o.offsets[i] + 1);

   253         byte[] result = new byte[len];

   254 

   255         int pos = 0;

   256         while (dotdots > 0) {

   257             result[pos++] = (byte)'.';

   258             result[pos++] = (byte)'.';

   259             if (pos < len)       // no tailing slash at the end

   260                 result[pos++] = (byte)'/';

   261             dotdots--;

   262         }

   263         if (i < oc)

   264             System.arraycopy(o.path, o.offsets[i],

   265                              result, pos,

   266                              o.path.length - o.offsets[i]);

   267         return new ZipPath(getFileSystem(), result);

   268     }

   269 

   270     @Override

   271     public ZipFileSystem getFileSystem() {

   272         return zfs;

   273     }

   274 

   275     @Override

   276     public boolean isAbsolute() {

   277         return (this.path.length > 0 && path[0] == '/');

   278     }

   279 

   280     @Override

   281     public ZipPath resolve(Path other) {

   282         final ZipPath o = checkPath(other);

   283         if (o.isAbsolute())

   284             return o;

   285         byte[] resolved = null;

   286         if (this.path[path.length - 1] == '/') {

   287             resolved = new byte[path.length + o.path.length];

   288             System.arraycopy(path, 0, resolved, 0, path.length);

   289             System.arraycopy(o.path, 0, resolved, path.length, o.path.length);

   290         } else {

   291             resolved = new byte[path.length + 1 + o.path.length];

   292             System.arraycopy(path, 0, resolved, 0, path.length);

   293             resolved[path.length] = '/';

   294             System.arraycopy(o.path, 0, resolved, path.length + 1, o.path.length);

   295         }

   296         return new ZipPath(zfs, resolved);

   297     }

   298 

   299     @Override

   300     public Path resolveSibling(Path other) {

   301         if (other == null)

   302             throw new NullPointerException();

   303         Path parent = getParent();

   304         return (parent == null) ? other : parent.resolve(other);

   305     }

   306 

   307     @Override

   308     public boolean startsWith(Path other) {

   309         final ZipPath o = checkPath(other);

   310         if (o.isAbsolute() != this.isAbsolute() ||

   311             o.path.length > this.path.length)

   312             return false;

   313         int olast = o.path.length;

   314         for (int i = 0; i < olast; i++) {

   315             if (o.path[i] != this.path[i])

   316                 return false;

   317         }

   318         olast--;

   319         return o.path.length == this.path.length ||

   320                o.path[olast] == '/' ||

   321                this.path[olast + 1] == '/';

   322     }

   323 

   324     @Override

   325     public boolean endsWith(Path other) {

   326         final ZipPath o = checkPath(other);

   327         int olast = o.path.length - 1;

   328         if (olast > 0 && o.path[olast] == '/')

   329             olast--;

   330         int last = this.path.length - 1;

   331         if (last > 0 && this.path[last] == '/')

   332             last--;

   333         if (olast == -1)    // o.path.length == 0

   334             return last == -1;

   335         if ((o.isAbsolute() &&(!this.isAbsolute() || olast != last)) ||

   336             (last < olast))

   337             return false;

   338         for (; olast >= 0; olast--, last--) {

   339             if (o.path[olast] != this.path[last])

   340                 return false;

   341         }

   342         return o.path[olast + 1] == '/' ||

   343                last == -1 || this.path[last] == '/';

   344     }

   345 

   346     @Override

   347     public ZipPath resolve(String other) {

   348         return resolve(getFileSystem().getPath(other));

   349     }

   350 

   351     @Override

   352     public final Path resolveSibling(String other) {

   353         return resolveSibling(getFileSystem().getPath(other));

   354     }

   355 

   356     @Override

   357     public final boolean startsWith(String other) {

   358         return startsWith(getFileSystem().getPath(other));

   359     }

   360 

   361     @Override

   362     public final boolean endsWith(String other) {

   363         return endsWith(getFileSystem().getPath(other));

   364     }

   365 

   366     @Override

   367     public Path normalize() {

   368         byte[] resolved = getResolved();

   369         if (resolved == path)    // no change

   370             return this;

   371         return new ZipPath(zfs, resolved, true);

   372     }

   373 

   374     private ZipPath checkPath(Path path) {

   375         if (path == null)

   376             throw new NullPointerException();

   377         if (!(path instanceof ZipPath))

   378             throw new ProviderMismatchException();

   379         return (ZipPath) path;

   380     }

   381 

   382     // create offset list if not already created

   383     private void initOffsets() {

   384         if (offsets == null) {

   385             int count, index;

   386             // count names

   387             count = 0;

   388             index = 0;

   389             while (index < path.length) {

   390                 byte c = path[index++];

   391                 if (c != '/') {

   392                     count++;

   393                     while (index < path.length && path[index] != '/')

   394                         index++;

   395                 }

   396             }

   397             // populate offsets

   398             int[] result = new int[count];

   399             count = 0;

   400             index = 0;

   401             while (index < path.length) {

   402                 byte c = path[index];

   403                 if (c == '/') {

   404                     index++;

   405                 } else {

   406                     result[count++] = index++;

   407                     while (index < path.length && path[index] != '/')

   408                         index++;

   409                 }

   410             }

   411             synchronized (this) {

   412                 if (offsets == null)

   413                     offsets = result;

   414             }

   415         }

   416     }

   417 

   418     // resolved path for locating zip entry inside the zip file,

   419     // the result path does not contain ./ and .. components

   420     private volatile byte[] resolved = null;

   421     byte[] getResolvedPath() {

   422         byte[] r = resolved;

   423         if (r == null) {

   424             if (isAbsolute())

   425                 r = getResolved();

   426             else

   427                 r = toAbsolutePath().getResolvedPath();

   428             if (r[0] == '/')

   429                 r = Arrays.copyOfRange(r, 1, r.length);

   430             resolved = r;

   431         }

   432         return resolved;

   433     }

   434 

   435     // removes redundant slashs, replace "\" to zip separator "/"

   436     // and check for invalid characters

   437     private byte[] normalize(byte[] path) {

   438         if (path.length == 0)

   439             return path;

   440         byte prevC = 0;

   441         for (int i = 0; i < path.length; i++) {

   442             byte c = path[i];

   443             if (c == '\\')

   444                 return normalize(path, i);

   445             if (c == (byte)'/' && prevC == '/')

   446                 return normalize(path, i - 1);

   447             if (c == '\u0000')

   448                 throw new InvalidPathException(zfs.getString(path),

   449                                                "Path: nul character not allowed");

   450             prevC = c;

   451         }

   452         return path;

   453     }

   454 

   455     private byte[] normalize(byte[] path, int off) {

   456         byte[] to = new byte[path.length];

   457         int n = 0;

   458         while (n < off) {

   459             to[n] = path[n];

   460             n++;

   461         }

   462         int m = n;

   463         byte prevC = 0;

   464         while (n < path.length) {

   465             byte c = path[n++];

   466             if (c == (byte)'\\')

   467                 c = (byte)'/';

   468             if (c == (byte)'/' && prevC == (byte)'/')

   469                 continue;

   470             if (c == '\u0000')

   471                 throw new InvalidPathException(zfs.getString(path),

   472                                                "Path: nul character not allowed");

   473             to[m++] = c;

   474             prevC = c;

   475         }

   476         if (m > 1 && to[m - 1] == '/')

   477             m--;

   478         return (m == to.length)? to : Arrays.copyOf(to, m);

   479     }

   480 

   481     // Remove DotSlash(./) and resolve DotDot (..) components

   482     private byte[] getResolved() {

   483         if (path.length == 0)

   484             return path;

   485         for (int i = 0; i < path.length; i++) {

   486             byte c = path[i];

   487             if (c == (byte)'.')

   488                 return resolve0();

   489         }

   490         return path;

   491     }

   492 

   493     // TBD: performance, avoid initOffsets

   494     private byte[] resolve0() {

   495         byte[] to = new byte[path.length];

   496         int nc = getNameCount();

   497         int[] lastM = new int[nc];

   498         int lastMOff = -1;

   499         int m = 0;

   500         for (int i = 0; i < nc; i++) {

   501             int n = offsets[i];

   502             int len = (i == offsets.length - 1)?

   503                       (path.length - n):(offsets[i + 1] - n - 1);

   504             if (len == 1 && path[n] == (byte)'.') {

   505                 if (m == 0 && path[0] == '/')   // absolute path

   506                     to[m++] = '/';

   507                 continue;

   508             }

   509             if (len == 2 && path[n] == '.' && path[n + 1] == '.') {

   510                 if (lastMOff >= 0) {

   511                     m = lastM[lastMOff--];  // retreat

   512                     continue;

   513                 }

   514                 if (path[0] == '/') {  // "/../xyz" skip

   515                     if (m == 0)

   516                         to[m++] = '/';

   517                 } else {               // "../xyz" -> "../xyz"

   518                     if (m != 0 && to[m-1] != '/')

   519                         to[m++] = '/';

   520                     while (len-- > 0)

   521                         to[m++] = path[n++];

   522                 }

   523                 continue;

   524             }

   525             if (m == 0 && path[0] == '/' ||   // absolute path

   526                 m != 0 && to[m-1] != '/') {   // not the first name

   527                 to[m++] = '/';

   528             }

   529             lastM[++lastMOff] = m;

   530             while (len-- > 0)

   531                 to[m++] = path[n++];

   532         }

   533         if (m > 1 && to[m - 1] == '/')

   534             m--;

   535         return (m == to.length)? to : Arrays.copyOf(to, m);

   536     }

   537 

   538     @Override

   539     public String toString() {

   540         return zfs.getString(path);

   541     }

   542 

   543     @Override

   544     public int hashCode() {

   545         int h = hashcode;

   546         if (h == 0)

   547             hashcode = h = Arrays.hashCode(path);

   548         return h;

   549     }

   550 

   551     @Override

   552     public boolean equals(Object obj) {

   553         return obj != null &&

   554                obj instanceof ZipPath &&

   555                this.zfs == ((ZipPath)obj).zfs &&

   556                compareTo((Path) obj) == 0;

   557     }

   558 

   559     @Override

   560     public int compareTo(Path other) {

   561         final ZipPath o = checkPath(other);

   562         int len1 = this.path.length;

   563         int len2 = o.path.length;

   564 

   565         int n = Math.min(len1, len2);

   566         byte v1[] = this.path;

   567         byte v2[] = o.path;

   568 

   569         int k = 0;

   570         while (k < n) {

   571             int c1 = v1[k] & 0xff;

   572             int c2 = v2[k] & 0xff;

   573             if (c1 != c2)

   574                 return c1 - c2;

   575             k++;

   576         }

   577         return len1 - len2;

   578     }

   579 

   580     public WatchKey register(

   581             WatchService watcher,

   582             WatchEvent.Kind<?>[] events,

   583             WatchEvent.Modifier... modifiers) {

   584         if (watcher == null || events == null || modifiers == null) {

   585             throw new NullPointerException();

   586         }

   587         throw new UnsupportedOperationException();

   588     }

   589 

   590     @Override

   591     public WatchKey register(WatchService watcher, WatchEvent.Kind<?>... events) {

   592         return register(watcher, events, new WatchEvent.Modifier[0]);

   593     }

   594 

   595     @Override

   596     public final File toFile() {

   597         throw new UnsupportedOperationException();

   598     }

   599 

   600     @Override

   601     public Iterator<Path> iterator() {

   602         return new Iterator<Path>() {

   603             private int i = 0;

   604 

   605             @Override

   606             public boolean hasNext() {

   607                 return (i < getNameCount());

   608             }

   609 

   610             @Override

   611             public Path next() {

   612                 if (i < getNameCount()) {

   613                     Path result = getName(i);

   614                     i++;

   615                     return result;

   616                 } else {

   617                     throw new NoSuchElementException();

   618                 }

   619             }

   620 

   621             @Override

   622             public void remove() {

   623                 throw new ReadOnlyFileSystemException();

   624             }

   625         };

   626     }

   627 

   628     /////////////////////////////////////////////////////////////////////

   629 

   630 

   631     void createDirectory(FileAttribute<?>... attrs)

   632         throws IOException

   633     {

   634         zfs.createDirectory(getResolvedPath(), attrs);

   635     }

   636 

   637     InputStream newInputStream(OpenOption... options) throws IOException

   638     {

   639         if (options.length > 0) {

   640             for (OpenOption opt : options) {

   641                 if (opt != READ)

   642                     throw new UnsupportedOperationException("'" + opt + "' not allowed");

   643             }

   644         }

   645         return zfs.newInputStream(getResolvedPath());

   646     }

   647 

   648     DirectoryStream<Path> newDirectoryStream(Filter<? super Path> filter)

   649         throws IOException

   650     {

   651         return new ZipDirectoryStream(this, filter);

   652     }

   653 

   654     void delete() throws IOException {

   655         zfs.deleteFile(getResolvedPath(), true);

   656     }

   657 

   658     void deleteIfExists() throws IOException {

   659         zfs.deleteFile(getResolvedPath(), false);

   660     }

   661 

   662     ZipFileAttributes getAttributes() throws IOException

   663     {

   664         ZipFileAttributes zfas = zfs.getFileAttributes(getResolvedPath());

   665         if (zfas == null)

   666             throw new NoSuchFileException(toString());

   667         return zfas;

   668     }

   669 

   670     void setAttribute(String attribute, Object value, LinkOption... options)

   671         throws IOException

   672     {

   673         String type = null;

   674         String attr = null;

   675         int colonPos = attribute.indexOf(':');

   676         if (colonPos == -1) {

   677             type = "basic";

   678             attr = attribute;

   679         } else {

   680             type = attribute.substring(0, colonPos++);

   681             attr = attribute.substring(colonPos);

   682         }

   683         ZipFileAttributeView view = ZipFileAttributeView.get(this, type);

   684         if (view == null)

   685             throw new UnsupportedOperationException("view <" + view + "> is not supported");

   686         view.setAttribute(attr, value);

   687     }

   688 

   689     void setTimes(FileTime mtime, FileTime atime, FileTime ctime)

   690         throws IOException

   691     {

   692         zfs.setTimes(getResolvedPath(), mtime, atime, ctime);

   693     }

   694 

   695     Map<String, Object> readAttributes(String attributes, LinkOption... options)

   696         throws IOException

   697 

   698     {

   699         String view = null;

   700         String attrs = null;

   701         int colonPos = attributes.indexOf(':');

   702         if (colonPos == -1) {

   703             view = "basic";

   704             attrs = attributes;

   705         } else {

   706             view = attributes.substring(0, colonPos++);

   707             attrs = attributes.substring(colonPos);

   708         }

   709         ZipFileAttributeView zfv = ZipFileAttributeView.get(this, view);

   710         if (zfv == null) {

   711             throw new UnsupportedOperationException("view not supported");

   712         }

   713         return zfv.readAttributes(attrs);

   714     }

   715 

   716     FileStore getFileStore() throws IOException {

   717         // each ZipFileSystem only has one root (as requested for now)

   718         if (exists())

   719             return zfs.getFileStore(this);

   720         throw new NoSuchFileException(zfs.getString(path));

   721     }

   722 

   723     boolean isSameFile(Path other) throws IOException {

   724         if (this.equals(other))

   725             return true;

   726         if (other == null ||

   727             this.getFileSystem() != other.getFileSystem())

   728             return false;

   729         this.checkAccess();

   730         ((ZipPath)other).checkAccess();

   731         return Arrays.equals(this.getResolvedPath(),

   732                              ((ZipPath)other).getResolvedPath());

   733     }

   734 

   735     SeekableByteChannel newByteChannel(Set<? extends OpenOption> options,

   736                                        FileAttribute<?>... attrs)

   737         throws IOException

   738     {

   739         return zfs.newByteChannel(getResolvedPath(), options, attrs);

   740     }

   741 

   742 

   743     FileChannel newFileChannel(Set<? extends OpenOption> options,

   744                                FileAttribute<?>... attrs)

   745         throws IOException

   746     {

   747         return zfs.newFileChannel(getResolvedPath(), options, attrs);

   748     }

   749 

   750     void checkAccess(AccessMode... modes) throws IOException {

   751         boolean w = false;

   752         boolean x = false;

   753         for (AccessMode mode : modes) {

   754             switch (mode) {

   755                 case READ:

   756                     break;

   757                 case WRITE:

   758                     w = true;

   759                     break;

   760                 case EXECUTE:

   761                     x = true;

   762                     break;

   763                 default:

   764                     throw new UnsupportedOperationException();

   765             }

   766         }

   767         ZipFileAttributes attrs = zfs.getFileAttributes(getResolvedPath());

   768         if (attrs == null && (path.length != 1 || path[0] != '/'))

   769             throw new NoSuchFileException(toString());

   770         if (w) {

   771             if (zfs.isReadOnly())

   772                 throw new AccessDeniedException(toString());

   773         }

   774         if (x)

   775             throw new AccessDeniedException(toString());

   776     }

   777 

   778     boolean exists() {

   779         if (path.length == 1 && path[0] == '/')

   780             return true;

   781         try {

   782             return zfs.exists(getResolvedPath());

   783         } catch (IOException x) {}

   784         return false;

   785     }

   786 

   787     OutputStream newOutputStream(OpenOption... options) throws IOException

   788     {

   789         if (options.length == 0)

   790             return zfs.newOutputStream(getResolvedPath(),

   791                                        CREATE_NEW, WRITE);

   792         return zfs.newOutputStream(getResolvedPath(), options);

   793     }

   794 

   795     void move(ZipPath target, CopyOption... options)

   796         throws IOException

   797     {

   798         if (Files.isSameFile(this.zfs.getZipFile(), target.zfs.getZipFile()))

   799         {

   800             zfs.copyFile(true,

   801                          getResolvedPath(), target.getResolvedPath(),

   802                          options);

   803         } else {

   804             copyToTarget(target, options);

   805             delete();

   806         }

   807     }

   808 

   809     void copy(ZipPath target, CopyOption... options)

   810         throws IOException

   811     {

   812         if (Files.isSameFile(this.zfs.getZipFile(), target.zfs.getZipFile()))

   813             zfs.copyFile(false,

   814                          getResolvedPath(), target.getResolvedPath(),

   815                          options);

   816         else

   817             copyToTarget(target, options);

   818     }

   819 

   820     private void copyToTarget(ZipPath target, CopyOption... options)

   821         throws IOException

   822     {

   823         boolean replaceExisting = false;

   824         boolean copyAttrs = false;

   825         for (CopyOption opt : options) {

   826             if (opt == REPLACE_EXISTING)

   827                 replaceExisting = true;

   828             else if (opt == COPY_ATTRIBUTES)

   829                 copyAttrs = true;

   830         }

   831         // attributes of source file

   832         ZipFileAttributes zfas = getAttributes();

   833         // check if target exists

   834         boolean exists;

   835         if (replaceExisting) {

   836             try {

   837                 target.deleteIfExists();

   838                 exists = false;

   839             } catch (DirectoryNotEmptyException x) {

   840                 exists = true;

   841             }

   842         } else {

   843             exists = target.exists();

   844         }

   845         if (exists)

   846             throw new FileAlreadyExistsException(target.toString());

   847 

   848         if (zfas.isDirectory()) {

   849             // create directory or file

   850             target.createDirectory();

   851         } else {

   852             InputStream is = zfs.newInputStream(getResolvedPath());

   853             try {

   854                 OutputStream os = target.newOutputStream();

   855                 try {

   856                     byte[] buf = new byte[8192];

   857                     int n = 0;

   858                     while ((n = is.read(buf)) != -1) {

   859                         os.write(buf, 0, n);

   860                     }

   861                 } finally {

   862                     os.close();

   863                 }

   864             } finally {

   865                 is.close();

   866             }

   867         }

   868         if (copyAttrs) {

   869             BasicFileAttributeView view =

   870                 ZipFileAttributeView.get(target, BasicFileAttributeView.class);

   871             try {

   872                 view.setTimes(zfas.lastModifiedTime(),

   873                               zfas.lastAccessTime(),

   874                               zfas.creationTime());

   875             } catch (IOException x) {

   876                 // rollback?

   877                 try {

   878                     target.delete();

   879                 } catch (IOException ignore) { }

   880                 throw x;

   881             }

   882         }

   883     }

   884 }