HttpConfig.java
/*
* Copyright (C) 2008, 2010, Google Inc.
* Copyright (C) 2017, Thomas Wolf <thomas.wolf@paranor.ch> and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.transport;
import java.io.IOException;
import java.net.URISyntaxException;
import java.text.MessageFormat;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.function.Supplier;
import org.eclipse.jgit.annotations.NonNull;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.lib.StoredConfig;
import org.eclipse.jgit.util.StringUtils;
import org.eclipse.jgit.util.SystemReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A representation of the "http.*" config values in a git
* {@link org.eclipse.jgit.lib.Config}. git provides for setting values for
* specific URLs through "http.<url>.*" subsections. git always considers
* only the initial original URL for such settings, not any redirected URL.
*
* @since 4.9
*/
public class HttpConfig {
private static final Logger LOG = LoggerFactory.getLogger(HttpConfig.class);
private static final String FTP = "ftp"; //$NON-NLS-1$
/** git config section key for http settings. */
public static final String HTTP = "http"; //$NON-NLS-1$
/** git config key for the "followRedirects" setting. */
public static final String FOLLOW_REDIRECTS_KEY = "followRedirects"; //$NON-NLS-1$
/** git config key for the "maxRedirects" setting. */
public static final String MAX_REDIRECTS_KEY = "maxRedirects"; //$NON-NLS-1$
/** git config key for the "postBuffer" setting. */
public static final String POST_BUFFER_KEY = "postBuffer"; //$NON-NLS-1$
/** git config key for the "sslVerify" setting. */
public static final String SSL_VERIFY_KEY = "sslVerify"; //$NON-NLS-1$
/**
* git config key for the "userAgent" setting.
*
* @since 5.10
*/
public static final String USER_AGENT = "userAgent"; //$NON-NLS-1$
/**
* git config key for the "extraHeader" setting.
*
* @since 5.10
*/
public static final String EXTRA_HEADER = "extraHeader"; //$NON-NLS-1$
/**
* git config key for the "cookieFile" setting.
*
* @since 5.4
*/
public static final String COOKIE_FILE_KEY = "cookieFile"; //$NON-NLS-1$
/**
* git config key for the "saveCookies" setting.
*
* @since 5.4
*/
public static final String SAVE_COOKIES_KEY = "saveCookies"; //$NON-NLS-1$
/**
* Custom JGit config key which holds the maximum number of cookie files to
* keep in the cache.
*
* @since 5.4
*/
public static final String COOKIE_FILE_CACHE_LIMIT_KEY = "cookieFileCacheLimit"; //$NON-NLS-1$
private static final int DEFAULT_COOKIE_FILE_CACHE_LIMIT = 10;
private static final String MAX_REDIRECT_SYSTEM_PROPERTY = "http.maxRedirects"; //$NON-NLS-1$
private static final int DEFAULT_MAX_REDIRECTS = 5;
private static final int MAX_REDIRECTS = (new Supplier<Integer>() {
@Override
public Integer get() {
String rawValue = SystemReader.getInstance()
.getProperty(MAX_REDIRECT_SYSTEM_PROPERTY);
Integer value = Integer.valueOf(DEFAULT_MAX_REDIRECTS);
if (rawValue != null) {
try {
value = Integer.valueOf(Integer.parseUnsignedInt(rawValue));
} catch (NumberFormatException e) {
LOG.warn(MessageFormat.format(
JGitText.get().invalidSystemProperty,
MAX_REDIRECT_SYSTEM_PROPERTY, rawValue, value));
}
}
return value;
}
}).get().intValue();
private static final String ENV_HTTP_USER_AGENT = "GIT_HTTP_USER_AGENT"; //$NON-NLS-1$
/**
* Config values for http.followRedirect.
*/
public enum HttpRedirectMode implements Config.ConfigEnum {
/** Always follow redirects (up to the http.maxRedirects limit). */
TRUE("true"), //$NON-NLS-1$
/**
* Only follow redirects on the initial GET request. This is the
* default.
*/
INITIAL("initial"), //$NON-NLS-1$
/** Never follow redirects. */
FALSE("false"); //$NON-NLS-1$
private final String configValue;
private HttpRedirectMode(String configValue) {
this.configValue = configValue;
}
@Override
public String toConfigValue() {
return configValue;
}
@Override
public boolean matchConfigValue(String s) {
return configValue.equals(s);
}
}
private int postBuffer;
private boolean sslVerify;
private HttpRedirectMode followRedirects;
private int maxRedirects;
private String userAgent;
private List<String> extraHeaders;
private String cookieFile;
private boolean saveCookies;
private int cookieFileCacheLimit;
/**
* Get the "http.postBuffer" setting
*
* @return the value of the "http.postBuffer" setting
*/
public int getPostBuffer() {
return postBuffer;
}
/**
* Get the "http.sslVerify" setting
*
* @return the value of the "http.sslVerify" setting
*/
public boolean isSslVerify() {
return sslVerify;
}
/**
* Get the "http.followRedirects" setting
*
* @return the value of the "http.followRedirects" setting
*/
public HttpRedirectMode getFollowRedirects() {
return followRedirects;
}
/**
* Get the "http.maxRedirects" setting
*
* @return the value of the "http.maxRedirects" setting
*/
public int getMaxRedirects() {
return maxRedirects;
}
/**
* Get the "http.userAgent" setting
*
* @return the value of the "http.userAgent" setting
* @since 5.10
*/
public String getUserAgent() {
return userAgent;
}
/**
* Get the "http.extraHeader" setting
*
* @return the value of the "http.extraHeader" setting
* @since 5.10
*/
@NonNull
public List<String> getExtraHeaders() {
return extraHeaders == null ? Collections.emptyList() : extraHeaders;
}
/**
* Get the "http.cookieFile" setting
*
* @return the value of the "http.cookieFile" setting
*
* @since 5.4
*/
public String getCookieFile() {
return cookieFile;
}
/**
* Get the "http.saveCookies" setting
*
* @return the value of the "http.saveCookies" setting
*
* @since 5.4
*/
public boolean getSaveCookies() {
return saveCookies;
}
/**
* Get the "http.cookieFileCacheLimit" setting (gives the maximum number of
* cookie files to keep in the LRU cache)
*
* @return the value of the "http.cookieFileCacheLimit" setting
*
* @since 5.4
*/
public int getCookieFileCacheLimit() {
return cookieFileCacheLimit;
}
/**
* Creates a new {@link org.eclipse.jgit.transport.HttpConfig} tailored to
* the given {@link org.eclipse.jgit.transport.URIish}.
*
* @param config
* to read the {@link org.eclipse.jgit.transport.HttpConfig} from
* @param uri
* to get the configuration values for
*/
public HttpConfig(Config config, URIish uri) {
init(config, uri);
}
/**
* Creates a {@link org.eclipse.jgit.transport.HttpConfig} that reads values
* solely from the user config.
*
* @param uri
* to get the configuration values for
*/
public HttpConfig(URIish uri) {
StoredConfig userConfig = null;
try {
userConfig = SystemReader.getInstance().getUserConfig();
} catch (IOException | ConfigInvalidException e) {
// Log it and then work with default values.
LOG.error(e.getMessage(), e);
init(new Config(), uri);
return;
}
init(userConfig, uri);
}
private void init(Config config, URIish uri) {
// Set defaults from the section first
int postBufferSize = config.getInt(HTTP, POST_BUFFER_KEY,
1 * 1024 * 1024);
boolean sslVerifyFlag = config.getBoolean(HTTP, SSL_VERIFY_KEY, true);
HttpRedirectMode followRedirectsMode = config.getEnum(
HttpRedirectMode.values(), HTTP, null,
FOLLOW_REDIRECTS_KEY, HttpRedirectMode.INITIAL);
int redirectLimit = config.getInt(HTTP, MAX_REDIRECTS_KEY,
MAX_REDIRECTS);
if (redirectLimit < 0) {
redirectLimit = MAX_REDIRECTS;
}
String agent = config.getString(HTTP, null, USER_AGENT);
if (agent != null) {
agent = UserAgent.clean(agent);
}
userAgent = agent;
String[] headers = config.getStringList(HTTP, null, EXTRA_HEADER);
// https://git-scm.com/docs/git-config#Documentation/git-config.txt-httpextraHeader
// "an empty value will reset the extra headers to the empty list."
int start = findLastEmpty(headers) + 1;
if (start > 0) {
headers = Arrays.copyOfRange(headers, start, headers.length);
}
extraHeaders = Arrays.asList(headers);
cookieFile = config.getString(HTTP, null, COOKIE_FILE_KEY);
saveCookies = config.getBoolean(HTTP, SAVE_COOKIES_KEY, false);
cookieFileCacheLimit = config.getInt(HTTP, COOKIE_FILE_CACHE_LIMIT_KEY,
DEFAULT_COOKIE_FILE_CACHE_LIMIT);
String match = findMatch(config.getSubsections(HTTP), uri);
if (match != null) {
// Override with more specific items
postBufferSize = config.getInt(HTTP, match, POST_BUFFER_KEY,
postBufferSize);
sslVerifyFlag = config.getBoolean(HTTP, match, SSL_VERIFY_KEY,
sslVerifyFlag);
followRedirectsMode = config.getEnum(HttpRedirectMode.values(),
HTTP, match, FOLLOW_REDIRECTS_KEY, followRedirectsMode);
int newMaxRedirects = config.getInt(HTTP, match, MAX_REDIRECTS_KEY,
redirectLimit);
if (newMaxRedirects >= 0) {
redirectLimit = newMaxRedirects;
}
String uriSpecificUserAgent = config.getString(HTTP, match,
USER_AGENT);
if (uriSpecificUserAgent != null) {
userAgent = UserAgent.clean(uriSpecificUserAgent);
}
String[] uriSpecificExtraHeaders = config.getStringList(HTTP, match,
EXTRA_HEADER);
if (uriSpecificExtraHeaders.length > 0) {
start = findLastEmpty(uriSpecificExtraHeaders) + 1;
if (start > 0) {
uriSpecificExtraHeaders = Arrays.copyOfRange(
uriSpecificExtraHeaders, start,
uriSpecificExtraHeaders.length);
}
extraHeaders = Arrays.asList(uriSpecificExtraHeaders);
}
String urlSpecificCookieFile = config.getString(HTTP, match,
COOKIE_FILE_KEY);
if (urlSpecificCookieFile != null) {
cookieFile = urlSpecificCookieFile;
}
saveCookies = config.getBoolean(HTTP, match, SAVE_COOKIES_KEY,
saveCookies);
}
// Environment overrides config
agent = SystemReader.getInstance().getenv(ENV_HTTP_USER_AGENT);
if (!StringUtils.isEmptyOrNull(agent)) {
userAgent = UserAgent.clean(agent);
}
postBuffer = postBufferSize;
sslVerify = sslVerifyFlag;
followRedirects = followRedirectsMode;
maxRedirects = redirectLimit;
}
private int findLastEmpty(String[] values) {
for (int i = values.length - 1; i >= 0; i--) {
if (values[i] == null) {
return i;
}
}
return -1;
}
/**
* Determines the best match from a set of subsection names (representing
* prefix URLs) for the given {@link URIish}.
*
* @param names
* to match against the {@code uri}
* @param uri
* to find a match for
* @return the best matching subsection name, or {@code null} if no
* subsection matches
*/
private String findMatch(Set<String> names, URIish uri) {
String bestMatch = null;
int bestMatchLength = -1;
boolean withUser = false;
String uPath = uri.getPath();
boolean hasPath = !StringUtils.isEmptyOrNull(uPath);
if (hasPath) {
uPath = normalize(uPath);
if (uPath == null) {
// Normalization failed; warning was logged.
return null;
}
}
for (String s : names) {
try {
URIish candidate = new URIish(s);
// Scheme and host must match case-insensitively
if (!compare(uri.getScheme(), candidate.getScheme())
|| !compare(uri.getHost(), candidate.getHost())) {
continue;
}
// Ports must match after default ports have been substituted
if (defaultedPort(uri.getPort(),
uri.getScheme()) != defaultedPort(candidate.getPort(),
candidate.getScheme())) {
continue;
}
// User: if present in candidate, must match
boolean hasUser = false;
if (candidate.getUser() != null) {
if (!candidate.getUser().equals(uri.getUser())) {
continue;
}
hasUser = true;
}
// Path: prefix match, longer is better
String cPath = candidate.getPath();
int matchLength = -1;
if (StringUtils.isEmptyOrNull(cPath)) {
matchLength = 0;
} else {
if (!hasPath) {
continue;
}
// Paths can match only on segments
matchLength = segmentCompare(uPath, cPath);
if (matchLength < 0) {
continue;
}
}
// A longer path match is always preferred even over a user
// match. If the path matches are equal, a match with user wins
// over a match without user.
if (matchLength > bestMatchLength
|| (!withUser && hasUser && matchLength >= 0
&& matchLength == bestMatchLength)) {
bestMatch = s;
bestMatchLength = matchLength;
withUser = hasUser;
}
} catch (URISyntaxException e) {
LOG.warn(MessageFormat
.format(JGitText.get().httpConfigInvalidURL, s));
}
}
return bestMatch;
}
private boolean compare(String a, String b) {
if (a == null) {
return b == null;
}
return a.equalsIgnoreCase(b);
}
private int defaultedPort(int port, String scheme) {
if (port >= 0) {
return port;
}
if (FTP.equalsIgnoreCase(scheme)) {
return 21;
} else if (HTTP.equalsIgnoreCase(scheme)) {
return 80;
} else {
return 443; // https
}
}
static int segmentCompare(String uriPath, String m) {
// Precondition: !uriPath.isEmpty() && !m.isEmpty(),and u must already
// be normalized
String matchPath = normalize(m);
if (matchPath == null || !uriPath.startsWith(matchPath)) {
return -1;
}
// We can match only on a segment boundary: either both paths are equal,
// or if matchPath does not end in '/', there is a '/' in uriPath right
// after the match.
int uLength = uriPath.length();
int mLength = matchPath.length();
if (mLength == uLength || matchPath.charAt(mLength - 1) == '/'
|| (mLength < uLength && uriPath.charAt(mLength) == '/')) {
return mLength;
}
return -1;
}
static String normalize(String path) {
// C-git resolves . and .. segments
int i = 0;
int length = path.length();
StringBuilder builder = new StringBuilder(length);
builder.append('/');
if (length > 0 && path.charAt(0) == '/') {
i = 1;
}
while (i < length) {
int slash = path.indexOf('/', i);
if (slash < 0) {
slash = length;
}
if (slash == i || (slash == i + 1 && path.charAt(i) == '.')) {
// Skip /. or also double slashes
} else if (slash == i + 2 && path.charAt(i) == '.'
&& path.charAt(i + 1) == '.') {
// Remove previous segment if we have "/.."
int l = builder.length() - 2; // Skip terminating slash.
while (l >= 0 && builder.charAt(l) != '/') {
l--;
}
if (l < 0) {
LOG.warn(MessageFormat.format(
JGitText.get().httpConfigCannotNormalizeURL, path));
return null;
}
builder.setLength(l + 1);
} else {
// Include the slash, if any
builder.append(path, i, Math.min(length, slash + 1));
}
i = slash + 1;
}
if (builder.length() > 1 && builder.charAt(builder.length() - 1) == '/'
&& length > 0 && path.charAt(length - 1) != '/') {
// . or .. normalization left a trailing slash when the original
// path had none at the end
builder.setLength(builder.length() - 1);
}
return builder.toString();
}
}