| /* | |
| * ProGuard -- shrinking, optimization, obfuscation, and preverification | |
| * of Java bytecode. | |
| * | |
| * Copyright (c) 2002-2019 Guardsquare NV | |
| * | |
| * This program is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License as published by the Free | |
| * Software Foundation; either version 2 of the License, or (at your option) | |
| * any later version. | |
| * | |
| * This program 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 for | |
| * more details. | |
| * | |
| * You should have received a copy of the GNU General Public License along | |
| * with this program; if not, write to the Free Software Foundation, Inc., | |
| * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| */ | |
| package proguard; | |
| import proguard.classfile.*; | |
| import proguard.classfile.util.ClassUtil; | |
| import proguard.configuration.ConfigurationLogger; | |
| import proguard.io.*; | |
| import proguard.util.*; | |
| import java.io.*; | |
| import java.nio.charset.Charset; | |
| import java.util.*; | |
| /** | |
| * This class writes the output class files. | |
| * | |
| * @author Eric Lafortune | |
| */ | |
| public class OutputWriter | |
| { | |
| private final Configuration configuration; | |
| /** | |
| * Creates a new OutputWriter to write output class files as specified by | |
| * the given configuration. | |
| */ | |
| public OutputWriter(Configuration configuration) | |
| { | |
| this.configuration = configuration; | |
| } | |
| /** | |
| * Writes the given class pool to class files, based on the current | |
| * configuration. | |
| */ | |
| public void execute(ClassPool programClassPool, | |
| MultiValueMap<String, String> injectedClassNameMap) throws IOException | |
| { | |
| ClassPath programJars = configuration.programJars; | |
| // Create a data entry writer factory with common archival parameters. | |
| DataEntryWriterFactory dataEntryWriterFactory = | |
| new DataEntryWriterFactory(programClassPool, | |
| injectedClassNameMap); | |
| int firstInputIndex = 0; | |
| int lastInputIndex = 0; | |
| // Go over all program class path entries. | |
| for (int index = 0; index < programJars.size(); index++) | |
| { | |
| // Is it an input entry? | |
| ClassPathEntry entry = programJars.get(index); | |
| if (!entry.isOutput()) | |
| { | |
| // It's an input entry. Remember the highest index. | |
| lastInputIndex = index; | |
| } | |
| else | |
| { | |
| // It's an output entry. Is it the last one in a | |
| // series of output entries? | |
| int nextIndex = index + 1; | |
| if (nextIndex == programJars.size() || | |
| !programJars.get(nextIndex).isOutput()) | |
| { | |
| // Write the processed input entries to the output entries. | |
| writeOutput(dataEntryWriterFactory, | |
| programClassPool, | |
| programJars, | |
| firstInputIndex, | |
| lastInputIndex + 1, | |
| nextIndex); | |
| // Start with the next series of input entries. | |
| firstInputIndex = nextIndex; | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Transfers the specified input jars to the specified output jars. | |
| */ | |
| private void writeOutput(DataEntryWriterFactory dataEntryWriterFactory, | |
| ClassPool programClassPool, | |
| ClassPath classPath, | |
| int fromInputIndex, | |
| int fromOutputIndex, | |
| int toOutputIndex) | |
| throws IOException | |
| { | |
| try | |
| { | |
| // Construct the writer that can write apks, jars, wars, ears, zips, | |
| // and directories, cascading over the specified output entries. | |
| DataEntryWriter writer = | |
| dataEntryWriterFactory.createDataEntryWriter(classPath, | |
| fromOutputIndex, | |
| toOutputIndex); | |
| if (configuration.addConfigurationDebugging) | |
| { | |
| writer = new ExtraDataEntryWriter(ConfigurationLogger.CLASS_MAP_FILENAME, | |
| writer, | |
| new ClassMapDataEntryWriter(programClassPool, writer)); | |
| System.err.println("Warning: -addconfigurationdebugging is enabled; the resulting build will contain obfuscation information."); | |
| System.err.println("It should only be used for debugging purposes."); | |
| } | |
| DataEntryWriter resourceWriter = writer; | |
| // Adapt plain resource file names that correspond to class names, | |
| // if necessary. | |
| if (configuration.obfuscate && | |
| configuration.adaptResourceFileNames != null) | |
| { | |
| // Rename processed general resources. | |
| resourceWriter = | |
| renameResourceFiles(programClassPool, | |
| resourceWriter); | |
| } | |
| // By default, just copy resource files into the above writers. | |
| DataEntryReader resourceCopier = | |
| new DataEntryCopier(resourceWriter); | |
| // We're now switching to the reader side, operating on the | |
| // contents possibly parsed from the input streams. | |
| DataEntryReader resourceRewriter = resourceCopier; | |
| // Adapt resource file contents, if allowed. | |
| if ((configuration.shrink || | |
| configuration.optimize || | |
| configuration.obfuscate) && | |
| configuration.adaptResourceFileContents != null) | |
| { | |
| DataEntryReader adaptingContentWriter = resourceRewriter; | |
| // Adapt the contents of general resource files (manifests | |
| // and native libraries). | |
| if (configuration.obfuscate) | |
| { | |
| adaptingContentWriter = | |
| adaptResourceFiles(programClassPool, | |
| resourceWriter); | |
| } | |
| // Add the overall filter for adapting resource file contents. | |
| resourceRewriter = | |
| new NameFilter(configuration.adaptResourceFileContents, | |
| adaptingContentWriter, | |
| resourceRewriter); | |
| } | |
| // Write any kept directories. | |
| DataEntryReader reader = | |
| writeDirectories(programClassPool, | |
| resourceCopier, | |
| resourceRewriter); | |
| // Trigger writing classes. | |
| reader = | |
| new ClassFilter(new IdleRewriter(writer), | |
| reader); | |
| // Go over the specified input entries and write their processed | |
| // versions. | |
| new InputReader(configuration).readInput(" Copying resources from program ", | |
| classPath, | |
| fromInputIndex, | |
| fromOutputIndex, | |
| reader); | |
| // Close all output entries. | |
| writer.close(); | |
| } | |
| catch (IOException ex) | |
| { | |
| throw (IOException)new IOException("Can't write [" + classPath.get(fromOutputIndex).getName() + "] (" + ex.getMessage() + ")").initCause(ex); | |
| } | |
| } | |
| /** | |
| * Returns a writer that writes possibly renamed resource files to the | |
| * given resource writer. | |
| */ | |
| private DataEntryWriter renameResourceFiles(ClassPool programClassPool, | |
| DataEntryWriter dataEntryWriter) | |
| { | |
| Map packagePrefixMap = createPackagePrefixMap(programClassPool); | |
| return | |
| new NameFilteredDataEntryWriter(configuration.adaptResourceFileNames, | |
| new RenamedDataEntryWriter(programClassPool, packagePrefixMap, dataEntryWriter), | |
| dataEntryWriter); | |
| } | |
| /** | |
| * Returns a reader that writes all general resource files (manifest, | |
| * native libraries, text files) with shrunk, optimized, and obfuscated | |
| * contents to the given writer. | |
| */ | |
| private DataEntryReader adaptResourceFiles(ClassPool programClassPool, | |
| DataEntryWriter writer) | |
| { | |
| // Pick a suitable encoding. | |
| Charset charset = configuration.android ? | |
| Charset.forName("UTF-8") : | |
| Charset.defaultCharset(); | |
| // Filter between the various general resource files. | |
| return | |
| new NameFilter("META-INF/MANIFEST.MF,META-INF/*.SF", | |
| new ManifestRewriter(programClassPool, charset, writer), | |
| new DataEntryRewriter(programClassPool, charset, writer)); | |
| } | |
| /** | |
| * Writes possibly renamed directories that should be preserved to the | |
| * given resource copier, and non-directories to the given file copier. | |
| */ | |
| private DirectoryFilter writeDirectories(ClassPool programClassPool, | |
| DataEntryReader directoryCopier, | |
| DataEntryReader fileCopier) | |
| { | |
| DataEntryReader directoryRewriter = null; | |
| // Wrap the directory copier with a filter and a data entry renamer. | |
| if (configuration.keepDirectories != null) | |
| { | |
| Map packagePrefixMap = createPackagePrefixMap(programClassPool); | |
| directoryRewriter = | |
| new NameFilter(configuration.keepDirectories, | |
| new RenamedDataEntryReader(packagePrefixMap, | |
| directoryCopier, | |
| directoryCopier)); | |
| } | |
| // Filter on directories and files. | |
| return new DirectoryFilter(directoryRewriter, fileCopier); | |
| } | |
| /** | |
| * Creates a map of old package prefixes to new package prefixes, based on | |
| * the given class pool. | |
| */ | |
| private static Map createPackagePrefixMap(ClassPool classPool) | |
| { | |
| Map packagePrefixMap = new HashMap(); | |
| Iterator iterator = classPool.classNames(); | |
| while (iterator.hasNext()) | |
| { | |
| String className = (String)iterator.next(); | |
| String packagePrefix = ClassUtil.internalPackagePrefix(className); | |
| String mappedNewPackagePrefix = (String)packagePrefixMap.get(packagePrefix); | |
| if (mappedNewPackagePrefix == null || | |
| !mappedNewPackagePrefix.equals(packagePrefix)) | |
| { | |
| String newClassName = classPool.getClass(className).getName(); | |
| String newPackagePrefix = ClassUtil.internalPackagePrefix(newClassName); | |
| packagePrefixMap.put(packagePrefix, newPackagePrefix); | |
| } | |
| } | |
| return packagePrefixMap; | |
| } | |
| } |