src/java.base/share/classes/jdk/internal/jmod/JmodFile.java - master - githubmirror/jdk17u-dev

src/java.base/share/classes/jdk/internal/jmod/JmodFile.java
240 строк7 KB
Sergey Tsypanov
8263560: Remove needless wrapping with BufferedInputStream
30 мар 2021, 09:47
30 мар 2021, 09:471a681fa
/*
 * Copyright (c) 2016, 2017, 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 jdk.internal.jmod;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

/**
 * Helper class to read JMOD file
 */
public class JmodFile implements AutoCloseable {
    // jmod magic number and version number
    private static final int JMOD_MAJOR_VERSION = 0x01;
    private static final int JMOD_MINOR_VERSION = 0x00;
    private static final byte[] JMOD_MAGIC_NUMBER = {
        0x4A, 0x4D, /* JM */
        JMOD_MAJOR_VERSION, JMOD_MINOR_VERSION, /* version 1.0 */
    };

    public static void checkMagic(Path file) throws IOException {
        try (InputStream in = Files.newInputStream(file)) {
            // validate the header
            byte[] magic = in.readNBytes(4);
            if (magic.length != 4) {
                throw new IOException("Invalid JMOD file: " + file);
            }
            if (magic[0] != JMOD_MAGIC_NUMBER[0] ||
                magic[1] != JMOD_MAGIC_NUMBER[1]) {
                throw new IOException("Invalid JMOD file: " + file.toString());
            }
            if (magic[2] > JMOD_MAJOR_VERSION ||
                (magic[2] == JMOD_MAJOR_VERSION && magic[3] > JMOD_MINOR_VERSION)) {
                throw new IOException("Unsupported jmod version: " +
                    magic[2] + "." + magic[3] + " in " + file.toString());
            }
        }
    }

    /**
     * JMOD sections
     */
    public static enum Section {
        CLASSES("classes"),
        CONFIG("conf"),
        HEADER_FILES("include"),
        LEGAL_NOTICES("legal"),
        MAN_PAGES("man"),
        NATIVE_LIBS("lib"),
        NATIVE_CMDS("bin");

        private final String jmodDir;
        private Section(String jmodDir) {
            this.jmodDir = jmodDir;
        }

        /**
         * Returns the directory name in the JMOD file corresponding to
         * this section
         */
        public String jmodDir() { return jmodDir; }
    }

    /**
     * JMOD file entry.
     *
     * Each entry corresponds to a ZipEntry whose name is:
     *   Section::jmodDir + '/' + name
     */
    public static class Entry {
        private final ZipEntry zipEntry;
        private final Section section;
        private final String name;

        private Entry(ZipEntry e) {
            String name = e.getName();
            int i = name.indexOf('/');
            if (i <= 1) {
                throw new RuntimeException("invalid jmod entry: " + name);
            }

            this.zipEntry = e;
            this.section = section(name.substring(0, i));
            this.name = name.substring(i+1);
        }

        /**
         * Returns the section of this entry.
         */
        public Section section() {
            return section;
        }

        /**
         * Returns the name of this entry.
         */
        public String name() {
            return name;
        }

        /**
         * Returns true if the entry is a directory in the JMOD file.
         */
        public boolean isDirectory() {
            return zipEntry.isDirectory();
        }

        /**
         * Returns the size of this entry.
         */
        public long size() {
            return zipEntry.getSize();
        }

        public ZipEntry zipEntry() {
            return zipEntry;
        }

        @Override
        public String toString() {
            return section.jmodDir() + "/" + name;
        }

        /*
         * A map from the jmodDir name to Section
         */
        static final Map<String, Section> NAME_TO_SECTION =
            Arrays.stream(Section.values())
                  .collect(Collectors.toMap(Section::jmodDir, Function.identity()));

        static Section section(String name) {
            if (!NAME_TO_SECTION.containsKey(name)) {
                throw new IllegalArgumentException("invalid section: " + name);

            }
            return NAME_TO_SECTION.get(name);
        }

    }

    private final Path file;
    private final ZipFile zipfile;

    /**
     * Constructs a {@code JmodFile} from a given path.
     */
    public JmodFile(Path file) throws IOException {
        checkMagic(file);
        this.file = file;
        this.zipfile = new ZipFile(file.toFile());
    }

    public static void writeMagicNumber(OutputStream os) throws IOException {
        os.write(JMOD_MAGIC_NUMBER);
    }

    /**
     * Returns the {@code Entry} for a resource in a JMOD file section
     * or {@code null} if not found.
     */
    public Entry getEntry(Section section, String name) {
        String entry = section.jmodDir() + "/" + name;
        ZipEntry ze = zipfile.getEntry(entry);
        return (ze != null) ? new Entry(ze) : null;
    }

    /**
     * Opens an {@code InputStream} for reading the named entry of the given
     * section in this JMOD file.
     *
     * @throws IOException if the named entry is not found, or I/O error
     *         occurs when reading it
     */
    public InputStream getInputStream(Section section, String name)
        throws IOException
    {
        String entry = section.jmodDir() + "/" + name;
        ZipEntry e = zipfile.getEntry(entry);
        if (e == null) {
            throw new IOException(name + " not found: " + file);
        }
        return zipfile.getInputStream(e);
    }

    /**
     * Opens an {@code InputStream} for reading an entry in the JMOD file.
     *
     * @throws IOException if an I/O error occurs
     */
    public InputStream getInputStream(Entry entry) throws IOException {
        return zipfile.getInputStream(entry.zipEntry());
    }

    /**
     * Returns a stream of entries in this JMOD file.
     */
    public Stream<Entry> stream() {
        return zipfile.stream()
                      .map(Entry::new);
    }

    @Override
    public void close() throws IOException {
        if (zipfile != null) {
            zipfile.close();
        }
    }
}