| /* | |
| * Copyright (c) 1996, 2025, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| package sun.tools.jar; | |
| import java.io.*; | |
| import java.lang.module.Configuration; | |
| import java.lang.module.FindException; | |
| import java.lang.module.InvalidModuleDescriptorException; | |
| import java.lang.module.ModuleDescriptor; | |
| import java.lang.module.ModuleDescriptor.Exports; | |
| import java.lang.module.ModuleDescriptor.Opens; | |
| import java.lang.module.ModuleDescriptor.Provides; | |
| import java.lang.module.ModuleDescriptor.Version; | |
| import java.lang.module.ModuleFinder; | |
| import java.lang.module.ModuleReader; | |
| import java.lang.module.ModuleReference; | |
| import java.lang.module.ResolvedModule; | |
| import java.net.URI; | |
| import java.nio.ByteBuffer; | |
| import java.nio.file.Files; | |
| import java.nio.file.Path; | |
| import java.nio.file.Paths; | |
| import java.nio.file.StandardCopyOption; | |
| import java.nio.file.attribute.FileTime; | |
| import java.text.MessageFormat; | |
| import java.time.LocalDateTime; | |
| import java.util.*; | |
| import java.util.function.Consumer; | |
| import java.util.jar.Attributes; | |
| import java.util.jar.JarFile; | |
| import java.util.jar.JarOutputStream; | |
| import java.util.jar.Manifest; | |
| import java.util.regex.Pattern; | |
| import java.util.stream.Collectors; | |
| import java.util.stream.Stream; | |
| import java.util.zip.CRC32; | |
| import java.util.zip.ZipEntry; | |
| import java.util.zip.ZipFile; | |
| import java.util.zip.ZipInputStream; | |
| import java.util.zip.ZipOutputStream; | |
| import jdk.internal.module.Checks; | |
| import jdk.internal.module.ModuleHashes; | |
| import jdk.internal.module.ModuleHashesBuilder; | |
| import jdk.internal.module.ModuleInfo; | |
| import jdk.internal.module.ModuleInfoExtender; | |
| import jdk.internal.module.ModuleResolution; | |
| import jdk.internal.module.ModuleTarget; | |
| import jdk.internal.opt.CommandLine; | |
| import static java.nio.file.StandardCopyOption.REPLACE_EXISTING; | |
| import static java.util.jar.JarFile.MANIFEST_NAME; | |
| import static java.util.stream.Collectors.joining; | |
| import static sun.tools.jar.JarIndex.INDEX_NAME; | |
| /** | |
| * 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. | |
| */ | |
| public class Main { | |
| String program; | |
| PrintWriter out, err; | |
| String fname, mname, ename; | |
| String zname = ""; | |
| String rootjar = null; | |
| private static final int BASE_VERSION = 0; | |
| private static class Entry { | |
| final String name; | |
| final File file; | |
| final boolean isDir; | |
| Entry(File file, String name, boolean isDir) { | |
| this.file = file; | |
| this.isDir = isDir; | |
| this.name = name; | |
| } | |
| @Override | |
| public boolean equals(Object o) { | |
| if (this == o) return true; | |
| if (!(o instanceof Entry)) return false; | |
| return this.file.equals(((Entry)o).file); | |
| } | |
| @Override | |
| public int hashCode() { | |
| return file.hashCode(); | |
| } | |
| } | |
| // An entryName(path)->Entry map generated during "expand", it helps to | |
| // decide whether or not an existing entry in a jar file needs to be | |
| // replaced, during the "update" operation. | |
| Map<String, Entry> entryMap = new HashMap<>(); | |
| // All entries need to be added/updated. | |
| Set<Entry> entries = new LinkedHashSet<>(); | |
| // module-info.class entries need to be added/updated. | |
| Map<String, ModuleInfoEntry> moduleInfos = new HashMap<>(); | |
| // A paths Set for each version, where each Set contains directories | |
| // specified by the "-C" operation. | |
| Map<Integer,Set<String>> pathsMap = new HashMap<>(); | |
| // There's also a files array per version | |
| // base version is the first entry and then follow with the version given | |
| // from the --release option in the command-line order. | |
| // The value of each entry is the files given in the command-line order. | |
| Map<Integer,String[]> filesMap = new LinkedHashMap<>(); | |
| // Do we think this is a multi-release jar? Set to true | |
| // if --release option found followed by at least file | |
| boolean isMultiRelease; | |
| // The last parsed --release value, if any. Used in conjunction with | |
| // "-d,--describe-module" to select the operative module descriptor. | |
| int releaseValue = -1; | |
| /* | |
| * cflag: create | |
| * uflag: update | |
| * xflag: xtract | |
| * tflag: table | |
| * vflag: verbose | |
| * flag0: no zip compression (store only) | |
| * Mflag: DO NOT generate a manifest file (just ZIP) | |
| * iflag: generate jar index | |
| * pflag: preserve/don't strip leading slash and .. component from file name | |
| * dflag: print module descriptor | |
| * kflag: keep existing file | |
| */ | |
| boolean cflag, uflag, xflag, tflag, vflag, flag0, Mflag, iflag, pflag, dflag, kflag, validate; | |
| boolean suppressDeprecateMsg = false; | |
| // destination directory for extraction | |
| String xdestDir = null; | |
| /* To support additional GNU Style informational options */ | |
| Consumer<PrintWriter> info; | |
| /* Modular jar related options */ | |
| Version moduleVersion; | |
| Pattern modulesToHash; | |
| ModuleResolution moduleResolution = ModuleResolution.empty(); | |
| ModuleFinder moduleFinder = ModuleFinder.of(); | |
| static final String MODULE_INFO = "module-info.class"; | |
| static final String MANIFEST_DIR = "META-INF/"; | |
| static final String VERSIONS_DIR = MANIFEST_DIR + "versions/"; | |
| static final String VERSION = "1.0"; | |
| static final int VERSIONS_DIR_LENGTH = VERSIONS_DIR.length(); | |
| private static ResourceBundle rsrc; | |
| /* Date option for entry timestamps resolved to UTC Local time */ | |
| LocalDateTime date; | |
| /** | |
| * If true, maintain compatibility with JDK releases prior to 6.0 by | |
| * timestamping extracted files with the time at which they are extracted. | |
| * Default is to use the time given in the archive. | |
| */ | |
| private static final boolean useExtractionTime = | |
| Boolean.getBoolean("sun.tools.jar.useExtractionTime"); | |
| /** | |
| * Initialize ResourceBundle | |
| */ | |
| static { | |
| try { | |
| rsrc = ResourceBundle.getBundle("sun.tools.jar.resources.jar"); | |
| } catch (MissingResourceException e) { | |
| throw new Error("Fatal: Resource for jar is missing"); | |
| } | |
| } | |
| static String getMsg(String key) { | |
| try { | |
| return (rsrc.getString(key)); | |
| } catch (MissingResourceException e) { | |
| throw new Error("Error in message file", e); | |
| } | |
| } | |
| static String formatMsg(String key, String... args) { | |
| String msg = getMsg(key); | |
| return MessageFormat.format(msg, (Object[]) args); | |
| } | |
| public Main(PrintStream out, PrintStream err, String program) { | |
| this.out = new PrintWriter(out, true); | |
| this.err = new PrintWriter(err, true); | |
| this.program = program; | |
| } | |
| public Main(PrintWriter out, PrintWriter err, String program) { | |
| 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)) { | |
| return false; | |
| } | |
| File tmpFile = null; | |
| try { | |
| if (cflag || uflag) { | |
| if (fname != null) { | |
| // The name of the zip file as it would appear as its own | |
| // zip file entry. We use this to make sure that we don't | |
| // add the zip file to itself. | |
| zname = fname.replace(File.separatorChar, '/'); | |
| if (zname.startsWith("./")) { | |
| zname = zname.substring(2); | |
| } | |
| } | |
| } | |
| if (cflag) { | |
| Manifest manifest = null; | |
| if (!Mflag) { | |
| if (mname != null) { | |
| try (InputStream in = new FileInputStream(mname)) { | |
| manifest = new Manifest(new BufferedInputStream(in)); | |
| } | |
| } else { | |
| manifest = new Manifest(); | |
| } | |
| addVersion(manifest); | |
| addCreatedBy(manifest); | |
| if (isAmbiguousMainClass(manifest)) { | |
| return false; | |
| } | |
| if (ename != null) { | |
| addMainClass(manifest, ename); | |
| } | |
| if (isMultiRelease) { | |
| addMultiRelease(manifest); | |
| } | |
| } | |
| expand(); | |
| if (!ok) { | |
| return false; | |
| } | |
| if (!moduleInfos.isEmpty()) { | |
| // All actual file entries (excl manifest and module-info.class) | |
| Set<String> jentries = new HashSet<>(); | |
| // all packages if it's a class or resource | |
| Set<String> packages = new HashSet<>(); | |
| entries.stream() | |
| .filter(e -> !e.isDir) | |
| .forEach( e -> { | |
| addPackageIfNamed(packages, e.name); | |
| jentries.add(e.name); | |
| }); | |
| addExtendedModuleAttributes(moduleInfos, packages); | |
| // Basic consistency checks for modular jars. | |
| if (!checkModuleInfo(moduleInfos.get(MODULE_INFO), jentries)) | |
| return false; | |
| } else if (moduleVersion != null || modulesToHash != null) { | |
| error(getMsg("error.module.options.without.info")); | |
| return false; | |
| } | |
| if (vflag && fname == null) { | |
| // Disable verbose output so that it does not appear | |
| // on stdout along with file data | |
| // error("Warning: -v option ignored"); | |
| vflag = false; | |
| } | |
| String tmpFilePrefix = (fname == null) | |
| ? "tmpjar" | |
| : fname.substring(fname.indexOf(File.separatorChar) + 1); | |
| if (tmpFilePrefix.length() < 3) { | |
| tmpFilePrefix = "tmpjar" + tmpFilePrefix; | |
| } | |
| tmpFile = createTemporaryFile(tmpFilePrefix, ".jar"); | |
| try (OutputStream out = new FileOutputStream(tmpFile)) { | |
| create(new BufferedOutputStream(out, 4096), manifest); | |
| } | |
| validateAndClose(tmpFile); | |
| } else if (uflag) { | |
| File inputFile = null; | |
| if (fname != null) { | |
| inputFile = new File(fname); | |
| tmpFile = createTempFileInSameDirectoryAs(inputFile); | |
| } else { | |
| vflag = false; | |
| tmpFile = createTemporaryFile("tmpjar", ".jar"); | |
| } | |
| expand(); | |
| if (!ok) { | |
| return false; | |
| } | |
| try (FileInputStream in = (fname != null) ? new FileInputStream(inputFile) | |
| : new FileInputStream(FileDescriptor.in); | |
| FileOutputStream out = new FileOutputStream(tmpFile); | |
| InputStream manifest = (!Mflag && (mname != null)) ? | |
| (new FileInputStream(mname)) : null; | |
| ) { | |
| boolean updateOk = update(in, new BufferedOutputStream(out), | |
| manifest, moduleInfos, null); | |
| if (ok) { | |
| ok = updateOk; | |
| } | |
| } | |
| validateAndClose(tmpFile); | |
| } else if (tflag) { | |
| replaceFSC(filesMap); | |
| // For the "list table contents" action, access using the | |
| // ZipFile class is always most efficient since only a | |
| // "one-finger" scan through the central directory is required. | |
| String[] files = filesMapToFiles(filesMap); | |
| if (fname != null) { | |
| list(fname, files); | |
| } else { | |
| try (InputStream in = new FileInputStream(FileDescriptor.in); | |
| BufferedInputStream bis = new BufferedInputStream(in)) { | |
| list(bis, files); | |
| } | |
| } | |
| } else if (xflag) { | |
| if (xdestDir != null) { | |
| final Path destPath = Paths.get(xdestDir); | |
| try { | |
| Files.createDirectories(destPath); | |
| } catch (IOException ioe) { | |
| throw new IOException(formatMsg("error.create.dir", | |
| destPath.toString()), ioe); | |
| } | |
| } | |
| replaceFSC(filesMap); | |
| // For the extract action, when extracting all the entries, | |
| // access using the ZipInputStream class is most efficient, | |
| // since only a single sequential scan through the zip file is | |
| // required. When using the ZipFile class, a "two-finger" scan | |
| // is required, but this is likely to be more efficient when a | |
| // partial extract is requested. In case the zip file has | |
| // "leading garbage", we fall back from the ZipInputStream | |
| // implementation to the ZipFile implementation, since only the | |
| // latter can handle it. | |
| String[] files = filesMapToFiles(filesMap); | |
| if (fname != null) { | |
| extract(fname, files); | |
| } else { | |
| try (InputStream in = new FileInputStream(FileDescriptor.in); | |
| BufferedInputStream bis = new BufferedInputStream(in)) { | |
| extract(bis, files); | |
| } | |
| } | |
| } else if (iflag) { | |
| if (!suppressDeprecateMsg) { | |
| warn(getMsg("warn.index.is.ignored")); | |
| warn(formatMsg("warn.flag.is.deprecated", "--generate-index/-i")); | |
| } | |
| String[] files = filesMap.get(BASE_VERSION); // base entries only, can be null | |
| genIndex(rootjar, files); | |
| } else if (dflag) { | |
| boolean found; | |
| if (fname != null) { | |
| try (ZipFile zf = new ZipFile(fname)) { | |
| found = describeModule(zf); | |
| } | |
| } else { | |
| try (FileInputStream fin = new FileInputStream(FileDescriptor.in)) { | |
| found = describeModuleFromStream(fin); | |
| } | |
| } | |
| if (!found) | |
| error(getMsg("error.module.descriptor.not.found")); | |
| } else if (validate) { | |
| File file; | |
| if (fname != null) { | |
| file = new File(fname); | |
| } else { | |
| tmpFile = createTemporaryFile("tmpJar", ".jar"); | |
| file = tmpFile; | |
| try (InputStream in = new FileInputStream(FileDescriptor.in); | |
| OutputStream os = Files.newOutputStream(file.toPath())) { | |
| in.transferTo(os); | |
| } | |
| } | |
| ok = validateJar(file); | |
| } | |
| } catch (IOException e) { | |
| fatalError(e); | |
| ok = false; | |
| } catch (Error ee) { | |
| ee.printStackTrace(err); | |
| ok = false; | |
| } catch (Throwable t) { | |
| t.printStackTrace(err); | |
| ok = false; | |
| } finally { | |
| if (tmpFile != null && tmpFile.exists()) | |
| tmpFile.delete(); | |
| } | |
| out.flush(); | |
| err.flush(); | |
| return ok; | |
| } | |
| private boolean validateJar(File file) throws IOException { | |
| try { | |
| return Validator.validate(this, file); | |
| } catch (IOException e) { | |
| error(formatMsg("error.validator.jarfile.exception", fname, e.getMessage())); | |
| return true; | |
| } | |
| } | |
| private void validateAndClose(File tmpfile) throws IOException { | |
| if (ok && isMultiRelease) { | |
| ok = validateJar(tmpfile); | |
| if (!ok) { | |
| error(formatMsg("error.validator.jarfile.invalid", fname)); | |
| } | |
| } | |
| Path path = tmpfile.toPath(); | |
| try { | |
| if (ok) { | |
| if (fname != null) { | |
| Path target = Paths.get(fname); | |
| Path parent = target.getParent(); | |
| if (parent != null) { | |
| Files.createDirectories(parent); | |
| } | |
| Files.move(path, target, StandardCopyOption.REPLACE_EXISTING); | |
| } else { | |
| Files.copy(path, new FileOutputStream(FileDescriptor.out)); | |
| } | |
| } | |
| } finally { | |
| Files.deleteIfExists(path); | |
| } | |
| } | |
| private String[] filesMapToFiles(Map<Integer,String[]> filesMap) { | |
| if (filesMap.isEmpty()) return null; | |
| return filesMap.entrySet() | |
| .stream() | |
| .flatMap(this::filesToEntryNames) | |
| .toArray(String[]::new); | |
| } | |
| Stream<String> filesToEntryNames(Map.Entry<Integer,String[]> fileEntries) { | |
| int version = fileEntries.getKey(); | |
| Set<String> cpaths = pathsMap.get(version); | |
| return Stream.of(fileEntries.getValue()) | |
| .map(f -> toVersionedName(toEntryName(f, cpaths, false), version)); | |
| } | |
| /** | |
| * Parses command line arguments. | |
| */ | |
| boolean parseArgs(String[] args) { | |
| /* Preprocess and expand @file arguments */ | |
| try { | |
| args = CommandLine.parse(args); | |
| } catch (FileNotFoundException e) { | |
| fatalError(formatMsg("error.cant.open", e.getMessage())); | |
| return false; | |
| } catch (IOException e) { | |
| fatalError(e); | |
| return false; | |
| } | |
| /* parse flags */ | |
| int count = 1; | |
| try { | |
| String flags = args[0]; | |
| // Note: flags.length == 2 can be treated as the short version of | |
| // the GNU option since the there cannot be any other options, | |
| // excluding -C, as per the old way. | |
| if (flags.startsWith("--") || | |
| (flags.startsWith("-") && flags.length() == 2)) { | |
| try { | |
| count = GNUStyleOptions.parseOptions(this, args); | |
| } catch (GNUStyleOptions.BadArgs x) { | |
| if (info == null) { | |
| if (x.showUsage) { | |
| usageError(x.getMessage()); | |
| } else { | |
| error(x.getMessage()); | |
| } | |
| return false; | |
| } | |
| } | |
| if (info != null) { | |
| info.accept(out); | |
| return true; | |
| } | |
| } else { | |
| // Legacy/compatibility options | |
| if (flags.startsWith("-")) { | |
| flags = flags.substring(1); | |
| } | |
| for (int i = 0; i < flags.length(); i++) { | |
| switch (flags.charAt(i)) { | |
| case 'c': | |
| if (xflag || tflag || uflag || iflag) { | |
| usageError(getMsg("error.multiple.main.operations")); | |
| return false; | |
| } | |
| cflag = true; | |
| break; | |
| case 'u': | |
| if (cflag || xflag || tflag || iflag) { | |
| usageError(getMsg("error.multiple.main.operations")); | |
| return false; | |
| } | |
| uflag = true; | |
| break; | |
| case 'x': | |
| if (cflag || uflag || tflag || iflag) { | |
| usageError(getMsg("error.multiple.main.operations")); | |
| return false; | |
| } | |
| xflag = true; | |
| break; | |
| case 't': | |
| if (cflag || uflag || xflag || iflag) { | |
| usageError(getMsg("error.multiple.main.operations")); | |
| return false; | |
| } | |
| tflag = true; | |
| break; | |
| case 'M': | |
| Mflag = true; | |
| break; | |
| case 'v': | |
| vflag = true; | |
| break; | |
| case 'f': | |
| fname = args[count++]; | |
| break; | |
| case 'm': | |
| mname = args[count++]; | |
| break; | |
| case '0': | |
| flag0 = true; | |
| break; | |
| case 'k': | |
| kflag = true; | |
| break; | |
| case 'i': | |
| if (cflag || uflag || xflag || tflag) { | |
| usageError(getMsg("error.multiple.main.operations")); | |
| return false; | |
| } | |
| // do not increase the counter, files will contain rootjar | |
| rootjar = args[count++]; | |
| iflag = true; | |
| break; | |
| case 'e': | |
| ename = args[count++]; | |
| break; | |
| case 'P': | |
| pflag = true; | |
| break; | |
| default: | |
| usageError(formatMsg("error.illegal.option", | |
| String.valueOf(flags.charAt(i)))); | |
| return false; | |
| } | |
| } | |
| } | |
| } catch (ArrayIndexOutOfBoundsException e) { | |
| usageError(getMsg("main.usage.summary")); | |
| return false; | |
| } | |
| if (!cflag && !tflag && !xflag && !uflag && !iflag && !dflag && !validate) { | |
| usageError(getMsg("error.bad.option")); | |
| return false; | |
| } | |
| if (kflag && !xflag) { | |
| warn(formatMsg("warn.option.is.ignored", "--keep-old-files/-k/k")); | |
| } | |
| /* parse file arguments */ | |
| int n = args.length - count; | |
| if (n > 0) { | |
| int version = BASE_VERSION; | |
| int k = 0; | |
| String[] nameBuf = new String[n]; | |
| pathsMap.put(version, new HashSet<>()); | |
| try { | |
| for (int i = count; i < args.length; i++) { | |
| if (args[i].equals("-C")) { | |
| if (dflag) { | |
| // "--describe-module/-d" does not require file argument(s), | |
| // but does accept --release | |
| usageError(getMsg("error.bad.dflag")); | |
| return false; | |
| } | |
| /* change the directory */ | |
| String dir = args[++i]; | |
| if (xflag && xdestDir != null) { | |
| // extract option doesn't allow more than one destination directory | |
| usageError(getMsg("error.extract.multiple.dest.dir")); | |
| return false; | |
| } | |
| dir = (dir.endsWith(File.separator) ? | |
| dir : (dir + File.separator)); | |
| dir = dir.replace(File.separatorChar, '/'); | |
| boolean hasUNC = (File.separatorChar == '\\'&& dir.startsWith("//")); | |
| while (dir.indexOf("//") > -1) { | |
| dir = dir.replace("//", "/"); | |
| } | |
| if (hasUNC) { // Restore Windows UNC path. | |
| dir = "/" + dir; | |
| } | |
| if (xflag) { | |
| xdestDir = dir; | |
| } else { | |
| pathsMap.get(version).add(dir); | |
| nameBuf[k++] = dir + args[++i]; | |
| } | |
| } else if (args[i].startsWith("--release")) { | |
| int v = BASE_VERSION; | |
| try { | |
| v = Integer.valueOf(args[++i]); | |
| } catch (NumberFormatException x) { | |
| error(formatMsg("error.release.value.notnumber", args[i])); | |
| // this will fall into the next error, thus returning false | |
| } | |
| if (v < 9) { | |
| usageError(formatMsg("error.release.value.toosmall", String.valueOf(v))); | |
| return false; | |
| } | |
| // associate the files, if any, with the previous version number | |
| if (k > 0) { | |
| String[] files = new String[k]; | |
| System.arraycopy(nameBuf, 0, files, 0, k); | |
| filesMap.put(version, files); | |
| isMultiRelease = version > BASE_VERSION; | |
| } | |
| // reset the counters and start with the new version number | |
| k = 0; | |
| nameBuf = new String[n]; | |
| version = v; | |
| releaseValue = version; | |
| pathsMap.put(version, new HashSet<>()); | |
| } else { | |
| if (dflag) { | |
| // "--describe-module/-d" does not require file argument(s), | |
| // but does accept --release | |
| usageError(getMsg("error.bad.dflag")); | |
| return false; | |
| } | |
| nameBuf[k++] = args[i]; | |
| } | |
| } | |
| } catch (ArrayIndexOutOfBoundsException e) { | |
| usageError(getMsg("error.bad.file.arg")); | |
| return false; | |
| } | |
| // associate remaining files, if any, with a version | |
| if (k > 0) { | |
| String[] files = new String[k]; | |
| System.arraycopy(nameBuf, 0, files, 0, k); | |
| filesMap.put(version, files); | |
| isMultiRelease = version > BASE_VERSION; | |
| } | |
| } else if (cflag && (mname == null)) { | |
| usageError(getMsg("error.bad.cflag")); | |
| return false; | |
| } else if (uflag) { | |
| if ((mname != null) || (ename != null) || moduleVersion != null) { | |
| /* just want to update the manifest */ | |
| return true; | |
| } else { | |
| usageError(getMsg("error.bad.uflag")); | |
| return false; | |
| } | |
| } | |
| if (xflag && pflag && xdestDir != null) { | |
| usageError(getMsg("error.extract.pflag.not.allowed")); | |
| return false; | |
| } | |
| return true; | |
| } | |
| /* | |
| * Add the package of the given resource name if it's a .class | |
| * or a resource in a named package. | |
| */ | |
| void addPackageIfNamed(Set<String> packages, String name) { | |
| if (name.startsWith(VERSIONS_DIR)) { | |
| // trim the version dir prefix | |
| int i0 = VERSIONS_DIR_LENGTH; | |
| int i = name.indexOf('/', i0); | |
| if (i <= 0) { | |
| warn(formatMsg("warn.release.unexpected.versioned.entry", name)); | |
| return; | |
| } | |
| while (i0 < i) { | |
| char c = name.charAt(i0); | |
| if (c < '0' || c > '9') { | |
| warn(formatMsg("warn.release.unexpected.versioned.entry", name)); | |
| return; | |
| } | |
| i0++; | |
| } | |
| name = name.substring(i + 1, name.length()); | |
| } | |
| String pn = toPackageName(name); | |
| // add if this is a class or resource in a package | |
| if (Checks.isPackageName(pn)) { | |
| packages.add(pn); | |
| } | |
| } | |
| private String toEntryName(String name, Set<String> cpaths, boolean isDir) { | |
| name = name.replace(File.separatorChar, '/'); | |
| if (isDir) { | |
| name = name.endsWith("/") ? name : name + "/"; | |
| } | |
| String matchPath = ""; | |
| for (String path : cpaths) { | |
| if (name.startsWith(path) && path.length() > matchPath.length()) { | |
| matchPath = path; | |
| } | |
| } | |
| name = safeName(name.substring(matchPath.length())); | |
| // the old implementaton doesn't remove | |
| // "./" if it was led by "/" (?) | |
| if (name.startsWith("./")) { | |
| name = name.substring(2); | |
| } | |
| return name; | |
| } | |
| private static String toVersionedName(String name, int version) { | |
| return version > BASE_VERSION | |
| ? VERSIONS_DIR + version + "/" + name : name; | |
| } | |
| private static String toPackageName(String path) { | |
| int index = path.lastIndexOf('/'); | |
| if (index != -1) { | |
| return path.substring(0, index).replace('/', '.'); | |
| } else { | |
| return ""; | |
| } | |
| } | |
| private void expand() throws IOException { | |
| for (int version : filesMap.keySet()) { | |
| String[] files = filesMap.get(version); | |
| expand(null, files, pathsMap.get(version), version); | |
| } | |
| } | |
| /** | |
| * Expands list of files to process into full list of all files that | |
| * can be found by recursively descending directories. | |
| * | |
| * @param dir parent directory | |
| * @param files list of files to expand | |
| * @param cpaths set of directories specified by -C option for the files | |
| * @throws IOException if an I/O error occurs | |
| */ | |
| private void expand(File dir, String[] files, Set<String> cpaths, int version) | |
| throws IOException | |
| { | |
| if (files == null) { | |
| return; | |
| } | |
| for (int i = 0; i < files.length; i++) { | |
| File f; | |
| if (dir == null) { | |
| f = new File(files[i]); | |
| } else { | |
| f = new File(dir, files[i]); | |
| } | |
| boolean isDir = f.isDirectory(); | |
| String name = toEntryName(f.getPath(), cpaths, isDir); | |
| if (version != BASE_VERSION) { | |
| if (name.startsWith(VERSIONS_DIR)) { | |
| // the entry starts with VERSIONS_DIR and version != BASE_VERSION, | |
| // which means the "[dirs|files]" in --release v [dirs|files] | |
| // includes VERSIONS_DIR-ed entries --> warning and skip (?) | |
| error(formatMsg("error.release.unexpected.versioned.entry", | |
| name, String.valueOf(version))); | |
| ok = false; | |
| return; | |
| } | |
| name = toVersionedName(name, version); | |
| } | |
| if (f.isFile()) { | |
| Entry e = new Entry(f, name, false); | |
| if (isModuleInfoEntry(name)) { | |
| Path path = f.toPath(); | |
| byte[] fileContent = Files.readAllBytes(path); | |
| ModuleInfoEntry mie = new StreamedModuleInfoEntry(name, fileContent, Files.getLastModifiedTime(path)); | |
| moduleInfos.putIfAbsent(name, mie); | |
| if (uflag) { | |
| entryMap.put(name, e); | |
| } | |
| } else if (entries.add(e)) { | |
| if (uflag) { | |
| entryMap.put(name, e); | |
| } | |
| } | |
| } else if (isDir) { | |
| Entry e = new Entry(f, name, true); | |
| if (entries.add(e)) { | |
| // utilize entryMap for the duplicate dir check even in | |
| // case of cflag == true. | |
| // dir name conflict/duplicate could happen with -C option. | |
| // just remove the last "e" from the "entries" (zos will fail | |
| // with "duplicated" entries), but continue expanding the | |
| // sub tree | |
| if (entryMap.containsKey(name)) { | |
| entries.remove(e); | |
| } else { | |
| entryMap.put(name, e); | |
| } | |
| String[] dirFiles = f.list(); | |
| // Ensure files list is sorted for reproducible jar content | |
| if (dirFiles != null) { | |
| Arrays.sort(dirFiles); | |
| } | |
| expand(f, dirFiles, cpaths, version); | |
| } | |
| } else { | |
| error(formatMsg("error.nosuch.fileordir", String.valueOf(f))); | |
| ok = false; | |
| } | |
| } | |
| } | |
| /** | |
| * Creates a new JAR file. | |
| */ | |
| void create(OutputStream out, Manifest manifest) throws IOException | |
| { | |
| try (ZipOutputStream zos = new JarOutputStream(out)) { | |
| if (flag0) { | |
| zos.setMethod(ZipOutputStream.STORED); | |
| } | |
| // TODO: check module-info attributes against manifest ?? | |
| if (manifest != null) { | |
| if (vflag) { | |
| output(getMsg("out.added.manifest")); | |
| } | |
| ZipEntry e = new ZipEntry(MANIFEST_DIR); | |
| setZipEntryTime(e); | |
| e.setMethod(ZipEntry.STORED); | |
| e.setSize(0); | |
| e.setCrc(0); | |
| zos.putNextEntry(e); | |
| e = new ZipEntry(MANIFEST_NAME); | |
| setZipEntryTime(e); | |
| if (flag0) { | |
| crc32Manifest(e, manifest); | |
| } | |
| zos.putNextEntry(e); | |
| manifest.write(zos); | |
| zos.closeEntry(); | |
| } | |
| updateModuleInfo(moduleInfos, zos); | |
| for (Entry entry : entries) { | |
| addFile(zos, entry); | |
| } | |
| } | |
| } | |
| private char toUpperCaseASCII(char c) { | |
| 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, | |
| Map<String, ModuleInfoEntry> moduleInfos, | |
| JarIndex jarIndex) throws IOException | |
| { | |
| boolean updateOk = true; | |
| try (ZipInputStream zis = new ZipInputStream(in); | |
| ZipOutputStream zos = new JarOutputStream(out)) { | |
| if (jarIndex != null) { | |
| addIndex(jarIndex, zos); | |
| } | |
| ZipEntry e = null; | |
| boolean foundManifest = false; | |
| // All actual entries added/updated/existing, in the jar file (excl manifest | |
| // and module-info.class ). | |
| Set<String> jentries = new HashSet<>(); | |
| // put the old entries first, replace if necessary | |
| while ((e = zis.getNextEntry()) != null) { | |
| String name = e.getName(); | |
| boolean isManifestEntry = equalsIgnoreCase(name, MANIFEST_NAME); | |
| boolean isModuleInfoEntry = isModuleInfoEntry(name); | |
| if ((jarIndex != null && equalsIgnoreCase(name, INDEX_NAME)) | |
| || (Mflag && isManifestEntry)) { | |
| continue; | |
| } else if (isManifestEntry && ((newManifest != null) || | |
| (ename != null) || isMultiRelease)) { | |
| 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. | |
| try (FileInputStream fis = new FileInputStream(mname)) { | |
| if (isAmbiguousMainClass(new Manifest(fis))) { | |
| return false; | |
| } | |
| } | |
| } | |
| // Update the manifest. | |
| Manifest old = new Manifest(zis); | |
| if (newManifest != null) { | |
| old.read(newManifest); | |
| } | |
| if (!updateManifest(old, zos)) { | |
| return false; | |
| } | |
| } else if (moduleInfos != null && isModuleInfoEntry) { | |
| moduleInfos.putIfAbsent(name, new StreamedModuleInfoEntry(name, zis.readAllBytes(), e.getLastModifiedTime())); | |
| } else { | |
| boolean isDir = e.isDirectory(); | |
| if (!entryMap.containsKey(name)) { // copy the old stuff | |
| // do our own compression | |
| ZipEntry e2 = new ZipEntry(name); | |
| e2.setMethod(e.getMethod()); | |
| setZipEntryTime(e2, e.getTime()); | |
| e2.setComment(e.getComment()); | |
| e2.setExtra(e.getExtra()); | |
| if (e.getMethod() == ZipEntry.STORED) { | |
| e2.setSize(e.getSize()); | |
| e2.setCrc(e.getCrc()); | |
| } | |
| zos.putNextEntry(e2); | |
| copy(zis, zos); | |
| } else { // replace with the new files | |
| Entry ent = entryMap.get(name); | |
| addFile(zos, ent); | |
| entryMap.remove(name); | |
| entries.remove(ent); | |
| isDir = ent.isDir; | |
| } | |
| if (!isDir) { | |
| jentries.add(name); | |
| } | |
| } | |
| } | |
| // add the remaining new files | |
| for (Entry entry : entries) { | |
| addFile(zos, entry); | |
| if (!entry.isDir) { | |
| jentries.add(entry.name); | |
| } | |
| } | |
| if (!foundManifest) { | |
| if (newManifest != null) { | |
| Manifest m = new Manifest(newManifest); | |
| updateOk = !isAmbiguousMainClass(m); | |
| if (updateOk) { | |
| if (!updateManifest(m, zos)) { | |
| updateOk = false; | |
| } | |
| } | |
| } else if (ename != null) { | |
| if (!updateManifest(new Manifest(), zos)) { | |
| updateOk = false; | |
| } | |
| } | |
| } | |
| if (updateOk) { | |
| if (moduleInfos != null && !moduleInfos.isEmpty()) { | |
| Set<String> pkgs = new HashSet<>(); | |
| jentries.forEach(je -> addPackageIfNamed(pkgs, je)); | |
| addExtendedModuleAttributes(moduleInfos, pkgs); | |
| updateOk = checkModuleInfo(moduleInfos.get(MODULE_INFO), jentries); | |
| updateModuleInfo(moduleInfos, zos); | |
| // TODO: check manifest main classes, etc | |
| } else if (moduleVersion != null || modulesToHash != null) { | |
| error(getMsg("error.module.options.without.info")); | |
| updateOk = false; | |
| } | |
| } | |
| } | |
| return updateOk; | |
| } | |
| private void addIndex(JarIndex index, ZipOutputStream zos) | |
| throws IOException | |
| { | |
| ZipEntry e = new ZipEntry(INDEX_NAME); | |
| setZipEntryTime(e); | |
| if (flag0) { | |
| CRC32OutputStream os = new CRC32OutputStream(); | |
| index.write(os); | |
| os.updateEntry(e); | |
| } | |
| zos.putNextEntry(e); | |
| index.write(zos); | |
| zos.closeEntry(); | |
| } | |
| private void updateModuleInfo(Map<String, ModuleInfoEntry> moduleInfos, ZipOutputStream zos) | |
| throws IOException | |
| { | |
| String fmt = uflag ? "out.update.module-info": "out.added.module-info"; | |
| for (Map.Entry<String, ModuleInfoEntry> mi : moduleInfos.entrySet()) { | |
| String name = mi.getKey(); | |
| ModuleInfoEntry mie = mi.getValue(); | |
| byte[] bytes = mie.readAllBytes(); | |
| ZipEntry e = new ZipEntry(name); | |
| FileTime lastModified = mie.getLastModifiedTime(); | |
| if (lastModified != null) { | |
| setZipEntryTime(e, lastModified.toMillis()); | |
| } else { | |
| setZipEntryTime(e); | |
| } | |
| if (flag0) { | |
| crc32ModuleInfo(e, bytes); | |
| } | |
| zos.putNextEntry(e); | |
| zos.write(bytes); | |
| zos.closeEntry(); | |
| if (vflag) { | |
| output(formatMsg(fmt, name)); | |
| } | |
| } | |
| } | |
| private boolean updateManifest(Manifest m, ZipOutputStream zos) | |
| throws IOException | |
| { | |
| addVersion(m); | |
| addCreatedBy(m); | |
| if (ename != null) { | |
| addMainClass(m, ename); | |
| } | |
| if (isMultiRelease) { | |
| addMultiRelease(m); | |
| } | |
| ZipEntry e = new ZipEntry(MANIFEST_NAME); | |
| setZipEntryTime(e); | |
| if (flag0) { | |
| crc32Manifest(e, m); | |
| } | |
| zos.putNextEntry(e); | |
| m.write(zos); | |
| if (vflag) { | |
| output(getMsg("out.update.manifest")); | |
| } | |
| return true; | |
| } | |
| private static final boolean isWinDriveLetter(char c) { | |
| return ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')); | |
| } | |
| private String safeName(String name) { | |
| if (!pflag) { | |
| int len = name.length(); | |
| int i = name.lastIndexOf("../"); | |
| if (i == -1) { | |
| i = 0; | |
| } else { | |
| i += 3; // strip any dot-dot components | |
| } | |
| if (File.separatorChar == '\\') { | |
| // the spec requests no drive letter. skip if | |
| // the entry name has one. | |
| while (i < len) { | |
| int off = i; | |
| if (i + 1 < len && | |
| name.charAt(i + 1) == ':' && | |
| isWinDriveLetter(name.charAt(i))) { | |
| i += 2; | |
| } | |
| while (i < len && name.charAt(i) == '/') { | |
| i++; | |
| } | |
| if (i == off) { | |
| break; | |
| } | |
| } | |
| } else { | |
| while (i < len && name.charAt(i) == '/') { | |
| i++; | |
| } | |
| } | |
| if (i != 0) { | |
| name = name.substring(i); | |
| } | |
| } | |
| return name; | |
| } | |
| private void addVersion(Manifest m) { | |
| Attributes global = m.getMainAttributes(); | |
| if (global.getValue(Attributes.Name.MANIFEST_VERSION) == null) { | |
| global.put(Attributes.Name.MANIFEST_VERSION, VERSION); | |
| } | |
| } | |
| private void addCreatedBy(Manifest m) { | |
| Attributes global = m.getMainAttributes(); | |
| if (global.getValue(new Attributes.Name("Created-By")) == null) { | |
| String javaVendor = System.getProperty("java.vendor"); | |
| String jdkVersion = System.getProperty("java.version"); | |
| global.put(new Attributes.Name("Created-By"), jdkVersion + " (" + | |
| javaVendor + ")"); | |
| } | |
| } | |
| private void addMainClass(Manifest m, String mainApp) { | |
| Attributes global = m.getMainAttributes(); | |
| // overrides any existing Main-Class attribute | |
| global.put(Attributes.Name.MAIN_CLASS, mainApp); | |
| } | |
| private void addMultiRelease(Manifest m) { | |
| Attributes global = m.getMainAttributes(); | |
| global.put(Attributes.Name.MULTI_RELEASE, "true"); | |
| } | |
| private boolean isAmbiguousMainClass(Manifest m) { | |
| if (ename != null) { | |
| Attributes global = m.getMainAttributes(); | |
| if ((global.get(Attributes.Name.MAIN_CLASS) != null)) { | |
| usageError(getMsg("error.bad.eflag")); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * Adds a new file entry to the ZIP output stream. | |
| */ | |
| void addFile(ZipOutputStream zos, Entry entry) throws IOException { | |
| File file = entry.file; | |
| String name = entry.name; | |
| boolean isDir = entry.isDir; | |
| if (name.isEmpty() || name.equals(".") || name.equals(zname)) { | |
| return; | |
| } else if ((name.equals(MANIFEST_DIR) || name.equals(MANIFEST_NAME)) | |
| && !Mflag) { | |
| if (vflag) { | |
| output(formatMsg("out.ignore.entry", name)); | |
| } | |
| return; | |
| } else if (name.equals(MODULE_INFO)) { | |
| throw new Error("Unexpected module info: " + name); | |
| } | |
| long size = isDir ? 0 : file.length(); | |
| if (vflag) { | |
| out.print(formatMsg("out.adding", name)); | |
| } | |
| ZipEntry e = new ZipEntry(name); | |
| setZipEntryTime(e, file.lastModified()); | |
| if (size == 0) { | |
| e.setMethod(ZipEntry.STORED); | |
| e.setSize(0); | |
| e.setCrc(0); | |
| } else if (flag0) { | |
| crc32File(e, file); | |
| } | |
| zos.putNextEntry(e); | |
| if (!isDir) { | |
| copy(file, zos); | |
| } | |
| zos.closeEntry(); | |
| /* report how much compression occurred. */ | |
| if (vflag) { | |
| size = e.getSize(); | |
| long csize = e.getCompressedSize(); | |
| out.print(formatMsg("out.size", String.valueOf(size), String.valueOf(csize))); | |
| if (e.getMethod() == ZipEntry.DEFLATED) { | |
| long ratio = 0; | |
| if (size != 0) { | |
| ratio = ((size - csize) * 100) / size; | |
| } | |
| output(formatMsg("out.deflated", String.valueOf(ratio))); | |
| } else { | |
| output(getMsg("out.stored")); | |
| } | |
| } | |
| } | |
| /** | |
| * A buffer for use only by copy(InputStream, OutputStream). | |
| * 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 { | |
| try (InputStream in = new FileInputStream(from)) { | |
| copy(in, to); | |
| } | |
| } | |
| /** | |
| * 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 { | |
| try (OutputStream out = new FileOutputStream(to)) { | |
| copy(from, out); | |
| } | |
| } | |
| /** | |
| * Computes the crc32 of a module-info.class. This is necessary when the | |
| * ZipOutputStream is in STORED mode. | |
| */ | |
| private void crc32ModuleInfo(ZipEntry e, byte[] bytes) throws IOException { | |
| CRC32OutputStream os = new CRC32OutputStream(); | |
| ByteArrayInputStream in = new ByteArrayInputStream(bytes); | |
| in.transferTo(os); | |
| os.updateEntry(e); | |
| } | |
| /** | |
| * 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 { | |
| CRC32OutputStream os = new CRC32OutputStream(); | |
| m.write(os); | |
| os.updateEntry(e); | |
| } | |
| /** | |
| * Computes the crc32 of a File. This is necessary when the | |
| * ZipOutputStream is in STORED mode. | |
| */ | |
| private void crc32File(ZipEntry e, File f) throws IOException { | |
| CRC32OutputStream os = new CRC32OutputStream(); | |
| copy(f, os); | |
| if (os.n != f.length()) { | |
| throw new JarException(formatMsg( | |
| "error.incorrect.length", f.getPath())); | |
| } | |
| os.updateEntry(e); | |
| } | |
| void replaceFSC(Map<Integer, String []> filesMap) { | |
| filesMap.keySet().forEach(version -> { | |
| String[] files = filesMap.get(version); | |
| if (files != null) { | |
| for (int i = 0; i < files.length; i++) { | |
| files[i] = files[i].replace(File.separatorChar, '/'); | |
| } | |
| } | |
| }); | |
| } | |
| Set<ZipEntry> newDirSet() { | |
| return new HashSet<ZipEntry>() { | |
| public boolean add(ZipEntry e) { | |
| return ((e == null || useExtractionTime) ? false : super.add(e)); | |
| }}; | |
| } | |
| void updateLastModifiedTime(Set<ZipEntry> zes) throws IOException { | |
| for (ZipEntry ze : zes) { | |
| long lastModified = ze.getTime(); | |
| if (lastModified != -1) { | |
| String name = safeName(ze.getName().replace(File.separatorChar, '/')); | |
| if (name.length() != 0) { | |
| File f = new File(xdestDir, name.replace('/', File.separatorChar)); | |
| f.setLastModified(lastModified); | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Extracts specified entries from JAR file. | |
| */ | |
| void extract(InputStream in, String[] files) throws IOException { | |
| if (vflag) { | |
| output(formatMsg("out.extract.dir", Path.of(xdestDir == null ? "." : xdestDir).normalize() | |
| .toAbsolutePath().toString())); | |
| } | |
| ZipInputStream zis = new ZipInputStream(in); | |
| ZipEntry e; | |
| Set<ZipEntry> dirs = newDirSet(); | |
| while ((e = zis.getNextEntry()) != null) { | |
| if (files == null) { | |
| dirs.add(extractFile(zis, e)); | |
| } else { | |
| String name = e.getName(); | |
| for (String file : files) { | |
| if (name.startsWith(file)) { | |
| dirs.add(extractFile(zis, e)); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| // Update timestamps of directories specified in archive with their | |
| // timestamps as given in the archive. We do this after extraction, | |
| // 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 { | |
| if (vflag) { | |
| output(formatMsg("out.extract.dir", Path.of(xdestDir == null ? "." : xdestDir).normalize() | |
| .toAbsolutePath().toString())); | |
| } | |
| final Set<ZipEntry> dirs; | |
| try (ZipFile zf = new ZipFile(fname)) { | |
| dirs = newDirSet(); | |
| Enumeration<? extends ZipEntry> zes = zf.entries(); | |
| while (zes.hasMoreElements()) { | |
| ZipEntry e = zes.nextElement(); | |
| if (files == null) { | |
| dirs.add(extractFile(zf.getInputStream(e), e)); | |
| } else { | |
| String name = e.getName(); | |
| for (String file : files) { | |
| if (name.startsWith(file)) { | |
| dirs.add(extractFile(zf.getInputStream(e), e)); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| 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 { | |
| ZipEntry rc = null; | |
| // The spec requires all slashes MUST be forward '/', it is possible | |
| // an offending zip/jar entry may uses the backwards slash in its | |
| // name. It might cause problem on Windows platform as it skips | |
| // our "safe" check for leading slash and dot-dot. So replace them | |
| // with '/'. | |
| String name = safeName(e.getName().replace(File.separatorChar, '/')); | |
| if (name.length() == 0) { | |
| return rc; // leading '/' or 'dot-dot' only path | |
| } | |
| // the xdestDir points to the user specified location where the jar needs to | |
| // be extracted. By default xdestDir is null and represents current working | |
| // directory. | |
| // jar extraction using -P option is only allowed when the destination | |
| // directory isn't specified (and hence defaults to current working directory). | |
| // In such cases using this java.io.File constructor which accepts a null parent path | |
| // allows us to extract entries that may have leading slashes and hence may need | |
| // to be extracted outside of the current directory. | |
| File f = new File(xdestDir, name.replace('/', File.separatorChar)); | |
| if (e.isDirectory()) { | |
| if (f.exists()) { | |
| if (!f.isDirectory()) { | |
| throw new IOException(formatMsg("error.create.dir", | |
| f.getPath())); | |
| } | |
| } else { | |
| if (!f.mkdirs()) { | |
| throw new IOException(formatMsg("error.create.dir", | |
| f.getPath())); | |
| } else { | |
| rc = e; | |
| } | |
| } | |
| if (vflag) { | |
| output(formatMsg("out.create", name)); | |
| } | |
| } else { | |
| if (f.exists() && kflag) { | |
| if (vflag) { | |
| output(formatMsg("out.kept", name)); | |
| } | |
| return rc; | |
| } | |
| if (f.getParent() != null) { | |
| File d = new File(f.getParent()); | |
| if (!d.exists() && !d.mkdirs() || !d.isDirectory()) { | |
| throw new IOException(formatMsg( | |
| "error.create.dir", d.getPath())); | |
| } | |
| } | |
| try { | |
| copy(is, f); | |
| } finally { | |
| if (is instanceof ZipInputStream) | |
| ((ZipInputStream)is).closeEntry(); | |
| else | |
| is.close(); | |
| } | |
| if (vflag) { | |
| if (e.getMethod() == ZipEntry.DEFLATED) { | |
| output(formatMsg("out.inflated", name)); | |
| } else { | |
| output(formatMsg("out.extracted", name)); | |
| } | |
| } | |
| } | |
| if (!useExtractionTime) { | |
| long lastModified = e.getTime(); | |
| if (lastModified != -1) { | |
| f.setLastModified(lastModified); | |
| } | |
| } | |
| return rc; | |
| } | |
| /** | |
| * Lists contents of JAR file. | |
| */ | |
| void list(InputStream in, String[] files) throws IOException { | |
| ZipInputStream zis = new ZipInputStream(in); | |
| ZipEntry e; | |
| while ((e = zis.getNextEntry()) != null) { | |
| /* | |
| * In the case of a compressed (deflated) entry, the entry size | |
| * is stored immediately following the entry data and cannot be | |
| * determined until the entry is fully read. Therefore, we close | |
| * the entry first before printing out its attributes. | |
| */ | |
| zis.closeEntry(); | |
| printEntry(e, files); | |
| } | |
| } | |
| /** | |
| * Lists contents of JAR file, via ZipFile. | |
| */ | |
| void list(String fname, String[] files) throws IOException { | |
| try (ZipFile zf = new ZipFile(fname)) { | |
| Enumeration<? extends ZipEntry> zes = zf.entries(); | |
| while (zes.hasMoreElements()) { | |
| printEntry(zes.nextElement(), files); | |
| } | |
| } | |
| } | |
| /** | |
| * Outputs the class index table to the INDEX.LIST file of the | |
| * root jar file. | |
| */ | |
| void dumpIndex(String rootjar, JarIndex index) throws IOException { | |
| File jarFile = new File(rootjar); | |
| Path jarPath = jarFile.toPath(); | |
| Path tmpPath = createTempFileInSameDirectoryAs(jarFile).toPath(); | |
| try { | |
| if (update(Files.newInputStream(jarPath), | |
| Files.newOutputStream(tmpPath), | |
| null, null, index)) { | |
| try { | |
| Files.move(tmpPath, jarPath, REPLACE_EXISTING); | |
| } catch (IOException e) { | |
| throw new IOException(getMsg("error.write.file"), e); | |
| } | |
| } | |
| } finally { | |
| Files.deleteIfExists(tmpPath); | |
| } | |
| } | |
| private HashSet<String> jarPaths = new HashSet<String>(); | |
| /** | |
| * Generates the transitive closure of the Class-Path attribute for | |
| * the specified jar file. | |
| */ | |
| List<String> getJarPath(String jar) throws IOException { | |
| List<String> files = new ArrayList<String>(); | |
| files.add(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 | |
| // '/' as separators, so we need to change them to the | |
| // appropriate one before we open the jar file. | |
| try (JarFile jarFile = new JarFile(jar.replace('/', File.separatorChar))) { | |
| Manifest man = jarFile.getManifest(); | |
| if (man != null) { | |
| Attributes attr = man.getMainAttributes(); | |
| if (attr != null) { | |
| String value = attr.getValue(Attributes.Name.CLASS_PATH); | |
| if (value != null) { | |
| StringTokenizer st = new StringTokenizer(value); | |
| while (st.hasMoreTokens()) { | |
| String ajar = st.nextToken(); | |
| if (!ajar.endsWith("/")) { // it is a jar file | |
| ajar = path.concat(ajar); | |
| /* check on cyclic dependency */ | |
| if (! jarPaths.contains(ajar)) { | |
| files.addAll(getJarPath(ajar)); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return files; | |
| } | |
| /** | |
| * Generates class index file for the specified root jar file. | |
| */ | |
| void genIndex(String rootjar, String[] files) throws IOException { | |
| List<String> jars = getJarPath(rootjar); | |
| int njars = jars.size(); | |
| String[] jarfiles; | |
| if (njars == 1 && files != null) { | |
| // no class-path attribute defined in rootjar, will | |
| // use command line specified list of jars | |
| for (int i = 0; i < files.length; i++) { | |
| jars.addAll(getJarPath(files[i])); | |
| } | |
| njars = jars.size(); | |
| } | |
| 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); | |
| } else { | |
| String name = e.getName(); | |
| for (String file : files) { | |
| if (name.startsWith(file)) { | |
| printEntry(e); | |
| return; | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Prints entry information. | |
| */ | |
| void printEntry(ZipEntry e) throws IOException { | |
| if (vflag) { | |
| StringBuilder sb = new StringBuilder(); | |
| String s = Long.toString(e.getSize()); | |
| for (int i = 6 - s.length(); i > 0; --i) { | |
| sb.append(' '); | |
| } | |
| sb.append(s).append(' ').append(new Date(e.getTime()).toString()); | |
| sb.append(' ').append(e.getName()); | |
| output(sb.toString()); | |
| } else { | |
| output(e.getName()); | |
| } | |
| } | |
| /** | |
| * Prints usage message. | |
| */ | |
| void usageError(String s) { | |
| err.println(s); | |
| err.println(getMsg("main.usage.summary.try")); | |
| } | |
| /** | |
| * A fatal exception has been caught. No recovery possible | |
| */ | |
| void fatalError(Exception e) { | |
| e.printStackTrace(err); | |
| } | |
| /** | |
| * A fatal condition has been detected; message is "s". | |
| * No recovery possible | |
| */ | |
| void fatalError(String s) { | |
| error(program + ": " + s); | |
| } | |
| /** | |
| * Print an output message; like verbose output and the like | |
| */ | |
| protected void output(String s) { | |
| out.println(s); | |
| } | |
| /** | |
| * Print an error message; like something is broken | |
| */ | |
| void error(String s) { | |
| err.println(s); | |
| } | |
| /** | |
| * Print a warning message | |
| */ | |
| void warn(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()); | |
| } | |
| } | |
| /** | |
| * Attempt to create temporary file in the system-provided temporary folder, if failed attempts | |
| * to create it in the same folder as the file in parameter (if any) | |
| */ | |
| private File createTemporaryFile(String tmpbase, String suffix) { | |
| File tmpfile = null; | |
| try { | |
| tmpfile = File.createTempFile(tmpbase, suffix); | |
| } catch (IOException | SecurityException e) { | |
| // Unable to create file due to permission violation or security exception | |
| } | |
| if (tmpfile == null) { | |
| // We were unable to create temporary file, fall back to temporary file in the | |
| // same folder as the JAR file | |
| if (fname != null) { | |
| try { | |
| File tmpfolder = new File(fname).getAbsoluteFile().getParentFile(); | |
| tmpfile = File.createTempFile(tmpbase, ".tmp" + suffix, tmpfolder); | |
| } catch (IOException ioe) { | |
| // Last option failed - fall gracefully | |
| fatalError(ioe); | |
| } | |
| } else { | |
| // No options left - we can not compress to stdout without access to the temporary folder | |
| fatalError(new IOException(getMsg("error.create.tempfile"))); | |
| } | |
| } | |
| return tmpfile; | |
| } | |
| // Modular jar support | |
| /** | |
| * Associates a module descriptor's zip entry name along with its | |
| * bytes and an optional URI. | |
| */ | |
| interface ModuleInfoEntry { | |
| String name(); | |
| Optional<String> uriString(); | |
| InputStream bytes() throws IOException; | |
| /** | |
| * @return Returns the last modified time of the module-info.class. | |
| * Returns null if the last modified time is unknown or cannot be | |
| * determined. | |
| */ | |
| FileTime getLastModifiedTime(); | |
| default byte[] readAllBytes() throws IOException { | |
| try (InputStream is = bytes()) { | |
| return is.readAllBytes(); | |
| } | |
| } | |
| } | |
| static class ZipFileModuleInfoEntry implements ModuleInfoEntry { | |
| private final ZipFile zipFile; | |
| private final ZipEntry entry; | |
| ZipFileModuleInfoEntry(ZipFile zipFile, ZipEntry entry) { | |
| this.zipFile = zipFile; | |
| this.entry = entry; | |
| } | |
| @Override public String name() { return entry.getName(); } | |
| @Override public InputStream bytes() throws IOException { | |
| return zipFile.getInputStream(entry); | |
| } | |
| @Override | |
| public FileTime getLastModifiedTime() { | |
| return entry.getLastModifiedTime(); | |
| } | |
| /** Returns an optional containing the effective URI. */ | |
| @Override public Optional<String> uriString() { | |
| String uri = (Paths.get(zipFile.getName())).toUri().toString(); | |
| uri = "jar:" + uri + "!/" + entry.getName(); | |
| return Optional.of(uri); | |
| } | |
| } | |
| static class StreamedModuleInfoEntry implements ModuleInfoEntry { | |
| private final String name; | |
| private final byte[] bytes; | |
| private final FileTime lastModifiedTime; | |
| StreamedModuleInfoEntry(String name, byte[] bytes, FileTime lastModifiedTime) { | |
| this.name = name; | |
| this.bytes = bytes; | |
| this.lastModifiedTime = lastModifiedTime; | |
| } | |
| @Override public String name() { return name; } | |
| @Override public InputStream bytes() throws IOException { | |
| return new ByteArrayInputStream(bytes); | |
| } | |
| @Override | |
| public byte[] readAllBytes() throws IOException { | |
| return bytes; | |
| } | |
| @Override | |
| public FileTime getLastModifiedTime() { | |
| return lastModifiedTime; | |
| } | |
| /** Returns an empty optional. */ | |
| @Override public Optional<String> uriString() { | |
| return Optional.empty(); // no URI can be derived | |
| } | |
| } | |
| /** Describes a module from a given zip file. */ | |
| private boolean describeModule(ZipFile zipFile) throws IOException { | |
| ZipFileModuleInfoEntry[] infos = zipFile.stream() | |
| .filter(e -> isModuleInfoEntry(e.getName())) | |
| .sorted(ENTRY_COMPARATOR) | |
| .map(e -> new ZipFileModuleInfoEntry(zipFile, e)) | |
| .toArray(ZipFileModuleInfoEntry[]::new); | |
| if (infos.length == 0) { | |
| // No module descriptor found, derive and describe the automatic module | |
| String fn = zipFile.getName(); | |
| ModuleFinder mf = ModuleFinder.of(Paths.get(fn)); | |
| try { | |
| Set<ModuleReference> mref = mf.findAll(); | |
| if (mref.isEmpty()) { | |
| output(formatMsg("error.unable.derive.automodule", fn)); | |
| return true; | |
| } | |
| ModuleDescriptor md = mref.iterator().next().descriptor(); | |
| output(getMsg("out.automodule") + "\n"); | |
| describeModule(md, null, null, ""); | |
| } catch (FindException e) { | |
| String msg = formatMsg("error.unable.derive.automodule", fn); | |
| Throwable t = e.getCause(); | |
| if (t != null) | |
| msg = msg + "\n" + t.getMessage(); | |
| output(msg); | |
| } | |
| } else { | |
| return describeModuleFromEntries(infos); | |
| } | |
| return true; | |
| } | |
| private boolean describeModuleFromStream(FileInputStream fis) | |
| throws IOException | |
| { | |
| List<ModuleInfoEntry> infos = new LinkedList<>(); | |
| try (BufferedInputStream bis = new BufferedInputStream(fis); | |
| ZipInputStream zis = new ZipInputStream(bis)) { | |
| ZipEntry e; | |
| while ((e = zis.getNextEntry()) != null) { | |
| String ename = e.getName(); | |
| if (isModuleInfoEntry(ename)) { | |
| infos.add(new StreamedModuleInfoEntry(ename, zis.readAllBytes(), e.getLastModifiedTime())); | |
| } | |
| } | |
| } | |
| if (infos.size() == 0) | |
| return false; | |
| ModuleInfoEntry[] sorted = infos.stream() | |
| .sorted(Comparator.comparing(ModuleInfoEntry::name, ENTRYNAME_COMPARATOR)) | |
| .toArray(ModuleInfoEntry[]::new); | |
| return describeModuleFromEntries(sorted); | |
| } | |
| private boolean lessThanEqualReleaseValue(ModuleInfoEntry entry) { | |
| return intVersionFromEntry(entry) <= releaseValue ? true : false; | |
| } | |
| private static String versionFromEntryName(String name) { | |
| String s = name.substring(VERSIONS_DIR_LENGTH); | |
| return s.substring(0, s.indexOf("/")); | |
| } | |
| private static int intVersionFromEntry(ModuleInfoEntry entry) { | |
| String name = entry.name(); | |
| if (!name.startsWith(VERSIONS_DIR)) | |
| return BASE_VERSION; | |
| String s = name.substring(VERSIONS_DIR_LENGTH); | |
| s = s.substring(0, s.indexOf('/')); | |
| return Integer.valueOf(s); | |
| } | |
| /** | |
| * Describes a single module descriptor, determined by the specified | |
| * --release, if any, from the given ordered entries. | |
| * The given infos must be ordered as per ENTRY_COMPARATOR. | |
| */ | |
| private boolean describeModuleFromEntries(ModuleInfoEntry[] infos) | |
| throws IOException | |
| { | |
| assert infos.length > 0; | |
| // Informative: output all non-root descriptors, if any | |
| String releases = Arrays.stream(infos) | |
| .filter(e -> !e.name().equals(MODULE_INFO)) | |
| .map(ModuleInfoEntry::name) | |
| .map(Main::versionFromEntryName) | |
| .collect(joining(" ")); | |
| if (!releases.isEmpty()) | |
| output("releases: " + releases + "\n"); | |
| // Describe the operative descriptor for the specified --release, if any | |
| if (releaseValue != -1) { | |
| ModuleInfoEntry entry = null; | |
| int i = 0; | |
| while (i < infos.length && lessThanEqualReleaseValue(infos[i])) { | |
| entry = infos[i]; | |
| i++; | |
| } | |
| if (entry == null) { | |
| output(formatMsg("error.no.operative.descriptor", | |
| String.valueOf(releaseValue))); | |
| return false; | |
| } | |
| String uriString = entry.uriString().orElse(""); | |
| try (InputStream is = entry.bytes()) { | |
| describeModule(is, uriString); | |
| } | |
| } else { | |
| // no specific --release specified, output the root, if any | |
| if (infos[0].name().equals(MODULE_INFO)) { | |
| String uriString = infos[0].uriString().orElse(""); | |
| try (InputStream is = infos[0].bytes()) { | |
| describeModule(is, uriString); | |
| } | |
| } else { | |
| // no root, output message to specify --release | |
| output(getMsg("error.no.root.descriptor")); | |
| } | |
| } | |
| return true; | |
| } | |
| static <T> String toLowerCaseString(Collection<T> set) { | |
| if (set.isEmpty()) { return ""; } | |
| return " " + set.stream().map(e -> e.toString().toLowerCase(Locale.ROOT)) | |
| .sorted().collect(joining(" ")); | |
| } | |
| static <T> String toString(Collection<T> set) { | |
| if (set.isEmpty()) { return ""; } | |
| return " " + set.stream().map(e -> e.toString()).sorted().collect(joining(" ")); | |
| } | |
| private void describeModule(InputStream entryInputStream, String uriString) | |
| throws IOException | |
| { | |
| ModuleInfo.Attributes attrs = ModuleInfo.read(entryInputStream, null); | |
| ModuleDescriptor md = attrs.descriptor(); | |
| ModuleTarget target = attrs.target(); | |
| ModuleHashes hashes = attrs.recordedHashes(); | |
| describeModule(md, target, hashes, uriString); | |
| } | |
| private void describeModule(ModuleDescriptor md, | |
| ModuleTarget target, | |
| ModuleHashes hashes, | |
| String uriString) | |
| throws IOException | |
| { | |
| StringBuilder sb = new StringBuilder(); | |
| sb.append(md.toNameAndVersion()); | |
| if (!uriString.isEmpty()) | |
| sb.append(" ").append(uriString); | |
| if (md.isOpen()) | |
| sb.append(" open"); | |
| if (md.isAutomatic()) | |
| sb.append(" automatic"); | |
| sb.append("\n"); | |
| // unqualified exports (sorted by package) | |
| md.exports().stream() | |
| .sorted(Comparator.comparing(Exports::source)) | |
| .filter(e -> !e.isQualified()) | |
| .forEach(e -> sb.append("exports ").append(e.source()) | |
| .append(toLowerCaseString(e.modifiers())) | |
| .append("\n")); | |
| // dependences | |
| md.requires().stream().sorted() | |
| .forEach(r -> sb.append("requires ").append(r.name()) | |
| .append(toLowerCaseString(r.modifiers())) | |
| .append("\n")); | |
| // service use and provides | |
| md.uses().stream().sorted() | |
| .forEach(s -> sb.append("uses ").append(s).append("\n")); | |
| md.provides().stream() | |
| .sorted(Comparator.comparing(Provides::service)) | |
| .forEach(p -> sb.append("provides ").append(p.service()) | |
| .append(" with") | |
| .append(toString(p.providers())) | |
| .append("\n")); | |
| // qualified exports | |
| md.exports().stream() | |
| .sorted(Comparator.comparing(Exports::source)) | |
| .filter(Exports::isQualified) | |
| .forEach(e -> sb.append("qualified exports ").append(e.source()) | |
| .append(" to").append(toLowerCaseString(e.targets())) | |
| .append("\n")); | |
| // open packages | |
| md.opens().stream() | |
| .sorted(Comparator.comparing(Opens::source)) | |
| .filter(o -> !o.isQualified()) | |
| .forEach(o -> sb.append("opens ").append(o.source()) | |
| .append(toLowerCaseString(o.modifiers())) | |
| .append("\n")); | |
| md.opens().stream() | |
| .sorted(Comparator.comparing(Opens::source)) | |
| .filter(Opens::isQualified) | |
| .forEach(o -> sb.append("qualified opens ").append(o.source()) | |
| .append(toLowerCaseString(o.modifiers())) | |
| .append(" to").append(toLowerCaseString(o.targets())) | |
| .append("\n")); | |
| // non-exported/non-open packages | |
| Set<String> concealed = new TreeSet<>(md.packages()); | |
| md.exports().stream().map(Exports::source).forEach(concealed::remove); | |
| md.opens().stream().map(Opens::source).forEach(concealed::remove); | |
| concealed.forEach(p -> sb.append("contains ").append(p).append("\n")); | |
| md.mainClass().ifPresent(v -> sb.append("main-class ").append(v).append("\n")); | |
| if (target != null) { | |
| String targetPlatform = target.targetPlatform(); | |
| if (!targetPlatform.isEmpty()) | |
| sb.append("platform ").append(targetPlatform).append("\n"); | |
| } | |
| if (hashes != null) { | |
| hashes.names().stream().sorted().forEach( | |
| mod -> sb.append("hashes ").append(mod).append(" ") | |
| .append(hashes.algorithm()).append(" ") | |
| .append(toHex(hashes.hashFor(mod))) | |
| .append("\n")); | |
| } | |
| output(sb.toString()); | |
| } | |
| private static String toHex(byte[] ba) { | |
| StringBuilder sb = new StringBuilder(ba.length << 1); | |
| for (byte b: ba) { | |
| sb.append(String.format("%02x", b & 0xff)); | |
| } | |
| return sb.toString(); | |
| } | |
| static String toBinaryName(String classname) { | |
| return (classname.replace('.', '/')) + ".class"; | |
| } | |
| private boolean checkModuleInfo(ModuleInfoEntry moduleInfoEntry, Set<String> entries) | |
| throws IOException | |
| { | |
| boolean ok = true; | |
| if (moduleInfoEntry != null) { // no root module-info.class if null | |
| try { | |
| // ModuleDescriptor.read() checks open/exported pkgs vs packages | |
| ModuleDescriptor md = ModuleDescriptor.read(moduleInfoEntry.bytes()); | |
| // A module must have the implementation class of the services it 'provides'. | |
| if (md.provides().stream().map(Provides::providers).flatMap(List::stream) | |
| .filter(p -> !entries.contains(toBinaryName(p))) | |
| .peek(p -> fatalError(formatMsg("error.missing.provider", p))) | |
| .count() != 0) { | |
| ok = false; | |
| } | |
| } catch (InvalidModuleDescriptorException x) { | |
| fatalError(x.getMessage()); | |
| ok = false; | |
| } | |
| } | |
| return ok; | |
| } | |
| /** | |
| * Adds extended modules attributes to the given module-info's. The given | |
| * Map values are updated in-place. | |
| */ | |
| private void addExtendedModuleAttributes(Map<String, ModuleInfoEntry> moduleInfos, | |
| Set<String> packages) | |
| throws IOException | |
| { | |
| for (Map.Entry<String, ModuleInfoEntry> e: moduleInfos.entrySet()) { | |
| ModuleInfoEntry mie = e.getValue(); | |
| byte[] bytes = mie.readAllBytes(); | |
| ModuleDescriptor md = ModuleDescriptor.read(ByteBuffer.wrap(bytes)); | |
| byte[] extended = extendedInfoBytes(md, bytes, packages); | |
| // replace the entry value with the extended bytes | |
| e.setValue(new StreamedModuleInfoEntry(mie.name(), extended, mie.getLastModifiedTime())); | |
| } | |
| } | |
| static boolean isModuleInfoEntry(String name) { | |
| // root or versioned module-info.class | |
| if (name.endsWith(MODULE_INFO)) { | |
| int end = name.length() - MODULE_INFO.length(); | |
| if (end == 0) | |
| return true; | |
| if (name.startsWith(VERSIONS_DIR)) { | |
| int off = VERSIONS_DIR_LENGTH; | |
| if (off == end) // meta-inf/versions/module-info.class | |
| return false; | |
| while (off < end - 1) { | |
| char c = name.charAt(off++); | |
| if (c < '0' || c > '9') | |
| return false; | |
| } | |
| return name.charAt(off) == '/'; | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * Returns a byte array containing the given module-info.class plus any | |
| * extended attributes. | |
| * | |
| * If --module-version, --main-class, or other options were provided | |
| * then the corresponding class file attributes are added to the | |
| * module-info here. | |
| */ | |
| private byte[] extendedInfoBytes(ModuleDescriptor md, | |
| byte[] miBytes, | |
| Set<String> packages) | |
| throws IOException | |
| { | |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); | |
| InputStream is = new ByteArrayInputStream(miBytes); | |
| ModuleInfoExtender extender = ModuleInfoExtender.newExtender(is); | |
| // Add (or replace) the Packages attribute | |
| extender.packages(packages); | |
| // --main-class | |
| if (ename != null) | |
| extender.mainClass(ename); | |
| // --module-version | |
| if (moduleVersion != null) | |
| extender.version(moduleVersion); | |
| // --hash-modules | |
| if (modulesToHash != null) { | |
| String mn = md.name(); | |
| Hasher hasher = new Hasher(md, fname); | |
| ModuleHashes moduleHashes = hasher.computeHashes(mn); | |
| if (moduleHashes != null) { | |
| extender.hashes(moduleHashes); | |
| } else { | |
| warn("warning: no module is recorded in hash in " + mn); | |
| } | |
| } | |
| if (moduleResolution.value() != 0) { | |
| extender.moduleResolution(moduleResolution); | |
| } | |
| extender.write(baos); | |
| return baos.toByteArray(); | |
| } | |
| /** | |
| * Compute and record hashes | |
| */ | |
| private class Hasher { | |
| final ModuleHashesBuilder hashesBuilder; | |
| final ModuleFinder finder; | |
| final Set<String> modules; | |
| Hasher(ModuleDescriptor descriptor, String fname) throws IOException { | |
| // Create a module finder that finds the modular JAR | |
| // being created/updated | |
| URI uri = Paths.get(fname).toUri(); | |
| ModuleReference mref = new ModuleReference(descriptor, uri) { | |
| @Override | |
| public ModuleReader open() { | |
| throw new UnsupportedOperationException("should not reach here"); | |
| } | |
| }; | |
| // Compose a module finder with the module path and | |
| // the modular JAR being created or updated | |
| this.finder = ModuleFinder.compose(moduleFinder, | |
| new ModuleFinder() { | |
| @Override | |
| public Optional<ModuleReference> find(String name) { | |
| if (descriptor.name().equals(name)) | |
| return Optional.of(mref); | |
| else | |
| return Optional.empty(); | |
| } | |
| @Override | |
| public Set<ModuleReference> findAll() { | |
| return Collections.singleton(mref); | |
| } | |
| }); | |
| // Determine the modules that matches the pattern {@code modulesToHash} | |
| Set<String> roots = finder.findAll().stream() | |
| .map(ref -> ref.descriptor().name()) | |
| .filter(mn -> modulesToHash.matcher(mn).find()) | |
| .collect(Collectors.toSet()); | |
| // use system module path unless it creates a modular JAR for | |
| // a module that is present in the system image e.g. upgradeable | |
| // module | |
| ModuleFinder system; | |
| String name = descriptor.name(); | |
| if (name != null && ModuleFinder.ofSystem().find(name).isPresent()) { | |
| system = ModuleFinder.of(); | |
| } else { | |
| system = ModuleFinder.ofSystem(); | |
| } | |
| // get a resolved module graph | |
| Configuration config = | |
| Configuration.empty().resolve(system, finder, roots); | |
| // filter modules resolved from the system module finder | |
| this.modules = config.modules().stream() | |
| .map(ResolvedModule::name) | |
| .filter(mn -> roots.contains(mn) && !system.find(mn).isPresent()) | |
| .collect(Collectors.toSet()); | |
| this.hashesBuilder = new ModuleHashesBuilder(config, modules); | |
| } | |
| /** | |
| * Compute hashes of the specified module. | |
| * | |
| * It records the hashing modules that depend upon the specified | |
| * module directly or indirectly. | |
| */ | |
| ModuleHashes computeHashes(String name) { | |
| if (hashesBuilder == null) | |
| return null; | |
| return hashesBuilder.computeHashes(Set.of(name)).get(name); | |
| } | |
| } | |
| // sort base entries before versioned entries, and sort entry classes with | |
| // nested classes so that the outter class appears before the associated | |
| // nested class | |
| static Comparator<String> ENTRYNAME_COMPARATOR = (s1, s2) -> { | |
| if (s1.equals(s2)) return 0; | |
| boolean b1 = s1.startsWith(VERSIONS_DIR); | |
| boolean b2 = s2.startsWith(VERSIONS_DIR); | |
| if (b1 && !b2) return 1; | |
| if (!b1 && b2) return -1; | |
| int n = 0; // starting char for String compare | |
| if (b1 && b2) { | |
| // normally strings would be sorted so "10" goes before "9", but | |
| // version number strings need to be sorted numerically | |
| n = VERSIONS_DIR.length(); // skip the common prefix | |
| int i1 = s1.indexOf('/', n); | |
| int i2 = s2.indexOf('/', n); | |
| if (i1 == -1) throw new Validator.InvalidJarException(s1); | |
| if (i2 == -1) throw new Validator.InvalidJarException(s2); | |
| // shorter version numbers go first | |
| if (i1 != i2) return i1 - i2; | |
| // otherwise, handle equal length numbers below | |
| } | |
| int l1 = s1.length(); | |
| int l2 = s2.length(); | |
| int lim = Math.min(l1, l2); | |
| for (int k = n; k < lim; k++) { | |
| char c1 = s1.charAt(k); | |
| char c2 = s2.charAt(k); | |
| if (c1 != c2) { | |
| // change natural ordering so '.' comes before '$' | |
| // i.e. outer classes come before nested classes | |
| if (c1 == '$' && c2 == '.') return 1; | |
| if (c1 == '.' && c2 == '$') return -1; | |
| return c1 - c2; | |
| } | |
| } | |
| return l1 - l2; | |
| }; | |
| static Comparator<ZipEntry> ENTRY_COMPARATOR = | |
| Comparator.comparing(ZipEntry::getName, ENTRYNAME_COMPARATOR); | |
| // Set the ZipEntry dostime using date if specified otherwise the current time | |
| private void setZipEntryTime(ZipEntry e) { | |
| setZipEntryTime(e, System.currentTimeMillis()); | |
| } | |
| // Set the ZipEntry dostime using the date if specified | |
| // otherwise the original time | |
| private void setZipEntryTime(ZipEntry e, long origTime) { | |
| if (date != null) { | |
| e.setTimeLocal(date); | |
| } else { | |
| e.setTime(origTime); | |
| } | |
| } | |
| } |