stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

6994145: (zipfs) README should be updated

Browse Source 
6994161: (zipfs) newFileSystem method should FileSystemAlreadyExistsException
6994152: (zipfs) copyTo ignores COPY_ATTRIBUTES option

Zipfile update

Reviewed-by: alanb
This commit is contained in:
Xueming Shen 2010-11-15 09:26:49 -08:00
parent cdcbbea8cb
commit d581e4f434
14 changed files with 1027 additions and 733 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
jdk/make/mkdemo/nio/zipfs/Makefile
View File

@ -42,3 +42,10 @@ DEMO_DESTDIR = $(DEMODIR)/nio/$(DEMONAME)
# #
include $(BUILDDIR)/common/Demo.gmk include $(BUILDDIR)/common/Demo.gmk
#EXTJAR = $(EXTDIR)/$(DEMONAME).jar
#
#all : build $(EXTJAR)
#
#$(EXTJAR) : $(DEMO_JAR)
# $(prep-target)
# $(CP) $(DEMO_JAR) $(EXTJAR)

65
jdk/src/share/demo/nio/zipfs/Demo.java
View File

@ -75,9 +75,15 @@ public class Demo {
// copy an external src file into zipfile // copy an external src file into zipfile
// as entry dst // as entry dst
copyin_attrs, // <java Demo copyin_attrs zipfile src dst>
// copy an external src file into zipfile
// as entry dst, with attributes (timestamp)
copyout, // <java Demo copyout zipfile src dst> copyout, // <java Demo copyout zipfile src dst>
// copy zipfile entry src" out to file dst // copy zipfile entry src" out to file dst
copyout_attrs, // <java Demo copyout_attrs zipfile src dst>
zzmove, // <java Demo zzmove zfsrc zfdst path> zzmove, // <java Demo zzmove zfsrc zfdst path>
// move entry path/dir from zfsrc to zfdst // move entry path/dir from zfsrc to zfdst
@ -94,6 +100,9 @@ public class Demo {
setmtime, // <java Demo setmtime zipfile "MM/dd/yy-HH:mm:ss" path...> setmtime, // <java Demo setmtime zipfile "MM/dd/yy-HH:mm:ss" path...>
// set the lastModifiedTime of entry path // set the lastModifiedTime of entry path
setatime, // <java Demo setatime zipfile "MM/dd/yy-HH:mm:ss" path...>
setctime, // <java Demo setctime zipfile "MM/dd/yy-HH:mm:ss" path...>
lsdir, // <java Demo lsdir zipfile dir> lsdir, // <java Demo lsdir zipfile dir>
// list dir's direct child files/dirs // list dir's direct child files/dirs
@ -135,12 +144,14 @@ public class Demo {
attrs2, // <java Demo attrs2 zipfile file [...]> attrs2, // <java Demo attrs2 zipfile file [...]>
// test different ways to print attrs // test different ways to print attrs
prof,
} }
public static void main(String[] args) throws Throwable { public static void main(String[] args) throws Throwable {
Action action = Action.valueOf(args[0]);; Action action = Action.valueOf(args[0]);
Map<String, Object> env = env = new HashMap<String, Object>(); Map<String, Object> env = env = new HashMap<>();
if (action == Action.create) if (action == Action.create)
env.put("createNew", true); env.put("createNew", true);
if (action == Action.tlist || action == Action.twalk) if (action == Action.tlist || action == Action.twalk)
@ -185,6 +196,16 @@ public class Demo {
dst = fs.getPath(args[3]); dst = fs.getPath(args[3]);
src.copyTo(dst); src.copyTo(dst);
break; break;
case copyin_attrs:
src = Paths.get(args[2]);
dst = fs.getPath(args[3]);
src.copyTo(dst, COPY_ATTRIBUTES);
break;
case copyout_attrs:
src = fs.getPath(args[2]);
dst = Paths.get(args[3]);
src.copyTo(dst, COPY_ATTRIBUTES);
break;
case zzmove: case zzmove:
fs2 = FileSystems.newFileSystem( fs2 = FileSystems.newFileSystem(
URI.create("zip" + Paths.get(args[2]).toUri().toString().substring(4)), URI.create("zip" + Paths.get(args[2]).toUri().toString().substring(4)),
@ -206,6 +227,7 @@ public class Demo {
case attrs: case attrs:
for (int i = 2; i < args.length; i++) { for (int i = 2; i < args.length; i++) {
path = fs.getPath(args[i]); path = fs.getPath(args[i]);
System.out.println(path);
System.out.println( System.out.println(
Attributes.readBasicFileAttributes(path).toString()); Attributes.readBasicFileAttributes(path).toString());
} }
@ -221,6 +243,28 @@ public class Demo {
Attributes.readBasicFileAttributes(path).toString()); Attributes.readBasicFileAttributes(path).toString());
} }
break; break;
case setctime:
df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
newDatetime = df.parse(args[2]);
for (int i = 3; i < args.length; i++) {
path = fs.getPath(args[i]);
path.setAttribute("creationTime",
FileTime.fromMillis(newDatetime.getTime()));
System.out.println(
Attributes.readBasicFileAttributes(path).toString());
}
break;
case setatime:
df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
newDatetime = df.parse(args[2]);
for (int i = 3; i < args.length; i++) {
path = fs.getPath(args[i]);
path.setAttribute("lastAccessTime",
FileTime.fromMillis(newDatetime.getTime()));
System.out.println(
Attributes.readBasicFileAttributes(path).toString());
}
break;
case attrsspace: case attrsspace:
path = fs.getPath("/"); path = fs.getPath("/");
FileStore fstore = path.getFileStore(); FileStore fstore = path.getFileStore();
@ -293,6 +337,7 @@ public class Demo {
case attrs2: case attrs2:
for (int i = 2; i < args.length; i++) { for (int i = 2; i < args.length; i++) {
path = fs.getPath(args[i]); path = fs.getPath(args[i]);
System.out.printf("%n%s%n", path);
System.out.println("-------(1)---------"); System.out.println("-------(1)---------");
System.out.println( System.out.println(
Attributes.readBasicFileAttributes(path).toString()); Attributes.readBasicFileAttributes(path).toString());
@ -308,6 +353,13 @@ public class Demo {
} }
} }
break; break;
case prof:
list(fs.getPath("/"), false);
while (true) {
Thread.sleep(10000);
//list(fs.getPath("/"), true);
System.out.println("sleeping...");
}
} }
} catch (Exception x) { } catch (Exception x) {
x.printStackTrace(); x.printStackTrace();
@ -501,10 +553,11 @@ public class Demo {
} }
private static void list(Path path, boolean verbose ) throws IOException { private static void list(Path path, boolean verbose ) throws IOException {
if (verbose) if (!"/".equals(path.toString())) {
System.out.println(Attributes.readBasicFileAttributes(path).toString()); System.out.printf(" %s%n", path.toString());
else if (verbose)
System.out.printf(" %s%n", path.toString()); System.out.println(Attributes.readBasicFileAttributes(path).toString());
}
if (path.notExists()) if (path.notExists())
return; return;
if (Attributes.readBasicFileAttributes(path).isDirectory()) { if (Attributes.readBasicFileAttributes(path).isDirectory()) {

6
jdk/src/share/demo/nio/zipfs/README.txt
View File

@ -2,7 +2,7 @@ ZipFileSystem is a file system provider that treats the contents of a zip or
JAR file as a java.nio.file.FileSystem. JAR file as a java.nio.file.FileSystem.
To deploy the provider you must copy zipfs.jar into your extensions To deploy the provider you must copy zipfs.jar into your extensions
directory or else add <JDK_HOME>/demo/nio/ZipFileSystem/zipfs.jar directory or else add <JDK_HOME>/demo/nio/zipfs/zipfs.jar
to your class path. to your class path.
The factory methods defined by the java.nio.file.FileSystems class can be The factory methods defined by the java.nio.file.FileSystems class can be
@ -10,8 +10,8 @@ used to create a FileSystem, eg:
// use file type detection // use file type detection
Map<String,?> env = Collections.emptyMap(); Map<String,?> env = Collections.emptyMap();
Path jarfile = Path.get("foo.jar"); Path jarfile = Paths.get("foo.jar");
FileSystem fs = FileSystems.newFileSystem(jarfile, env); FileSystem fs = FileSystems.newFileSystem(jarfile, env, null);
-or -or

17
jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/JarFileSystemProvider.java
View File

@ -68,4 +68,21 @@ public class JarFileSystemProvider extends ZipFileSystemProvider
throw new AssertionError(e); //never thrown throw new AssertionError(e); //never thrown
} }
} }
@Override
public Path getPath(URI uri) {
FileSystem fs = getFileSystem(uri);
String path = uri.getFragment();
if (path == null) {
String uristr = uri.toString();
int off = uristr.indexOf("!/");
if (off != -1)
path = uristr.substring(off + 2);
}
if (path != null)
return fs.getPath(path);
throw new IllegalArgumentException("URI: "
+ uri
+ " does not contain path fragment ex. jar:///c:/foo.zip!/BAR");
}
} }

50
jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipConstants.java
View File

@ -31,7 +31,6 @@
package com.sun.nio.zipfs; package com.sun.nio.zipfs;
import java.nio.ByteBuffer;
/** /**
* *
@ -48,6 +47,7 @@ class ZipConstants {
static final int METHOD_BZIP2 = 12; static final int METHOD_BZIP2 = 12;
static final int METHOD_LZMA = 14; static final int METHOD_LZMA = 14;
static final int METHOD_LZ77 = 19; static final int METHOD_LZ77 = 19;
static final int METHOD_AES = 99;
/* /*
* General purpose big flag * General purpose big flag
@ -168,7 +168,8 @@ class ZipConstants {
static final int EXTID_ZIP64 = 0x0001; // ZIP64 static final int EXTID_ZIP64 = 0x0001; // ZIP64
static final int EXTID_NTFS = 0x000a; // NTFS static final int EXTID_NTFS = 0x000a; // NTFS
static final int EXTID_UNIX = 0x000d; // UNIX static final int EXTID_UNIX = 0x000d; // UNIX
static final int EXTID_EFS = 0x0017; // Strong Encryption
static final int EXTID_EXTT = 0x5455; // Info-ZIP Extended Timestamp
/* /*
* fields access methods * fields access methods
@ -226,34 +227,23 @@ class ZipConstants {
static final long ZIP64_ENDOFF(byte[] b) { return LL(b, 48);} // central directory offset static final long ZIP64_ENDOFF(byte[] b) { return LL(b, 48);} // central directory offset
static final long ZIP64_LOCOFF(byte[] b) { return LL(b, 8);} // zip64 end offset static final long ZIP64_LOCOFF(byte[] b) { return LL(b, 8);} // zip64 end offset
////////////////////////////////////////// // central directory header (CEN) fields
static final int CH(ByteBuffer b, int pos) { static final long CENSIG(byte[] b, int pos) { return LG(b, pos + 0); }
return b.get(pos) & 0xff; static final int CENVEM(byte[] b, int pos) { return SH(b, pos + 4); }
} static final int CENVER(byte[] b, int pos) { return SH(b, pos + 6); }
static final int SH(ByteBuffer b, int pos) { static final int CENFLG(byte[] b, int pos) { return SH(b, pos + 8); }
return b.getShort(pos) & 0xffff; static final int CENHOW(byte[] b, int pos) { return SH(b, pos + 10);}
} static final long CENTIM(byte[] b, int pos) { return LG(b, pos + 12);}
static final long LG(ByteBuffer b, int pos) { static final long CENCRC(byte[] b, int pos) { return LG(b, pos + 16);}
return b.getInt(pos) & 0xffffffffL; static final long CENSIZ(byte[] b, int pos) { return LG(b, pos + 20);}
} static final long CENLEN(byte[] b, int pos) { return LG(b, pos + 24);}
static final int CENNAM(byte[] b, int pos) { return SH(b, pos + 28);}
// central directory header (END) fields static final int CENEXT(byte[] b, int pos) { return SH(b, pos + 30);}
static final long CENSIG(ByteBuffer b, int pos) { return LG(b, pos + 0); } static final int CENCOM(byte[] b, int pos) { return SH(b, pos + 32);}
static final int CENVEM(ByteBuffer b, int pos) { return SH(b, pos + 4); } static final int CENDSK(byte[] b, int pos) { return SH(b, pos + 34);}
static final int CENVER(ByteBuffer b, int pos) { return SH(b, pos + 6); } static final int CENATT(byte[] b, int pos) { return SH(b, pos + 36);}
static final int CENFLG(ByteBuffer b, int pos) { return SH(b, pos + 8); } static final long CENATX(byte[] b, int pos) { return LG(b, pos + 38);}
static final int CENHOW(ByteBuffer b, int pos) { return SH(b, pos + 10);} static final long CENOFF(byte[] b, int pos) { return LG(b, pos + 42);}
static final long CENTIM(ByteBuffer b, int pos) { return LG(b, pos + 12);}
static final long CENCRC(ByteBuffer b, int pos) { return LG(b, pos + 16);}
static final long CENSIZ(ByteBuffer b, int pos) { return LG(b, pos + 20);}
static final long CENLEN(ByteBuffer b, int pos) { return LG(b, pos + 24);}
static final int CENNAM(ByteBuffer b, int pos) { return SH(b, pos + 28);}
static final int CENEXT(ByteBuffer b, int pos) { return SH(b, pos + 30);}
static final int CENCOM(ByteBuffer b, int pos) { return SH(b, pos + 32);}
static final int CENDSK(ByteBuffer b, int pos) { return SH(b, pos + 34);}
static final int CENATT(ByteBuffer b, int pos) { return SH(b, pos + 36);}
static final long CENATX(ByteBuffer b, int pos) { return LG(b, pos + 38);}
static final long CENOFF(ByteBuffer b, int pos) { return LG(b, pos + 42);}
/* The END header is followed by a variable length comment of size < 64k. */ /* The END header is followed by a variable length comment of size < 64k. */
static final long END_MAXLEN = 0xFFFF + ENDHDR; static final long END_MAXLEN = 0xFFFF + ENDHDR;

3
jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipDirectoryStream.java
View File

@ -38,7 +38,6 @@ import java.nio.file.Path;
import java.util.Iterator; import java.util.Iterator;
import java.util.NoSuchElementException; import java.util.NoSuchElementException;
import java.io.IOException; import java.io.IOException;
import static com.sun.nio.zipfs.ZipUtils.*;
/** /**
* *
@ -77,7 +76,7 @@ public class ZipDirectoryStream implements DirectoryStream<Path> {
} catch (IOException e) { } catch (IOException e) {
throw new IllegalStateException(e); throw new IllegalStateException(e);
} }
return new Iterator<Path>() { return new Iterator<>() {
private Path next; private Path next;
@Override @Override
public boolean hasNext() { public boolean hasNext() {

5
jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileAttributeView.java
View File

@ -32,7 +32,6 @@
package com.sun.nio.zipfs; package com.sun.nio.zipfs;
import java.nio.file.ReadOnlyFileSystemException;
import java.nio.file.attribute.BasicFileAttributeView; import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.FileAttributeView; import java.nio.file.attribute.FileAttributeView;
import java.nio.file.attribute.FileTime; import java.nio.file.attribute.FileTime;
@ -113,6 +112,10 @@ public class ZipFileAttributeView implements BasicFileAttributeView
try { try {
if (AttrID.valueOf(attribute) == AttrID.lastModifiedTime) if (AttrID.valueOf(attribute) == AttrID.lastModifiedTime)
setTimes ((FileTime)value, null, null); setTimes ((FileTime)value, null, null);
if (AttrID.valueOf(attribute) == AttrID.lastAccessTime)
setTimes (null, (FileTime)value, null);
if (AttrID.valueOf(attribute) == AttrID.creationTime)
setTimes (null, null, (FileTime)value);
return; return;
} catch (IllegalArgumentException x) {} } catch (IllegalArgumentException x) {}
throw new UnsupportedOperationException("'" + attribute + throw new UnsupportedOperationException("'" + attribute +

19
jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileAttributes.java
View File

@ -56,7 +56,7 @@ public class ZipFileAttributes implements BasicFileAttributes
@Override @Override
public FileTime creationTime() { public FileTime creationTime() {
if (e.ctime != -1) if (e.ctime != -1)
return FileTime.fromMillis(dosToJavaTime(e.ctime)); return FileTime.fromMillis(e.ctime);
return null; return null;
} }
@ -78,13 +78,13 @@ public class ZipFileAttributes implements BasicFileAttributes
@Override @Override
public FileTime lastAccessTime() { public FileTime lastAccessTime() {
if (e.atime != -1) if (e.atime != -1)
return FileTime.fromMillis(dosToJavaTime(e.atime)); return FileTime.fromMillis(e.atime);
return null; return null;
} }
@Override @Override
public FileTime lastModifiedTime() { public FileTime lastModifiedTime() {
return FileTime.fromMillis(dosToJavaTime(e.mtime)); return FileTime.fromMillis(e.mtime);
} }
@Override @Override
@ -103,10 +103,6 @@ public class ZipFileAttributes implements BasicFileAttributes
} }
///////// zip entry attributes /////////// ///////// zip entry attributes ///////////
public byte[] name() {
return Arrays.copyOf(e.name, e.name.length);
}
public long compressedSize() { public long compressedSize() {
return e.csize; return e.csize;
} }
@ -132,10 +128,13 @@ public class ZipFileAttributes implements BasicFileAttributes
} }
public String toString() { public String toString() {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder(1024);
Formatter fm = new Formatter(sb); Formatter fm = new Formatter(sb);
fm.format("[/%s]%n", new String(e.name)); // TBD encoding if (creationTime() != null)
fm.format(" creationTime : %s%n", creationTime()); fm.format(" creationTime : %tc%n", creationTime().toMillis());
else
fm.format(" creationTime : null%n");
if (lastAccessTime() != null) if (lastAccessTime() != null)
fm.format(" lastAccessTime : %tc%n", lastAccessTime().toMillis()); fm.format(" lastAccessTime : %tc%n", lastAccessTime().toMillis());
else else

1284
jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileSystem.java
View File

File diff suppressed because it is too large Load Diff

25
jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipFileSystemProvider.java
View File

@ -55,6 +55,8 @@ import java.util.Set;
*/ */
public class ZipFileSystemProvider extends FileSystemProvider { public class ZipFileSystemProvider extends FileSystemProvider {
private final Map<Path, ZipFileSystem> filesystems = new HashMap<>(); private final Map<Path, ZipFileSystem> filesystems = new HashMap<>();
public ZipFileSystemProvider() {} public ZipFileSystemProvider() {}
@ -101,10 +103,16 @@ public class ZipFileSystemProvider extends FileSystemProvider {
throws IOException throws IOException
{ {
synchronized(filesystems) { synchronized(filesystems) {
if (filesystems.containsKey(path)) Path realPath = null;
throw new FileSystemAlreadyExistsException(); if (path.exists()) {
realPath = path.toRealPath(true);
if (filesystems.containsKey(realPath))
throw new FileSystemAlreadyExistsException();
}
ZipFileSystem zipfs = new ZipFileSystem(this, path, env); ZipFileSystem zipfs = new ZipFileSystem(this, path, env);
filesystems.put(path, zipfs); if (realPath == null)
realPath = path.toRealPath(true);
filesystems.put(realPath, zipfs);
return zipfs; return zipfs;
} }
} }
@ -137,16 +145,21 @@ public class ZipFileSystemProvider extends FileSystemProvider {
@Override @Override
public FileSystem getFileSystem(URI uri) { public FileSystem getFileSystem(URI uri) {
synchronized (filesystems) { synchronized (filesystems) {
ZipFileSystem zipfs = filesystems.get(uriToPath(uri)); ZipFileSystem zipfs = null;
try {
zipfs = filesystems.get(uriToPath(uri).toRealPath(true));
} catch (IOException x) {
// ignore the ioe from toRealPath(), return FSNFE
}
if (zipfs == null) if (zipfs == null)
throw new FileSystemNotFoundException(); throw new FileSystemNotFoundException();
return zipfs; return zipfs;
} }
} }
void removeFileSystem(Path zfpath) { void removeFileSystem(Path zfpath) throws IOException {
synchronized (filesystems) { synchronized (filesystems) {
filesystems.remove(zfpath); filesystems.remove(zfpath.toRealPath(true));
} }
} }
} }

221
jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipInfo.java
View File

@ -31,7 +31,6 @@
package com.sun.nio.zipfs; package com.sun.nio.zipfs;
import java.io.PrintStream;
import java.nio.file.Paths; import java.nio.file.Paths;
import java.util.Collections; import java.util.Collections;
import java.util.Iterator; import java.util.Iterator;
@ -41,7 +40,7 @@ import static com.sun.nio.zipfs.ZipConstants.*;
import static com.sun.nio.zipfs.ZipUtils.*; import static com.sun.nio.zipfs.ZipUtils.*;
/** /**
* Print the loc and cen tables of the ZIP file * Print all loc and cen headers of the ZIP file
* *
* @author Xueming Shen * @author Xueming Shen
*/ */
@ -49,34 +48,38 @@ import static com.sun.nio.zipfs.ZipUtils.*;
public class ZipInfo { public class ZipInfo {
public static void main(String[] args) throws Throwable { public static void main(String[] args) throws Throwable {
if (args.length < 2) { if (args.length < 1) {
print("Usage: java ZipInfo [cen|loc] zfname"); print("Usage: java ZipInfo zfname");
} else { } else {
Map<String, ?> env = Collections.emptyMap(); Map<String, ?> env = Collections.emptyMap();
ZipFileSystem zfs = (ZipFileSystem)(new ZipFileSystemProvider() ZipFileSystem zfs = (ZipFileSystem)(new ZipFileSystemProvider()
.newFileSystem(Paths.get(args[1]), env)); .newFileSystem(Paths.get(args[0]), env));
byte[] cen = zfs.cen;
if (cen == null) {
print("zip file is empty%n");
return;
}
int pos = 0;
byte[] buf = new byte[1024];
int no = 1;
while (pos + CENHDR < cen.length) {
print("----------------#%d--------------------%n", no++);
printCEN(cen, pos);
long pos = 0; // use size CENHDR as the extra bytes to read, just in case the
// loc.extra is bigger than the cen.extra, try to avoid to read
if ("loc".equals(args[0])) { // twice
print("[Local File Header]%n"); long len = LOCHDR + CENNAM(cen, pos) + CENEXT(cen, pos) + CENHDR;
byte[] buf = new byte[1024]; if (zfs.readFullyAt(buf, 0, len, locoff(cen, pos)) != len)
for (int i = 0; i < zfs.getEntryNames().length; i++) { zfs.zerror("read loc header failed");
Entry loc = Entry.readLOC(zfs, pos, buf); if (LOCEXT(buf) > CENEXT(cen, pos) + CENHDR) {
print("--------loc[%x]--------%n", pos); // have to read the second time;
printLOC(loc); len = LOCHDR + LOCNAM(buf) + LOCEXT(buf);
pos = loc.endPos; if (zfs.readFullyAt(buf, 0, len, locoff(cen, pos)) != len)
} zfs.zerror("read loc header failed");
} if ("cen".equals(args[0])) {
int i = 0;
Iterator<ZipFileSystem.IndexNode> itr = zfs.inodes.values().iterator();
print("[Central Directory Header]%n");
while (itr.hasNext()) {
Entry cen = Entry.readCEN(zfs.cen, itr.next().pos);
print("--------cen[%d]--------%n", i);
printCEN(cen);
i++;
} }
printLOC(buf);
pos += CENHDR + CENNAM(cen, pos) + CENEXT(cen, pos) + CENCOM(cen, pos);
} }
zfs.close(); zfs.close();
} }
@ -86,47 +89,135 @@ public class ZipInfo {
System.out.printf(fmt, objs); System.out.printf(fmt, objs);
} }
static void printLOC(Entry loc) { static void printLOC(byte[] loc) {
print(" [%x, %x]%n", loc.startPos, loc.endPos); print("%n");
print(" Signature : %8x%n", LOCSIG); print("[Local File Header]%n");
print(" Version : %4x [%d.%d]%n", print(" Signature : %#010x%n", LOCSIG(loc));
loc.version, loc. version/10, loc. version%10); if (LOCSIG(loc) != LOCSIG) {
print(" Flag : %4x%n", loc.flag); print(" Wrong signature!");
print(" Method : %4x%n", loc. method); return;
print(" LastMTime : %8x [%tc]%n", }
loc.mtime, dosToJavaTime(loc.mtime)); print(" Version : %#6x [%d.%d]%n",
print(" CRC : %8x%n", loc.crc); LOCVER(loc), LOCVER(loc) / 10, LOCVER(loc) % 10);
print(" CSize : %8x%n", loc.csize); print(" Flag : %#6x%n", LOCFLG(loc));
print(" Size : %8x%n", loc.size); print(" Method : %#6x%n", LOCHOW(loc));
print(" NameLength : %4x [%s]%n", print(" LastMTime : %#10x [%tc]%n",
loc.nlen, new String(loc.name)); LOCTIM(loc), dosToJavaTime(LOCTIM(loc)));
print(" ExtraLength : %4x%n", loc.elen); print(" CRC : %#10x%n", LOCCRC(loc));
if (loc.hasZip64) print(" CSize : %#10x%n", LOCSIZ(loc));
print(" *ZIP64*%n"); print(" Size : %#10x%n", LOCLEN(loc));
print(" NameLength : %#6x [%s]%n",
LOCNAM(loc), new String(loc, LOCHDR, LOCNAM(loc)));
print(" ExtraLength : %#6x%n", LOCEXT(loc));
if (LOCEXT(loc) != 0)
printExtra(loc, LOCHDR + LOCNAM(loc), LOCEXT(loc));
} }
static void printCEN(Entry cen) { static void printCEN(byte[] cen, int off) {
print(" Signature : %08x%n", CENSIG); print("[Central Directory Header]%n");
print(" VerMadeby : %4x [%d.%d]%n", print(" Signature : %#010x%n", CENSIG(cen, off));
cen.versionMade, cen.versionMade/10, cen.versionMade%10); if (CENSIG(cen, off) != CENSIG) {
print(" VerExtract : %4x [%d.%d]%n", print(" Wrong signature!");
cen.version, cen.version/10, cen.version%10); return;
print(" Flag : %4x%n", cen.flag); }
print(" Method : %4x%n", cen.method); print(" VerMadeby : %#6x [%d, %d.%d]%n",
print(" LastMTime : %8x [%tc]%n", CENVEM(cen, off), (CENVEM(cen, off) >> 8),
cen.mtime, dosToJavaTime(cen.mtime)); (CENVEM(cen, off) & 0xff) / 10,
print(" CRC : %8x%n", cen.crc); (CENVEM(cen, off) & 0xff) % 10);
print(" CSize : %8x%n", cen.csize); print(" VerExtract : %#6x [%d.%d]%n",
print(" Size : %8x%n", cen.size); CENVER(cen, off), CENVER(cen, off) / 10, CENVER(cen, off) % 10);
print(" NameLen : %4x [%s]%n", print(" Flag : %#6x%n", CENFLG(cen, off));
cen.nlen, new String(cen.name)); print(" Method : %#6x%n", CENHOW(cen, off));
print(" ExtraLen : %4x%n", cen.elen); print(" LastMTime : %#10x [%tc]%n",
print(" CommentLen : %4x%n", cen.clen); CENTIM(cen, off), dosToJavaTime(CENTIM(cen, off)));
print(" DiskStart : %4x%n", cen.disk); print(" CRC : %#10x%n", CENCRC(cen, off));
print(" Attrs : %4x%n", cen.attrs); print(" CSize : %#10x%n", CENSIZ(cen, off));
print(" AttrsEx : %8x%n", cen.attrsEx); print(" Size : %#10x%n", CENLEN(cen, off));
print(" LocOff : %8x%n", cen.locoff); print(" NameLen : %#6x [%s]%n",
if (cen.hasZip64) CENNAM(cen, off), new String(cen, off + CENHDR, CENNAM(cen, off)));
print(" *ZIP64*%n"); print(" ExtraLen : %#6x%n", CENEXT(cen, off));
if (CENEXT(cen, off) != 0)
printExtra(cen, off + CENHDR + CENNAM(cen, off), CENEXT(cen, off));
print(" CommentLen : %#6x%n", CENCOM(cen, off));
print(" DiskStart : %#6x%n", CENDSK(cen, off));
print(" Attrs : %#6x%n", CENATT(cen, off));
print(" AttrsEx : %#10x%n", CENATX(cen, off));
print(" LocOff : %#10x%n", CENOFF(cen, off));
}
static long locoff(byte[] cen, int pos) {
long locoff = CENOFF(cen, pos);
if (locoff == ZIP64_MINVAL) { //ZIP64
int off = pos + CENHDR + CENNAM(cen, pos);
int end = off + CENEXT(cen, pos);
while (off + 4 < end) {
int tag = SH(cen, off);
int sz = SH(cen, off + 2);
if (tag != EXTID_ZIP64) {
off += 4 + sz;
continue;
}
off += 4;
if (CENLEN(cen, pos) == ZIP64_MINVAL)
off += 8;
if (CENSIZ(cen, pos) == ZIP64_MINVAL)
off += 8;
return LL(cen, off);
}
// should never be here
}
return locoff;
}
static void printExtra(byte[] extra, int off, int len) {
int end = off + len;
while (off + 4 < end) {
int tag = SH(extra, off);
int sz = SH(extra, off + 2);
print(" [tag=0x%04x, sz=%d, data= ", tag, sz);
if (off + sz > end) {
print(" Error: Invalid extra data, beyond extra length");
break;
}
off += 4;
for (int i = 0; i < sz; i++)
print("%02x ", extra[off + i]);
print("]%n");
switch (tag) {
case EXTID_ZIP64 :
print(" ->ZIP64: ");
int pos = off;
while (pos + 8 <= off + sz) {
print(" *0x%x ", LL(extra, pos));
pos += 8;
}
print("%n");
break;
case EXTID_NTFS:
print(" ->PKWare NTFS%n");
// 4 bytes reserved
if (SH(extra, off + 4) != 0x0001 || SH(extra, off + 6) != 24)
print(" Error: Invalid NTFS sub-tag or subsz");
print(" mtime:%tc%n",
winToJavaTime(LL(extra, off + 8)));
print(" atime:%tc%n",
winToJavaTime(LL(extra, off + 16)));
print(" ctime:%tc%n",
winToJavaTime(LL(extra, off + 24)));
break;
case EXTID_EXTT:
print(" ->Inof-ZIP Extended Timestamp: flag=%x%n",extra[off]);
pos = off + 1 ;
while (pos + 4 <= off + sz) {
print(" *%tc%n",
unixToJavaTime(LG(extra, pos)));
pos += 4;
}
break;
default:
}
off += sz;
}
} }
} }

19
jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipPath.java
View File

@ -32,24 +32,19 @@
package com.sun.nio.zipfs; package com.sun.nio.zipfs;
import java.io.File; import java.io.File;
import java.io.FilterInputStream;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
import java.io.OutputStream; import java.io.OutputStream;
import java.net.URI; import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel; import java.nio.channels.FileChannel;
import java.nio.channels.SeekableByteChannel; import java.nio.channels.SeekableByteChannel;
import java.nio.file.*; import java.nio.file.*;
import java.nio.file.DirectoryStream.Filter; import java.nio.file.DirectoryStream.Filter;
import java.nio.file.spi.FileSystemProvider;
import java.nio.file.attribute.BasicFileAttributeView; import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.FileAttribute; import java.nio.file.attribute.FileAttribute;
import java.nio.file.attribute.FileAttributeView; import java.nio.file.attribute.FileAttributeView;
import java.nio.file.attribute.FileTime; import java.nio.file.attribute.FileTime;
import java.util.*; import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static java.nio.file.StandardOpenOption.*; import static java.nio.file.StandardOpenOption.*;
import static java.nio.file.StandardCopyOption.*; import static java.nio.file.StandardCopyOption.*;
@ -599,7 +594,7 @@ public class ZipPath extends Path {
} }
private static final DirectoryStream.Filter<Path> acceptAllFilter = private static final DirectoryStream.Filter<Path> acceptAllFilter =
new DirectoryStream.Filter<Path>() { new DirectoryStream.Filter<>() {
@Override public boolean accept(Path entry) { return true; } @Override public boolean accept(Path entry) { return true; }
}; };
@ -625,7 +620,7 @@ public class ZipPath extends Path {
// create a matcher and return a filter that uses it. // create a matcher and return a filter that uses it.
final PathMatcher matcher = getFileSystem().getPathMatcher("glob:" + glob); final PathMatcher matcher = getFileSystem().getPathMatcher("glob:" + glob);
DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<Path>() { DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<>() {
@Override @Override
public boolean accept(Path entry) { public boolean accept(Path entry) {
return matcher.matches(entry.getName()); return matcher.matches(entry.getName());
@ -758,7 +753,7 @@ public class ZipPath extends Path {
@Override @Override
public Iterator<Path> iterator() { public Iterator<Path> iterator() {
return new Iterator<Path>() { return new Iterator<>() {
private int i = 0; private int i = 0;
@Override @Override
@ -803,7 +798,7 @@ public class ZipPath extends Path {
@Override @Override
public SeekableByteChannel newByteChannel(OpenOption... options) public SeekableByteChannel newByteChannel(OpenOption... options)
throws IOException { throws IOException {
Set<OpenOption> set = new HashSet<OpenOption>(options.length); Set<OpenOption> set = new HashSet<>(options.length);
Collections.addAll(set, options); Collections.addAll(set, options);
return newByteChannel(set); return newByteChannel(set);
} }
@ -908,7 +903,7 @@ public class ZipPath extends Path {
if (opt == REPLACE_EXISTING) if (opt == REPLACE_EXISTING)
replaceExisting = true; replaceExisting = true;
else if (opt == COPY_ATTRIBUTES) else if (opt == COPY_ATTRIBUTES)
copyAttrs = false; copyAttrs = true;
} }
// attributes of source file // attributes of source file
ZipFileAttributes zfas = getAttributes(); ZipFileAttributes zfas = getAttributes();
@ -951,7 +946,9 @@ public class ZipPath extends Path {
BasicFileAttributeView view = BasicFileAttributeView view =
target.getFileAttributeView(BasicFileAttributeView.class); target.getFileAttributeView(BasicFileAttributeView.class);
try { try {
view.setTimes(zfas.lastModifiedTime(), null, null); view.setTimes(zfas.lastModifiedTime(),
zfas.lastAccessTime(),
zfas.creationTime());
} catch (IOException x) { } catch (IOException x) {
// rollback? // rollback?
try { try {

28
jdk/src/share/demo/nio/zipfs/com/sun/nio/zipfs/ZipUtils.java
View File

@ -36,6 +36,7 @@ import java.io.OutputStream;
import java.util.Arrays; import java.util.Arrays;
import java.util.Date; import java.util.Date;
import java.util.regex.PatternSyntaxException; import java.util.regex.PatternSyntaxException;
import java.util.concurrent.TimeUnit;
/** /**
* *
@ -48,7 +49,7 @@ class ZipUtils {
* Writes a 16-bit short to the output stream in little-endian byte order. * Writes a 16-bit short to the output stream in little-endian byte order.
*/ */
public static void writeShort(OutputStream os, int v) throws IOException { public static void writeShort(OutputStream os, int v) throws IOException {
os.write((v >>> 0) & 0xff); os.write(v & 0xff);
os.write((v >>> 8) & 0xff); os.write((v >>> 8) & 0xff);
} }
@ -56,7 +57,7 @@ class ZipUtils {
* Writes a 32-bit int to the output stream in little-endian byte order. * Writes a 32-bit int to the output stream in little-endian byte order.
*/ */
public static void writeInt(OutputStream os, long v) throws IOException { public static void writeInt(OutputStream os, long v) throws IOException {
os.write((int)((v >>> 0) & 0xff)); os.write((int)(v & 0xff));
os.write((int)((v >>> 8) & 0xff)); os.write((int)((v >>> 8) & 0xff));
os.write((int)((v >>> 16) & 0xff)); os.write((int)((v >>> 16) & 0xff));
os.write((int)((v >>> 24) & 0xff)); os.write((int)((v >>> 24) & 0xff));
@ -66,7 +67,7 @@ class ZipUtils {
* Writes a 64-bit int to the output stream in little-endian byte order. * Writes a 64-bit int to the output stream in little-endian byte order.
*/ */
public static void writeLong(OutputStream os, long v) throws IOException { public static void writeLong(OutputStream os, long v) throws IOException {
os.write((int)((v >>> 0) & 0xff)); os.write((int)(v & 0xff));
os.write((int)((v >>> 8) & 0xff)); os.write((int)((v >>> 8) & 0xff));
os.write((int)((v >>> 16) & 0xff)); os.write((int)((v >>> 16) & 0xff));
os.write((int)((v >>> 24) & 0xff)); os.write((int)((v >>> 24) & 0xff));
@ -132,6 +133,27 @@ class ZipUtils {
d.getSeconds() >> 1; d.getSeconds() >> 1;
} }
// used to adjust values between Windows and java epoch
private static final long WINDOWS_EPOCH_IN_MICROSECONDS = -11644473600000000L;
public static final long winToJavaTime(long wtime) {
return TimeUnit.MILLISECONDS.convert(
wtime / 10 + WINDOWS_EPOCH_IN_MICROSECONDS, TimeUnit.MICROSECONDS);
}
public static final long javaToWinTime(long time) {
return (TimeUnit.MICROSECONDS.convert(time, TimeUnit.MILLISECONDS)
- WINDOWS_EPOCH_IN_MICROSECONDS) * 10;
}
public static final long unixToJavaTime(long utime) {
return TimeUnit.MILLISECONDS.convert(utime, TimeUnit.SECONDS);
}
public static final long javaToUnixTime(long time) {
return TimeUnit.SECONDS.convert(time, TimeUnit.MILLISECONDS);
}
private static final String regexMetaChars = ".^$+{[]|()"; private static final String regexMetaChars = ".^$+{[]|()";
private static final String globMetaChars = "\\*?[{"; private static final String globMetaChars = "\\*?[{";
private static boolean isRegexMeta(char c) { private static boolean isRegexMeta(char c) {

11
jdk/test/demo/zipfs/ZipFSTester.java
View File

@ -64,7 +64,6 @@ public class ZipFSTester {
fs0.close(); // sync to file fs0.close(); // sync to file
fs = newZipFileSystem(tmpfsPath, new HashMap<String, Object>()); fs = newZipFileSystem(tmpfsPath, new HashMap<String, Object>());
try { try {
// prepare a src // prepare a src
Path src = getTempPath(); Path src = getTempPath();
@ -146,13 +145,6 @@ public class ZipFSTester {
Path fs2Path = getTempPath(); Path fs2Path = getTempPath();
Path fs3Path = getTempPath(); Path fs3Path = getTempPath();
if (fs1Path.exists())
fs1Path.delete();
if (fs2Path.exists())
fs2Path.delete();
if (fs3Path.exists())
fs3Path.delete();
// create a new filesystem, copy everything from fs // create a new filesystem, copy everything from fs
Map<String, Object> env = new HashMap<String, Object>(); Map<String, Object> env = new HashMap<String, Object>();
env.put("createNew", true); env.put("createNew", true);
@ -280,7 +272,6 @@ public class ZipFSTester {
walk(fs4.getPath("/")); walk(fs4.getPath("/"));
System.out.println("closing: fs4"); System.out.println("closing: fs4");
fs4.close(); fs4.close();
System.out.printf("failed=%d%n", failed); System.out.printf("failed=%d%n", failed);
fs1Path.delete(); fs1Path.delete();
@ -426,6 +417,8 @@ public class ZipFSTester {
} }
private static void mkdirs(Path path) throws IOException { private static void mkdirs(Path path) throws IOException {
if (path.exists())
return;
path = path.toAbsolutePath(); path = path.toAbsolutePath();
Path parent = path.getParent(); Path parent = path.getParent();
if (parent != null) { if (parent != null) {