blob: 7981bec1a5addc98a68ba1c4bbcc68c7ef13c842 [file]
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package org.apache.maven.plugins.install;
import javax.inject.Inject;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.Model;
import org.apache.maven.model.Parent;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.apache.maven.model.io.xpp3.MavenXpp3Writer;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import org.eclipse.aether.DefaultRepositoryCache;
import org.eclipse.aether.DefaultRepositorySystemSession;
import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.artifact.ArtifactType;
import org.eclipse.aether.artifact.DefaultArtifact;
import org.eclipse.aether.installation.InstallRequest;
import org.eclipse.aether.installation.InstallationException;
import org.eclipse.aether.repository.LocalRepository;
import org.eclipse.aether.repository.LocalRepositoryManager;
import org.eclipse.aether.util.artifact.SubArtifact;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static java.util.Objects.isNull;
/**
* Installs a file in the local repository.
*
* @author <a href="mailto:brett@apache.org">Brett Porter</a>
*/
@Mojo(name = "install-file", requiresProject = false, aggregator = true, threadSafe = true)
public class InstallFileMojo extends AbstractMojo {
private static final String LS = System.lineSeparator();
private static final String ILLEGAL_VERSION_CHARS = "\\/:\"<>|?*[](){},";
/** The {@code encoding} pseudo-attribute of an XML declaration. */
private static final Pattern ENCODING_PSEUDO_ATTR = Pattern.compile("encoding\\s*=\\s*[\"']([^\"']+)[\"']");
private final Logger log = LoggerFactory.getLogger(getClass());
private final RepositorySystem repositorySystem;
@Parameter(defaultValue = "${session}", required = true, readonly = true)
private MavenSession session;
/**
* GroupId of the artifact to be installed. Retrieved from POM file if one is specified or extracted from
* {@code pom.xml} in jar if available.
*/
@Parameter(property = "groupId")
private String groupId;
/**
* ArtifactId of the artifact to be installed. Retrieved from POM file if one is specified or extracted from
* {@code pom.xml} in jar if available.
*/
@Parameter(property = "artifactId")
private String artifactId;
/**
* Version of the artifact to be installed. Retrieved from POM file if one is specified or extracted from
* {@code pom.xml} in jar if available.
*/
@Parameter(property = "version")
private String version;
/**
* Packaging type of the artifact to be installed. Retrieved from POM file if one is specified or extracted from
* {@code pom.xml} in jar if available.
*/
@Parameter(property = "packaging")
private String packaging;
/**
* Classifier type of the artifact to be installed. For example, "sources" or "javadoc". Defaults to none which
* means this is the project's main artifact.
*
* @since 2.2
*/
@Parameter(property = "classifier")
private String classifier;
/**
* Extension of the artifact to be installed. If set, will override plugin own logic to detect extension. If not set,
* as Maven expected, packaging determines the artifact extension.
*
* @since 3.1.3
*/
@Parameter(property = "extension")
private String extension;
/**
* The file to be installed in the local repository.
*/
@Parameter(property = "file", required = true)
private File file;
/**
* The bundled API docs for the artifact.
*
* @since 2.3
*/
@Parameter(property = "javadoc")
private File javadoc;
/**
* The bundled sources for the artifact.
*
* @since 2.3
*/
@Parameter(property = "sources")
private File sources;
/**
* Location of an existing POM file to be installed alongside the main artifact, given by the {@link #file}
* parameter.
*
* @since 2.1
*/
@Parameter(property = "pomFile")
private File pomFile;
/**
* Generate a minimal POM for the artifact if none is supplied via the parameter {@link #pomFile}. Defaults to
* <code>true</code> if there is no existing POM in the local repository yet.
*
* @since 2.1
*/
@Parameter(property = "generatePom")
private Boolean generatePom;
/**
* The path for a specific local repository directory. If not specified the local repository path configured in the
* Maven settings will be used.
*
* @since 2.2
*/
@Parameter(property = "localRepositoryPath")
private File localRepositoryPath;
private static final Predicate<String> IS_EMPTY = s -> isNull(s) || s.isEmpty();
private static final Predicate<String> IS_POM_PACKAGING = "pom"::equals;
@Inject
public InstallFileMojo(RepositorySystem repositorySystem) {
this.repositorySystem = repositorySystem;
}
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
if (!file.exists()) {
String message = "The specified file '" + file.getPath() + "' does not exist";
log.error(message);
throw new MojoFailureException(message);
}
RepositorySystemSession repositorySystemSession = session.getRepositorySession();
if (localRepositoryPath != null) {
// "clone" repository session and replace localRepository
DefaultRepositorySystemSession newSession =
new DefaultRepositorySystemSession(session.getRepositorySession());
// Clear cache, since we're using a new local repository
newSession.setCache(new DefaultRepositoryCache());
// keep same repositoryType
String contentType = newSession.getLocalRepository().getContentType();
if ("enhanced".equals(contentType)) {
contentType = "default";
}
LocalRepositoryManager localRepositoryManager = repositorySystem.newLocalRepositoryManager(
newSession, new LocalRepository(localRepositoryPath, contentType));
newSession.setLocalRepositoryManager(localRepositoryManager);
repositorySystemSession = newSession;
log.debug(
"localRepoPath: {}", localRepositoryManager.getRepository().getBasedir());
}
File temporaryPom = null;
if (pomFile != null) {
processModel(readModel(pomFile));
} else {
if (Boolean.TRUE.equals(generatePom)) {
// generatePom explicitly requested: skip embedded POM
} else if (groupId != null && artifactId != null && version != null && packaging != null) {
// The operator supplied the complete coordinates: do not let metadata embedded inside the
// (potentially untrusted) file silently become the authoritative POM for those coordinates.
// A minimal POM is generated below instead; use -DpomFile to install a curated POM.
log.info(
"Ignoring any POM embedded in {}: complete coordinates were supplied, so a minimal"
+ " POM will be generated instead. Use -DpomFile to install a specific POM.",
file.getName());
} else {
// Coordinates that were supplied are cross-checked against the embedded POM inside
// readingPomFromJarFile(): a mismatch fails the build rather than installing the
// embedded POM verbatim at operator-chosen coordinates.
temporaryPom = readingPomFromJarFile();
pomFile = temporaryPom;
if (pomFile != null) {
log.info("Using JAR embedded POM as pomFile");
}
}
}
if (isNull(groupId) || isNull(artifactId) || isNull(version) || isNull(packaging)) {
throw new MojoExecutionException("The artifact information is incomplete: 'groupId', 'artifactId', "
+ "'version' and 'packaging' are required.");
}
if (!isValidGroupId(groupId) || !isValidId(artifactId) || !isValidId(packaging) || !isValidVersion(version)) {
throw new MojoExecutionException(
"The artifact information is not valid: uses invalid characters or empty/dot-only values.");
}
InstallRequest installRequest = new InstallRequest();
String mainArtifactExtension;
if (classifier == null && "pom".equals(packaging)) {
mainArtifactExtension = "pom";
} else {
ArtifactType artifactType =
session.getRepositorySession().getArtifactTypeRegistry().get(packaging);
if (artifactType != null) {
if (StringUtils.isEmpty(classifier) && !StringUtils.isEmpty(artifactType.getClassifier())) {
classifier = artifactType.getClassifier();
}
mainArtifactExtension = artifactType.getExtension();
} else {
mainArtifactExtension = packaging;
}
}
if (extension != null && !Objects.equals(extension, mainArtifactExtension)) {
log.warn(
"Main artifact extension should be '{}' but was overridden to '{}'",
mainArtifactExtension,
extension);
}
Artifact mainArtifact = new DefaultArtifact(
groupId, artifactId, classifier, extension != null ? extension : mainArtifactExtension, version)
.setFile(file);
installRequest.addArtifact(mainArtifact);
File artifactLocalFile = getLocalRepositoryFile(repositorySystemSession, mainArtifact);
File pomLocalFile = getPomLocalRepositoryFile(repositorySystemSession, mainArtifact);
if (file.equals(artifactLocalFile)) {
throw new MojoFailureException("Cannot install artifact. " + "Artifact is already in the local repository."
+ LS + LS + "File in question is: " + file + LS);
}
if (artifactLocalFile.exists() && contentDiffers(artifactLocalFile, file)) {
log.warn(
"The local repository already contains {}:{}:{} at {} with different content:"
+ " it will be overwritten by {}",
groupId,
artifactId,
version,
artifactLocalFile,
file);
}
verifyContainment(repositorySystemSession, artifactLocalFile);
if (!IS_POM_PACKAGING.test(packaging)) {
if (isNull(pomFile)) {
if (Boolean.TRUE.equals(generatePom) || (generatePom == null && !pomLocalFile.exists())) {
temporaryPom = generatePomFile();
log.debug("Installing generated POM");
installRequest.addArtifact(new SubArtifact(mainArtifact, "", "pom", temporaryPom));
} else if (generatePom == null) {
log.debug("Skipping installation of generated POM, already present in local repository");
}
} else {
installRequest.addArtifact(new SubArtifact(mainArtifact, "", "pom", pomFile));
}
}
if (sources != null) {
installRequest.addArtifact(new SubArtifact(mainArtifact, "sources", "jar", sources));
}
if (javadoc != null) {
installRequest.addArtifact(new SubArtifact(mainArtifact, "javadoc", "jar", javadoc));
}
try {
repositorySystem.install(repositorySystemSession, installRequest);
} catch (InstallationException e) {
throw new MojoExecutionException(e.getMessage(), e);
} finally {
if (temporaryPom != null) {
// noinspection ResultOfMethodCallIgnored
temporaryPom.delete();
}
}
}
private static final Pattern POM_ENTRY_PATTERN = Pattern.compile("META-INF/maven/.*/pom\\.xml");
private static final Predicate<JarEntry> IS_POM_ENTRY =
entry -> POM_ENTRY_PATTERN.matcher(entry.getName()).matches();
private File readingPomFromJarFile() throws MojoExecutionException {
String base = file.getName();
if (base.contains(".")) {
base = base.substring(0, base.lastIndexOf('.'));
}
try (JarFile jarFile = new JarFile(file)) {
List<JarEntry> pomEntries = jarFile.stream().filter(IS_POM_ENTRY).collect(Collectors.toList());
if (pomEntries.size() > 1) {
throw new MojoExecutionException("Found " + pomEntries.size() + " POM entries in " + file.getName()
+ ": "
+ pomEntries.stream().map(JarEntry::getName).collect(Collectors.joining(", "))
+ ". Cannot decide which one to trust: use -DpomFile or supply explicit"
+ " -DgroupId/-DartifactId/-Dversion/-Dpackaging instead.");
}
JarEntry pomEntry = pomEntries.isEmpty() ? null : pomEntries.get(0);
if (isNull(pomEntry)) {
// This means there is no entry which matches the "pom.xml"...(or in other words: not packaged by Maven)
log.info("pom.xml not found in {}", file.getName());
return null;
}
log.info("Loading {} from {}", pomEntry.getName(), file.getName());
Path tempPomFile = Files.createTempFile(base, ".pom");
Files.copy(jarFile.getInputStream(pomEntry), tempPomFile, StandardCopyOption.REPLACE_EXISTING);
rejectDoctype(tempPomFile, pomEntry.getName());
Model model = readModel(tempPomFile.toFile());
validateEmbeddedPomEntryPath(pomEntry.getName(), model);
crossCheckOperatorCoordinates(pomEntry.getName(), model);
processModel(model);
log.info(
"Using coordinates {}:{}:{}:{} from JAR embedded POM {}",
groupId,
artifactId,
version,
packaging,
pomEntry.getName());
return tempPomFile.toFile();
} catch (IOException e) {
// ignore, artifact not packaged by Maven
return null;
}
}
/**
* Parses a POM.
*
* @param pomFile The path of the POM file to parse, must not be <code>null</code>.
* @return The model from the POM file, never <code>null</code>.
* @throws MojoExecutionException If the POM could not be parsed.
*/
private Model readModel(File pomFile) throws MojoExecutionException {
try (InputStream reader = Files.newInputStream(pomFile.toPath())) {
return new MavenXpp3Reader().read(reader);
} catch (FileNotFoundException e) {
throw new MojoExecutionException("File not found " + pomFile, e);
} catch (IOException e) {
throw new MojoExecutionException("Error reading POM " + pomFile, e);
} catch (XmlPullParserException e) {
throw new MojoExecutionException("Error parsing POM " + pomFile, e);
}
}
/**
* Defense-in-depth pre-screen for the JAR embedded POM: the entry is wire-origin, potentially
* attacker-authored XML, and it is handed to {@link MavenXpp3Reader} whose DTD and external-entity
* posture this plugin can neither configure nor guarantee across core versions. A valid POM never
* carries a DOCTYPE declaration, so any embedded POM containing one is rejected before it reaches
* the parser. The scan is encoding-aware: the bytes are decoded with the same charset an XML parser
* is required to autodetect (BOM / first-bytes / encoding pseudo-attribute, XML 1.0 Appendix F),
* so a UTF-16 or UTF-32 document cannot smuggle a NUL-interleaved DOCTYPE past a naive single-byte
* scan. This intentionally does not apply to the operator's own {@code -DpomFile}.
*
* @param embeddedPom the temporary file holding the extracted entry, must not be <code>null</code>
* @param entryName the name of the matched JAR entry, must not be <code>null</code>
* @throws MojoExecutionException if the content contains a DOCTYPE declaration or cannot be read
*/
private void rejectDoctype(Path embeddedPom, String entryName) throws MojoExecutionException {
String content;
try {
byte[] bytes = Files.readAllBytes(embeddedPom);
content = new String(bytes, detectXmlCharset(bytes, entryName));
} catch (IOException e) {
throw new MojoExecutionException("Error reading embedded POM " + embeddedPom, e);
}
if (content.contains("<!DOCTYPE")) {
throw new MojoExecutionException("The POM embedded in " + file.getName() + " (" + entryName
+ ") contains a DOCTYPE declaration. A POM must not declare a DOCTYPE; refusing to"
+ " parse untrusted embedded XML with a DTD. Use -DpomFile or supply explicit"
+ " coordinates instead.");
}
}
/**
* Detects the character encoding of raw XML bytes the way an XML parser is required to
* (XML 1.0 Appendix F): byte-order mark first, then the byte pattern of a leading {@code <?xml},
* then the {@code encoding} pseudo-attribute of the XML declaration, defaulting to UTF-8.
*
* @param bytes the raw entry bytes, must not be <code>null</code>
* @param entryName the name of the matched JAR entry, for error messages
* @return the detected charset, never <code>null</code>
* @throws MojoExecutionException if the detected/declared encoding is unsupported
*/
private Charset detectXmlCharset(byte[] bytes, String entryName) throws MojoExecutionException {
if (bytes.length >= 4) {
int b0 = bytes[0] & 0xFF;
int b1 = bytes[1] & 0xFF;
int b2 = bytes[2] & 0xFF;
int b3 = bytes[3] & 0xFF;
// 4-byte BOMs and BOM-less "<?xml" patterns
if (b0 == 0x00 && b1 == 0x00 && b2 == 0xFE && b3 == 0xFF) {
return charsetOrFail("UTF-32BE", entryName);
}
if (b0 == 0xFF && b1 == 0xFE && b2 == 0x00 && b3 == 0x00) {
return charsetOrFail("UTF-32LE", entryName);
}
if (b0 == 0x00 && b1 == 0x00 && b2 == 0x00 && b3 == 0x3C) {
return charsetOrFail("UTF-32BE", entryName);
}
if (b0 == 0x3C && b1 == 0x00 && b2 == 0x00 && b3 == 0x00) {
return charsetOrFail("UTF-32LE", entryName);
}
if (b0 == 0x00 && b1 == 0x3C && b2 == 0x00 && b3 == 0x3F) {
return StandardCharsets.UTF_16BE;
}
if (b0 == 0x3C && b1 == 0x00 && b2 == 0x3F && b3 == 0x00) {
return StandardCharsets.UTF_16LE;
}
if (b0 == 0x4C && b1 == 0x6F && b2 == 0xA7 && b3 == 0x94) {
// "<?xm" in EBCDIC
String ebcdicPrefix =
new String(bytes, 0, Math.min(bytes.length, 1024), charsetOrFail("IBM037", entryName));
int ebcdicDeclEnd = ebcdicPrefix.indexOf("?>");
String ebcdicDecl = ebcdicDeclEnd >= 0 ? ebcdicPrefix.substring(0, ebcdicDeclEnd) : ebcdicPrefix;
Matcher ebcdicMatcher = ENCODING_PSEUDO_ATTR.matcher(ebcdicDecl);
if (ebcdicMatcher.find()) {
return charsetOrFail(ebcdicMatcher.group(1), entryName);
}
throw new MojoExecutionException("The POM embedded in " + file.getName() + " (" + entryName
+ ") is EBCDIC-encoded but its XML declaration names no encoding, so the exact"
+ " code page cannot be determined and it cannot be screened for a DOCTYPE"
+ " declaration. Use -DpomFile or supply explicit coordinates instead.");
}
}
if (bytes.length >= 2) {
int b0 = bytes[0] & 0xFF;
int b1 = bytes[1] & 0xFF;
if (b0 == 0xFE && b1 == 0xFF) {
return StandardCharsets.UTF_16BE;
}
if (b0 == 0xFF && b1 == 0xFE) {
return StandardCharsets.UTF_16LE;
}
}
// ASCII-compatible family: honor a declared encoding if present
int offset =
bytes.length >= 3 && (bytes[0] & 0xFF) == 0xEF && (bytes[1] & 0xFF) == 0xBB && (bytes[2] & 0xFF) == 0xBF
? 3
: 0;
String prefix = new String(bytes, offset, Math.min(bytes.length - offset, 1024), StandardCharsets.ISO_8859_1);
if (prefix.startsWith("<?xml")) {
int declEnd = prefix.indexOf("?>");
if (declEnd < 0) {
throw new MojoExecutionException("The POM embedded in " + file.getName() + " (" + entryName
+ ") has an XML declaration that does not terminate within the sniffed prefix, so"
+ " its declared encoding cannot be determined and it cannot be screened for a"
+ " DOCTYPE declaration. Use -DpomFile or supply explicit coordinates instead.");
}
Matcher matcher = ENCODING_PSEUDO_ATTR.matcher(prefix.substring(0, declEnd));
if (matcher.find()) {
return charsetOrFail(matcher.group(1), entryName);
}
}
return StandardCharsets.UTF_8;
}
/**
* Resolves a detected or declared encoding name, failing closed if this JVM cannot decode it.
*/
private Charset charsetOrFail(String name, String entryName) throws MojoExecutionException {
try {
return Charset.forName(name);
} catch (IllegalArgumentException e) {
throw new MojoExecutionException("The POM embedded in " + file.getName() + " (" + entryName
+ ") uses an encoding this JVM cannot decode ('" + name + "'), so it cannot be screened"
+ " for a DOCTYPE declaration. Use -DpomFile or supply explicit coordinates instead.");
}
}
/**
* Verifies that the {@code <groupId>/<artifactId>} components of the matched
* {@code META-INF/maven/<groupId>/<artifactId>/pom.xml} entry path agree with the effective
* coordinates declared by the embedded POM itself.
*
* @param entryName the name of the matched JAR entry, must not be <code>null</code>
* @param model the model parsed from that entry, must not be <code>null</code>
* @throws MojoExecutionException if the entry path does not match the model
*/
private void validateEmbeddedPomEntryPath(String entryName, Model model) throws MojoExecutionException {
String[] segments = entryName.split("/");
// expected shape: META-INF/maven/<groupId>/<artifactId>/pom.xml
if (segments.length != 5) {
throw new MojoExecutionException("Unexpected embedded POM entry path '" + entryName + "' in "
+ file.getName() + ": expected META-INF/maven/<groupId>/<artifactId>/pom.xml."
+ " Use -DpomFile or supply explicit coordinates instead.");
}
String entryGroupId = segments[2];
String entryArtifactId = segments[3];
Parent parent = model.getParent();
String modelGroupId =
model.getGroupId() != null ? model.getGroupId() : (parent != null ? parent.getGroupId() : null);
String modelArtifactId = model.getArtifactId();
if (!entryGroupId.equals(modelGroupId) || !entryArtifactId.equals(modelArtifactId)) {
throw new MojoExecutionException("The POM embedded in " + file.getName() + " declares " + modelGroupId
+ ":" + modelArtifactId + " but is packaged under entry path '" + entryName + "' ("
+ entryGroupId + ":" + entryArtifactId + "). Refusing to adopt coordinates from inconsistent"
+ " embedded metadata: use -DpomFile or supply explicit"
+ " -DgroupId/-DartifactId/-Dversion/-Dpackaging.");
}
}
/**
* Cross-checks every operator-supplied coordinate (groupId, artifactId, version) against the
* effective values declared by the embedded POM and fails on any mismatch.
*
* @param entryName the name of the matched JAR entry, must not be <code>null</code>
* @param model the model parsed from that entry, must not be <code>null</code>
* @throws MojoExecutionException if an operator-supplied coordinate disagrees with the embedded POM
*/
private void crossCheckOperatorCoordinates(String entryName, Model model) throws MojoExecutionException {
Parent parent = model.getParent();
String modelGroupId =
model.getGroupId() != null ? model.getGroupId() : (parent != null ? parent.getGroupId() : null);
String modelArtifactId = model.getArtifactId();
String modelVersion =
model.getVersion() != null ? model.getVersion() : (parent != null ? parent.getVersion() : null);
List<String> mismatches = new ArrayList<>();
if (groupId != null && !groupId.equals(modelGroupId)) {
mismatches.add("groupId: supplied '" + groupId + "' but embedded POM declares '" + modelGroupId + "'");
}
if (artifactId != null && !artifactId.equals(modelArtifactId)) {
mismatches.add(
"artifactId: supplied '" + artifactId + "' but embedded POM declares '" + modelArtifactId + "'");
}
if (version != null && !version.equals(modelVersion)) {
mismatches.add("version: supplied '" + version + "' but embedded POM declares '" + modelVersion + "'");
}
if (!mismatches.isEmpty()) {
throw new MojoExecutionException("The POM embedded in " + file.getName() + " (" + entryName
+ ") does not match the supplied coordinates: " + String.join("; ", mismatches)
+ ". Refusing to install a mismatching embedded POM at operator-chosen coordinates:"
+ " use -DpomFile, supply all of -DgroupId/-DartifactId/-Dversion/-Dpackaging, or pass"
+ " -DgeneratePom=true.");
}
}
/**
* Returns {@code true} if the two files exist with different content, or cannot be compared
* (fail-closed for warning purposes). Uses byte-by-byte comparison since {@code Files.mismatch()}
* is not available on Java 8.
*/
private boolean contentDiffers(File existing, File candidate) {
try {
if (existing.length() != candidate.length()) {
return true;
}
byte[] existingBytes = Files.readAllBytes(existing.toPath());
byte[] candidateBytes = Files.readAllBytes(candidate.toPath());
for (int i = 0; i < existingBytes.length; i++) {
if (existingBytes[i] != candidateBytes[i]) {
return true;
}
}
return false;
} catch (IOException e) {
return true;
}
}
/**
* Defense in depth: verifies that the composed layout path stays inside the local repository.
*/
private void verifyContainment(RepositorySystemSession repoSession, File artifactLocalFile)
throws MojoExecutionException {
File repositoryRoot = repoSession.getLocalRepository().getBasedir().getAbsoluteFile();
File resolvedInstallPath = artifactLocalFile.getAbsoluteFile();
try {
String repoCanonical = repositoryRoot.getCanonicalPath();
String installCanonical = resolvedInstallPath.getCanonicalPath();
if (!installCanonical.startsWith(repoCanonical + File.separator)
&& !installCanonical.equals(repoCanonical)) {
throw new MojoExecutionException("The artifact coordinates " + groupId + ":" + artifactId + ":"
+ version + " resolve to a path outside the local repository: " + resolvedInstallPath
+ " is not under " + repositoryRoot);
}
} catch (IOException e) {
throw new MojoExecutionException("Failed to resolve canonical path for containment check", e);
}
}
/**
* Populates missing mojo parameters from the specified POM.
*
* @param model The POM to extract missing artifact coordinates from, must not be <code>null</code>.
*/
private void processModel(Model model) {
Parent parent = model.getParent();
if (this.groupId == null) {
this.groupId = model.getGroupId();
if (this.groupId == null && parent != null) {
this.groupId = parent.getGroupId();
}
}
if (this.artifactId == null) {
this.artifactId = model.getArtifactId();
}
if (this.version == null) {
this.version = model.getVersion();
if (this.version == null && parent != null) {
this.version = parent.getVersion();
}
}
if (this.packaging == null) {
this.packaging = model.getPackaging();
}
}
/**
* Generates a minimal model from the user-supplied artifact information.
*
* @return The generated model, never <code>null</code>.
*/
private Model generateModel() {
Model model = new Model();
model.setModelVersion("4.0.0");
model.setGroupId(groupId);
model.setArtifactId(artifactId);
model.setVersion(version);
model.setPackaging(packaging);
model.setDescription("POM was created from install:install-file");
return model;
}
/**
* Generates a (temporary) POM file from the plugin configuration. It's the responsibility of the caller to delete
* the generated file when no longer needed.
*
* @return The path to the generated POM file, never <code>null</code>.
* @throws MojoExecutionException If the POM file could not be generated.
*/
private File generatePomFile() throws MojoExecutionException {
Model model = generateModel();
try {
Path tempPomFile = Files.createTempFile("mvninstall", ".pom");
try (OutputStream writer = Files.newOutputStream(tempPomFile)) {
new MavenXpp3Writer().write(writer, model);
return tempPomFile.toFile();
}
} catch (IOException e) {
throw new MojoExecutionException("Error writing temporary POM file: " + e.getMessage(), e);
}
}
/**
* Gets the path of the specified artifact within the local repository. Note that the returned path need not exist
* (yet).
*/
private File getLocalRepositoryFile(RepositorySystemSession session, Artifact artifact) {
String path = session.getLocalRepositoryManager().getPathForLocalArtifact(artifact);
return new File(session.getLocalRepository().getBasedir(), path);
}
/**
* Gets the path of the specified artifact POM within the local repository. Note that the returned path need
* not exist (yet).
*/
private File getPomLocalRepositoryFile(RepositorySystemSession session, Artifact artifact) {
SubArtifact pomArtifact = new SubArtifact(artifact, "", "pom");
String path = session.getLocalRepositoryManager().getPathForLocalArtifact(pomArtifact);
return new File(session.getLocalRepository().getBasedir(), path);
}
// these below should be shared (duplicated in m-install-p, m-deploy-p)
/**
* Returns {@code true} if passed in string is "valid Maven ID" (artifactId or packaging): non-empty,
* not consisting solely of {@code '.'} characters (so it can never form a {@code .}/{@code ..} path
* segment in the local repository layout), and using only allowed characters.
*/
private boolean isValidId(String id) {
if (id == null || id.isEmpty()) {
return false;
}
boolean seenNonDot = false;
for (int i = 0; i < id.length(); i++) {
char c = id.charAt(i);
if (!(c >= 'a' && c <= 'z'
|| c >= 'A' && c <= 'Z'
|| c >= '0' && c <= '9'
|| c == '-'
|| c == '_'
|| c == '.')) {
return false;
}
if (c != '.') {
seenNonDot = true;
}
}
return seenNonDot;
}
/**
* Returns {@code true} if passed in string is a valid Maven groupId: a valid ID whose dot-separated
* segments are all non-empty. Leading, trailing or consecutive dots would produce empty path segments
* after the dots-to-directories transform of the local repository layout.
*/
private boolean isValidGroupId(String groupId) {
return isValidId(groupId) && !groupId.startsWith(".") && !groupId.endsWith(".") && !groupId.contains("..");
}
/**
* Returns {@code true} if passed in string is "valid Maven (simple. non range, expression, etc) version":
* non-empty, not consisting solely of {@code '.'} characters, and free of illegal characters.
*/
private boolean isValidVersion(String version) {
if (version == null || version.isEmpty()) {
return false;
}
boolean seenNonDot = false;
for (int i = version.length() - 1; i >= 0; i--) {
char c = version.charAt(i);
if (ILLEGAL_VERSION_CHARS.indexOf(c) >= 0) {
return false;
}
if (c != '.') {
seenNonDot = true;
}
}
return seenNonDot;
}
}