This is an automated email from the ASF dual-hosted git repository.
markt pushed a commit to branch 7.0.x
in repository https://gitbox.apache.org/repos/asf/tomcat.git
commit 47c9f3813795f881f1d9b93ec3c1a259641f1a06
Author: Mark Thomas <ma...@apache.org>
AuthorDate: Wed Jan 15 19:40:52 2020 +0000
Use setProperty and test return value in preference to setAttribute
---
.../apache/catalina/core/ApplicationContext.java | 2 +-
.../connector/TestCoyoteAdapterRequestFuzzing.java | 2 +-
.../apache/catalina/core/TestAsyncContextImpl.java | 3 +-
.../catalina/core/TestSwallowAbortedUploads.java | 2 +-
.../apache/catalina/mbeans/TestRegistration.java | 2 +-
.../apache/catalina/startup/TomcatBaseTest.java | 7 +-
.../coyote/http11/TestAbstractHttp11Processor.java | 650 +++++++++++++++++++++
.../apache/tomcat/util/http/TestMimeHeaders.java | 3 +-
test/org/apache/tomcat/util/net/TestCustomSsl.java | 7 +-
test/org/apache/tomcat/util/net/TesterSupport.java | 22 +-
10 files changed, 673 insertions(+), 27 deletions(-)
diff --git a/java/org/apache/catalina/core/ApplicationContext.java
b/java/org/apache/catalina/core/ApplicationContext.java
index 833c06e..dfd02a9 100644
--- a/java/org/apache/catalina/core/ApplicationContext.java
+++ b/java/org/apache/catalina/core/ApplicationContext.java
@@ -1043,7 +1043,7 @@ public class ApplicationContext implements ServletContext
{
Connector[] connectors = service.findConnectors();
// Need at least one SSL enabled connector to use the SSL session ID.
for (Connector connector : connectors) {
- if (Boolean.TRUE.equals(connector.getAttribute("SSLEnabled"))) {
+ if (Boolean.TRUE.equals(connector.getProperty("SSLEnabled"))) {
supportedSessionTrackingModes.add(SessionTrackingMode.SSL);
break;
}
diff --git
a/test/org/apache/catalina/connector/TestCoyoteAdapterRequestFuzzing.java
b/test/org/apache/catalina/connector/TestCoyoteAdapterRequestFuzzing.java
index b998ba1..6c89fd3 100644
--- a/test/org/apache/catalina/connector/TestCoyoteAdapterRequestFuzzing.java
+++ b/test/org/apache/catalina/connector/TestCoyoteAdapterRequestFuzzing.java
@@ -110,7 +110,7 @@ public class TestCoyoteAdapterRequestFuzzing extends
TomcatBaseTest {
@Test
public void doTest() throws Exception {
Tomcat tomcat = getTomcatInstance();
- tomcat.getConnector().setAttribute("restrictedUserAgents",
"value-not-important");
+
Assert.assertTrue(tomcat.getConnector().setProperty("restrictedUserAgents",
"value-not-important"));
File appDir = new File("test/webapp");
Context ctxt = tomcat.addContext("", appDir.getAbsolutePath());
diff --git a/test/org/apache/catalina/core/TestAsyncContextImpl.java
b/test/org/apache/catalina/core/TestAsyncContextImpl.java
index 7aff34b..54a9e8b 100644
--- a/test/org/apache/catalina/core/TestAsyncContextImpl.java
+++ b/test/org/apache/catalina/core/TestAsyncContextImpl.java
@@ -165,8 +165,7 @@ public class TestAsyncContextImpl extends TomcatBaseTest {
Tomcat tomcat = getTomcatInstance();
// Minimise pauses during test
- tomcat.getConnector().setAttribute(
- "connectionTimeout", Integer.valueOf(3000));
+
Assert.assertTrue(tomcat.getConnector().setProperty("connectionTimeout",
"3000"));
// No file system docBase required
Context ctx = tomcat.addContext("", null);
diff --git a/test/org/apache/catalina/core/TestSwallowAbortedUploads.java
b/test/org/apache/catalina/core/TestSwallowAbortedUploads.java
index b8f71ed..450d9fc 100644
--- a/test/org/apache/catalina/core/TestSwallowAbortedUploads.java
+++ b/test/org/apache/catalina/core/TestSwallowAbortedUploads.java
@@ -430,7 +430,7 @@ public class TestSwallowAbortedUploads extends
TomcatBaseTest {
// No need for target to exist.
if (!limit) {
- tomcat.getConnector().setAttribute("maxSwallowSize", "-1");
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxSwallowSize", "-1"));
}
tomcat.start();
diff --git a/test/org/apache/catalina/mbeans/TestRegistration.java
b/test/org/apache/catalina/mbeans/TestRegistration.java
index 892ff8d..bc14553 100644
--- a/test/org/apache/catalina/mbeans/TestRegistration.java
+++ b/test/org/apache/catalina/mbeans/TestRegistration.java
@@ -169,7 +169,7 @@ public class TestRegistration extends TomcatBaseTest {
// Disable keep-alive otherwise request processing threads in
keep-alive
// won't shut down fast enough with BIO to de-register the processor
// triggering a test failure
- tomcat.getConnector().setAttribute("maxKeepAliveRequests",
Integer.valueOf(1));
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
tomcat.start();
diff --git a/test/org/apache/catalina/startup/TomcatBaseTest.java
b/test/org/apache/catalina/startup/TomcatBaseTest.java
index eec6416..e0757d8 100644
--- a/test/org/apache/catalina/startup/TomcatBaseTest.java
+++ b/test/org/apache/catalina/startup/TomcatBaseTest.java
@@ -112,12 +112,11 @@ public abstract class TomcatBaseTest extends
LoggingBaseTest {
String protocol = getProtocol();
Connector connector = new Connector(protocol);
// Listen only on localhost
- connector.setAttribute("address",
- InetAddress.getByName("localhost").getHostAddress());
+ Assert.assertTrue(connector.setProperty("address",
InetAddress.getByName("localhost").getHostAddress()));
// Use random free port
connector.setPort(0);
// Mainly set to reduce timeouts during async tests
- connector.setAttribute("connectionTimeout", "3000");
+ Assert.assertTrue(connector.setProperty("connectionTimeout", "3000"));
tomcat.getService().addConnector(connector);
tomcat.setConnector(connector);
@@ -127,7 +126,7 @@ public abstract class TomcatBaseTest extends
LoggingBaseTest {
AprLifecycleListener listener = new AprLifecycleListener();
listener.setSSLRandomSeed("/dev/urandom");
server.addLifecycleListener(listener);
- connector.setAttribute("pollerThreadCount", Integer.valueOf(1));
+ Assert.assertTrue(connector.setProperty("pollerThreadCount", "1"));
}
File catalinaBase = getTemporaryDirectory();
diff --git a/test/org/apache/coyote/http11/TestAbstractHttp11Processor.java
b/test/org/apache/coyote/http11/TestAbstractHttp11Processor.java
index 6f71fab..b142431 100644
--- a/test/org/apache/coyote/http11/TestAbstractHttp11Processor.java
+++ b/test/org/apache/coyote/http11/TestAbstractHttp11Processor.java
@@ -25,11 +25,13 @@ import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
+import java.io.StringReader;
import java.io.Writer;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.nio.CharBuffer;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -56,6 +58,7 @@ import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.startup.TomcatBaseTest;
import org.apache.tomcat.util.buf.B2CConverter;
import org.apache.tomcat.util.buf.ByteChunk;
+import org.apache.tomcat.util.http.parser.TokenList;
public class TestAbstractHttp11Processor extends TomcatBaseTest {
@@ -63,6 +66,10 @@ public class TestAbstractHttp11Processor extends
TomcatBaseTest {
public void testResponseWithErrorChunked() throws Exception {
Tomcat tomcat = getTomcatInstance();
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
// No file system docBase required
Context ctxt = tomcat.addContext("", null);
@@ -1079,4 +1086,647 @@ public class TestAbstractHttp11Processor extends
TomcatBaseTest {
resp.setStatus(205);
}
}
+
+ /*
+ * Multiple, different Host headers
+ */
+ @Test
+ public void testMultipleHostHeader01() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new TesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET /foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: a" + SimpleHttpClient.CRLF +
+ "Host: b" + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 400 response.
+ Assert.assertTrue(client.isResponse400());
+ }
+
+ /*
+ * Multiple instances of the same Host header
+ */
+ @Test
+ public void testMultipleHostHeader02() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new TesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET /foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: a" + SimpleHttpClient.CRLF +
+ "Host: a" + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 400 response.
+ Assert.assertTrue(client.isResponse400());
+ }
+
+ @Test
+ public void testMissingHostHeader() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new TesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET /foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 400 response.
+ Assert.assertTrue(client.isResponse400());
+ }
+
+ @Test
+ public void testInconsistentHostHeader01() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+
Assert.assertTrue(tomcat.getConnector().setProperty("allowHostHeaderMismatch",
"false"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new TesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET http://a/foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: b" + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 400 response.
+ Assert.assertTrue(client.isResponse400());
+ }
+
+ @Test
+ public void testInconsistentHostHeader02() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+
Assert.assertTrue(tomcat.getConnector().setProperty("allowHostHeaderMismatch",
"false"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new TesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET http://a:8080/foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: b:8080" + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 400 response.
+ Assert.assertTrue(client.isResponse400());
+ }
+
+ @Test
+ public void testInconsistentHostHeader03() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+
Assert.assertTrue(tomcat.getConnector().setProperty("allowHostHeaderMismatch",
"false"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new TesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET http://user:pwd@a/foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: b" + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 400 response.
+ Assert.assertTrue(client.isResponse400());
+ }
+
+ /*
+ * Hostname (no port) is included in the request line, but Host header
+ * is empty.
+ * Added for bug 62739.
+ */
+ @Test
+ public void testInconsistentHostHeader04() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+
Assert.assertTrue(tomcat.getConnector().setProperty("allowHostHeaderMismatch",
"false"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new TesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET http://a/foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: " + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 400 response.
+ Assert.assertTrue(client.isResponse400());
+ }
+
+ /*
+ * Hostname (with port) is included in the request line, but Host header
+ * is empty.
+ * Added for bug 62739.
+ */
+ @Test
+ public void testInconsistentHostHeader05() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+
Assert.assertTrue(tomcat.getConnector().setProperty("allowHostHeaderMismatch",
"false"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new TesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET http://a:8080/foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: " + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 400 response.
+ Assert.assertTrue(client.isResponse400());
+ }
+
+ /*
+ * Hostname (with port and user) is included in the request line, but Host
+ * header is empty.
+ * Added for bug 62739.
+ */
+ @Test
+ public void testInconsistentHostHeader06() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+
Assert.assertTrue(tomcat.getConnector().setProperty("allowHostHeaderMismatch",
"false"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new TesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET http://user:pwd@a/foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: " + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 400 response.
+ Assert.assertTrue(client.isResponse400());
+ }
+
+
+ /*
+ * Request line host is an exact match for Host header (no port)
+ */
+ @Test
+ public void testConsistentHostHeader01() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new ServerNameTesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET http://a/foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: a" + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 200 response.
+ Assert.assertTrue(client.isResponse200());
+ Assert.assertEquals("request.getServerName() is [a] and
request.getServerPort() is 80", client.getResponseBody());
+ }
+
+ /*
+ * Request line host is an exact match for Host header (with port)
+ */
+ @Test
+ public void testConsistentHostHeader02() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new ServerNameTesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET http://a:8080/foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: a:8080" + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 200 response.
+ Assert.assertTrue(client.isResponse200());
+ Assert.assertEquals("request.getServerName() is [a] and
request.getServerPort() is 8080", client.getResponseBody());
+
+ }
+
+ /*
+ * Request line host is an exact match for Host header
+ * (no port, with user info)
+ */
+ @Test
+ public void testConsistentHostHeader03() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new ServerNameTesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET http://user:pwd@a/foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: a" + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 200 response.
+ Assert.assertTrue(client.isResponse200());
+ Assert.assertEquals("request.getServerName() is [a] and
request.getServerPort() is 80", client.getResponseBody());
+ }
+
+ /*
+ * Host header exists but its value is an empty string. This is valid if
+ * the request line does not include a hostname/port.
+ * Added for bug 62739.
+ */
+ @Test
+ public void testBlankHostHeader01() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new ServerNameTesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET /foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: " + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 200 response.
+ Assert.assertTrue(client.isResponse200());
+ Assert.assertEquals("request.getServerName() is [] and
request.getServerPort() is " + getPort(), client.getResponseBody());
+ }
+
+ /*
+ * Host header exists but has its value is empty (and there are multiple
+ * spaces after the ':'. This is valid if the request line does not
+ * include a hostname/port.
+ * Added for bug 62739.
+ */
+ @Test
+ public void testBlankHostHeader02() throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ // This setting means the connection will be closed at the end of the
+ // request
+
Assert.assertTrue(tomcat.getConnector().setProperty("maxKeepAliveRequests",
"1"));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new ServerNameTesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET /foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: " + SimpleHttpClient.CRLF +
+ SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest();
+
+ // Expected response is a 200 response.
+ Assert.assertTrue(client.isResponse200());
+ Assert.assertEquals("request.getServerName() is [] and
request.getServerPort() is " + getPort(), client.getResponseBody());
+ }
+
+
+ @Test
+ public void testKeepAliveHeader01() throws Exception {
+ doTestKeepAliveHeader(false, 3000, 10);
+ }
+
+ @Test
+ public void testKeepAliveHeader02() throws Exception {
+ doTestKeepAliveHeader(true, 5000, 1);
+ }
+
+ @Test
+ public void testKeepAliveHeader03() throws Exception {
+ doTestKeepAliveHeader(true, 5000, 10);
+ }
+
+ @Test
+ public void testKeepAliveHeader04() throws Exception {
+ doTestKeepAliveHeader(true, -1, 10);
+ }
+
+ @Test
+ public void testKeepAliveHeader05() throws Exception {
+ doTestKeepAliveHeader(true, -1, 1);
+ }
+
+ @Test
+ public void testKeepAliveHeader06() throws Exception {
+ doTestKeepAliveHeader(true, -1, -1);
+ }
+
+ private void doTestKeepAliveHeader(boolean sendKeepAlive, int
keepAliveTimeout,
+ int maxKeepAliveRequests) throws Exception {
+ Tomcat tomcat = getTomcatInstance();
+
+ tomcat.getConnector().setProperty("keepAliveTimeout",
Integer.toString(keepAliveTimeout));
+ tomcat.getConnector().setProperty("maxKeepAliveRequests",
Integer.toString(maxKeepAliveRequests));
+
+ // No file system docBase required
+ Context ctx = tomcat.addContext("", null);
+
+ // Add servlet
+ Tomcat.addServlet(ctx, "TesterServlet", new TesterServlet());
+ ctx.addServletMapping("/foo", "TesterServlet");
+
+ tomcat.start();
+
+ String request =
+ "GET /foo HTTP/1.1" + SimpleHttpClient.CRLF +
+ "Host: localhost:" + getPort() + SimpleHttpClient.CRLF;
+
+ if (sendKeepAlive) {
+ request += "Connection: keep-alive" + SimpleHttpClient.CRLF;
+ }
+
+ request += SimpleHttpClient.CRLF;
+
+ Client client = new Client(tomcat.getConnector().getLocalPort());
+ client.setRequest(new String[] {request});
+
+ client.connect();
+ client.processRequest(false);
+
+ Assert.assertTrue(client.isResponse200());
+
+ String connectionHeaderValue = null;
+ String keepAliveHeaderValue = null;
+ for (String header : client.getResponseHeaders()) {
+ if (header.startsWith("Connection:")) {
+ connectionHeaderValue = header.substring(header.indexOf(':') +
1).trim();
+ }
+ if (header.startsWith("Keep-Alive:")) {
+ keepAliveHeaderValue = header.substring(header.indexOf(':') +
1).trim();
+ }
+ }
+
+ if (!sendKeepAlive || keepAliveTimeout < 0
+ && (maxKeepAliveRequests < 0 || maxKeepAliveRequests > 1)) {
+ Assert.assertNull(connectionHeaderValue);
+ Assert.assertNull(keepAliveHeaderValue);
+ } else {
+ List<String> connectionHeaders = new ArrayList<String>();
+ TokenList.parseTokenList(new StringReader(connectionHeaderValue),
connectionHeaders);
+
+ if (sendKeepAlive && keepAliveTimeout > 0 &&
+ (maxKeepAliveRequests < 0 || maxKeepAliveRequests > 1)) {
+ Assert.assertEquals(1, connectionHeaders.size());
+ Assert.assertEquals("keep-alive", connectionHeaders.get(0));
+ Assert.assertEquals("timeout=" + keepAliveTimeout / 1000L,
keepAliveHeaderValue);
+ }
+
+ if (sendKeepAlive && maxKeepAliveRequests == 1) {
+ Assert.assertEquals(1, connectionHeaders.size());
+ Assert.assertEquals("close", connectionHeaders.get(0));
+ Assert.assertNull(keepAliveHeaderValue);
+ }
+ }
+ }
+
+
+ /**
+ * Test servlet that prints out the values of
+ * HttpServletRequest.getServerName() and
+ * HttpServletRequest.getServerPort() in the response body, e.g.:
+ *
+ * "request.getServerName() is [foo] and request.getServerPort() is 8080"
+ *
+ * or:
+ *
+ * "request.getServerName() is null and request.getServerPort() is 8080"
+ */
+ private static class ServerNameTesterServlet extends HttpServlet {
+
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ protected void doGet(HttpServletRequest req, HttpServletResponse resp)
+ throws ServletException, IOException {
+
+ resp.setContentType("text/plain");
+ PrintWriter out = resp.getWriter();
+
+ if (null == req.getServerName())
+ {
+ out.print("request.getServerName() is null");
+ } else {
+ out.print("request.getServerName() is [" + req.getServerName()
+ "]");
+ }
+
+ out.print(" and request.getServerPort() is " +
req.getServerPort());
+ }
+ }
}
diff --git a/test/org/apache/tomcat/util/http/TestMimeHeaders.java
b/test/org/apache/tomcat/util/http/TestMimeHeaders.java
index 90faeb2..1d88468 100644
--- a/test/org/apache/tomcat/util/http/TestMimeHeaders.java
+++ b/test/org/apache/tomcat/util/http/TestMimeHeaders.java
@@ -104,8 +104,7 @@ public class TestMimeHeaders extends TomcatBaseTest {
if (maxHeaderCount > 0) {
Assert.assertEquals(maxHeaderCount, alv.arraySize);
} else if (maxHeaderCount < 0) {
- int maxHttpHeaderSize = ((Integer) tomcat.getConnector()
- .getAttribute("maxHttpHeaderSize")).intValue();
+ int maxHttpHeaderSize = ((Integer)
tomcat.getConnector().getProperty("maxHttpHeaderSize")).intValue();
int headerCount = Math.min(count,
maxHttpHeaderSize / header.length() + 1);
int arraySize = 1;
diff --git a/test/org/apache/tomcat/util/net/TestCustomSsl.java
b/test/org/apache/tomcat/util/net/TestCustomSsl.java
index 0411b6f..db104e0 100644
--- a/test/org/apache/tomcat/util/net/TestCustomSsl.java
+++ b/test/org/apache/tomcat/util/net/TestCustomSsl.java
@@ -60,8 +60,7 @@ public class TestCustomSsl extends TomcatBaseTest {
File keystoreFile =
new File("test/" + TesterSupport.LOCALHOST_JKS);
- connector.setAttribute(
- "keystoreFile", keystoreFile.getAbsolutePath());
+ Assert.assertTrue(connector.setProperty("keystoreFile",
keystoreFile.getAbsolutePath()));
connector.setSecure(true);
connector.setProperty("SSLEnabled", "true");
@@ -110,8 +109,8 @@ public class TestCustomSsl extends TomcatBaseTest {
Assert.fail("Unexpected handler type");
}
if (serverTrustAll) {
- tomcat.getConnector().setAttribute("trustManagerClassName",
- "org.apache.tomcat.util.net.TesterSupport$TrustAllCerts");
+
Assert.assertTrue(tomcat.getConnector().setProperty("trustManagerClassName",
+ "org.apache.tomcat.util.net.TesterSupport$TrustAllCerts"));
}
// Start Tomcat
diff --git a/test/org/apache/tomcat/util/net/TesterSupport.java
b/test/org/apache/tomcat/util/net/TesterSupport.java
index b402f24..2b14955 100644
--- a/test/org/apache/tomcat/util/net/TesterSupport.java
+++ b/test/org/apache/tomcat/util/net/TesterSupport.java
@@ -47,6 +47,8 @@ import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
+import org.junit.Assert;
+
import org.apache.catalina.Context;
import org.apache.catalina.authenticator.SSLAuthenticator;
import org.apache.catalina.connector.Connector;
@@ -127,33 +129,31 @@ public final class TesterSupport {
connector.setProperty("sslProtocol", "tls");
java.net.URL keyStoreUrl = cl.getResource(keystore);
File keystoreFile = toFile(keyStoreUrl);
- connector.setAttribute("keystoreFile",
- keystoreFile.getAbsolutePath());
+ Assert.assertTrue(connector.setProperty("keystoreFile",
keystoreFile.getAbsolutePath()));
java.net.URL truststoreUrl = cl.getResource(CA_JKS);
File truststoreFile = toFile(truststoreUrl);
- connector.setAttribute("truststoreFile",
- truststoreFile.getAbsolutePath());
+ Assert.assertTrue(connector.setProperty("truststoreFile",
truststoreFile.getAbsolutePath()));
if (keystorePass != null) {
- connector.setAttribute("keystorePass", keystorePass);
+ Assert.assertTrue(connector.setProperty("keystorePass",
keystorePass));
}
if (keyPass != null) {
- connector.setAttribute("keyPass", keyPass);
+ Assert.assertTrue(connector.setProperty("keyPass", keyPass));
}
} else {
java.net.URL keyStoreUrl = cl.getResource(LOCALHOST_CERT_PEM);
File keystoreFile = toFile(keyStoreUrl);
- tomcat.getConnector().setAttribute("SSLCertificateFile",
- keystoreFile.getAbsolutePath());
+
Assert.assertTrue(tomcat.getConnector().setProperty("SSLCertificateFile",
+ keystoreFile.getAbsolutePath()));
java.net.URL sslCertificateKeyUrl =
cl.getResource(LOCALHOST_KEY_PEM);
File sslCertificateKeyFile = toFile(sslCertificateKeyUrl);
- tomcat.getConnector().setAttribute("SSLCertificateKeyFile",
- sslCertificateKeyFile.getAbsolutePath());
+
Assert.assertTrue(tomcat.getConnector().setProperty("SSLCertificateKeyFile",
+ sslCertificateKeyFile.getAbsolutePath()));
java.net.URL caUrl = cl.getResource(TesterSupport.CA_CERT_PEM);
File caFile = toFile(caUrl);
- tomcat.getConnector().setAttribute("SSLCACertificateFile",
caFile.getAbsolutePath());
+
Assert.assertTrue(tomcat.getConnector().setProperty("SSLCACertificateFile",
caFile.getAbsolutePath()));
}
tomcat.getConnector().setSecure(true);
tomcat.getConnector().setProperty("SSLEnabled", "true");
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@tomcat.apache.org
For additional commands, e-mail: dev-h...@tomcat.apache.org
