org.apache.coyote.http11.AbstractHttp11Protocol Maven / Gradle / Ivy
/*
* 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.coyote.http11;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.concurrent.ConcurrentHashMap;
import javax.servlet.http.HttpUpgradeHandler;
import org.apache.coyote.AbstractProtocol;
import org.apache.coyote.Processor;
import org.apache.coyote.UpgradeProtocol;
import org.apache.coyote.UpgradeToken;
import org.apache.coyote.http11.upgrade.InternalHttpUpgradeHandler;
import org.apache.coyote.http11.upgrade.UpgradeProcessorExternal;
import org.apache.coyote.http11.upgrade.UpgradeProcessorInternal;
import org.apache.tomcat.util.buf.StringUtils;
import org.apache.tomcat.util.net.AbstractEndpoint;
import org.apache.tomcat.util.net.SSLHostConfig;
import org.apache.tomcat.util.net.SocketWrapperBase;
import org.apache.tomcat.util.res.StringManager;
public abstract class AbstractHttp11Protocol extends AbstractProtocol {
protected static final StringManager sm =
StringManager.getManager(AbstractHttp11Protocol.class);
public AbstractHttp11Protocol(AbstractEndpoint endpoint) {
super(endpoint);
setConnectionTimeout(Constants.DEFAULT_CONNECTION_TIMEOUT);
ConnectionHandler cHandler = new ConnectionHandler<>(this);
setHandler(cHandler);
getEndpoint().setHandler(cHandler);
}
@Override
public void init() throws Exception {
for (UpgradeProtocol upgradeProtocol : upgradeProtocols) {
configureUpgradeProtocol(upgradeProtocol);
}
super.init();
}
@Override
protected String getProtocolName() {
return "Http";
}
/**
* {@inheritDoc}
*
* Over-ridden here to make the method visible to nested classes.
*/
@Override
protected AbstractEndpoint getEndpoint() {
return super.getEndpoint();
}
// ------------------------------------------------ HTTP specific properties
// ------------------------------------------ managed in the ProtocolHandler
/**
* Maximum size of the post which will be saved when processing certain
* requests, such as a POST.
*/
private int maxSavePostSize = 4 * 1024;
public int getMaxSavePostSize() { return maxSavePostSize; }
public void setMaxSavePostSize(int valueI) { maxSavePostSize = valueI; }
/**
* Maximum size of the HTTP message header.
*/
private int maxHttpHeaderSize = 8 * 1024;
public int getMaxHttpHeaderSize() { return maxHttpHeaderSize; }
public void setMaxHttpHeaderSize(int valueI) { maxHttpHeaderSize = valueI; }
/**
* Specifies a different (usually longer) connection timeout during data
* upload.
*/
private int connectionUploadTimeout = 300000;
public int getConnectionUploadTimeout() { return connectionUploadTimeout; }
public void setConnectionUploadTimeout(int i) {
connectionUploadTimeout = i;
}
/**
* If true, the connectionUploadTimeout will be ignored and the regular
* socket timeout will be used for the full duration of the connection.
*/
private boolean disableUploadTimeout = true;
public boolean getDisableUploadTimeout() { return disableUploadTimeout; }
public void setDisableUploadTimeout(boolean isDisabled) {
disableUploadTimeout = isDisabled;
}
/**
* Integrated compression support.
*/
private String compression = "off";
public String getCompression() { return compression; }
public void setCompression(String valueS) { compression = valueS; }
private String noCompressionUserAgents = null;
public String getNoCompressionUserAgents() {
return noCompressionUserAgents;
}
public void setNoCompressionUserAgents(String valueS) {
noCompressionUserAgents = valueS;
}
/**
* @return See {@link #getCompressibleMimeType()}
* @deprecated Use {@link #getCompressibleMimeType()}
*/
@Deprecated
public String getCompressableMimeType() {
return getCompressibleMimeType();
}
/**
* @param valueS See {@link #setCompressibleMimeType(String)}
* @deprecated Use {@link #setCompressibleMimeType(String)}
*/
@Deprecated
public void setCompressableMimeType(String valueS) {
setCompressibleMimeType(valueS);
}
/**
* @return See {@link #getCompressibleMimeTypes()}
* @deprecated Use {@link #getCompressibleMimeTypes()}
*/
@Deprecated
public String[] getCompressableMimeTypes() {
return getCompressibleMimeTypes();
}
private String compressibleMimeType = "text/html,text/xml,text/plain,text/css,text/javascript,application/javascript";
private String[] compressibleMimeTypes = null;
public String getCompressibleMimeType() { return compressibleMimeType; }
public void setCompressibleMimeType(String valueS) {
compressibleMimeType = valueS;
compressibleMimeTypes = null;
}
public String[] getCompressibleMimeTypes() {
String[] result = compressibleMimeTypes;
if (result != null) {
return result;
}
List values = new ArrayList<>();
StringTokenizer tokens = new StringTokenizer(compressibleMimeType, ",");
while (tokens.hasMoreTokens()) {
String token = tokens.nextToken().trim();
if (token.length() > 0) {
values.add(token);
}
}
result = values.toArray(new String[values.size()]);
compressibleMimeTypes = result;
return result;
}
private int compressionMinSize = 2048;
public int getCompressionMinSize() { return compressionMinSize; }
public void setCompressionMinSize(int valueI) {
compressionMinSize = valueI;
}
/**
* Regular expression that defines the User agents which should be
* restricted to HTTP/1.0 support.
*/
private String restrictedUserAgents = null;
public String getRestrictedUserAgents() { return restrictedUserAgents; }
public void setRestrictedUserAgents(String valueS) {
restrictedUserAgents = valueS;
}
/**
* Server header.
*/
private String server;
public String getServer() { return server; }
public void setServer( String server ) {
this.server = server;
}
private boolean serverRemoveAppProvidedValues = false;
public boolean getServerRemoveAppProvidedValues() { return serverRemoveAppProvidedValues; }
public void setServerRemoveAppProvidedValues(boolean serverRemoveAppProvidedValues) {
this.serverRemoveAppProvidedValues = serverRemoveAppProvidedValues;
}
/**
* Maximum size of trailing headers in bytes
*/
private int maxTrailerSize = 8192;
public int getMaxTrailerSize() { return maxTrailerSize; }
public void setMaxTrailerSize(int maxTrailerSize) {
this.maxTrailerSize = maxTrailerSize;
}
/**
* Maximum size of extension information in chunked encoding
*/
private int maxExtensionSize = 8192;
public int getMaxExtensionSize() { return maxExtensionSize; }
public void setMaxExtensionSize(int maxExtensionSize) {
this.maxExtensionSize = maxExtensionSize;
}
/**
* Maximum amount of request body to swallow.
*/
private int maxSwallowSize = 2 * 1024 * 1024;
public int getMaxSwallowSize() { return maxSwallowSize; }
public void setMaxSwallowSize(int maxSwallowSize) {
this.maxSwallowSize = maxSwallowSize;
}
/**
* This field indicates if the protocol is treated as if it is secure. This
* normally means https is being used but can be used to fake https e.g
* behind a reverse proxy.
*/
private boolean secure;
public boolean getSecure() { return secure; }
public void setSecure(boolean b) {
secure = b;
}
/**
* The names of headers that are allowed to be sent via a trailer when using
* chunked encoding. They are stored in lower case.
*/
private Set allowedTrailerHeaders =
Collections.newSetFromMap(new ConcurrentHashMap());
public void setAllowedTrailerHeaders(String commaSeparatedHeaders) {
// Jump through some hoops so we don't end up with an empty set while
// doing updates.
Set toRemove = new HashSet<>();
toRemove.addAll(allowedTrailerHeaders);
if (commaSeparatedHeaders != null) {
String[] headers = commaSeparatedHeaders.split(",");
for (String header : headers) {
String trimmedHeader = header.trim().toLowerCase(Locale.ENGLISH);
if (toRemove.contains(trimmedHeader)) {
toRemove.remove(trimmedHeader);
} else {
allowedTrailerHeaders.add(trimmedHeader);
}
}
allowedTrailerHeaders.removeAll(toRemove);
}
}
public String getAllowedTrailerHeaders() {
// Chances of a size change between these lines are small enough that a
// sync is unnecessary.
List copy = new ArrayList<>(allowedTrailerHeaders.size());
copy.addAll(allowedTrailerHeaders);
return StringUtils.join(copy);
}
public void addAllowedTrailerHeader(String header) {
if (header != null) {
allowedTrailerHeaders.add(header.trim().toLowerCase(Locale.ENGLISH));
}
}
public void removeAllowedTrailerHeader(String header) {
if (header != null) {
allowedTrailerHeaders.remove(header.trim().toLowerCase(Locale.ENGLISH));
}
}
/**
* The upgrade protocol instances configured.
*/
private final List upgradeProtocols = new ArrayList<>();
@Override
public void addUpgradeProtocol(UpgradeProtocol upgradeProtocol) {
upgradeProtocols.add(upgradeProtocol);
}
@Override
public UpgradeProtocol[] findUpgradeProtocols() {
return upgradeProtocols.toArray(new UpgradeProtocol[0]);
}
/**
* The protocols that are available via internal Tomcat support for access
* via HTTP upgrade.
*/
private final Map httpUpgradeProtocols = new HashMap<>();
/**
* The protocols that are available via internal Tomcat support for access
* via ALPN negotiation.
*/
private final Map negotiatedProtocols = new HashMap<>();
private void configureUpgradeProtocol(UpgradeProtocol upgradeProtocol) {
// HTTP Upgrade
String httpUpgradeName = upgradeProtocol.getHttpUpgradeName(getEndpoint().isSSLEnabled());
boolean httpUpgradeConfigured = false;
if (httpUpgradeName != null && httpUpgradeName.length() > 0) {
httpUpgradeProtocols.put(httpUpgradeName, upgradeProtocol);
httpUpgradeConfigured = true;
getLog().info(sm.getString("abstractHttp11Protocol.httpUpgradeConfigured",
getName(), httpUpgradeName));
}
// ALPN
String alpnName = upgradeProtocol.getAlpnName();
if (alpnName != null && alpnName.length() > 0) {
if (getEndpoint().isAlpnSupported()) {
negotiatedProtocols.put(alpnName, upgradeProtocol);
getEndpoint().addNegotiatedProtocol(alpnName);
getLog().info(sm.getString("abstractHttp11Protocol.alpnConfigured",
getName(), alpnName));
} else {
if (!httpUpgradeConfigured) {
// ALPN is not supported by this connector and the upgrade
// protocol implementation does not support standard HTTP
// upgrade so there is no way available to enable support
// for this protocol.
getLog().error(sm.getString("abstractHttp11Protocol.alpnWithNoAlpn",
upgradeProtocol.getClass().getName(), alpnName, getName()));
}
}
}
}
@Override
public UpgradeProtocol getNegotiatedProtocol(String negotiatedName) {
return negotiatedProtocols.get(negotiatedName);
}
@Override
public UpgradeProtocol getUpgradeProtocol(String upgradedName) {
return httpUpgradeProtocols.get(upgradedName);
}
// ------------------------------------------------ HTTP specific properties
// ------------------------------------------ passed through to the EndPoint
public boolean isSSLEnabled() { return getEndpoint().isSSLEnabled();}
public void setSSLEnabled(boolean SSLEnabled) {
getEndpoint().setSSLEnabled(SSLEnabled);
}
public boolean getUseSendfile() { return getEndpoint().getUseSendfile(); }
public void setUseSendfile(boolean useSendfile) { getEndpoint().setUseSendfile(useSendfile); }
/**
* @return The maximum number of requests which can be performed over a
* keep-alive connection. The default is the same as for Apache HTTP
* Server (100).
*/
public int getMaxKeepAliveRequests() {
return getEndpoint().getMaxKeepAliveRequests();
}
public void setMaxKeepAliveRequests(int mkar) {
getEndpoint().setMaxKeepAliveRequests(mkar);
}
// ----------------------------------------------- HTTPS specific properties
// ------------------------------------------ passed through to the EndPoint
public String getDefaultSSLHostConfigName() {
return getEndpoint().getDefaultSSLHostConfigName();
}
public void setDefaultSSLHostConfigName(String defaultSSLHostConfigName) {
getEndpoint().setDefaultSSLHostConfigName(defaultSSLHostConfigName);
if (defaultSSLHostConfig != null) {
defaultSSLHostConfig.setHostName(defaultSSLHostConfigName);
}
}
@Override
public void addSslHostConfig(SSLHostConfig sslHostConfig) {
getEndpoint().addSslHostConfig(sslHostConfig);
}
@Override
public SSLHostConfig[] findSslHostConfigs() {
return getEndpoint().findSslHostConfigs();
}
// ----------------------------------------------- HTTPS specific properties
// -------------------------------------------- Handled via an SSLHostConfig
private SSLHostConfig defaultSSLHostConfig = null;
private void registerDefaultSSLHostConfig() {
if (defaultSSLHostConfig == null) {
for (SSLHostConfig sslHostConfig : findSslHostConfigs()) {
if (getDefaultSSLHostConfigName().equals(sslHostConfig.getHostName())) {
defaultSSLHostConfig = sslHostConfig;
break;
}
}
if (defaultSSLHostConfig == null) {
defaultSSLHostConfig = new SSLHostConfig();
defaultSSLHostConfig.setHostName(getDefaultSSLHostConfigName());
getEndpoint().addSslHostConfig(defaultSSLHostConfig);
}
}
}
// TODO: All of these SSL getters and setters can be removed once it is no
// longer necessary to support the old configuration attributes (Tomcat 10?)
public String getSslEnabledProtocols() {
registerDefaultSSLHostConfig();
return StringUtils.join(defaultSSLHostConfig.getEnabledProtocols());
}
public void setSslEnabledProtocols(String enabledProtocols) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setProtocols(enabledProtocols);
}
public String getSSLProtocol() {
registerDefaultSSLHostConfig();
return StringUtils.join(defaultSSLHostConfig.getEnabledProtocols());
}
public void setSSLProtocol(String sslProtocol) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setProtocols(sslProtocol);
}
public String getKeystoreFile() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateKeystoreFile();
}
public void setKeystoreFile(String keystoreFile) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateKeystoreFile(keystoreFile);
}
public String getSSLCertificateChainFile() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateChainFile();
}
public void setSSLCertificateChainFile(String certificateChainFile) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateChainFile(certificateChainFile);
}
public String getSSLCertificateFile() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateFile();
}
public void setSSLCertificateFile(String certificateFile) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateFile(certificateFile);
}
public String getSSLCertificateKeyFile() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateKeyFile();
}
public void setSSLCertificateKeyFile(String certificateKeyFile) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateKeyFile(certificateKeyFile);
}
public String getAlgorithm() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getKeyManagerAlgorithm();
}
public void setAlgorithm(String keyManagerAlgorithm) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setKeyManagerAlgorithm(keyManagerAlgorithm);
}
public String getClientAuth() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateVerification().toString();
}
public void setClientAuth(String certificateVerification) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateVerification(certificateVerification);
}
public String getSSLVerifyClient() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateVerification().toString();
}
public void setSSLVerifyClient(String certificateVerification) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateVerification(certificateVerification);
}
public int getTrustMaxCertLength(){
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateVerificationDepth();
}
public void setTrustMaxCertLength(int certificateVerificationDepth){
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateVerificationDepth(certificateVerificationDepth);
}
public int getSSLVerifyDepth() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateVerificationDepth();
}
public void setSSLVerifyDepth(int certificateVerificationDepth) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateVerificationDepth(certificateVerificationDepth);
}
public String getUseServerCipherSuitesOrder() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getHonorCipherOrder();
}
public void setUseServerCipherSuitesOrder(String honorCipherOrder) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setHonorCipherOrder(honorCipherOrder);
}
public String getSSLHonorCipherOrder() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getHonorCipherOrder();
}
public void setSSLHonorCipherOrder(String honorCipherOrder) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setHonorCipherOrder(honorCipherOrder);
}
public String getCiphers() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCiphers();
}
public void setCiphers(String ciphers) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCiphers(ciphers);
}
public String getSSLCipherSuite() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCiphers();
}
public void setSSLCipherSuite(String ciphers) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCiphers(ciphers);
}
public String getKeystorePass() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateKeystorePassword();
}
public void setKeystorePass(String certificateKeystorePassword) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateKeystorePassword(certificateKeystorePassword);
}
public String getKeyPass() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateKeyPassword();
}
public void setKeyPass(String certificateKeyPassword) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateKeyPassword(certificateKeyPassword);
}
public String getSSLPassword() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateKeyPassword();
}
public void setSSLPassword(String certificateKeyPassword) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateKeyPassword(certificateKeyPassword);
}
public String getCrlFile(){
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateRevocationListFile();
}
public void setCrlFile(String certificateRevocationListFile){
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateRevocationListFile(certificateRevocationListFile);
}
public String getSSLCARevocationFile() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateRevocationListFile();
}
public void setSSLCARevocationFile(String certificateRevocationListFile) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateRevocationListFile(certificateRevocationListFile);
}
public String getSSLCARevocationPath() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateRevocationListPath();
}
public void setSSLCARevocationPath(String certificateRevocationListPath) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateRevocationListPath(certificateRevocationListPath);
}
public String getKeystoreType() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateKeystoreType();
}
public void setKeystoreType(String certificateKeystoreType) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateKeystoreType(certificateKeystoreType);
}
public String getKeystoreProvider() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateKeystoreProvider();
}
public void setKeystoreProvider(String certificateKeystoreProvider) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateKeystoreProvider(certificateKeystoreProvider);
}
public String getKeyAlias() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCertificateKeyAlias();
}
public void setKeyAlias(String certificateKeyAlias) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCertificateKeyAlias(certificateKeyAlias);
}
public String getTruststoreAlgorithm(){
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getTruststoreAlgorithm();
}
public void setTruststoreAlgorithm(String truststoreAlgorithm){
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setTruststoreAlgorithm(truststoreAlgorithm);
}
public String getTruststoreFile(){
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getTruststoreFile();
}
public void setTruststoreFile(String truststoreFile){
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setTruststoreFile(truststoreFile);
}
public String getTruststorePass(){
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getTruststorePassword();
}
public void setTruststorePass(String truststorePassword){
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setTruststorePassword(truststorePassword);
}
public String getTruststoreType(){
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getTruststoreType();
}
public void setTruststoreType(String truststoreType){
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setTruststoreType(truststoreType);
}
public String getTruststoreProvider(){
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getTruststoreProvider();
}
public void setTruststoreProvider(String truststoreProvider){
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setTruststoreProvider(truststoreProvider);
}
public String getSslProtocol() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getSslProtocol();
}
public void setSslProtocol(String sslProtocol) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setSslProtocol(sslProtocol);
}
public int getSessionCacheSize(){
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getSessionCacheSize();
}
public void setSessionCacheSize(int sessionCacheSize){
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setSessionCacheSize(sessionCacheSize);
}
public int getSessionTimeout(){
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getSessionTimeout();
}
public void setSessionTimeout(int sessionTimeout){
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setSessionTimeout(sessionTimeout);
}
public String getSSLCACertificatePath() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCaCertificatePath();
}
public void setSSLCACertificatePath(String caCertificatePath) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCaCertificatePath(caCertificatePath);
}
public String getSSLCACertificateFile() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getCaCertificateFile();
}
public void setSSLCACertificateFile(String caCertificateFile) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setCaCertificateFile(caCertificateFile);
}
public boolean getSSLDisableCompression() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getDisableCompression();
}
public void setSSLDisableCompression(boolean disableCompression) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setDisableCompression(disableCompression);
}
public boolean getSSLDisableSessionTickets() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getDisableSessionTickets();
}
public void setSSLDisableSessionTickets(boolean disableSessionTickets) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setDisableSessionTickets(disableSessionTickets);
}
public String getTrustManagerClassName() {
registerDefaultSSLHostConfig();
return defaultSSLHostConfig.getTrustManagerClassName();
}
public void setTrustManagerClassName(String trustManagerClassName) {
registerDefaultSSLHostConfig();
defaultSSLHostConfig.setTrustManagerClassName(trustManagerClassName);
}
// ------------------------------------------------------------- Common code
@SuppressWarnings("deprecation")
@Override
protected Processor createProcessor() {
Http11Processor processor = new Http11Processor(getMaxHttpHeaderSize(), getEndpoint(),
getMaxTrailerSize(), allowedTrailerHeaders, getMaxExtensionSize(),
getMaxSwallowSize(), httpUpgradeProtocols, getSendReasonPhrase());
processor.setAdapter(getAdapter());
processor.setMaxKeepAliveRequests(getMaxKeepAliveRequests());
processor.setConnectionUploadTimeout(getConnectionUploadTimeout());
processor.setDisableUploadTimeout(getDisableUploadTimeout());
processor.setCompressionMinSize(getCompressionMinSize());
processor.setCompression(getCompression());
processor.setNoCompressionUserAgents(getNoCompressionUserAgents());
processor.setCompressibleMimeTypes(getCompressibleMimeTypes());
processor.setRestrictedUserAgents(getRestrictedUserAgents());
processor.setMaxSavePostSize(getMaxSavePostSize());
processor.setServer(getServer());
processor.setServerRemoveAppProvidedValues(getServerRemoveAppProvidedValues());
return processor;
}
@Override
protected Processor createUpgradeProcessor(
SocketWrapperBase socket,
UpgradeToken upgradeToken) {
HttpUpgradeHandler httpUpgradeHandler = upgradeToken.getHttpUpgradeHandler();
if (httpUpgradeHandler instanceof InternalHttpUpgradeHandler) {
return new UpgradeProcessorInternal(socket, upgradeToken);
} else {
return new UpgradeProcessorExternal(socket, upgradeToken);
}
}
}