Support http.<url>.* configs

Git has a rather elaborate mechanism to specify HTTP configuration
options per URL, based on pattern matching the URL against "http"
subsection names.[1] The URLs used for this matching are always the
original URLs; redirected URLs do not participate.

* Scheme and host must match exactly case-insensitively.
* An optional user name must match exactly.
* Ports must match exactly after default ports have been filled in.
* The path of a subsection, if any, must match a segment prefix of
  the path of the URL.
* Matches with user name take precedence over equal-length path
  matches without, but longer path matches are preferred over
  shorter matches with user name.

Implement this for JGit. Factor out the HttpConfig from TransportHttp
and implement the matching and override mechanism.

The set of supported settings is still the same; JGit currently
supports only followRedirects, postBuffer, and sslVerify, plus the
JGit-specific maxRedirects key.

Add tests for path normalization and prefix matching only on segment
separators, and use the new mechanism in SmartClientSmartServerSslTest
to disable sslVerify selectively for only the test server URLs.

Compare also bug 374703 and bug 465492. With this commit it would be
possible to set sslVerify to false for only the git server using a
self-signed certificate instead of having to switch it off globally
via http.sslVerify.

[1] https://git-scm.com/docs/git-config

Change-Id: I42a3c2399cb937cd7884116a2a32fcaa7a418fcb
Signed-off-by: Thomas Wolf <thomas.wolf@paranor.ch>

2 files changed, 432 insertions, 0 deletions

diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/HttpConfigTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/HttpConfigTest.java
new file mode 100644
index 0000000000..c6b016a4cc
--- /dev/null
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/HttpConfigTest.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2017, Thomas Wolf <thomas.wolf@paranor.ch>
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.transport;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.eclipse.jgit.lib.Config;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Tests for correctly resolving URIs when reading http.* values from a
+ * {@link Config}.
+ */
+public class HttpConfigTest {
+
+	private static final String DEFAULT = "[http]\n" + "\tpostBuffer = 1\n"
+			+ "\tsslVerify= true\n" + "\tfollowRedirects = true\n"
+			+ "\tmaxRedirects = 5\n\n";
+
+	private Config config;
+
+	@Before
+	public void setUp() {
+		config = new Config();
+	}
+
+	@Test
+	public void testDefault() throws Exception {
+		HttpConfig http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo.git"));
+		assertEquals(1024 * 1024, http.getPostBuffer());
+		assertTrue(http.isSslVerify());
+		assertEquals(HttpConfig.HttpRedirectMode.INITIAL,
+				http.getFollowRedirects());
+	}
+
+	@Test
+	public void testMatchSuccess() throws Exception {
+		config.fromText(DEFAULT + "[http \"http://example.com\"]\n"
+				+ "\tpostBuffer = 1024\n");
+		HttpConfig http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo.git"));
+		assertEquals(1024, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("https://example.com/path/repo.git"));
+		assertEquals(1, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://example.org/path/repo.git"));
+		assertEquals(1, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://example.com:80/path/repo.git"));
+		assertEquals(1024, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://example.com:8080/path/repo.git"));
+		assertEquals(1, http.getPostBuffer());
+	}
+
+	@Test
+	public void testMatchWithOnlySchemeInConfig() throws Exception {
+		config.fromText(
+				DEFAULT + "[http \"http://\"]\n" + "\tpostBuffer = 1024\n");
+		HttpConfig http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo.git"));
+		assertEquals(1, http.getPostBuffer());
+	}
+
+	@Test
+	public void testMatchWithPrefixUriInConfig() throws Exception {
+		config.fromText(DEFAULT + "[http \"http://example\"]\n"
+				+ "\tpostBuffer = 1024\n");
+		HttpConfig http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo.git"));
+		assertEquals(1, http.getPostBuffer());
+	}
+
+	@Test
+	public void testMatchCaseSensitivity() throws Exception {
+		config.fromText(DEFAULT + "[http \"http://exAMPle.com\"]\n"
+				+ "\tpostBuffer = 1024\n");
+		HttpConfig http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo.git"));
+		assertEquals(1024, http.getPostBuffer());
+	}
+
+	@Test
+	public void testMatchWithInvalidUriInConfig() throws Exception {
+		config.fromText(
+				DEFAULT + "[http \"///\"]\n" + "\tpostBuffer = 1024\n");
+		HttpConfig http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo.git"));
+		assertEquals(1, http.getPostBuffer());
+	}
+
+	@Test
+	public void testMatchWithInvalidAndValidUriInConfig() throws Exception {
+		config.fromText(DEFAULT + "[http \"///\"]\n" + "\tpostBuffer = 1024\n"
+				+ "[http \"http://example.com\"]\n" + "\tpostBuffer = 2048\n");
+		HttpConfig http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo.git"));
+		assertEquals(2048, http.getPostBuffer());
+	}
+
+	@Test
+	public void testMatchWithHostEndingInSlash() throws Exception {
+		config.fromText(DEFAULT + "[http \"http://example.com/\"]\n"
+				+ "\tpostBuffer = 1024\n");
+		HttpConfig http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo.git"));
+		assertEquals(1024, http.getPostBuffer());
+	}
+
+	@Test
+	public void testMatchWithUser() throws Exception {
+		config.fromText(DEFAULT + "[http \"http://example.com/path\"]\n"
+				+ "\tpostBuffer = 1024\n"
+				+ "[http \"http://example.com/path/repo\"]\n"
+				+ "\tpostBuffer = 2048\n"
+				+ "[http \"http://user@example.com/path\"]\n"
+				+ "\tpostBuffer = 4096\n");
+		HttpConfig http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo.git"));
+		assertEquals(1024, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://user@example.com/path/repo.git"));
+		assertEquals(4096, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://user@example.com/path/repo/foo.git"));
+		assertEquals(2048, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://user@example.com/path/foo.git"));
+		assertEquals(4096, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://example.com/path/foo.git"));
+		assertEquals(1024, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://User@example.com/path/repo/foo.git"));
+		assertEquals(2048, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://User@example.com/path/foo.git"));
+		assertEquals(1024, http.getPostBuffer());
+	}
+
+	@Test
+	public void testMatchLonger() throws Exception {
+		config.fromText(DEFAULT + "[http \"http://example.com/path\"]\n"
+				+ "\tpostBuffer = 1024\n"
+				+ "[http \"http://example.com/path/repo\"]\n"
+				+ "\tpostBuffer = 2048\n");
+		HttpConfig http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo.git"));
+		assertEquals(1024, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://example.com/foo/repo.git"));
+		assertEquals(1, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("https://example.com/path/repo.git"));
+		assertEquals(1, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://example.com/path/repo/.git"));
+		assertEquals(2048, http.getPostBuffer());
+		http = new HttpConfig(config, new URIish("http://example.com/path"));
+		assertEquals(1024, http.getPostBuffer());
+		http = new HttpConfig(config,
+				new URIish("http://user@example.com/path"));
+		assertEquals(1024, http.getPostBuffer());
+	}
+}
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/HttpConfigUriPathTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/HttpConfigUriPathTest.java
new file mode 100644
index 0000000000..94de2f211a
--- /dev/null
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/HttpConfigUriPathTest.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2017, Thomas Wolf <thomas.wolf@paranor.ch>
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.transport;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.junit.Test;
+
+/**
+ * Basic URI path prefix match tests for {@link HttpConfig}.
+ */
+public class HttpConfigUriPathTest {
+
+	@Test
+	public void testNormalizationEmptyPaths() {
+		assertEquals("/", HttpConfig.normalize(""));
+		assertEquals("/", HttpConfig.normalize("/"));
+	}
+
+	@Test
+	public void testNormalization() {
+		assertEquals("/f", HttpConfig.normalize("f"));
+		assertEquals("/f", HttpConfig.normalize("/f"));
+		assertEquals("/f/", HttpConfig.normalize("/f/"));
+		assertEquals("/foo", HttpConfig.normalize("foo"));
+		assertEquals("/foo", HttpConfig.normalize("/foo"));
+		assertEquals("/foo/", HttpConfig.normalize("/foo/"));
+		assertEquals("/foo/bar", HttpConfig.normalize("foo/bar"));
+		assertEquals("/foo/bar", HttpConfig.normalize("/foo/bar"));
+		assertEquals("/foo/bar/", HttpConfig.normalize("/foo/bar/"));
+	}
+
+	@Test
+	public void testNormalizationWithDot() {
+		assertEquals("/", HttpConfig.normalize("."));
+		assertEquals("/", HttpConfig.normalize("/."));
+		assertEquals("/", HttpConfig.normalize("/./"));
+		assertEquals("/foo", HttpConfig.normalize("foo/."));
+		assertEquals("/foo/bar", HttpConfig.normalize("/foo/./bar"));
+		assertEquals("/foo/bar", HttpConfig.normalize("/foo/bar/."));
+		assertEquals("/foo/bar/", HttpConfig.normalize("/foo/bar/./"));
+		assertEquals("/foo/bar", HttpConfig.normalize("/foo/./././bar"));
+		assertEquals("/foo/bar/", HttpConfig.normalize("/foo/./././bar/"));
+		assertEquals("/foo/bar", HttpConfig.normalize("/foo/bar/././."));
+		assertEquals("/foo/bar/", HttpConfig.normalize("/foo/bar/./././"));
+		assertEquals("/foo/bar/.baz/bam",
+				HttpConfig.normalize("/foo/bar/.baz/bam"));
+		assertEquals("/foo/bar/.baz/bam/",
+				HttpConfig.normalize("/foo/bar/.baz/bam/"));
+	}
+
+	@Test
+	public void testNormalizationWithDotDot() {
+		assertEquals("/", HttpConfig.normalize("foo/.."));
+		assertEquals("/", HttpConfig.normalize("/foo/.."));
+		assertEquals("/", HttpConfig.normalize("/foo/../bar/.."));
+		assertEquals("/", HttpConfig.normalize("/foo/.././bar/.."));
+		assertEquals("/bar", HttpConfig.normalize("foo/../bar"));
+		assertEquals("/bar", HttpConfig.normalize("/foo/../bar"));
+		assertEquals("/bar", HttpConfig.normalize("/foo/./.././bar"));
+		assertEquals("/bar/", HttpConfig.normalize("/foo/../bar/"));
+		assertEquals("/bar/", HttpConfig.normalize("/foo/./.././bar/"));
+		assertEquals("/foo/bar", HttpConfig.normalize("/foo/bar/baz/.."));
+		assertEquals("/foo/bar/", HttpConfig.normalize("/foo/bar/baz/../"));
+		assertEquals("/foo", HttpConfig.normalize("/foo/bar/baz/../.."));
+		assertEquals("/foo", HttpConfig.normalize("/foo/bar/baz/../.."));
+		assertEquals("/foo", HttpConfig.normalize("/foo/bar/baz/.././.."));
+		assertEquals("/foo", HttpConfig.normalize("/foo/bar/baz/../././.."));
+		assertEquals("/foo/baz", HttpConfig.normalize("/foo/bar/../baz"));
+		assertEquals("/foo/baz/", HttpConfig.normalize("/foo/bar/../baz/"));
+		assertEquals("/foo/baz", HttpConfig.normalize("/foo/bar/../baz/."));
+		assertEquals("/foo/baz/", HttpConfig.normalize("/foo/bar/../baz/./"));
+		assertEquals("/foo", HttpConfig.normalize("/foo/bar/../baz/.."));
+		assertEquals("/foo/", HttpConfig.normalize("/foo/bar/../baz/../"));
+		assertEquals("/baz", HttpConfig.normalize("/foo/bar/../../baz"));
+		assertEquals("/baz/", HttpConfig.normalize("/foo/bar/../../baz/"));
+		assertEquals("/foo/.b/bar", HttpConfig.normalize("/foo/.b/bar"));
+		assertEquals("/.f/foo/.b/bar/", HttpConfig.normalize(".f/foo/.b/bar/"));
+		assertEquals("/foo/bar/..baz/bam",
+				HttpConfig.normalize("/foo/bar/..baz/bam"));
+		assertEquals("/foo/bar/..baz/bam/",
+				HttpConfig.normalize("/foo/bar/..baz/bam/"));
+		assertEquals("/foo/bar/.../baz/bam",
+				HttpConfig.normalize("/foo/bar/.../baz/bam"));
+		assertEquals("/foo/bar/.../baz/bam/",
+				HttpConfig.normalize("/foo/bar/.../baz/bam/"));
+	}
+
+	@Test
+	public void testNormalizationWithDoubleSlash() {
+		assertEquals("/", HttpConfig.normalize("//"));
+		assertEquals("/foo/", HttpConfig.normalize("///foo//"));
+		assertEquals("/foo", HttpConfig.normalize("///foo//."));
+		assertEquals("/foo/", HttpConfig.normalize("///foo//.////"));
+		assertEquals("/foo/bar", HttpConfig.normalize("/foo//bar"));
+		assertEquals("/foo/bar", HttpConfig.normalize("/foo//bar//."));
+		assertEquals("/foo/bar/", HttpConfig.normalize("/foo//bar//./"));
+	}
+
+	@Test
+	public void testNormalizationWithDotDotFailing() {
+		assertNull(HttpConfig.normalize(".."));
+		assertNull(HttpConfig.normalize("/.."));
+		assertNull(HttpConfig.normalize("/../"));
+		assertNull(HttpConfig.normalize("/../foo"));
+		assertNull(HttpConfig.normalize("./../foo"));
+		assertNull(HttpConfig.normalize("/./../foo"));
+		assertNull(HttpConfig.normalize("/foo/./.././.."));
+		assertNull(HttpConfig.normalize("/foo/../bar/../.."));
+		assertNull(HttpConfig.normalize("/foo/../bar/../../baz"));
+	}
+
+	@Test
+	public void testSegmentCompare() {
+		// 2nd parameter is the match, will be normalized
+		assertSuccess("/foo", "");
+		assertSuccess("/foo", "/");
+		assertSuccess("/foo", "//");
+		assertSuccess("/foo", "foo");
+		assertSuccess("/foo", "/foo");
+		assertSuccess("/foo/", "foo");
+		assertSuccess("/foo/", "/foo");
+		assertSuccess("/foo/", "foo/");
+		assertSuccess("/foo/", "/foo/");
+		assertSuccess("/foo/bar", "foo");
+		assertSuccess("/foo/bar", "foo/");
+		assertSuccess("/foo/bar", "foo/bar");
+		assertSuccess("/foo/bar/", "foo/bar");
+		assertSuccess("/foo/bar/", "foo/bar/");
+		assertSuccess("/foo/bar", "/foo/bar");
+		assertSuccess("/foo/bar/", "/foo/bar");
+		assertSuccess("/foo/bar/", "/foo/bar/");
+		assertSuccess("/foo/bar", "/foo/bar/..");
+		assertSuccess("/foo/bar/", "/foo/bar/..");
+		assertSuccess("/foo/bar/", "/foo/bar/../");
+		assertSuccess("/foo/bar", "/foo/./bar");
+		assertSuccess("/foo/bar/", "/foo/./bar/");
+		assertSuccess("/some/repo/.git", "/some/repo");
+		assertSuccess("/some/repo/bare.git", "/some/repo");
+		assertSuccess("/some/repo/.git", "/some/repo/.git");
+		assertSuccess("/some/repo/bare.git", "/some/repo/bare.git");
+	}
+
+	@Test
+	public void testSegmentCompareFailing() {
+		// 2nd parameter is the match, will be normalized
+		assertEquals(-1, HttpConfig.segmentCompare("/foo", "foo/"));
+		assertEquals(-1, HttpConfig.segmentCompare("/foo", "/foo/"));
+		assertEquals(-1, HttpConfig.segmentCompare("/foobar", "foo"));
+		assertEquals(-1, HttpConfig.segmentCompare("/foobar", "/foo"));
+		assertEquals(-1,
+				HttpConfig.segmentCompare("/foo/barbar/baz", "foo/bar"));
+		assertEquals(-1, HttpConfig.segmentCompare("/foo/barbar", "/foo/bar"));
+		assertEquals(-1,
+				HttpConfig.segmentCompare("/some/repo.git", "/some/repo"));
+		assertEquals(-1,
+				HttpConfig.segmentCompare("/some/repo.git", "/some/repo.g"));
+		assertEquals(-1, HttpConfig.segmentCompare("/some/repo/bare.git",
+				"/some/repo/bar"));
+		assertSuccess("/some/repo/bare.git", "/some/repo");
+		// Just to make sure we don't use the PathMatchers...
+		assertEquals(-1, HttpConfig.segmentCompare("/foo/barbar/baz", "**"));
+		assertEquals(-1,
+				HttpConfig.segmentCompare("/foo/barbar/baz", "**/foo"));
+		assertEquals(-1,
+				HttpConfig.segmentCompare("/foo/barbar/baz", "/*/barbar/**"));
+		assertEquals(-1, HttpConfig.segmentCompare("/foo", "/*"));
+		assertEquals(-1, HttpConfig.segmentCompare("/foo", "/???"));
+		assertEquals(-1, HttpConfig.segmentCompare("/foo/bar/baz", "bar"));
+		// Failing to normalize
+		assertEquals(-1,
+				HttpConfig.segmentCompare("/foo/bar/baz", "bar/../.."));
+	}
+
+	private void assertSuccess(String uri, String match) {
+		String normalized = HttpConfig.normalize(match);
+		assertEquals(normalized.length(),
+				HttpConfig.segmentCompare(uri, match));
+	}
+}