Java tutorial
/* * This file is part of dependency-check-core. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * Copyright (c) 2013 Jeremy Long. All Rights Reserved. */ package org.owasp.dependencycheck.utils; import java.io.BufferedInputStream; import java.io.Closeable; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.FilenameFilter; import java.io.IOException; import java.util.zip.ZipEntry; import java.util.zip.ZipInputStream; import org.apache.commons.compress.archivers.ArchiveEntry; import org.apache.commons.compress.archivers.ArchiveInputStream; import org.apache.commons.compress.archivers.zip.ZipArchiveInputStream; import org.apache.commons.compress.utils.IOUtils; import org.owasp.dependencycheck.Engine; import org.owasp.dependencycheck.analyzer.exception.AnalysisException; import org.owasp.dependencycheck.analyzer.exception.ArchiveExtractionException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Set of utilities to extract files from archives. * * @author Jeremy Long */ public final class ExtractionUtil { /** * The logger. */ private static final Logger LOGGER = LoggerFactory.getLogger(ExtractionUtil.class); /** * Private constructor for a utility class. */ private ExtractionUtil() { } /** * Extracts the contents of an archive into the specified directory. * * @param archive an archive file such as a WAR or EAR * @param extractTo a directory to extract the contents to * @throws ExtractionException thrown if an exception occurs while extracting the files */ public static void extractFiles(File archive, File extractTo) throws ExtractionException { extractFiles(archive, extractTo, null); } /** * Extracts the contents of an archive into the specified directory. The files are only extracted if they are supported by the * analyzers loaded into the specified engine. If the engine is specified as null then all files are extracted. * * @param archive an archive file such as a WAR or EAR * @param extractTo a directory to extract the contents to * @param engine the scanning engine * @throws ExtractionException thrown if there is an error extracting the files */ public static void extractFiles(File archive, File extractTo, Engine engine) throws ExtractionException { if (archive == null || extractTo == null) { return; } FileInputStream fis = null; ZipInputStream zis = null; try { fis = new FileInputStream(archive); } catch (FileNotFoundException ex) { LOGGER.debug("", ex); throw new ExtractionException("Archive file was not found.", ex); } zis = new ZipInputStream(new BufferedInputStream(fis)); ZipEntry entry; try { while ((entry = zis.getNextEntry()) != null) { if (entry.isDirectory()) { final File d = new File(extractTo, entry.getName()); if (!d.exists() && !d.mkdirs()) { final String msg = String.format("Unable to create '%s'.", d.getAbsolutePath()); throw new ExtractionException(msg); } } else { final File file = new File(extractTo, entry.getName()); if (engine == null || engine.accept(file)) { FileOutputStream fos = null; try { fos = new FileOutputStream(file); IOUtils.copy(zis, fos); } catch (FileNotFoundException ex) { LOGGER.debug("", ex); final String msg = String.format("Unable to find file '%s'.", file.getName()); throw new ExtractionException(msg, ex); } catch (IOException ex) { LOGGER.debug("", ex); final String msg = String.format("IO Exception while parsing file '%s'.", file.getName()); throw new ExtractionException(msg, ex); } finally { closeStream(fos); } } } } } catch (IOException ex) { final String msg = String.format("Exception reading archive '%s'.", archive.getName()); LOGGER.debug("", ex); throw new ExtractionException(msg, ex); } finally { closeStream(zis); } } /** * Extracts the contents of an archive into the specified directory. * * @param archive an archive file such as a WAR or EAR * @param destination a directory to extract the contents to * @param filter determines which files get extracted * @throws ExtractionException thrown if the archive is not found */ public static void extractFilesUsingFilter(File archive, File destination, FilenameFilter filter) throws ExtractionException { if (archive == null || destination == null) { return; } FileInputStream fis = null; try { fis = new FileInputStream(archive); } catch (FileNotFoundException ex) { LOGGER.debug("", ex); throw new ExtractionException("Archive file was not found.", ex); } try { extractArchive(new ZipArchiveInputStream(new BufferedInputStream(fis)), destination, filter); } catch (ArchiveExtractionException ex) { LOGGER.warn("Exception extracting archive '{}'.", archive.getName()); LOGGER.debug("", ex); } finally { try { fis.close(); } catch (IOException ex) { LOGGER.debug("", ex); } } } /** * Extracts files from an archive. * * @param input the archive to extract files from * @param destination the location to write the files too * @param filter determines which files get extracted * @throws ArchiveExtractionException thrown if there is an exception extracting files from the archive */ private static void extractArchive(ArchiveInputStream input, File destination, FilenameFilter filter) throws ArchiveExtractionException { ArchiveEntry entry; try { while ((entry = input.getNextEntry()) != null) { if (entry.isDirectory()) { final File dir = new File(destination, entry.getName()); if (!dir.exists() && !dir.mkdirs()) { final String msg = String.format("Unable to create directory '%s'.", dir.getAbsolutePath()); throw new AnalysisException(msg); } } else { extractFile(input, destination, filter, entry); } } } catch (IOException ex) { throw new ArchiveExtractionException(ex); } catch (Throwable ex) { throw new ArchiveExtractionException(ex); } finally { closeStream(input); } } /** * Extracts a file from an archive (input stream) and correctly builds the directory structure. * * @param input the archive input stream * @param destination where to write the file * @param filter the file filter to apply to the files being extracted * @param entry the entry from the archive to extract * @throws ExtractionException thrown if there is an error reading from the archive stream */ private static void extractFile(ArchiveInputStream input, File destination, FilenameFilter filter, ArchiveEntry entry) throws ExtractionException { final File file = new File(destination, entry.getName()); if (filter.accept(file.getParentFile(), file.getName())) { LOGGER.debug("Extracting '{}'", file.getPath()); FileOutputStream fos = null; try { createParentFile(file); fos = new FileOutputStream(file); IOUtils.copy(input, fos); } catch (FileNotFoundException ex) { LOGGER.debug("", ex); final String msg = String.format("Unable to find file '%s'.", file.getName()); throw new ExtractionException(msg, ex); } catch (IOException ex) { LOGGER.debug("", ex); final String msg = String.format("IO Exception while parsing file '%s'.", file.getName()); throw new ExtractionException(msg, ex); } finally { closeStream(fos); } } } /** * Closes the stream. * * @param stream the stream to close */ private static void closeStream(Closeable stream) { if (stream != null) { try { stream.close(); } catch (IOException ex) { LOGGER.trace("", ex); } } } /** * Ensures the parent path is correctly created on disk so that the file can be extracted to the correct location. * * @param file the file path * @throws ExtractionException thrown if the parent paths could not be created */ private static void createParentFile(final File file) throws ExtractionException { final File parent = file.getParentFile(); if (!parent.isDirectory() && !parent.mkdirs()) { final String msg = String.format("Unable to build directory '%s'.", parent.getAbsolutePath()); throw new ExtractionException(msg); } } }