1 /*
2 * Copyright (c) 2009, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.nio.zipfs;
27
28 import static java.lang.Boolean.TRUE;
29 import static jdk.nio.zipfs.ZipConstants.*;
30 import static jdk.nio.zipfs.ZipUtils.*;
31 import static java.nio.file.StandardOpenOption.*;
32 import static java.nio.file.StandardCopyOption.*;
33
34 import java.io.BufferedOutputStream;
35 import java.io.ByteArrayInputStream;
36 import java.io.ByteArrayOutputStream;
37 import java.io.EOFException;
38 import java.io.FilterOutputStream;
39 import java.io.IOException;
40 import java.io.InputStream;
41 import java.io.OutputStream;
42 import java.nio.ByteBuffer;
43 import java.nio.MappedByteBuffer;
44 import java.nio.channels.FileChannel;
45 import java.nio.channels.FileLock;
46 import java.nio.channels.ReadableByteChannel;
47 import java.nio.channels.SeekableByteChannel;
48 import java.nio.channels.WritableByteChannel;
49 import java.nio.file.*;
50 import java.nio.file.attribute.FileAttribute;
51 import java.nio.file.attribute.FileTime;
52 import java.nio.file.attribute.GroupPrincipal;
53 import java.nio.file.attribute.PosixFilePermission;
54 import java.nio.file.attribute.UserPrincipal;
55 import java.nio.file.attribute.UserPrincipalLookupService;
56 import java.nio.file.spi.FileSystemProvider;
57 import java.security.AccessController;
58 import java.security.PrivilegedAction;
59 import java.security.PrivilegedActionException;
60 import java.security.PrivilegedExceptionAction;
61 import java.util.ArrayList;
62 import java.util.Arrays;
63 import java.util.Collections;
64 import java.util.Formatter;
65 import java.util.HashSet;
66 import java.util.Iterator;
67 import java.util.LinkedHashMap;
68 import java.util.List;
69 import java.util.Map;
70 import java.util.Objects;
71 import java.util.Set;
72 import java.util.concurrent.locks.ReadWriteLock;
73 import java.util.concurrent.locks.ReentrantReadWriteLock;
74 import java.util.regex.Pattern;
75 import java.util.zip.CRC32;
76 import java.util.zip.Deflater;
77 import java.util.zip.DeflaterOutputStream;
78 import java.util.zip.Inflater;
79 import java.util.zip.InflaterInputStream;
80 import java.util.zip.ZipException;
81
82 /**
83 * A FileSystem built on a zip file
84 *
85 * @author Xueming Shen
86 */
87 class ZipFileSystem extends FileSystem {
88 private final ZipFileSystemProvider provider;
89 private final Path zfpath;
90 final ZipCoder zc;
91 private final ZipPath rootdir;
92 private boolean readOnly = false; // readonly file system
93
94 // configurable by env map
95 private final boolean noExtt; // see readExtra()
96 private final boolean useTempFile; // use a temp file for newOS, default
97 // is to use BAOS for better performance
98 private static final boolean isWindows = AccessController.doPrivileged(
99 (PrivilegedAction<Boolean>) () -> System.getProperty("os.name")
100 .startsWith("Windows"));
101 private final boolean forceEnd64;
102 private final int defaultMethod; // METHOD_STORED if "noCompression=true"
103 // METHOD_DEFLATED otherwise
104
105 ZipFileSystem(ZipFileSystemProvider provider,
106 Path zfpath,
107 Map<String, ?> env) throws IOException
108 {
109 // default encoding for name/comment
110 String nameEncoding = env.containsKey("encoding") ?
111 (String)env.get("encoding") : "UTF-8";
112 this.noExtt = "false".equals(env.get("zipinfo-time"));
113 this.useTempFile = isTrue(env, "useTempFile");
114 this.forceEnd64 = isTrue(env, "forceZIP64End");
115 this.defaultMethod = isTrue(env, "noCompression") ? METHOD_STORED: METHOD_DEFLATED;
116 if (Files.notExists(zfpath)) {
117 // create a new zip if not exists
118 if (isTrue(env, "create")) {
119 try (OutputStream os = Files.newOutputStream(zfpath, CREATE_NEW, WRITE)) {
120 new END().write(os, 0, forceEnd64);
121 }
122 } else {
123 throw new FileSystemNotFoundException(zfpath.toString());
124 }
125 }
126 // sm and existence check
127 zfpath.getFileSystem().provider().checkAccess(zfpath, AccessMode.READ);
128 boolean writeable = AccessController.doPrivileged(
129 (PrivilegedAction<Boolean>) () -> Files.isWritable(zfpath));
130 this.readOnly = !writeable;
131 this.zc = ZipCoder.get(nameEncoding);
132 this.rootdir = new ZipPath(this, new byte[]{'/'});
133 this.ch = Files.newByteChannel(zfpath, READ);
134 try {
135 this.cen = initCEN();
136 } catch (IOException x) {
137 try {
138 this.ch.close();
139 } catch (IOException xx) {
140 x.addSuppressed(xx);
141 }
142 throw x;
143 }
144 this.provider = provider;
145 this.zfpath = zfpath;
146 }
147
148 // returns true if there is a name=true/"true" setting in env
149 private static boolean isTrue(Map<String, ?> env, String name) {
150 return "true".equals(env.get(name)) || TRUE.equals(env.get(name));
151 }
152
153 @Override
154 public FileSystemProvider provider() {
155 return provider;
156 }
157
158 @Override
159 public String getSeparator() {
160 return "/";
161 }
162
163 @Override
164 public boolean isOpen() {
165 return isOpen;
166 }
167
168 @Override
169 public boolean isReadOnly() {
170 return readOnly;
171 }
172
173 private void checkWritable() throws IOException {
174 if (readOnly)
175 throw new ReadOnlyFileSystemException();
176 }
177
178 void setReadOnly() {
179 this.readOnly = true;
180 }
181
182 @Override
183 public Iterable<Path> getRootDirectories() {
184 return List.of(rootdir);
185 }
186
187 ZipPath getRootDir() {
188 return rootdir;
189 }
190
191 @Override
192 public ZipPath getPath(String first, String... more) {
193 if (more.length == 0) {
194 return new ZipPath(this, first);
195 }
196 StringBuilder sb = new StringBuilder();
197 sb.append(first);
198 for (String path : more) {
199 if (path.length() > 0) {
200 if (sb.length() > 0) {
201 sb.append('/');
202 }
203 sb.append(path);
204 }
205 }
206 return new ZipPath(this, sb.toString());
207 }
208
209 @Override
210 public UserPrincipalLookupService getUserPrincipalLookupService() {
211 throw new UnsupportedOperationException();
212 }
213
214 @Override
215 public WatchService newWatchService() {
216 throw new UnsupportedOperationException();
217 }
218
219 FileStore getFileStore(ZipPath path) {
220 return new ZipFileStore(path);
221 }
222
223 @Override
224 public Iterable<FileStore> getFileStores() {
225 return List.of(new ZipFileStore(rootdir));
226 }
227
228 private static final Set<String> supportedFileAttributeViews =
229 Set.of("basic", "zip");
230
231 @Override
232 public Set<String> supportedFileAttributeViews() {
233 return supportedFileAttributeViews;
234 }
235
236 @Override
237 public String toString() {
238 return zfpath.toString();
239 }
240
241 Path getZipFile() {
242 return zfpath;
243 }
244
245 private static final String GLOB_SYNTAX = "glob";
246 private static final String REGEX_SYNTAX = "regex";
247
248 @Override
249 public PathMatcher getPathMatcher(String syntaxAndInput) {
250 int pos = syntaxAndInput.indexOf(':');
251 if (pos <= 0 || pos == syntaxAndInput.length()) {
252 throw new IllegalArgumentException();
253 }
254 String syntax = syntaxAndInput.substring(0, pos);
255 String input = syntaxAndInput.substring(pos + 1);
256 String expr;
257 if (syntax.equalsIgnoreCase(GLOB_SYNTAX)) {
258 expr = toRegexPattern(input);
259 } else {
260 if (syntax.equalsIgnoreCase(REGEX_SYNTAX)) {
261 expr = input;
262 } else {
263 throw new UnsupportedOperationException("Syntax '" + syntax +
264 "' not recognized");
265 }
266 }
267 // return matcher
268 final Pattern pattern = Pattern.compile(expr);
269 return new PathMatcher() {
270 @Override
271 public boolean matches(Path path) {
272 return pattern.matcher(path.toString()).matches();
273 }
274 };
275 }
276
277 @Override
278 public void close() throws IOException {
279 beginWrite();
280 try {
281 if (!isOpen)
282 return;
283 isOpen = false; // set closed
284 } finally {
285 endWrite();
286 }
287 if (!streams.isEmpty()) { // unlock and close all remaining streams
288 Set<InputStream> copy = new HashSet<>(streams);
289 for (InputStream is : copy)
290 is.close();
291 }
292 beginWrite(); // lock and sync
293 try {
294 AccessController.doPrivileged((PrivilegedExceptionAction<Void>) () -> {
295 sync(); return null;
296 });
297 ch.close(); // close the ch just in case no update
298 // and sync didn't close the ch
299 } catch (PrivilegedActionException e) {
300 throw (IOException)e.getException();
301 } finally {
302 endWrite();
303 }
304
305 synchronized (inflaters) {
306 for (Inflater inf : inflaters)
307 inf.end();
308 }
309 synchronized (deflaters) {
310 for (Deflater def : deflaters)
311 def.end();
312 }
313
314 IOException ioe = null;
315 synchronized (tmppaths) {
316 for (Path p : tmppaths) {
317 try {
318 AccessController.doPrivileged(
319 (PrivilegedExceptionAction<Boolean>)() -> Files.deleteIfExists(p));
320 } catch (PrivilegedActionException e) {
321 IOException x = (IOException)e.getException();
322 if (ioe == null)
323 ioe = x;
324 else
325 ioe.addSuppressed(x);
326 }
327 }
328 }
329 provider.removeFileSystem(zfpath, this);
330 if (ioe != null)
331 throw ioe;
332 }
333
334 ZipFileAttributes getFileAttributes(byte[] path)
335 throws IOException
336 {
337 Entry e;
338 beginRead();
339 try {
340 ensureOpen();
341 e = getEntry(path);
342 if (e == null) {
343 IndexNode inode = getInode(path);
344 if (inode == null)
345 return null;
346 // pseudo directory, uses METHOD_STORED
347 e = new Entry(inode.name, inode.isdir, METHOD_STORED);
348 e.mtime = e.atime = e.ctime = zfsDefaultTimeStamp;
349 }
350 } finally {
351 endRead();
352 }
353 return e;
354 }
355
356 void checkAccess(byte[] path) throws IOException {
357 beginRead();
358 try {
359 ensureOpen();
360 // is it necessary to readCEN as a sanity check?
361 if (getInode(path) == null) {
362 throw new NoSuchFileException(toString());
363 }
364
365 } finally {
366 endRead();
367 }
368 }
369
370 void setTimes(byte[] path, FileTime mtime, FileTime atime, FileTime ctime)
371 throws IOException
372 {
373 checkWritable();
374 beginWrite();
375 try {
376 ensureOpen();
377 Entry e = getEntry(path); // ensureOpen checked
378 if (e == null)
379 throw new NoSuchFileException(getString(path));
380 if (e.type == Entry.CEN)
381 e.type = Entry.COPY; // copy e
382 if (mtime != null)
383 e.mtime = mtime.toMillis();
384 if (atime != null)
385 e.atime = atime.toMillis();
386 if (ctime != null)
387 e.ctime = ctime.toMillis();
388 update(e);
389 } finally {
390 endWrite();
391 }
392 }
393
394 boolean exists(byte[] path)
395 throws IOException
396 {
397 beginRead();
398 try {
399 ensureOpen();
400 return getInode(path) != null;
401 } finally {
402 endRead();
403 }
404 }
405
406 boolean isDirectory(byte[] path)
407 throws IOException
408 {
409 beginRead();
410 try {
411 IndexNode n = getInode(path);
412 return n != null && n.isDir();
413 } finally {
414 endRead();
415 }
416 }
417
418 // returns the list of child paths of "path"
419 Iterator<Path> iteratorOf(ZipPath dir,
420 DirectoryStream.Filter<? super Path> filter)
421 throws IOException
422 {
423 beginWrite(); // iteration of inodes needs exclusive lock
424 try {
425 ensureOpen();
426 byte[] path = dir.getResolvedPath();
427 IndexNode inode = getInode(path);
428 if (inode == null)
429 throw new NotDirectoryException(getString(path));
430 List<Path> list = new ArrayList<>();
431 IndexNode child = inode.child;
432 while (child != null) {
433 // (1) assume all path from zip file itself is "normalized"
434 // (2) IndexNode.name is absolute. see IndexNode(byte[],int,int)
435 // (3) if parent "dir" is relative when ZipDirectoryStream
436 // is created, the returned child path needs to be relative
437 // as well.
438 byte[] cname = child.name;
439 if (!dir.isAbsolute()) {
440 cname = Arrays.copyOfRange(cname, 1, cname.length);
441 }
442 ZipPath zpath = new ZipPath(this, cname, true);
443 if (filter == null || filter.accept(zpath))
444 list.add(zpath);
445 child = child.sibling;
446 }
447 return list.iterator();
448 } finally {
449 endWrite();
450 }
451 }
452
453 void createDirectory(byte[] dir, FileAttribute<?>... attrs)
454 throws IOException
455 {
456 checkWritable();
457 // dir = toDirectoryPath(dir);
458 beginWrite();
459 try {
460 ensureOpen();
461 if (dir.length == 0 || exists(dir)) // root dir, or exiting dir
462 throw new FileAlreadyExistsException(getString(dir));
463 checkParents(dir);
464 Entry e = new Entry(dir, Entry.NEW, true, METHOD_STORED, attrs);
465 update(e);
466 } finally {
467 endWrite();
468 }
469 }
470
471 void copyFile(boolean deletesrc, byte[]src, byte[] dst, CopyOption... options)
472 throws IOException
473 {
474 checkWritable();
475 if (Arrays.equals(src, dst))
476 return; // do nothing, src and dst are the same
477
478 beginWrite();
479 try {
480 ensureOpen();
481 Entry eSrc = getEntry(src); // ensureOpen checked
482
483 if (eSrc == null)
484 throw new NoSuchFileException(getString(src));
485 if (eSrc.isDir()) { // spec says to create dst dir
486 createDirectory(dst);
487 return;
488 }
489 boolean hasReplace = false;
490 boolean hasCopyAttrs = false;
491 for (CopyOption opt : options) {
492 if (opt == REPLACE_EXISTING)
493 hasReplace = true;
494 else if (opt == COPY_ATTRIBUTES)
495 hasCopyAttrs = true;
496 }
497 Entry eDst = getEntry(dst);
498 if (eDst != null) {
499 if (!hasReplace)
500 throw new FileAlreadyExistsException(getString(dst));
501 } else {
502 checkParents(dst);
503 }
504 Entry u = new Entry(eSrc, Entry.COPY); // copy eSrc entry
505 u.name(dst); // change name
506 if (eSrc.type == Entry.NEW || eSrc.type == Entry.FILECH)
507 {
508 u.type = eSrc.type; // make it the same type
509 if (deletesrc) { // if it's a "rename", take the data
510 u.bytes = eSrc.bytes;
511 u.file = eSrc.file;
512 } else { // if it's not "rename", copy the data
513 if (eSrc.bytes != null)
514 u.bytes = Arrays.copyOf(eSrc.bytes, eSrc.bytes.length);
515 else if (eSrc.file != null) {
516 u.file = getTempPathForEntry(null);
517 Files.copy(eSrc.file, u.file, REPLACE_EXISTING);
518 }
519 }
520 }
521 if (!hasCopyAttrs)
522 u.mtime = u.atime= u.ctime = System.currentTimeMillis();
523 update(u);
524 if (deletesrc)
525 updateDelete(eSrc);
526 } finally {
527 endWrite();
528 }
529 }
530
531 // Returns an output stream for writing the contents into the specified
532 // entry.
533 OutputStream newOutputStream(byte[] path, OpenOption... options)
534 throws IOException
535 {
536 checkWritable();
537 boolean hasCreateNew = false;
538 boolean hasCreate = false;
539 boolean hasAppend = false;
540 boolean hasTruncate = false;
541 for (OpenOption opt : options) {
542 if (opt == READ)
543 throw new IllegalArgumentException("READ not allowed");
544 if (opt == CREATE_NEW)
545 hasCreateNew = true;
546 if (opt == CREATE)
547 hasCreate = true;
548 if (opt == APPEND)
549 hasAppend = true;
550 if (opt == TRUNCATE_EXISTING)
551 hasTruncate = true;
552 }
553 if (hasAppend && hasTruncate)
554 throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed");
555 beginRead(); // only need a readlock, the "update()" will
556 try { // try to obtain a writelock when the os is
557 ensureOpen(); // being closed.
558 Entry e = getEntry(path);
559 if (e != null) {
560 if (e.isDir() || hasCreateNew)
561 throw new FileAlreadyExistsException(getString(path));
562 if (hasAppend) {
563 InputStream is = getInputStream(e);
564 OutputStream os = getOutputStream(new Entry(e, Entry.NEW));
565 is.transferTo(os);
566 is.close();
567 return os;
568 }
569 return getOutputStream(new Entry(e, Entry.NEW));
570 } else {
571 if (!hasCreate && !hasCreateNew)
572 throw new NoSuchFileException(getString(path));
573 checkParents(path);
574 return getOutputStream(new Entry(path, Entry.NEW, false, defaultMethod));
575 }
576 } finally {
577 endRead();
578 }
579 }
580
581 // Returns an input stream for reading the contents of the specified
582 // file entry.
583 InputStream newInputStream(byte[] path) throws IOException {
584 beginRead();
585 try {
586 ensureOpen();
587 Entry e = getEntry(path);
588 if (e == null)
589 throw new NoSuchFileException(getString(path));
590 if (e.isDir())
591 throw new FileSystemException(getString(path), "is a directory", null);
592 return getInputStream(e);
593 } finally {
594 endRead();
595 }
596 }
597
598 private void checkOptions(Set<? extends OpenOption> options) {
599 // check for options of null type and option is an intance of StandardOpenOption
600 for (OpenOption option : options) {
601 if (option == null)
602 throw new NullPointerException();
603 if (!(option instanceof StandardOpenOption))
604 throw new IllegalArgumentException();
605 }
606 if (options.contains(APPEND) && options.contains(TRUNCATE_EXISTING))
607 throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed");
608 }
609
610
611 // Returns an output SeekableByteChannel for either
612 // (1) writing the contents of a new entry, if the entry doesn't exit, or
613 // (2) updating/replacing the contents of an existing entry.
614 // Note: The content is not compressed.
615 private class EntryOutputChannel extends ByteArrayChannel {
616 Entry e;
617
618 EntryOutputChannel(Entry e) throws IOException {
619 super(e.size > 0? (int)e.size : 8192, false);
620 this.e = e;
621 if (e.mtime == -1)
622 e.mtime = System.currentTimeMillis();
623 if (e.method == -1)
624 e.method = defaultMethod;
625 // store size, compressed size, and crc-32 in datadescriptor
626 e.flag = FLAG_DATADESCR;
627 if (zc.isUTF8())
628 e.flag |= FLAG_USE_UTF8;
629 }
630
631 @Override
632 public void close() throws IOException {
633 e.bytes = toByteArray();
634 e.size = e.bytes.length;
635 e.crc = -1;
636 super.close();
637 update(e);
638 }
639 }
640
641 private int getCompressMethod(FileAttribute<?>... attrs) {
642 return defaultMethod;
643 }
644
645 // Returns a Writable/ReadByteChannel for now. Might consdier to use
646 // newFileChannel() instead, which dump the entry data into a regular
647 // file on the default file system and create a FileChannel on top of
648 // it.
649 SeekableByteChannel newByteChannel(byte[] path,
650 Set<? extends OpenOption> options,
651 FileAttribute<?>... attrs)
652 throws IOException
653 {
654 checkOptions(options);
655 if (options.contains(StandardOpenOption.WRITE) ||
656 options.contains(StandardOpenOption.APPEND)) {
657 checkWritable();
658 beginRead(); // only need a readlock, the "update()" will obtain
659 // thewritelock when the channel is closed
660 try {
661 ensureOpen();
662 Entry e = getEntry(path);
663 if (e != null) {
664 if (e.isDir() || options.contains(CREATE_NEW))
665 throw new FileAlreadyExistsException(getString(path));
666 SeekableByteChannel sbc =
667 new EntryOutputChannel(new Entry(e, Entry.NEW));
668 if (options.contains(APPEND)) {
669 try (InputStream is = getInputStream(e)) { // copyover
670 byte[] buf = new byte[8192];
671 ByteBuffer bb = ByteBuffer.wrap(buf);
672 int n;
673 while ((n = is.read(buf)) != -1) {
674 bb.position(0);
675 bb.limit(n);
676 sbc.write(bb);
677 }
678 }
679 }
680 return sbc;
681 }
682 if (!options.contains(CREATE) && !options.contains(CREATE_NEW))
683 throw new NoSuchFileException(getString(path));
684 checkParents(path);
685 return new EntryOutputChannel(
686 new Entry(path, Entry.NEW, false, getCompressMethod(attrs), attrs));
687
688 } finally {
689 endRead();
690 }
691 } else {
692 beginRead();
693 try {
694 ensureOpen();
695 Entry e = getEntry(path);
696 if (e == null || e.isDir())
697 throw new NoSuchFileException(getString(path));
698 try (InputStream is = getInputStream(e)) {
699 // TBD: if (e.size < NNNNN);
700 return new ByteArrayChannel(is.readAllBytes(), true);
701 }
702 } finally {
703 endRead();
704 }
705 }
706 }
707
708 // Returns a FileChannel of the specified entry.
709 //
710 // This implementation creates a temporary file on the default file system,
711 // copy the entry data into it if the entry exists, and then create a
712 // FileChannel on top of it.
713 FileChannel newFileChannel(byte[] path,
714 Set<? extends OpenOption> options,
715 FileAttribute<?>... attrs)
716 throws IOException
717 {
718 checkOptions(options);
719 final boolean forWrite = (options.contains(StandardOpenOption.WRITE) ||
720 options.contains(StandardOpenOption.APPEND));
721 beginRead();
722 try {
723 ensureOpen();
724 Entry e = getEntry(path);
725 if (forWrite) {
726 checkWritable();
727 if (e == null) {
728 if (!options.contains(StandardOpenOption.CREATE) &&
729 !options.contains(StandardOpenOption.CREATE_NEW)) {
730 throw new NoSuchFileException(getString(path));
731 }
732 } else {
733 if (options.contains(StandardOpenOption.CREATE_NEW)) {
734 throw new FileAlreadyExistsException(getString(path));
735 }
736 if (e.isDir())
737 throw new FileAlreadyExistsException("directory <"
738 + getString(path) + "> exists");
739 }
740 options = new HashSet<>(options);
741 options.remove(StandardOpenOption.CREATE_NEW); // for tmpfile
742 } else if (e == null || e.isDir()) {
743 throw new NoSuchFileException(getString(path));
744 }
745
746 final boolean isFCH = (e != null && e.type == Entry.FILECH);
747 final Path tmpfile = isFCH ? e.file : getTempPathForEntry(path);
748 final FileChannel fch = tmpfile.getFileSystem()
749 .provider()
750 .newFileChannel(tmpfile, options, attrs);
751 final Entry u = isFCH ? e : new Entry(path, tmpfile, Entry.FILECH, attrs);
752 if (forWrite) {
753 u.flag = FLAG_DATADESCR;
754 u.method = getCompressMethod(attrs);
755 }
756 // is there a better way to hook into the FileChannel's close method?
757 return new FileChannel() {
758 public int write(ByteBuffer src) throws IOException {
759 return fch.write(src);
760 }
761 public long write(ByteBuffer[] srcs, int offset, int length)
762 throws IOException
763 {
764 return fch.write(srcs, offset, length);
765 }
766 public long position() throws IOException {
767 return fch.position();
768 }
769 public FileChannel position(long newPosition)
770 throws IOException
771 {
772 fch.position(newPosition);
773 return this;
774 }
775 public long size() throws IOException {
776 return fch.size();
777 }
778 public FileChannel truncate(long size)
779 throws IOException
780 {
781 fch.truncate(size);
782 return this;
783 }
784 public void force(boolean metaData)
785 throws IOException
786 {
787 fch.force(metaData);
788 }
789 public long transferTo(long position, long count,
790 WritableByteChannel target)
791 throws IOException
792 {
793 return fch.transferTo(position, count, target);
794 }
795 public long transferFrom(ReadableByteChannel src,
796 long position, long count)
797 throws IOException
798 {
799 return fch.transferFrom(src, position, count);
800 }
801 public int read(ByteBuffer dst) throws IOException {
802 return fch.read(dst);
803 }
804 public int read(ByteBuffer dst, long position)
805 throws IOException
806 {
807 return fch.read(dst, position);
808 }
809 public long read(ByteBuffer[] dsts, int offset, int length)
810 throws IOException
811 {
812 return fch.read(dsts, offset, length);
813 }
814 public int write(ByteBuffer src, long position)
815 throws IOException
816 {
817 return fch.write(src, position);
818 }
819 public MappedByteBuffer map(MapMode mode,
820 long position, long size)
821 throws IOException
822 {
823 throw new UnsupportedOperationException();
824 }
825 public FileLock lock(long position, long size, boolean shared)
826 throws IOException
827 {
828 return fch.lock(position, size, shared);
829 }
830 public FileLock tryLock(long position, long size, boolean shared)
831 throws IOException
832 {
833 return fch.tryLock(position, size, shared);
834 }
835 protected void implCloseChannel() throws IOException {
836 fch.close();
837 if (forWrite) {
838 u.mtime = System.currentTimeMillis();
839 u.size = Files.size(u.file);
840
841 update(u);
842 } else {
843 if (!isFCH) // if this is a new fch for reading
844 removeTempPathForEntry(tmpfile);
845 }
846 }
847 };
848 } finally {
849 endRead();
850 }
851 }
852
853 // the outstanding input streams that need to be closed
854 private Set<InputStream> streams =
855 Collections.synchronizedSet(new HashSet<InputStream>());
856
857 private Set<Path> tmppaths = Collections.synchronizedSet(new HashSet<Path>());
858 private Path getTempPathForEntry(byte[] path) throws IOException {
859 Path tmpPath = createTempFileInSameDirectoryAs(zfpath);
860 if (path != null) {
861 Entry e = getEntry(path);
862 if (e != null) {
863 try (InputStream is = newInputStream(path)) {
864 Files.copy(is, tmpPath, REPLACE_EXISTING);
865 }
866 }
867 }
868 return tmpPath;
869 }
870
871 private void removeTempPathForEntry(Path path) throws IOException {
872 Files.delete(path);
873 tmppaths.remove(path);
874 }
875
876 // check if all parents really exit. ZIP spec does not require
877 // the existence of any "parent directory".
878 private void checkParents(byte[] path) throws IOException {
879 beginRead();
880 try {
881 while ((path = getParent(path)) != null &&
882 path != ROOTPATH) {
883 if (!inodes.containsKey(IndexNode.keyOf(path))) {
884 throw new NoSuchFileException(getString(path));
885 }
886 }
887 } finally {
888 endRead();
889 }
890 }
891
892 private static byte[] ROOTPATH = new byte[] { '/' };
893 private static byte[] getParent(byte[] path) {
894 int off = getParentOff(path);
895 if (off <= 1)
896 return ROOTPATH;
897 return Arrays.copyOf(path, off);
898 }
899
900 private static int getParentOff(byte[] path) {
901 int off = path.length - 1;
902 if (off > 0 && path[off] == '/') // isDirectory
903 off--;
904 while (off > 0 && path[off] != '/') { off--; }
905 return off;
906 }
907
908 private final void beginWrite() {
909 rwlock.writeLock().lock();
910 }
911
912 private final void endWrite() {
913 rwlock.writeLock().unlock();
914 }
915
916 private final void beginRead() {
917 rwlock.readLock().lock();
918 }
919
920 private final void endRead() {
921 rwlock.readLock().unlock();
922 }
923
924 ///////////////////////////////////////////////////////////////////
925
926 private volatile boolean isOpen = true;
927 private final SeekableByteChannel ch; // channel to the zipfile
928 final byte[] cen; // CEN & ENDHDR
929 private END end;
930 private long locpos; // position of first LOC header (usually 0)
931
932 private final ReadWriteLock rwlock = new ReentrantReadWriteLock();
933
934 // name -> pos (in cen), IndexNode itself can be used as a "key"
935 private LinkedHashMap<IndexNode, IndexNode> inodes;
936
937 final byte[] getBytes(String name) {
938 return zc.getBytes(name);
939 }
940
941 final String getString(byte[] name) {
942 return zc.toString(name);
943 }
944
945 @SuppressWarnings("deprecation")
946 protected void finalize() throws IOException {
947 close();
948 }
949
950 // Reads len bytes of data from the specified offset into buf.
951 // Returns the total number of bytes read.
952 // Each/every byte read from here (except the cen, which is mapped).
953 final long readFullyAt(byte[] buf, int off, long len, long pos)
954 throws IOException
955 {
956 ByteBuffer bb = ByteBuffer.wrap(buf);
957 bb.position(off);
958 bb.limit((int)(off + len));
959 return readFullyAt(bb, pos);
960 }
961
962 private final long readFullyAt(ByteBuffer bb, long pos)
963 throws IOException
964 {
965 synchronized(ch) {
966 return ch.position(pos).read(bb);
967 }
968 }
969
970 // Searches for end of central directory (END) header. The contents of
971 // the END header will be read and placed in endbuf. Returns the file
972 // position of the END header, otherwise returns -1 if the END header
973 // was not found or an error occurred.
974 private END findEND() throws IOException
975 {
976 byte[] buf = new byte[READBLOCKSZ];
977 long ziplen = ch.size();
978 long minHDR = (ziplen - END_MAXLEN) > 0 ? ziplen - END_MAXLEN : 0;
979 long minPos = minHDR - (buf.length - ENDHDR);
980
981 for (long pos = ziplen - buf.length; pos >= minPos; pos -= (buf.length - ENDHDR))
982 {
983 int off = 0;
984 if (pos < 0) {
985 // Pretend there are some NUL bytes before start of file
986 off = (int)-pos;
987 Arrays.fill(buf, 0, off, (byte)0);
988 }
989 int len = buf.length - off;
990 if (readFullyAt(buf, off, len, pos + off) != len)
991 zerror("zip END header not found");
992
993 // Now scan the block backwards for END header signature
994 for (int i = buf.length - ENDHDR; i >= 0; i--) {
995 if (buf[i+0] == (byte)'P' &&
996 buf[i+1] == (byte)'K' &&
997 buf[i+2] == (byte)'\005' &&
998 buf[i+3] == (byte)'\006' &&
999 (pos + i + ENDHDR + ENDCOM(buf, i) == ziplen)) {
1000 // Found END header
1001 buf = Arrays.copyOfRange(buf, i, i + ENDHDR);
1002 END end = new END();
1003 end.endsub = ENDSUB(buf);
1004 end.centot = ENDTOT(buf);
1005 end.cenlen = ENDSIZ(buf);
1006 end.cenoff = ENDOFF(buf);
1007 end.comlen = ENDCOM(buf);
1008 end.endpos = pos + i;
1009 // try if there is zip64 end;
1010 byte[] loc64 = new byte[ZIP64_LOCHDR];
1011 if (end.endpos < ZIP64_LOCHDR ||
1012 readFullyAt(loc64, 0, loc64.length, end.endpos - ZIP64_LOCHDR)
1013 != loc64.length ||
1014 !locator64SigAt(loc64, 0)) {
1015 return end;
1016 }
1017 long end64pos = ZIP64_LOCOFF(loc64);
1018 byte[] end64buf = new byte[ZIP64_ENDHDR];
1019 if (readFullyAt(end64buf, 0, end64buf.length, end64pos)
1020 != end64buf.length ||
1021 !end64SigAt(end64buf, 0)) {
1022 return end;
1023 }
1024 // end64 found,
1025 long cenlen64 = ZIP64_ENDSIZ(end64buf);
1026 long cenoff64 = ZIP64_ENDOFF(end64buf);
1027 long centot64 = ZIP64_ENDTOT(end64buf);
1028 // double-check
1029 if (cenlen64 != end.cenlen && end.cenlen != ZIP64_MINVAL ||
1030 cenoff64 != end.cenoff && end.cenoff != ZIP64_MINVAL ||
1031 centot64 != end.centot && end.centot != ZIP64_MINVAL32) {
1032 return end;
1033 }
1034 // to use the end64 values
1035 end.cenlen = cenlen64;
1036 end.cenoff = cenoff64;
1037 end.centot = (int)centot64; // assume total < 2g
1038 end.endpos = end64pos;
1039 return end;
1040 }
1041 }
1042 }
1043 zerror("zip END header not found");
1044 return null; //make compiler happy
1045 }
1046
1047 // Reads zip file central directory. Returns the file position of first
1048 // CEN header, otherwise returns -1 if an error occurred. If zip->msg != NULL
1049 // then the error was a zip format error and zip->msg has the error text.
1050 // Always pass in -1 for knownTotal; it's used for a recursive call.
1051 private byte[] initCEN() throws IOException {
1052 end = findEND();
1053 if (end.endpos == 0) {
1054 inodes = new LinkedHashMap<>(10);
1055 locpos = 0;
1056 buildNodeTree();
1057 return null; // only END header present
1058 }
1059 if (end.cenlen > end.endpos)
1060 zerror("invalid END header (bad central directory size)");
1061 long cenpos = end.endpos - end.cenlen; // position of CEN table
1062
1063 // Get position of first local file (LOC) header, taking into
1064 // account that there may be a stub prefixed to the zip file.
1065 locpos = cenpos - end.cenoff;
1066 if (locpos < 0)
1067 zerror("invalid END header (bad central directory offset)");
1068
1069 // read in the CEN and END
1070 byte[] cen = new byte[(int)(end.cenlen + ENDHDR)];
1071 if (readFullyAt(cen, 0, cen.length, cenpos) != end.cenlen + ENDHDR) {
1072 zerror("read CEN tables failed");
1073 }
1074 // Iterate through the entries in the central directory
1075 inodes = new LinkedHashMap<>(end.centot + 1);
1076 int pos = 0;
1077 int limit = cen.length - ENDHDR;
1078 while (pos < limit) {
1079 if (!cenSigAt(cen, pos))
1080 zerror("invalid CEN header (bad signature)");
1081 int method = CENHOW(cen, pos);
1082 int nlen = CENNAM(cen, pos);
1083 int elen = CENEXT(cen, pos);
1084 int clen = CENCOM(cen, pos);
1085 if ((CENFLG(cen, pos) & 1) != 0) {
1086 zerror("invalid CEN header (encrypted entry)");
1087 }
1088 if (method != METHOD_STORED && method != METHOD_DEFLATED) {
1089 zerror("invalid CEN header (unsupported compression method: " + method + ")");
1090 }
1091 if (pos + CENHDR + nlen > limit) {
1092 zerror("invalid CEN header (bad header size)");
1093 }
1094 IndexNode inode = new IndexNode(cen, pos, nlen);
1095 inodes.put(inode, inode);
1096
1097 // skip ext and comment
1098 pos += (CENHDR + nlen + elen + clen);
1099 }
1100 if (pos + ENDHDR != cen.length) {
1101 zerror("invalid CEN header (bad header size)");
1102 }
1103 buildNodeTree();
1104 return cen;
1105 }
1106
1107 private void ensureOpen() throws IOException {
1108 if (!isOpen)
1109 throw new ClosedFileSystemException();
1110 }
1111
1112 // Creates a new empty temporary file in the same directory as the
1113 // specified file. A variant of Files.createTempFile.
1114 private Path createTempFileInSameDirectoryAs(Path path)
1115 throws IOException
1116 {
1117 Path parent = path.toAbsolutePath().getParent();
1118 Path dir = (parent == null) ? path.getFileSystem().getPath(".") : parent;
1119 Path tmpPath = Files.createTempFile(dir, "zipfstmp", null);
1120 tmppaths.add(tmpPath);
1121 return tmpPath;
1122 }
1123
1124 ////////////////////update & sync //////////////////////////////////////
1125
1126 private boolean hasUpdate = false;
1127
1128 // shared key. consumer guarantees the "writeLock" before use it.
1129 private final IndexNode LOOKUPKEY = new IndexNode(null, -1);
1130
1131 private void updateDelete(IndexNode inode) {
1132 beginWrite();
1133 try {
1134 removeFromTree(inode);
1135 inodes.remove(inode);
1136 hasUpdate = true;
1137 } finally {
1138 endWrite();
1139 }
1140 }
1141
1142 private void update(Entry e) {
1143 beginWrite();
1144 try {
1145 IndexNode old = inodes.put(e, e);
1146 if (old != null) {
1147 removeFromTree(old);
1148 }
1149 if (e.type == Entry.NEW || e.type == Entry.FILECH || e.type == Entry.COPY) {
1150 IndexNode parent = inodes.get(LOOKUPKEY.as(getParent(e.name)));
1151 e.sibling = parent.child;
1152 parent.child = e;
1153 }
1154 hasUpdate = true;
1155 } finally {
1156 endWrite();
1157 }
1158 }
1159
1160 // copy over the whole LOC entry (header if necessary, data and ext) from
1161 // old zip to the new one.
1162 private long copyLOCEntry(Entry e, boolean updateHeader,
1163 OutputStream os,
1164 long written, byte[] buf)
1165 throws IOException
1166 {
1167 long locoff = e.locoff; // where to read
1168 e.locoff = written; // update the e.locoff with new value
1169
1170 // calculate the size need to write out
1171 long size = 0;
1172 // if there is A ext
1173 if ((e.flag & FLAG_DATADESCR) != 0) {
1174 if (e.size >= ZIP64_MINVAL || e.csize >= ZIP64_MINVAL)
1175 size = 24;
1176 else
1177 size = 16;
1178 }
1179 // read loc, use the original loc.elen/nlen
1180 //
1181 // an extra byte after loc is read, which should be the first byte of the
1182 // 'name' field of the loc. if this byte is '/', which means the original
1183 // entry has an absolute path in original zip/jar file, the e.writeLOC()
1184 // is used to output the loc, in which the leading "/" will be removed
1185 if (readFullyAt(buf, 0, LOCHDR + 1 , locoff) != LOCHDR + 1)
1186 throw new ZipException("loc: reading failed");
1187
1188 if (updateHeader || LOCNAM(buf) > 0 && buf[LOCHDR] == '/') {
1189 locoff += LOCHDR + LOCNAM(buf) + LOCEXT(buf); // skip header
1190 size += e.csize;
1191 written = e.writeLOC(os) + size;
1192 } else {
1193 os.write(buf, 0, LOCHDR); // write out the loc header
1194 locoff += LOCHDR;
1195 // use e.csize, LOCSIZ(buf) is zero if FLAG_DATADESCR is on
1196 // size += LOCNAM(buf) + LOCEXT(buf) + LOCSIZ(buf);
1197 size += LOCNAM(buf) + LOCEXT(buf) + e.csize;
1198 written = LOCHDR + size;
1199 }
1200 int n;
1201 while (size > 0 &&
1202 (n = (int)readFullyAt(buf, 0, buf.length, locoff)) != -1)
1203 {
1204 if (size < n)
1205 n = (int)size;
1206 os.write(buf, 0, n);
1207 size -= n;
1208 locoff += n;
1209 }
1210 return written;
1211 }
1212
1213 private long writeEntry(Entry e, OutputStream os, byte[] buf)
1214 throws IOException {
1215
1216 if (e.bytes == null && e.file == null) // dir, 0-length data
1217 return 0;
1218
1219 long written = 0;
1220 try (OutputStream os2 = e.method == METHOD_STORED ?
1221 new EntryOutputStreamCRC32(e, os) : new EntryOutputStreamDef(e, os)) {
1222 if (e.bytes != null) { // in-memory
1223 os2.write(e.bytes, 0, e.bytes.length);
1224 } else if (e.file != null) { // tmp file
1225 if (e.type == Entry.NEW || e.type == Entry.FILECH) {
1226 try (InputStream is = Files.newInputStream(e.file)) {
1227 is.transferTo(os2);
1228 }
1229 }
1230 Files.delete(e.file);
1231 tmppaths.remove(e.file);
1232 }
1233 }
1234 written += e.csize;
1235 if ((e.flag & FLAG_DATADESCR) != 0) {
1236 written += e.writeEXT(os);
1237 }
1238 return written;
1239 }
1240
1241 // sync the zip file system, if there is any udpate
1242 private void sync() throws IOException {
1243
1244 if (!hasUpdate)
1245 return;
1246 Path tmpFile = createTempFileInSameDirectoryAs(zfpath);
1247 try (OutputStream os = new BufferedOutputStream(Files.newOutputStream(tmpFile, WRITE)))
1248 {
1249 ArrayList<Entry> elist = new ArrayList<>(inodes.size());
1250 long written = 0;
1251 byte[] buf = new byte[8192];
1252 Entry e = null;
1253
1254 // write loc
1255 for (IndexNode inode : inodes.values()) {
1256 if (inode instanceof Entry) { // an updated inode
1257 e = (Entry)inode;
1258 try {
1259 if (e.type == Entry.COPY) {
1260 // entry copy: the only thing changed is the "name"
1261 // and "nlen" in LOC header, so we udpate/rewrite the
1262 // LOC in new file and simply copy the rest (data and
1263 // ext) without enflating/deflating from the old zip
1264 // file LOC entry.
1265 written += copyLOCEntry(e, true, os, written, buf);
1266 } else { // NEW, FILECH or CEN
1267 e.locoff = written;
1268 written += e.writeLOC(os); // write loc header
1269 written += writeEntry(e, os, buf);
1270 }
1271 elist.add(e);
1272 } catch (IOException x) {
1273 x.printStackTrace(); // skip any in-accurate entry
1274 }
1275 } else { // unchanged inode
1276 if (inode.pos == -1) {
1277 continue; // pseudo directory node
1278 }
1279 if (inode.name.length == 1 && inode.name[0] == '/') {
1280 continue; // no root '/' directory even it
1281 // exits in original zip/jar file.
1282 }
1283 e = Entry.readCEN(this, inode);
1284 try {
1285 written += copyLOCEntry(e, false, os, written, buf);
1286 elist.add(e);
1287 } catch (IOException x) {
1288 x.printStackTrace(); // skip any wrong entry
1289 }
1290 }
1291 }
1292
1293 // now write back the cen and end table
1294 end.cenoff = written;
1295 for (Entry entry : elist) {
1296 written += entry.writeCEN(os);
1297 }
1298 end.centot = elist.size();
1299 end.cenlen = written - end.cenoff;
1300 end.write(os, written, forceEnd64);
1301 }
1302
1303 ch.close();
1304 Files.delete(zfpath);
1305 Files.move(tmpFile, zfpath, REPLACE_EXISTING);
1306 hasUpdate = false; // clear
1307 }
1308
1309 IndexNode getInode(byte[] path) {
1310 if (path == null)
1311 throw new NullPointerException("path");
1312 return inodes.get(IndexNode.keyOf(path));
1313 }
1314
1315 Entry getEntry(byte[] path) throws IOException {
1316 IndexNode inode = getInode(path);
1317 if (inode instanceof Entry)
1318 return (Entry)inode;
1319 if (inode == null || inode.pos == -1)
1320 return null;
1321 return Entry.readCEN(this, inode);
1322 }
1323
1324 public void deleteFile(byte[] path, boolean failIfNotExists)
1325 throws IOException
1326 {
1327 checkWritable();
1328
1329 IndexNode inode = getInode(path);
1330 if (inode == null) {
1331 if (path != null && path.length == 0)
1332 throw new ZipException("root directory </> can't not be delete");
1333 if (failIfNotExists)
1334 throw new NoSuchFileException(getString(path));
1335 } else {
1336 if (inode.isDir() && inode.child != null)
1337 throw new DirectoryNotEmptyException(getString(path));
1338 updateDelete(inode);
1339 }
1340 }
1341
1342 // Returns an out stream for either
1343 // (1) writing the contents of a new entry, if the entry exits, or
1344 // (2) updating/replacing the contents of the specified existing entry.
1345 private OutputStream getOutputStream(Entry e) throws IOException {
1346
1347 if (e.mtime == -1)
1348 e.mtime = System.currentTimeMillis();
1349 if (e.method == -1)
1350 e.method = defaultMethod;
1351 // store size, compressed size, and crc-32 in datadescr
1352 e.flag = FLAG_DATADESCR;
1353 if (zc.isUTF8())
1354 e.flag |= FLAG_USE_UTF8;
1355 OutputStream os;
1356 if (useTempFile) {
1357 e.file = getTempPathForEntry(null);
1358 os = Files.newOutputStream(e.file, WRITE);
1359 } else {
1360 os = new ByteArrayOutputStream((e.size > 0)? (int)e.size : 8192);
1361 }
1362 return new EntryOutputStream(e, os);
1363 }
1364
1365 private class EntryOutputStream extends FilterOutputStream {
1366 private Entry e;
1367 private long written;
1368 private boolean isClosed;
1369
1370 EntryOutputStream(Entry e, OutputStream os) throws IOException {
1371 super(os);
1372 this.e = Objects.requireNonNull(e, "Zip entry is null");
1373 // this.written = 0;
1374 }
1375
1376 @Override
1377 public synchronized void write(int b) throws IOException {
1378 out.write(b);
1379 written += 1;
1380 }
1381
1382 @Override
1383 public synchronized void write(byte b[], int off, int len)
1384 throws IOException {
1385 out.write(b, off, len);
1386 written += len;
1387 }
1388
1389 @Override
1390 public synchronized void close() throws IOException {
1391 if (isClosed) {
1392 return;
1393 }
1394 isClosed = true;
1395 e.size = written;
1396 if (out instanceof ByteArrayOutputStream)
1397 e.bytes = ((ByteArrayOutputStream)out).toByteArray();
1398 super.close();
1399 update(e);
1400 }
1401 }
1402
1403 // Wrapper output stream class to write out a "stored" entry.
1404 // (1) this class does not close the underlying out stream when
1405 // being closed.
1406 // (2) no need to be "synchronized", only used by sync()
1407 private class EntryOutputStreamCRC32 extends FilterOutputStream {
1408 private Entry e;
1409 private CRC32 crc;
1410 private long written;
1411 private boolean isClosed;
1412
1413 EntryOutputStreamCRC32(Entry e, OutputStream os) throws IOException {
1414 super(os);
1415 this.e = Objects.requireNonNull(e, "Zip entry is null");
1416 this.crc = new CRC32();
1417 }
1418
1419 @Override
1420 public void write(int b) throws IOException {
1421 out.write(b);
1422 crc.update(b);
1423 written += 1;
1424 }
1425
1426 @Override
1427 public void write(byte b[], int off, int len)
1428 throws IOException {
1429 out.write(b, off, len);
1430 crc.update(b, off, len);
1431 written += len;
1432 }
1433
1434 @Override
1435 public void close() throws IOException {
1436 if (isClosed)
1437 return;
1438 isClosed = true;
1439 e.size = e.csize = written;
1440 e.crc = crc.getValue();
1441 }
1442 }
1443
1444 // Wrapper output stream class to write out a "deflated" entry.
1445 // (1) this class does not close the underlying out stream when
1446 // being closed.
1447 // (2) no need to be "synchronized", only used by sync()
1448 private class EntryOutputStreamDef extends DeflaterOutputStream {
1449 private CRC32 crc;
1450 private Entry e;
1451 private boolean isClosed;
1452
1453 EntryOutputStreamDef(Entry e, OutputStream os) throws IOException {
1454 super(os, getDeflater());
1455 this.e = Objects.requireNonNull(e, "Zip entry is null");
1456 this.crc = new CRC32();
1457 }
1458
1459 @Override
1460 public void write(byte b[], int off, int len)
1461 throws IOException {
1462 super.write(b, off, len);
1463 crc.update(b, off, len);
1464 }
1465
1466 @Override
1467 public void close() throws IOException {
1468 if (isClosed)
1469 return;
1470 isClosed = true;
1471 finish();
1472 e.size = def.getBytesRead();
1473 e.csize = def.getBytesWritten();
1474 e.crc = crc.getValue();
1475 }
1476 }
1477
1478 private InputStream getInputStream(Entry e)
1479 throws IOException
1480 {
1481 InputStream eis = null;
1482
1483 if (e.type == Entry.NEW) {
1484 // now bytes & file is uncompressed.
1485 if (e.bytes != null)
1486 return new ByteArrayInputStream(e.bytes);
1487 else if (e.file != null)
1488 return Files.newInputStream(e.file);
1489 else
1490 throw new ZipException("update entry data is missing");
1491 } else if (e.type == Entry.FILECH) {
1492 // FILECH result is un-compressed.
1493 eis = Files.newInputStream(e.file);
1494 // TBD: wrap to hook close()
1495 // streams.add(eis);
1496 return eis;
1497 } else { // untouched CEN or COPY
1498 eis = new EntryInputStream(e, ch);
1499 }
1500 if (e.method == METHOD_DEFLATED) {
1501 // MORE: Compute good size for inflater stream:
1502 long bufSize = e.size + 2; // Inflater likes a bit of slack
1503 if (bufSize > 65536)
1504 bufSize = 8192;
1505 final long size = e.size;
1506 eis = new InflaterInputStream(eis, getInflater(), (int)bufSize) {
1507 private boolean isClosed = false;
1508 public void close() throws IOException {
1509 if (!isClosed) {
1510 releaseInflater(inf);
1511 this.in.close();
1512 isClosed = true;
1513 streams.remove(this);
1514 }
1515 }
1516 // Override fill() method to provide an extra "dummy" byte
1517 // at the end of the input stream. This is required when
1518 // using the "nowrap" Inflater option. (it appears the new
1519 // zlib in 7 does not need it, but keep it for now)
1520 protected void fill() throws IOException {
1521 if (eof) {
1522 throw new EOFException(
1523 "Unexpected end of ZLIB input stream");
1524 }
1525 len = this.in.read(buf, 0, buf.length);
1526 if (len == -1) {
1527 buf[0] = 0;
1528 len = 1;
1529 eof = true;
1530 }
1531 inf.setInput(buf, 0, len);
1532 }
1533 private boolean eof;
1534
1535 public int available() throws IOException {
1536 if (isClosed)
1537 return 0;
1538 long avail = size - inf.getBytesWritten();
1539 return avail > (long) Integer.MAX_VALUE ?
1540 Integer.MAX_VALUE : (int) avail;
1541 }
1542 };
1543 } else if (e.method == METHOD_STORED) {
1544 // TBD: wrap/ it does not seem necessary
1545 } else {
1546 throw new ZipException("invalid compression method");
1547 }
1548 streams.add(eis);
1549 return eis;
1550 }
1551
1552 // Inner class implementing the input stream used to read
1553 // a (possibly compressed) zip file entry.
1554 private class EntryInputStream extends InputStream {
1555 private final SeekableByteChannel zfch; // local ref to zipfs's "ch". zipfs.ch might
1556 // point to a new channel after sync()
1557 private long pos; // current position within entry data
1558 protected long rem; // number of remaining bytes within entry
1559
1560 EntryInputStream(Entry e, SeekableByteChannel zfch)
1561 throws IOException
1562 {
1563 this.zfch = zfch;
1564 rem = e.csize;
1565 pos = e.locoff;
1566 if (pos == -1) {
1567 Entry e2 = getEntry(e.name);
1568 if (e2 == null) {
1569 throw new ZipException("invalid loc for entry <" + e.name + ">");
1570 }
1571 pos = e2.locoff;
1572 }
1573 pos = -pos; // lazy initialize the real data offset
1574 }
1575
1576 public int read(byte b[], int off, int len) throws IOException {
1577 ensureOpen();
1578 initDataPos();
1579 if (rem == 0) {
1580 return -1;
1581 }
1582 if (len <= 0) {
1583 return 0;
1584 }
1585 if (len > rem) {
1586 len = (int) rem;
1587 }
1588 // readFullyAt()
1589 long n = 0;
1590 ByteBuffer bb = ByteBuffer.wrap(b);
1591 bb.position(off);
1592 bb.limit(off + len);
1593 synchronized(zfch) {
1594 n = zfch.position(pos).read(bb);
1595 }
1596 if (n > 0) {
1597 pos += n;
1598 rem -= n;
1599 }
1600 if (rem == 0) {
1601 close();
1602 }
1603 return (int)n;
1604 }
1605
1606 public int read() throws IOException {
1607 byte[] b = new byte[1];
1608 if (read(b, 0, 1) == 1) {
1609 return b[0] & 0xff;
1610 } else {
1611 return -1;
1612 }
1613 }
1614
1615 public long skip(long n) throws IOException {
1616 ensureOpen();
1617 if (n > rem)
1618 n = rem;
1619 pos += n;
1620 rem -= n;
1621 if (rem == 0) {
1622 close();
1623 }
1624 return n;
1625 }
1626
1627 public int available() {
1628 return rem > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) rem;
1629 }
1630
1631 public void close() {
1632 rem = 0;
1633 streams.remove(this);
1634 }
1635
1636 private void initDataPos() throws IOException {
1637 if (pos <= 0) {
1638 pos = -pos + locpos;
1639 byte[] buf = new byte[LOCHDR];
1640 if (readFullyAt(buf, 0, buf.length, pos) != LOCHDR) {
1641 throw new ZipException("invalid loc " + pos + " for entry reading");
1642 }
1643 pos += LOCHDR + LOCNAM(buf) + LOCEXT(buf);
1644 }
1645 }
1646 }
1647
1648 static void zerror(String msg) throws ZipException {
1649 throw new ZipException(msg);
1650 }
1651
1652 // Maxmum number of de/inflater we cache
1653 private final int MAX_FLATER = 20;
1654 // List of available Inflater objects for decompression
1655 private final List<Inflater> inflaters = new ArrayList<>();
1656
1657 // Gets an inflater from the list of available inflaters or allocates
1658 // a new one.
1659 private Inflater getInflater() {
1660 synchronized (inflaters) {
1661 int size = inflaters.size();
1662 if (size > 0) {
1663 Inflater inf = inflaters.remove(size - 1);
1664 return inf;
1665 } else {
1666 return new Inflater(true);
1667 }
1668 }
1669 }
1670
1671 // Releases the specified inflater to the list of available inflaters.
1672 private void releaseInflater(Inflater inf) {
1673 synchronized (inflaters) {
1674 if (inflaters.size() < MAX_FLATER) {
1675 inf.reset();
1676 inflaters.add(inf);
1677 } else {
1678 inf.end();
1679 }
1680 }
1681 }
1682
1683 // List of available Deflater objects for compression
1684 private final List<Deflater> deflaters = new ArrayList<>();
1685
1686 // Gets a deflater from the list of available deflaters or allocates
1687 // a new one.
1688 private Deflater getDeflater() {
1689 synchronized (deflaters) {
1690 int size = deflaters.size();
1691 if (size > 0) {
1692 Deflater def = deflaters.remove(size - 1);
1693 return def;
1694 } else {
1695 return new Deflater(Deflater.DEFAULT_COMPRESSION, true);
1696 }
1697 }
1698 }
1699
1700 // End of central directory record
1701 static class END {
1702 // these 2 fields are not used by anyone and write() uses "0"
1703 // int disknum;
1704 // int sdisknum;
1705 int endsub; // endsub
1706 int centot; // 4 bytes
1707 long cenlen; // 4 bytes
1708 long cenoff; // 4 bytes
1709 int comlen; // comment length
1710 byte[] comment;
1711
1712 /* members of Zip64 end of central directory locator */
1713 // int diskNum;
1714 long endpos;
1715 // int disktot;
1716
1717 void write(OutputStream os, long offset, boolean forceEnd64) throws IOException {
1718 boolean hasZip64 = forceEnd64; // false;
1719 long xlen = cenlen;
1720 long xoff = cenoff;
1721 if (xlen >= ZIP64_MINVAL) {
1722 xlen = ZIP64_MINVAL;
1723 hasZip64 = true;
1724 }
1725 if (xoff >= ZIP64_MINVAL) {
1726 xoff = ZIP64_MINVAL;
1727 hasZip64 = true;
1728 }
1729 int count = centot;
1730 if (count >= ZIP64_MINVAL32) {
1731 count = ZIP64_MINVAL32;
1732 hasZip64 = true;
1733 }
1734 if (hasZip64) {
1735 long off64 = offset;
1736 //zip64 end of central directory record
1737 writeInt(os, ZIP64_ENDSIG); // zip64 END record signature
1738 writeLong(os, ZIP64_ENDHDR - 12); // size of zip64 end
1739 writeShort(os, 45); // version made by
1740 writeShort(os, 45); // version needed to extract
1741 writeInt(os, 0); // number of this disk
1742 writeInt(os, 0); // central directory start disk
1743 writeLong(os, centot); // number of directory entries on disk
1744 writeLong(os, centot); // number of directory entries
1745 writeLong(os, cenlen); // length of central directory
1746 writeLong(os, cenoff); // offset of central directory
1747
1748 //zip64 end of central directory locator
1749 writeInt(os, ZIP64_LOCSIG); // zip64 END locator signature
1750 writeInt(os, 0); // zip64 END start disk
1751 writeLong(os, off64); // offset of zip64 END
1752 writeInt(os, 1); // total number of disks (?)
1753 }
1754 writeInt(os, ENDSIG); // END record signature
1755 writeShort(os, 0); // number of this disk
1756 writeShort(os, 0); // central directory start disk
1757 writeShort(os, count); // number of directory entries on disk
1758 writeShort(os, count); // total number of directory entries
1759 writeInt(os, xlen); // length of central directory
1760 writeInt(os, xoff); // offset of central directory
1761 if (comment != null) { // zip file comment
1762 writeShort(os, comment.length);
1763 writeBytes(os, comment);
1764 } else {
1765 writeShort(os, 0);
1766 }
1767 }
1768 }
1769
1770 // Internal node that links a "name" to its pos in cen table.
1771 // The node itself can be used as a "key" to lookup itself in
1772 // the HashMap inodes.
1773 static class IndexNode {
1774 byte[] name;
1775 int hashcode; // node is hashable/hashed by its name
1776 int pos = -1; // position in cen table, -1 menas the
1777 // entry does not exists in zip file
1778 boolean isdir;
1779
1780 IndexNode(byte[] name, boolean isdir) {
1781 name(name);
1782 this.isdir = isdir;
1783 this.pos = -1;
1784 }
1785
1786 IndexNode(byte[] name, int pos) {
1787 name(name);
1788 this.pos = pos;
1789 }
1790
1791 // constructor for cenInit() (1) remove tailing '/' (2) pad leading '/'
1792 IndexNode(byte[] cen, int pos, int nlen) {
1793 int noff = pos + CENHDR;
1794 if (cen[noff + nlen - 1] == '/') {
1795 isdir = true;
1796 nlen--;
1797 }
1798 if (nlen > 0 && cen[noff] == '/') {
1799 name = Arrays.copyOfRange(cen, noff, noff + nlen);
1800 } else {
1801 name = new byte[nlen + 1];
1802 System.arraycopy(cen, noff, name, 1, nlen);
1803 name[0] = '/';
1804 }
1805 name(name);
1806 this.pos = pos;
1807 }
1808
1809 private static final ThreadLocal<IndexNode> cachedKey = new ThreadLocal<>();
1810
1811 final static IndexNode keyOf(byte[] name) { // get a lookup key;
1812 IndexNode key = cachedKey.get();
1813 if (key == null) {
1814 key = new IndexNode(name, -1);
1815 cachedKey.set(key);
1816 }
1817 return key.as(name);
1818 }
1819
1820 final void name(byte[] name) {
1821 this.name = name;
1822 this.hashcode = Arrays.hashCode(name);
1823 }
1824
1825 final IndexNode as(byte[] name) { // reuse the node, mostly
1826 name(name); // as a lookup "key"
1827 return this;
1828 }
1829
1830 boolean isDir() {
1831 return isdir;
1832 }
1833
1834 public boolean equals(Object other) {
1835 if (!(other instanceof IndexNode)) {
1836 return false;
1837 }
1838 if (other instanceof ParentLookup) {
1839 return ((ParentLookup)other).equals(this);
1840 }
1841 return Arrays.equals(name, ((IndexNode)other).name);
1842 }
1843
1844 public int hashCode() {
1845 return hashcode;
1846 }
1847
1848 IndexNode() {}
1849 IndexNode sibling;
1850 IndexNode child; // 1st child
1851 }
1852
1853 static class Entry extends IndexNode implements ZipFileAttributes {
1854
1855 static final int CEN = 1; // entry read from cen
1856 static final int NEW = 2; // updated contents in bytes or file
1857 static final int FILECH = 3; // fch update in "file"
1858 static final int COPY = 4; // copy of a CEN entry
1859
1860 byte[] bytes; // updated content bytes
1861 Path file; // use tmp file to store bytes;
1862 int type = CEN; // default is the entry read from cen
1863
1864 // entry attributes
1865 int version;
1866 int flag;
1867 int posixPerms = -1; // posix permissions
1868 int method = -1; // compression method
1869 long mtime = -1; // last modification time (in DOS time)
1870 long atime = -1; // last access time
1871 long ctime = -1; // create time
1872 long crc = -1; // crc-32 of entry data
1873 long csize = -1; // compressed size of entry data
1874 long size = -1; // uncompressed size of entry data
1875 byte[] extra;
1876
1877 // cen
1878
1879 // these fields are not used
1880 // int versionMade;
1881 // int disk;
1882 // int attrs;
1883 // long attrsEx;
1884 long locoff;
1885 byte[] comment;
1886
1887 Entry() {}
1888
1889 Entry(byte[] name, boolean isdir, int method) {
1890 name(name);
1891 this.isdir = isdir;
1892 this.mtime = this.ctime = this.atime = System.currentTimeMillis();
1893 this.crc = 0;
1894 this.size = 0;
1895 this.csize = 0;
1896 this.method = method;
1897 }
1898
1899 @SuppressWarnings("unchecked")
1900 Entry(byte[] name, int type, boolean isdir, int method, FileAttribute<?>... attrs) {
1901 this(name, isdir, method);
1902 this.type = type;
1903 for (FileAttribute<?> attr : attrs) {
1904 String attrName = attr.name();
1905 if (attrName.equals("posix:permissions") || attrName.equals("unix:permissions")) {
1906 posixPerms = ZipUtils.permsToFlags((Set<PosixFilePermission>)attr.value());
1907 }
1908 }
1909 }
1910
1911 Entry(Entry e, int type) {
1912 name(e.name);
1913 this.isdir = e.isdir;
1914 this.version = e.version;
1915 this.ctime = e.ctime;
1916 this.atime = e.atime;
1917 this.mtime = e.mtime;
1918 this.crc = e.crc;
1919 this.size = e.size;
1920 this.csize = e.csize;
1921 this.method = e.method;
1922 this.extra = e.extra;
1923 /*
1924 this.versionMade = e.versionMade;
1925 this.disk = e.disk;
1926 this.attrs = e.attrs;
1927 this.attrsEx = e.attrsEx;
1928 */
1929 this.locoff = e.locoff;
1930 this.comment = e.comment;
1931 this.posixPerms = e.posixPerms;
1932 this.type = type;
1933 }
1934
1935 @SuppressWarnings("unchecked")
1936 Entry(byte[] name, Path file, int type, FileAttribute<?>... attrs) {
1937 this(name, type, false, METHOD_STORED);
1938 this.file = file;
1939 for (FileAttribute<?> attr : attrs) {
1940 String attrName = attr.name();
1941 if (attrName.equals("posix:permissions") || attrName.equals("unix:permissions")) {
1942 posixPerms = ZipUtils.permsToFlags((Set<PosixFilePermission>)attr.value());
1943 }
1944 }
1945 }
1946
1947 int version(boolean zip64) throws ZipException {
1948 if (zip64) {
1949 return 45;
1950 }
1951 if (method == METHOD_DEFLATED)
1952 return 20;
1953 else if (method == METHOD_STORED)
1954 return 10;
1955 throw new ZipException("unsupported compression method");
1956 }
1957
1958 /**
1959 * Adds information about compatibility of file attribute information
1960 * to a version value.
1961 */
1962 int versionMadeBy(int version) {
1963 return (posixPerms < 0) ? version :
1964 VERSION_BASE_UNIX | (version & 0xff);
1965 }
1966
1967 ///////////////////// CEN //////////////////////
1968 static Entry readCEN(ZipFileSystem zipfs, IndexNode inode)
1969 throws IOException
1970 {
1971 return new Entry().cen(zipfs, inode);
1972 }
1973
1974 private Entry cen(ZipFileSystem zipfs, IndexNode inode)
1975 throws IOException
1976 {
1977 byte[] cen = zipfs.cen;
1978 int pos = inode.pos;
1979 if (!cenSigAt(cen, pos))
1980 zerror("invalid CEN header (bad signature)");
1981 version = CENVER(cen, pos);
1982 flag = CENFLG(cen, pos);
1983 method = CENHOW(cen, pos);
1984 mtime = dosToJavaTime(CENTIM(cen, pos));
1985 crc = CENCRC(cen, pos);
1986 csize = CENSIZ(cen, pos);
1987 size = CENLEN(cen, pos);
1988 int nlen = CENNAM(cen, pos);
1989 int elen = CENEXT(cen, pos);
1990 int clen = CENCOM(cen, pos);
1991 /*
1992 versionMade = CENVEM(cen, pos);
1993 disk = CENDSK(cen, pos);
1994 attrs = CENATT(cen, pos);
1995 attrsEx = CENATX(cen, pos);
1996 */
1997 if (CENVEM_FA(cen, pos) == FILE_ATTRIBUTES_UNIX) {
1998 posixPerms = CENATX_PERMS(cen, pos) & 0xFFF; // 12 bits for setuid, setgid, sticky + perms
1999 }
2000 locoff = CENOFF(cen, pos);
2001 pos += CENHDR;
2002 this.name = inode.name;
2003 this.isdir = inode.isdir;
2004 this.hashcode = inode.hashcode;
2005
2006 pos += nlen;
2007 if (elen > 0) {
2008 extra = Arrays.copyOfRange(cen, pos, pos + elen);
2009 pos += elen;
2010 readExtra(zipfs);
2011 }
2012 if (clen > 0) {
2013 comment = Arrays.copyOfRange(cen, pos, pos + clen);
2014 }
2015 return this;
2016 }
2017
2018 int writeCEN(OutputStream os) throws IOException {
2019 long csize0 = csize;
2020 long size0 = size;
2021 long locoff0 = locoff;
2022 int elen64 = 0; // extra for ZIP64
2023 int elenNTFS = 0; // extra for NTFS (a/c/mtime)
2024 int elenEXTT = 0; // extra for Extended Timestamp
2025 boolean foundExtraTime = false; // if time stamp NTFS, EXTT present
2026
2027 byte[] zname = isdir ? toDirectoryPath(name) : name;
2028
2029 // confirm size/length
2030 int nlen = (zname != null) ? zname.length - 1 : 0; // name has [0] as "slash"
2031 int elen = (extra != null) ? extra.length : 0;
2032 int eoff = 0;
2033 int clen = (comment != null) ? comment.length : 0;
2034 if (csize >= ZIP64_MINVAL) {
2035 csize0 = ZIP64_MINVAL;
2036 elen64 += 8; // csize(8)
2037 }
2038 if (size >= ZIP64_MINVAL) {
2039 size0 = ZIP64_MINVAL; // size(8)
2040 elen64 += 8;
2041 }
2042 if (locoff >= ZIP64_MINVAL) {
2043 locoff0 = ZIP64_MINVAL;
2044 elen64 += 8; // offset(8)
2045 }
2046 if (elen64 != 0) {
2047 elen64 += 4; // header and data sz 4 bytes
2048 }
2049 boolean zip64 = (elen64 != 0);
2050 int version0 = version(zip64);
2051 while (eoff + 4 < elen) {
2052 int tag = SH(extra, eoff);
2053 int sz = SH(extra, eoff + 2);
2054 if (tag == EXTID_EXTT || tag == EXTID_NTFS) {
2055 foundExtraTime = true;
2056 }
2057 eoff += (4 + sz);
2058 }
2059 if (!foundExtraTime) {
2060 if (isWindows) { // use NTFS
2061 elenNTFS = 36; // total 36 bytes
2062 } else { // Extended Timestamp otherwise
2063 elenEXTT = 9; // only mtime in cen
2064 }
2065 }
2066 writeInt(os, CENSIG); // CEN header signature
2067 writeShort(os, versionMadeBy(version0)); // version made by
2068 writeShort(os, version0); // version needed to extract
2069 writeShort(os, flag); // general purpose bit flag
2070 writeShort(os, method); // compression method
2071 // last modification time
2072 writeInt(os, (int)javaToDosTime(mtime));
2073 writeInt(os, crc); // crc-32
2074 writeInt(os, csize0); // compressed size
2075 writeInt(os, size0); // uncompressed size
2076 writeShort(os, nlen);
2077 writeShort(os, elen + elen64 + elenNTFS + elenEXTT);
2078
2079 if (comment != null) {
2080 writeShort(os, Math.min(clen, 0xffff));
2081 } else {
2082 writeShort(os, 0);
2083 }
2084 writeShort(os, 0); // starting disk number
2085 writeShort(os, 0); // internal file attributes (unused)
2086 writeInt(os, posixPerms > 0 ? posixPerms << 16 : 0); // external file
2087 // attributes, used for storing posix
2088 // permissions
2089 writeInt(os, locoff0); // relative offset of local header
2090 writeBytes(os, zname, 1, nlen);
2091 if (zip64) {
2092 writeShort(os, EXTID_ZIP64);// Zip64 extra
2093 writeShort(os, elen64 - 4); // size of "this" extra block
2094 if (size0 == ZIP64_MINVAL)
2095 writeLong(os, size);
2096 if (csize0 == ZIP64_MINVAL)
2097 writeLong(os, csize);
2098 if (locoff0 == ZIP64_MINVAL)
2099 writeLong(os, locoff);
2100 }
2101 if (elenNTFS != 0) {
2102 writeShort(os, EXTID_NTFS);
2103 writeShort(os, elenNTFS - 4);
2104 writeInt(os, 0); // reserved
2105 writeShort(os, 0x0001); // NTFS attr tag
2106 writeShort(os, 24);
2107 writeLong(os, javaToWinTime(mtime));
2108 writeLong(os, javaToWinTime(atime));
2109 writeLong(os, javaToWinTime(ctime));
2110 }
2111 if (elenEXTT != 0) {
2112 writeShort(os, EXTID_EXTT);
2113 writeShort(os, elenEXTT - 4);
2114 if (ctime == -1)
2115 os.write(0x3); // mtime and atime
2116 else
2117 os.write(0x7); // mtime, atime and ctime
2118 writeInt(os, javaToUnixTime(mtime));
2119 }
2120 if (extra != null) // whatever not recognized
2121 writeBytes(os, extra);
2122 if (comment != null) //TBD: 0, Math.min(commentBytes.length, 0xffff));
2123 writeBytes(os, comment);
2124 return CENHDR + nlen + elen + clen + elen64 + elenNTFS + elenEXTT;
2125 }
2126
2127 ///////////////////// LOC //////////////////////
2128
2129 int writeLOC(OutputStream os) throws IOException {
2130 writeInt(os, LOCSIG); // LOC header signature
2131 byte[] zname = isdir ? toDirectoryPath(name) : name;
2132 int nlen = (zname != null) ? zname.length - 1 : 0; // [0] is slash
2133 int elen = (extra != null) ? extra.length : 0;
2134 boolean foundExtraTime = false; // if extra timestamp present
2135 int eoff = 0;
2136 int elen64 = 0;
2137 boolean zip64 = false;
2138 int elenEXTT = 0;
2139 int elenNTFS = 0;
2140 if ((flag & FLAG_DATADESCR) != 0) {
2141 writeShort(os, version(zip64)); // version needed to extract
2142 writeShort(os, flag); // general purpose bit flag
2143 writeShort(os, method); // compression method
2144 // last modification time
2145 writeInt(os, (int)javaToDosTime(mtime));
2146 // store size, uncompressed size, and crc-32 in data descriptor
2147 // immediately following compressed entry data
2148 writeInt(os, 0);
2149 writeInt(os, 0);
2150 writeInt(os, 0);
2151 } else {
2152 if (csize >= ZIP64_MINVAL || size >= ZIP64_MINVAL) {
2153 elen64 = 20; //headid(2) + size(2) + size(8) + csize(8)
2154 zip64 = true;
2155 }
2156 writeShort(os, version(zip64)); // version needed to extract
2157 writeShort(os, flag); // general purpose bit flag
2158 writeShort(os, method); // compression method
2159 // last modification time
2160 writeInt(os, (int)javaToDosTime(mtime));
2161 writeInt(os, crc); // crc-32
2162 if (zip64) {
2163 writeInt(os, ZIP64_MINVAL);
2164 writeInt(os, ZIP64_MINVAL);
2165 } else {
2166 writeInt(os, csize); // compressed size
2167 writeInt(os, size); // uncompressed size
2168 }
2169 }
2170 while (eoff + 4 < elen) {
2171 int tag = SH(extra, eoff);
2172 int sz = SH(extra, eoff + 2);
2173 if (tag == EXTID_EXTT || tag == EXTID_NTFS) {
2174 foundExtraTime = true;
2175 }
2176 eoff += (4 + sz);
2177 }
2178 if (!foundExtraTime) {
2179 if (isWindows) {
2180 elenNTFS = 36; // NTFS, total 36 bytes
2181 } else { // on unix use "ext time"
2182 elenEXTT = 9;
2183 if (atime != -1)
2184 elenEXTT += 4;
2185 if (ctime != -1)
2186 elenEXTT += 4;
2187 }
2188 }
2189 writeShort(os, nlen);
2190 writeShort(os, elen + elen64 + elenNTFS + elenEXTT);
2191 writeBytes(os, zname, 1, nlen);
2192 if (zip64) {
2193 writeShort(os, EXTID_ZIP64);
2194 writeShort(os, 16);
2195 writeLong(os, size);
2196 writeLong(os, csize);
2197 }
2198 if (elenNTFS != 0) {
2199 writeShort(os, EXTID_NTFS);
2200 writeShort(os, elenNTFS - 4);
2201 writeInt(os, 0); // reserved
2202 writeShort(os, 0x0001); // NTFS attr tag
2203 writeShort(os, 24);
2204 writeLong(os, javaToWinTime(mtime));
2205 writeLong(os, javaToWinTime(atime));
2206 writeLong(os, javaToWinTime(ctime));
2207 }
2208 if (elenEXTT != 0) {
2209 writeShort(os, EXTID_EXTT);
2210 writeShort(os, elenEXTT - 4);// size for the folowing data block
2211 int fbyte = 0x1;
2212 if (atime != -1) // mtime and atime
2213 fbyte |= 0x2;
2214 if (ctime != -1) // mtime, atime and ctime
2215 fbyte |= 0x4;
2216 os.write(fbyte); // flags byte
2217 writeInt(os, javaToUnixTime(mtime));
2218 if (atime != -1)
2219 writeInt(os, javaToUnixTime(atime));
2220 if (ctime != -1)
2221 writeInt(os, javaToUnixTime(ctime));
2222 }
2223 if (extra != null) {
2224 writeBytes(os, extra);
2225 }
2226 return LOCHDR + nlen + elen + elen64 + elenNTFS + elenEXTT;
2227 }
2228
2229 // Data Descriptior
2230 int writeEXT(OutputStream os) throws IOException {
2231 writeInt(os, EXTSIG); // EXT header signature
2232 writeInt(os, crc); // crc-32
2233 if (csize >= ZIP64_MINVAL || size >= ZIP64_MINVAL) {
2234 writeLong(os, csize);
2235 writeLong(os, size);
2236 return 24;
2237 } else {
2238 writeInt(os, csize); // compressed size
2239 writeInt(os, size); // uncompressed size
2240 return 16;
2241 }
2242 }
2243
2244 // read NTFS, UNIX and ZIP64 data from cen.extra
2245 void readExtra(ZipFileSystem zipfs) throws IOException {
2246 if (extra == null)
2247 return;
2248 int elen = extra.length;
2249 int off = 0;
2250 int newOff = 0;
2251 while (off + 4 < elen) {
2252 // extra spec: HeaderID+DataSize+Data
2253 int pos = off;
2254 int tag = SH(extra, pos);
2255 int sz = SH(extra, pos + 2);
2256 pos += 4;
2257 if (pos + sz > elen) // invalid data
2258 break;
2259 switch (tag) {
2260 case EXTID_ZIP64 :
2261 if (size == ZIP64_MINVAL) {
2262 if (pos + 8 > elen) // invalid zip64 extra
2263 break; // fields, just skip
2264 size = LL(extra, pos);
2265 pos += 8;
2266 }
2267 if (csize == ZIP64_MINVAL) {
2268 if (pos + 8 > elen)
2269 break;
2270 csize = LL(extra, pos);
2271 pos += 8;
2272 }
2273 if (locoff == ZIP64_MINVAL) {
2274 if (pos + 8 > elen)
2275 break;
2276 locoff = LL(extra, pos);
2277 pos += 8;
2278 }
2279 break;
2280 case EXTID_NTFS:
2281 if (sz < 32)
2282 break;
2283 pos += 4; // reserved 4 bytes
2284 if (SH(extra, pos) != 0x0001)
2285 break;
2286 if (SH(extra, pos + 2) != 24)
2287 break;
2288 // override the loc field, datatime here is
2289 // more "accurate"
2290 mtime = winToJavaTime(LL(extra, pos + 4));
2291 atime = winToJavaTime(LL(extra, pos + 12));
2292 ctime = winToJavaTime(LL(extra, pos + 20));
2293 break;
2294 case EXTID_EXTT:
2295 // spec says the Extened timestamp in cen only has mtime
2296 // need to read the loc to get the extra a/ctime, if flag
2297 // "zipinfo-time" is not specified to false;
2298 // there is performance cost (move up to loc and read) to
2299 // access the loc table foreach entry;
2300 if (zipfs.noExtt) {
2301 if (sz == 5)
2302 mtime = unixToJavaTime(LG(extra, pos + 1));
2303 break;
2304 }
2305 byte[] buf = new byte[LOCHDR];
2306 if (zipfs.readFullyAt(buf, 0, buf.length , locoff)
2307 != buf.length)
2308 throw new ZipException("loc: reading failed");
2309 if (!locSigAt(buf, 0))
2310 throw new ZipException("loc: wrong sig ->"
2311 + Long.toString(getSig(buf, 0), 16));
2312 int locElen = LOCEXT(buf);
2313 if (locElen < 9) // EXTT is at lease 9 bytes
2314 break;
2315 int locNlen = LOCNAM(buf);
2316 buf = new byte[locElen];
2317 if (zipfs.readFullyAt(buf, 0, buf.length , locoff + LOCHDR + locNlen)
2318 != buf.length)
2319 throw new ZipException("loc extra: reading failed");
2320 int locPos = 0;
2321 while (locPos + 4 < buf.length) {
2322 int locTag = SH(buf, locPos);
2323 int locSZ = SH(buf, locPos + 2);
2324 locPos += 4;
2325 if (locTag != EXTID_EXTT) {
2326 locPos += locSZ;
2327 continue;
2328 }
2329 int end = locPos + locSZ - 4;
2330 int flag = CH(buf, locPos++);
2331 if ((flag & 0x1) != 0 && locPos <= end) {
2332 mtime = unixToJavaTime(LG(buf, locPos));
2333 locPos += 4;
2334 }
2335 if ((flag & 0x2) != 0 && locPos <= end) {
2336 atime = unixToJavaTime(LG(buf, locPos));
2337 locPos += 4;
2338 }
2339 if ((flag & 0x4) != 0 && locPos <= end) {
2340 ctime = unixToJavaTime(LG(buf, locPos));
2341 locPos += 4;
2342 }
2343 break;
2344 }
2345 break;
2346 default: // unknown tag
2347 System.arraycopy(extra, off, extra, newOff, sz + 4);
2348 newOff += (sz + 4);
2349 }
2350 off += (sz + 4);
2351 }
2352 if (newOff != 0 && newOff != extra.length)
2353 extra = Arrays.copyOf(extra, newOff);
2354 else
2355 extra = null;
2356 }
2357
2358 ///////// basic file attributes ///////////
2359 @Override
2360 public FileTime creationTime() {
2361 return FileTime.fromMillis(ctime == -1 ? mtime : ctime);
2362 }
2363
2364 @Override
2365 public boolean isDirectory() {
2366 return isDir();
2367 }
2368
2369 @Override
2370 public boolean isOther() {
2371 return false;
2372 }
2373
2374 @Override
2375 public boolean isRegularFile() {
2376 return !isDir();
2377 }
2378
2379 @Override
2380 public FileTime lastAccessTime() {
2381 return FileTime.fromMillis(atime == -1 ? mtime : atime);
2382 }
2383
2384 @Override
2385 public FileTime lastModifiedTime() {
2386 return FileTime.fromMillis(mtime);
2387 }
2388
2389 @Override
2390 public long size() {
2391 return size;
2392 }
2393
2394 @Override
2395 public boolean isSymbolicLink() {
2396 return false;
2397 }
2398
2399 @Override
2400 public Object fileKey() {
2401 return null;
2402 }
2403
2404 ///////// zip entry attributes ///////////
2405 public long compressedSize() {
2406 return csize;
2407 }
2408
2409 public long crc() {
2410 return crc;
2411 }
2412
2413 public int method() {
2414 return method;
2415 }
2416
2417 public byte[] extra() {
2418 if (extra != null)
2419 return Arrays.copyOf(extra, extra.length);
2420 return null;
2421 }
2422
2423 public byte[] comment() {
2424 if (comment != null)
2425 return Arrays.copyOf(comment, comment.length);
2426 return null;
2427 }
2428
2429 public String toString() {
2430 StringBuilder sb = new StringBuilder(1024);
2431 Formatter fm = new Formatter(sb);
2432 fm.format(" name : %s%n", new String(name));
2433 fm.format(" creationTime : %tc%n", creationTime().toMillis());
2434 fm.format(" lastAccessTime : %tc%n", lastAccessTime().toMillis());
2435 fm.format(" lastModifiedTime: %tc%n", lastModifiedTime().toMillis());
2436 fm.format(" isRegularFile : %b%n", isRegularFile());
2437 fm.format(" isDirectory : %b%n", isDirectory());
2438 fm.format(" isSymbolicLink : %b%n", isSymbolicLink());
2439 fm.format(" isOther : %b%n", isOther());
2440 fm.format(" fileKey : %s%n", fileKey());
2441 fm.format(" size : %d%n", size());
2442 fm.format(" compressedSize : %d%n", compressedSize());
2443 fm.format(" crc : %x%n", crc());
2444 fm.format(" method : %d%n", method());
2445 if (posixPerms != -1) {
2446 fm.format(" permissions : %s%n", permissions());
2447 }
2448 fm.close();
2449 return sb.toString();
2450 }
2451
2452 @Override
2453 public UserPrincipal owner() {
2454 throw new UnsupportedOperationException(
2455 "ZipFileSystem does not support owner.");
2456 }
2457
2458 @Override
2459 public GroupPrincipal group() {
2460 throw new UnsupportedOperationException(
2461 "ZipFileSystem does not support group.");
2462 }
2463
2464 @Override
2465 public Set<PosixFilePermission> permissions() {
2466 if (posixPerms == -1) {
2467 // in case there are no Posix permissions associated with the
2468 // entry, we should not return an empty set of permissions
2469 // because that would be an explicit set of permissions meaning
2470 // no permissions for anyone
2471 throw new UnsupportedOperationException(
2472 "No posix permissions associated with zip entry.");
2473 }
2474 return ZipUtils.permsFromFlags(posixPerms);
2475 }
2476
2477 @Override
2478 public void setPermissions(Set<PosixFilePermission> perms) {
2479 posixPerms = ZipUtils.permsToFlags(perms);
2480 }
2481 }
2482
2483 // ZIP directory has two issues:
2484 // (1) ZIP spec does not require the ZIP file to include
2485 // directory entry
2486 // (2) all entries are not stored/organized in a "tree"
2487 // structure.
2488 // A possible solution is to build the node tree ourself as
2489 // implemented below.
2490
2491 // default time stamp for pseudo entries
2492 private long zfsDefaultTimeStamp = System.currentTimeMillis();
2493
2494 private void removeFromTree(IndexNode inode) {
2495 IndexNode parent = inodes.get(LOOKUPKEY.as(getParent(inode.name)));
2496 IndexNode child = parent.child;
2497 if (child.equals(inode)) {
2498 parent.child = child.sibling;
2499 } else {
2500 IndexNode last = child;
2501 while ((child = child.sibling) != null) {
2502 if (child.equals(inode)) {
2503 last.sibling = child.sibling;
2504 break;
2505 } else {
2506 last = child;
2507 }
2508 }
2509 }
2510 }
2511
2512 // purely for parent lookup, so we don't have to copy the parent
2513 // name every time
2514 static class ParentLookup extends IndexNode {
2515 int len;
2516 ParentLookup() {}
2517
2518 final ParentLookup as(byte[] name, int len) { // as a lookup "key"
2519 name(name, len);
2520 return this;
2521 }
2522
2523 void name(byte[] name, int len) {
2524 this.name = name;
2525 this.len = len;
2526 // calculate the hashcode the same way as Arrays.hashCode() does
2527 int result = 1;
2528 for (int i = 0; i < len; i++)
2529 result = 31 * result + name[i];
2530 this.hashcode = result;
2531 }
2532
2533 @Override
2534 public boolean equals(Object other) {
2535 if (!(other instanceof IndexNode)) {
2536 return false;
2537 }
2538 byte[] oname = ((IndexNode)other).name;
2539 return Arrays.equals(name, 0, len,
2540 oname, 0, oname.length);
2541 }
2542
2543 }
2544
2545 private void buildNodeTree() throws IOException {
2546 beginWrite();
2547 try {
2548 IndexNode root = inodes.get(LOOKUPKEY.as(ROOTPATH));
2549 if (root == null) {
2550 root = new IndexNode(ROOTPATH, true);
2551 } else {
2552 inodes.remove(root);
2553 }
2554 IndexNode[] nodes = inodes.keySet().toArray(new IndexNode[0]);
2555 inodes.put(root, root);
2556 ParentLookup lookup = new ParentLookup();
2557 for (IndexNode node : nodes) {
2558 IndexNode parent;
2559 while (true) {
2560 int off = getParentOff(node.name);
2561 if (off <= 1) { // parent is root
2562 node.sibling = root.child;
2563 root.child = node;
2564 break;
2565 }
2566 lookup = lookup.as(node.name, off);
2567 if (inodes.containsKey(lookup)) {
2568 parent = inodes.get(lookup);
2569 node.sibling = parent.child;
2570 parent.child = node;
2571 break;
2572 }
2573 // add new pseudo directory entry
2574 parent = new IndexNode(Arrays.copyOf(node.name, off), true);
2575 inodes.put(parent, parent);
2576 node.sibling = parent.child;
2577 parent.child = node;
2578 node = parent;
2579 }
2580 }
2581 } finally {
2582 endWrite();
2583 }
2584 }
2585 }