jdk-sandbox: comparison jdk/src/share/classes/sun/tools/jar/Main.java

equal deleted inserted replaced

-:07b65d4b6227
+:855a6257b729
 */
 package sun.tools.jar;
 import java.io.*;
+import java.nio.file.Path;
 import java.util.*;
 import java.util.zip.*;
 import java.util.jar.*;
 import java.util.jar.Manifest;
 import java.text.MessageFormat;
 import sun.misc.JarIndex;
+import static sun.misc.JarIndex.INDEX_NAME;
+import static java.util.jar.JarFile.MANIFEST_NAME;
+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
 /**
 * This class implements a simple utility for creating files in the JAR
 * (Java Archive) file format. The JAR format is based on the ZIP file
 * format, with optional meta-information stored in a MANIFEST entry.
 Set<File> entries = new LinkedHashSet<File>();
 // Directories specified by "-C" operation.
 Set<String> paths = new HashSet<String>();
-CRC32 crc32 = new CRC32();
 /*
 * cflag: create
 * uflag: update
 * xflag: xtract
 * tflag: table
 * Mflag: DO NOT generate a manifest file (just ZIP)
 * iflag: generate jar index
 */
 boolean cflag, uflag, xflag, tflag, vflag, flag0, Mflag, iflag;
-static final String MANIFEST = JarFile.MANIFEST_NAME;
 static final String MANIFEST_DIR = "META-INF/";
 static final String VERSION = "1.0";
-static final String INDEX = JarIndex.INDEX_NAME;
 private static ResourceBundle rsrc;
 /**
 * If true, maintain compatibility with JDK releases prior to 6.0 by
 this.out = out;
 this.err = err;
 this.program = program;
 }
+/**
+* Creates a new empty temporary file in the same directory as the
+* specified file.  A variant of File.createTempFile.
+*/
+private static File createTempFileInSameDirectoryAs(File file)
+throws IOException {
+File dir = file.getParentFile();
+if (dir == null)
+dir = new File(".");
+return File.createTempFile("jartmp", null, dir);
+}
 private boolean ok;
-/*
+/**
 * Starts main program with the specified arguments.
 */
 public synchronized boolean run(String args[]) {
 ok = true;
 if (!parseArgs(args)) {
 } else {
 manifest = new Manifest();
 }
 addVersion(manifest);
 addCreatedBy(manifest);
-if (isAmbigousMainClass(manifest)) {
+if (isAmbiguousMainClass(manifest)) {
 if (in != null) {
 in.close();
 }
 return false;
 }
 File inputFile = null, tmpFile = null;
 FileInputStream in;
 FileOutputStream out;
 if (fname != null) {
 inputFile = new File(fname);
-String path = inputFile.getParent();
+tmpFile = createTempFileInSameDirectoryAs(inputFile);
-tmpFile = File.createTempFile("tmp", null,
-new File((path == null) ? "." : path));
 in = new FileInputStream(inputFile);
 out = new FileOutputStream(tmpFile);
 } else {
 in = new FileInputStream(FileDescriptor.in);
 out = new FileOutputStream(FileDescriptor.out);
 vflag = false;
 }
 InputStream manifest = (!Mflag && (mname != null)) ?
 (new FileInputStream(mname)) : null;
 expand(null, files, true);
-boolean updateOk = update(in, new BufferedOutputStream(out), manifest, null);
+boolean updateOk = update(in, new BufferedOutputStream(out),
+manifest, null);
 if (ok) {
 ok = updateOk;
 }
 in.close();
 out.close();
 out.flush();
 err.flush();
 return ok;
 }
-/*
+/**
-* Parse command line arguments.
+* Parses command line arguments.
 */
 boolean parseArgs(String args[]) {
 /* Preprocess and expand @file arguments */
 try {
 args = CommandLine.parse(args);
 }
 }
 return true;
 }
-/*
+/**
 * Expands list of files to process into full list of all files that
 * can be found by recursively descending directories.
 */
 void expand(File dir, String[] files, boolean isUpdate) {
 if (files == null) {
 ok = false;
 }
 }
 }
-/*
+/**
 * Creates a new JAR file.
 */
 void create(OutputStream out, Manifest manifest)
 throws IOException
 {
 ZipEntry e = new ZipEntry(MANIFEST_DIR);
 e.setTime(System.currentTimeMillis());
 e.setSize(0);
 e.setCrc(0);
 zos.putNextEntry(e);
-e = new ZipEntry(MANIFEST);
+e = new ZipEntry(MANIFEST_NAME);
 e.setTime(System.currentTimeMillis());
 if (flag0) {
 crc32Manifest(e, manifest);
 }
 zos.putNextEntry(e);
 addFile(zos, file);
 }
 zos.close();
 }
-/*
+private char toUpperCaseASCII(char c) {
-* update an existing jar file.
+return (c < 'a' || c > 'z') ? c : (char) (c + 'A' - 'a');
+}
+/**
+* Compares two strings for equality, ignoring case.  The second
+* argument must contain only upper-case ASCII characters.
+* We don't want case comparison to be locale-dependent (else we
+* have the notorious "turkish i bug").
+*/
+private boolean equalsIgnoreCase(String s, String upper) {
+assert upper.toUpperCase(java.util.Locale.ENGLISH).equals(upper);
+int len;
+if ((len = s.length()) != upper.length())
+return false;
+for (int i = 0; i < len; i++) {
+char c1 = s.charAt(i);
+char c2 = upper.charAt(i);
+if (c1 != c2 && toUpperCaseASCII(c1) != c2)
+return false;
+}
+return true;
+}
+/**
+* Updates an existing jar file.
 */
 boolean update(InputStream in, OutputStream out,
 InputStream newManifest,
 JarIndex jarIndex) throws IOException
 {
 ZipInputStream zis = new ZipInputStream(in);
 ZipOutputStream zos = new JarOutputStream(out);
 ZipEntry e = null;
 boolean foundManifest = false;
-byte[] buf = new byte[1024];
-int n = 0;
 boolean updateOk = true;
 if (jarIndex != null) {
 addIndex(jarIndex, zos);
 }
 // put the old entries first, replace if necessary
 while ((e = zis.getNextEntry()) != null) {
 String name = e.getName();
-boolean isManifestEntry = name.toUpperCase(
+boolean isManifestEntry = equalsIgnoreCase(name, MANIFEST_NAME);
-java.util.Locale.ENGLISH).
-equals(MANIFEST);
+if ((jarIndex != null && equalsIgnoreCase(name, INDEX_NAME))
-if ((name.toUpperCase().equals(INDEX) && jarIndex != null)
 || (Mflag && isManifestEntry)) {
 continue;
 } else if (isManifestEntry && ((newManifest != null) ||
 (ename != null))) {
 foundManifest = true;
 if (newManifest != null) {
 // Don't read from the newManifest InputStream, as we
 // might need it below, and we can't re-read the same data
 // twice.
 FileInputStream fis = new FileInputStream(mname);
-boolean ambigous = isAmbigousMainClass(new Manifest(fis));
+boolean ambiguous = isAmbiguousMainClass(new Manifest(fis));
 fis.close();
-if (ambigous) {
+if (ambiguous) {
 return false;
 }
 }
 // Update the manifest.
 if (e.getMethod() == ZipEntry.STORED) {
 e2.setSize(e.getSize());
 e2.setCrc(e.getCrc());
 }
 zos.putNextEntry(e2);
-while ((n = zis.read(buf, 0, buf.length)) != -1) {
+copy(zis, zos);
-zos.write(buf, 0, n);
-}
 } else { // replace with the new files
 File f = entryMap.get(name);
 addFile(zos, f);
 entryMap.remove(name);
 entries.remove(f);
 addFile(zos, f);
 }
 if (!foundManifest) {
 if (newManifest != null) {
 Manifest m = new Manifest(newManifest);
-updateOk = !isAmbigousMainClass(m);
+updateOk = !isAmbiguousMainClass(m);
 if (updateOk) {
 updateManifest(m, zos);
 }
 } else if (ename != null) {
 updateManifest(new Manifest(), zos);
 private void addIndex(JarIndex index, ZipOutputStream zos)
 throws IOException
 {
-ZipEntry e = new ZipEntry(INDEX);
+ZipEntry e = new ZipEntry(INDEX_NAME);
 e.setTime(System.currentTimeMillis());
 if (flag0) {
-e.setMethod(ZipEntry.STORED);
+CRC32OutputStream os = new CRC32OutputStream();
-File ifile = File.createTempFile("index", null, new File("."));
+index.write(os);
-BufferedOutputStream bos = new BufferedOutputStream
+os.updateEntry(e);
-(new FileOutputStream(ifile));
-index.write(bos);
-crc32File(e, ifile);
-bos.close();
-ifile.delete();
 }
 zos.putNextEntry(e);
 index.write(zos);
-if (vflag) {
+zos.closeEntry();
-// output(getMsg("out.update.manifest"));
-}
 }
 private void updateManifest(Manifest m, ZipOutputStream zos)
 throws IOException
 {
 addVersion(m);
 addCreatedBy(m);
 if (ename != null) {
 addMainClass(m, ename);
 }
-ZipEntry e = new ZipEntry(MANIFEST);
+ZipEntry e = new ZipEntry(MANIFEST_NAME);
 e.setTime(System.currentTimeMillis());
 if (flag0) {
-e.setMethod(ZipEntry.STORED);
 crc32Manifest(e, m);
 }
 zos.putNextEntry(e);
 m.write(zos);
 if (vflag) {
 private String entryName(String name) {
 name = name.replace(File.separatorChar, '/');
 String matchPath = "";
 for (String path : paths) {
-if (name.startsWith(path) && (path.length() > matchPath.length())) {
+if (name.startsWith(path)
+&& (path.length() > matchPath.length())) {
 matchPath = path;
 }
 }
 name = name.substring(matchPath.length());
 // overrides any existing Main-Class attribute
 global.put(Attributes.Name.MAIN_CLASS, mainApp);
 }
-private boolean isAmbigousMainClass(Manifest m) {
+private boolean isAmbiguousMainClass(Manifest m) {
 if (ename != null) {
 Attributes global = m.getMainAttributes();
 if ((global.get(Attributes.Name.MAIN_CLASS) != null)) {
 error(getMsg("error.bad.eflag"));
 usageError();
 }
 }
 return false;
 }
-/*
+/**
 * Adds a new file entry to the ZIP output stream.
 */
 void addFile(ZipOutputStream zos, File file) throws IOException {
 String name = file.getPath();
 boolean isDir = file.isDirectory();
 }
 name = entryName(name);
 if (name.equals("") || name.equals(".") || name.equals(zname)) {
 return;
-} else if ((name.equals(MANIFEST_DIR) || name.equals(MANIFEST))
+} else if ((name.equals(MANIFEST_DIR) || name.equals(MANIFEST_NAME))
 && !Mflag) {
 if (vflag) {
 output(formatMsg("out.ignore.entry", name));
 }
 return;
 if (size == 0) {
 e.setMethod(ZipEntry.STORED);
 e.setSize(0);
 e.setCrc(0);
 } else if (flag0) {
-e.setSize(size);
-e.setMethod(ZipEntry.STORED);
 crc32File(e, file);
 }
 zos.putNextEntry(e);
 if (!isDir) {
-byte[] buf = new byte[8192];
+copy(file, zos);
-int len;
-InputStream is = new BufferedInputStream(new FileInputStream(file));
-while ((len = is.read(buf, 0, buf.length)) != -1) {
-zos.write(buf, 0, len);
-}
-is.close();
 }
 zos.closeEntry();
 /* report how much compression occurred. */
 if (vflag) {
 size = e.getSize();
 output(getMsg("out.stored"));
 }
 }
 }
-/*
+/**
-* compute the crc32 of a file.  This is necessary when the ZipOutputStream
+* A buffer for use only by copy(InputStream, OutputStream).
-* is in STORED mode.
+* Not as clean as allocating a new buffer as needed by copy,
+* but significantly more efficient.
+*/
+private byte[] copyBuf = new byte[8192];
+/**
+* Copies all bytes from the input stream to the output stream.
+* Does not close or flush either stream.
+*
+* @param from the input stream to read from
+* @param to the output stream to write to
+* @throws IOException if an I/O error occurs
+*/
+private void copy(InputStream from, OutputStream to) throws IOException {
+int n;
+while ((n = from.read(copyBuf)) != -1)
+to.write(copyBuf, 0, n);
+}
+/**
+* Copies all bytes from the input file to the output stream.
+* Does not close or flush the output stream.
+*
+* @param from the input file to read from
+* @param to the output stream to write to
+* @throws IOException if an I/O error occurs
+*/
+private void copy(File from, OutputStream to) throws IOException {
+InputStream in = new FileInputStream(from);
+try {
+copy(in, to);
+} finally {
+in.close();
+}
+}
+/**
+* Copies all bytes from the input stream to the output file.
+* Does not close the input stream.
+*
+* @param from the input stream to read from
+* @param to the output file to write to
+* @throws IOException if an I/O error occurs
+*/
+private void copy(InputStream from, File to) throws IOException {
+OutputStream out = new FileOutputStream(to);
+try {
+copy(from, out);
+} finally {
+out.close();
+}
+}
+/**
+* Computes the crc32 of a Manifest.  This is necessary when the
+* ZipOutputStream is in STORED mode.
 */
 private void crc32Manifest(ZipEntry e, Manifest m) throws IOException {
-crc32.reset();
+CRC32OutputStream os = new CRC32OutputStream();
-CRC32OutputStream os = new CRC32OutputStream(crc32);
 m.write(os);
-e.setSize((long) os.n);
+os.updateEntry(e);
-e.setCrc(crc32.getValue());
+}
-}
+/**
-/*
+* Computes the crc32 of a File.  This is necessary when the
-* compute the crc32 of a file.  This is necessary when the ZipOutputStream
+* ZipOutputStream is in STORED mode.
-* is in STORED mode.
 */
 private void crc32File(ZipEntry e, File f) throws IOException {
-InputStream is = new BufferedInputStream(new FileInputStream(f));
+CRC32OutputStream os = new CRC32OutputStream();
-byte[] buf = new byte[8192];
+copy(f, os);
-crc32.reset();
+if (os.n != f.length()) {
-int r = 0;
-int nread = 0;
-long len = f.length();
-while ((r = is.read(buf)) != -1) {
-nread += r;
-crc32.update(buf, 0, r);
-}
-is.close();
-if (nread != (int) len) {
 throw new JarException(formatMsg(
 "error.incorrect.length", f.getPath()));
 }
-e.setCrc(crc32.getValue());
+os.updateEntry(e);
 }
 void replaceFSC(String files[]) {
 if (files != null) {
 for (String file : files) {
 file = file.replace(File.separatorChar, '/');
 }
 }
 }
+@SuppressWarnings("serial")
 Set<ZipEntry> newDirSet() {
 return new HashSet<ZipEntry>() {
 public boolean add(ZipEntry e) {
 return ((e == null || useExtractionTime) ? false : super.add(e));
 }};
 f.setLastModified(lastModified);
 }
 }
 }
-/*
+/**
 * Extracts specified entries from JAR file.
 */
 void extract(InputStream in, String files[]) throws IOException {
 ZipInputStream zis = new ZipInputStream(in);
 ZipEntry e;
 // instead of during, because creating a file in a directory changes
 // that directory's timestamp.
 updateLastModifiedTime(dirs);
 }
-/*
+/**
 * Extracts specified entries from JAR file, via ZipFile.
 */
 void extract(String fname, String files[]) throws IOException {
 ZipFile zf = new ZipFile(fname);
 Set<ZipEntry> dirs = newDirSet();
 }
 zf.close();
 updateLastModifiedTime(dirs);
 }
-/*
+/**
 * Extracts next entry from JAR file, creating directories as needed.  If
 * the entry is for a directory which doesn't exist prior to this
 * invocation, returns that entry, otherwise returns null.
 */
 ZipEntry extractFile(InputStream is, ZipEntry e) throws IOException {
 if (!d.exists() && !d.mkdirs() || !d.isDirectory()) {
 throw new IOException(formatMsg(
 "error.create.dir", d.getPath()));
 }
 }
-OutputStream os = new FileOutputStream(f);
-byte[] b = new byte[8192];
-int len;
 try {
-while ((len = is.read(b, 0, b.length)) != -1) {
+copy(is, f);
-os.write(b, 0, len);
-}
 } finally {
 if (is instanceof ZipInputStream)
 ((ZipInputStream)is).closeEntry();
 else
 is.close();
-os.close();
 }
 if (vflag) {
 if (e.getMethod() == ZipEntry.DEFLATED) {
 output(formatMsg("out.inflated", name));
 } else {
 }
 }
 return rc;
 }
-/*
+/**
 * Lists contents of JAR file.
 */
 void list(InputStream in, String files[]) throws IOException {
 ZipInputStream zis = new ZipInputStream(in);
 ZipEntry e;
 zis.closeEntry();
 printEntry(e, files);
 }
 }
-/*
+/**
 * Lists contents of JAR file, via ZipFile.
 */
 void list(String fname, String files[]) throws IOException {
 ZipFile zf = new ZipFile(fname);
 Enumeration<? extends ZipEntry> zes = zf.entries();
 }
 zf.close();
 }
 /**
-* Output the class index table to the INDEX.LIST file of the
+* Outputs the class index table to the INDEX.LIST file of the
 * root jar file.
 */
 void dumpIndex(String rootjar, JarIndex index) throws IOException {
-File scratchFile = File.createTempFile("scratch", null, new File("."));
 File jarFile = new File(rootjar);
-boolean updateOk = update(new FileInputStream(jarFile),
+Path jarPath = jarFile.toPath();
-new FileOutputStream(scratchFile),
+Path tmpPath = createTempFileInSameDirectoryAs(jarFile).toPath();
-null, index);
+try {
-jarFile.delete();
+if (update(jarPath.newInputStream(),
-if (!scratchFile.renameTo(jarFile)) {
+tmpPath.newOutputStream(),
-scratchFile.delete();
+null, index)) {
-throw new IOException(getMsg("error.write.file"));
+try {
-}
+tmpPath.moveTo(jarPath, REPLACE_EXISTING);
-scratchFile.delete();
+} catch (IOException e) {
-}
+throw new IOException(getMsg("error.write.file"), e);
+}
-private Hashtable jarTable = new Hashtable();
+}
-/*
+} finally {
-* Generate the transitive closure of the Class-Path attribute for
+tmpPath.deleteIfExists();
+}
+}
+private HashSet<String> jarPaths = new HashSet<String>();
+/**
+* Generates the transitive closure of the Class-Path attribute for
 * the specified jar file.
 */
-Vector getJarPath(String jar) throws IOException {
+List<String> getJarPath(String jar) throws IOException {
-Vector files = new Vector();
+List<String> files = new ArrayList<String>();
 files.add(jar);
-jarTable.put(jar, jar);
+jarPaths.add(jar);
 // take out the current path
 String path = jar.substring(0, Math.max(0, jar.lastIndexOf('/') + 1));
 // class path attribute will give us jar file name with
 while (st.hasMoreTokens()) {
 String ajar = st.nextToken();
 if (!ajar.endsWith("/")) {  // it is a jar file
 ajar = path.concat(ajar);
 /* check on cyclic dependency */
-if (jarTable.get(ajar) == null) {
+if (! jarPaths.contains(ajar)) {
 files.addAll(getJarPath(ajar));
 }
 }
 }
 }
 rf.close();
 return files;
 }
 /**
-* Generate class index file for the specified root jar file.
+* Generates class index file for the specified root jar file.
 */
 void genIndex(String rootjar, String[] files) throws IOException {
-Vector jars = getJarPath(rootjar);
+List<String> jars = getJarPath(rootjar);
 int njars = jars.size();
 String[] jarfiles;
 if (njars == 1 && files != null) {
 // no class-path attribute defined in rootjar, will
 for (int i = 0; i < files.length; i++) {
 jars.addAll(getJarPath(files[i]));
 }
 njars = jars.size();
 }
-jarfiles = (String[])jars.toArray(new String[njars]);
+jarfiles = jars.toArray(new String[njars]);
 JarIndex index = new JarIndex(jarfiles);
 dumpIndex(rootjar, index);
 }
-/*
+/**
 * Prints entry information, if requested.
 */
 void printEntry(ZipEntry e, String[] files) throws IOException {
 if (files == null) {
 printEntry(e);
 }
 }
 }
 }
-/*
+/**
 * Prints entry information.
 */
 void printEntry(ZipEntry e) throws IOException {
 if (vflag) {
 StringBuilder sb = new StringBuilder();
 } else {
 output(e.getName());
 }
 }
-/*
+/**
-* Print usage message and die.
+* Prints usage message.
 */
 void usageError() {
 error(getMsg("usage"));
 }
-/*
+/**
 * A fatal exception has been caught.  No recovery possible
 */
 void fatalError(Exception e) {
 e.printStackTrace();
 }
-/*
+/**
 * A fatal condition has been detected; message is "s".
 * No recovery possible
 */
 void fatalError(String s) {
 error(program + ": " + s);
 */
 protected void error(String s) {
 err.println(s);
 }
-/*
+/**
 * Main routine to start program.
 */
 public static void main(String args[]) {
 Main jartool = new Main(System.out, System.err, "jar");
 System.exit(jartool.run(args) ? 0 : 1);
 }
+/**
+* An OutputStream that doesn't send its output anywhere, (but could).
+* It's here to find the CRC32 of an input file, necessary for STORED
+* mode in ZIP.
+*/
+private static class CRC32OutputStream extends java.io.OutputStream {
+final CRC32 crc = new CRC32();
+long n = 0;
+CRC32OutputStream() {}
+public void write(int r) throws IOException {
+crc.update(r);
+n++;
+}
+public void write(byte[] b, int off, int len) throws IOException {
+crc.update(b, off, len);
+n += len;
+}
+/**
+* Updates a ZipEntry which describes the data read by this
+* output stream, in STORED mode.
+*/
+public void updateEntry(ZipEntry e) {
+e.setMethod(ZipEntry.STORED);
+e.setSize(n);
+e.setCrc(crc.getValue());
+}
+}
 }
-/*
-* an OutputStream that doesn't send its output anywhere, (but could).
-* It's here to find the CRC32 of a manifest, necessary for STORED only
-* mode in ZIP.
-*/
-final class CRC32OutputStream extends java.io.OutputStream {
-CRC32 crc;
-int n = 0;
-CRC32OutputStream(CRC32 crc) {
-this.crc = crc;
-}
-public void write(int r) throws IOException {
-crc.update(r);
-n++;
-}
-public void write(byte[] b) throws IOException {
-crc.update(b, 0, b.length);
-n += b.length;
-}
-public void write(byte[] b, int off, int len) throws IOException {
-crc.update(b, off, len);
-n += len - off;
-}
-}

changeset 3218	855a6257b729
parent 3056	0864d307b376
child 3288	db82a42da273