    001/*
    002 *  Licensed to the Apache Software Foundation (ASF) under one or more
    003 *  contributor license agreements.  See the NOTICE file distributed with
    004 *  this work for additional information regarding copyright ownership.
    005 *  The ASF licenses this file to You under the Apache License, Version 2.0
    006 *  (the "License"); you may not use this file except in compliance with
    007 *  the License.  You may obtain a copy of the License at
    008 *
    009 *     http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 *  Unless required by applicable law or agreed to in writing, software
    012 *  distributed under the License is distributed on an "AS IS" BASIS,
    013 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 *  See the License for the specific language governing permissions and
    015 *  limitations under the License.
    016 */
    017package org.apache.commons.compress.harmony.pack200;
    018
    019import java.io.BufferedInputStream;
    020import java.io.ByteArrayOutputStream;
    021import java.io.IOException;
    022import java.io.InputStream;
    023import java.io.OutputStream;
    024import java.util.ArrayList;
    025import java.util.Enumeration;
    026import java.util.Iterator;
    027import java.util.List;
    028import java.util.jar.JarEntry;
    029import java.util.jar.JarFile;
    030import java.util.jar.JarInputStream;
    031import java.util.jar.JarOutputStream;
    032import java.util.jar.Manifest;
    033import java.util.logging.FileHandler;
    034import java.util.logging.Level;
    035import java.util.logging.LogManager;
    036import java.util.logging.LogRecord;
    037import java.util.logging.Logger;
    038import java.util.logging.SimpleFormatter;
    039
    040import org.apache.commons.compress.harmony.pack200.Archive.PackingFile;
    041
    042public class PackingUtils {
    043
    044    private static final class PackingLogger extends Logger {
    045
    046        private boolean verbose;
    047
    048        protected PackingLogger(final String name, final String resourceBundleName) {
    049            super(name, resourceBundleName);
    050        }
    051
    052        @Override
    053        public void log(final LogRecord logRecord) {
    054            if (verbose) {
    055                super.log(logRecord);
    056            }
    057        }
    058
    059        public void setVerbose(final boolean isVerbose) {
    060            verbose = isVerbose;
    061        }
    062    }
    063
    064    private static PackingLogger packingLogger;
    065    private static FileHandler fileHandler;
    066
    067    static {
    068        packingLogger = new PackingLogger("org.harmony.apache.pack200", null);
    069        LogManager.getLogManager().addLogger(packingLogger);
    070    }
    071
    072    public static void config(final PackingOptions options) throws IOException {
    073        final String logFileName = options != null ? options.getLogFile() : null;
    074        if (fileHandler != null) {
    075            fileHandler.close();
    076        }
    077        if (logFileName != null) {
    078            fileHandler = new FileHandler(logFileName, false);
    079            fileHandler.setFormatter(new SimpleFormatter());
    080            packingLogger.addHandler(fileHandler);
    081            packingLogger.setUseParentHandlers(false);
    082        }
    083        if (options != null) {
    084            packingLogger.setVerbose(options.isVerbose());
    085        }
    086    }
    087
    088    /**
    089     * When effort is 0, the packer copys through the original jar file without compression
    090     *
    091     * @param jarFile      the input jar file
    092     * @param outputStream the jar output stream
    093     * @throws IOException If an I/O error occurs.
    094     */
    095    public static void copyThroughJar(final JarFile jarFile, final OutputStream outputStream) throws IOException {
    096        try (JarOutputStream jarOutputStream = new JarOutputStream(outputStream)) {
    097            jarOutputStream.setComment("PACK200");
    098            final byte[] bytes = new byte[16384];
    099            final Enumeration<JarEntry> entries = jarFile.entries();
    100            while (entries.hasMoreElements()) {
    101                final JarEntry jarEntry = entries.nextElement();
    102                jarOutputStream.putNextEntry(jarEntry);
    103                try (InputStream inputStream = jarFile.getInputStream(jarEntry)) {
    104                    int bytesRead;
    105                    while ((bytesRead = inputStream.read(bytes)) != -1) {
    106                        jarOutputStream.write(bytes, 0, bytesRead);
    107                    }
    108                    jarOutputStream.closeEntry();
    109                    log("Packed " + jarEntry.getName());
    110                }
    111            }
    112            jarFile.close();
    113        }
    114    }
    115
    116    /**
    117     * When effort is 0, the packer copies through the original jar input stream without compression
    118     *
    119     * @param jarInputStream the jar input stream
    120     * @param outputStream   the jar output stream
    121     * @throws IOException If an I/O error occurs.
    122     */
    123    public static void copyThroughJar(final JarInputStream jarInputStream, final OutputStream outputStream) throws IOException {
    124        final Manifest manifest = jarInputStream.getManifest();
    125        try (JarOutputStream jarOutputStream = new JarOutputStream(outputStream, manifest)) {
    126            jarOutputStream.setComment("PACK200");
    127            log("Packed " + JarFile.MANIFEST_NAME);
    128
    129            final byte[] bytes = new byte[16384];
    130            JarEntry jarEntry;
    131            int bytesRead;
    132            while ((jarEntry = jarInputStream.getNextJarEntry()) != null) {
    133                jarOutputStream.putNextEntry(jarEntry);
    134                while ((bytesRead = jarInputStream.read(bytes)) != -1) {
    135                    jarOutputStream.write(bytes, 0, bytesRead);
    136                }
    137                log("Packed " + jarEntry.getName());
    138            }
    139            jarInputStream.close();
    140        }
    141    }
    142
    143    public static List<PackingFile> getPackingFileListFromJar(final JarFile jarFile, final boolean keepFileOrder) throws IOException {
    144        final List<PackingFile> packingFileList = new ArrayList<>();
    145        final Enumeration<JarEntry> jarEntries = jarFile.entries();
    146        while (jarEntries.hasMoreElements()) {
    147            final JarEntry jarEntry = jarEntries.nextElement();
    148            try (InputStream inputStream = jarFile.getInputStream(jarEntry)) {
    149                final byte[] bytes = readJarEntry(jarEntry, new BufferedInputStream(inputStream));
    150                packingFileList.add(new PackingFile(bytes, jarEntry));
    151            }
    152        }
    153
    154        // check whether it need reorder packing file list
    155        if (!keepFileOrder) {
    156            reorderPackingFiles(packingFileList);
    157        }
    158        return packingFileList;
    159    }
    160
    161    public static List<PackingFile> getPackingFileListFromJar(final JarInputStream jarInputStream, final boolean keepFileOrder) throws IOException {
    162        final List<PackingFile> packingFileList = new ArrayList<>();
    163
    164        // add manifest file
    165        final Manifest manifest = jarInputStream.getManifest();
    166        if (manifest != null) {
    167            final ByteArrayOutputStream baos = new ByteArrayOutputStream();
    168            manifest.write(baos);
    169            packingFileList.add(new PackingFile(JarFile.MANIFEST_NAME, baos.toByteArray(), 0));
    170        }
    171
    172        // add rest of entries in the jar
    173        JarEntry jarEntry;
    174        byte[] bytes;
    175        while ((jarEntry = jarInputStream.getNextJarEntry()) != null) {
    176            bytes = readJarEntry(jarEntry, new BufferedInputStream(jarInputStream));
    177            packingFileList.add(new PackingFile(bytes, jarEntry));
    178        }
    179
    180        // check whether it need reorder packing file list
    181        if (!keepFileOrder) {
    182            reorderPackingFiles(packingFileList);
    183        }
    184        return packingFileList;
    185    }
    186
    187    public static void log(final String message) {
    188        packingLogger.log(Level.INFO, message);
    189    }
    190
    191    private static byte[] readJarEntry(final JarEntry jarEntry, final InputStream inputStream) throws IOException {
    192        long size = jarEntry.getSize();
    193        if (size > Integer.MAX_VALUE) {
    194            // TODO: Should probably allow this
    195            throw new IllegalArgumentException("Large Class!");
    196        }
    197        if (size < 0) {
    198            size = 0;
    199        }
    200        final byte[] bytes = new byte[(int) size];
    201        if (inputStream.read(bytes) != size) {
    202            throw new IllegalArgumentException("Error reading from stream");
    203        }
    204        return bytes;
    205    }
    206
    207    private static void reorderPackingFiles(final List<PackingFile> packingFileList) {
    208        final Iterator<PackingFile> iterator = packingFileList.iterator();
    209        while (iterator.hasNext()) {
    210            final PackingFile packingFile = iterator.next();
    211            if (packingFile.isDirectory()) {
    212                // remove directory entries
    213                iterator.remove();
    214            }
    215        }
    216
    217        // Sort files by name, "META-INF/MANIFEST.MF" should be put in the 1st
    218        // position
    219        packingFileList.sort((arg0, arg1) -> {
    220            final String fileName0 = arg0.getName();
    221            final String fileName1 = arg1.getName();
    222            if (fileName0.equals(fileName1)) {
    223                return 0;
    224            }
    225            if (JarFile.MANIFEST_NAME.equals(fileName0)) {
    226                return -1;
    227            }
    228            if (JarFile.MANIFEST_NAME.equals(fileName1)) {
    229                return 1;
    230            }
    231            return fileName0.compareTo(fileName1);
    232        });
    233    }
    234
    235}