public Http11AprProtocol() 
{
      
        setSoLinger(Constants.DEFAULT_CONNECTION_LINGER);
        setSoTimeout(Constants.DEFAULT_CONNECTION_TIMEOUT);
        //setServerSoTimeout(Constants.DEFAULT_SERVER_SOCKET_TIMEOUT);
        setTcpNoDelay(Constants.DEFAULT_TCP_NO_DELAY);
}

 public  void destroy() throws Exception 
{
        if(log.isInfoEnabled())
            log.info(sm.getString("http11protocol.stop", getName()));
        endpoint.destroy();
        if( tpOname!=null )
            Registry.getRegistry(null, null).unregisterComponent(tpOname);
        if( rgOname != null )
            Registry.getRegistry(null, null).unregisterComponent(rgOname);
}

 public Adapter getAdapter() 
{
 return adapter;
}

 public InetAddress getAddress() 
{
 return endpoint.getAddress();
}

 public Object getAttribute(String key) 
{
        if( log.isTraceEnabled())
            log.trace(sm.getString("http11protocol.getattribute", key));
        return attributes.get(key);
}

 public Iterator getAttributeNames() 
{
        return attributes.keySet().iterator();
}

 public int getBacklog() 
{
 return endpoint.getBacklog();
}

 public String getCompressableMimeType() 
{
        return compressableMimeTypes;
}

 public String getCompression() 
{
        return compression;
}

 public int getCompressionMinSize() 
{
        return compressionMinSize;
}

 public boolean getDisableUploadTimeout() 
{
        return disableUploadTimeout;
}

 public String getDomain() 
{
        return domain;
}

 public Executor getExecutor() 
{
 return endpoint.getExecutor();
}

 public boolean getKeepAlive() 
{
        return ((maxKeepAliveRequests != 0) && (maxKeepAliveRequests != 1));
}

Return the Keep-Alive policy for the connection.

 public int getKeepAliveTimeout() 
{
 return endpoint.getKeepAliveTimeout();
}

The number of seconds Tomcat will wait for a subsequent request before closing the connection.

 public int getMaxHttpHeaderSize() 
{
        return maxHttpHeaderSize;
}

 public int getMaxKeepAliveRequests() 
{
        return maxKeepAliveRequests;
}

 public int getMaxSavePostSize() 
{
        return maxSavePostSize;
}

 public int getMaxThreads() 
{
 return endpoint.getMaxThreads();
}

 public String getName() 
{
        String encodedAddr = "";
        if (getAddress() != null) {
            encodedAddr = "" + getAddress();
            if (encodedAddr.startsWith("/"))
                encodedAddr = encodedAddr.substring(1);
            encodedAddr = URLEncoder.encode(encodedAddr) + "-";
        }
        return ("http-" + encodedAddr + endpoint.getPort());
}

 public String getNoCompressionUserAgents() 
{
        return noCompressionUserAgents;
}

 public ObjectName getObjectName() 
{
        return oname;
}

 public int getPollTime() 
{
 return endpoint.getPollTime();
}

 public int getPollerSize() 
{
 return endpoint.getPollerSize();
}

 public int getPort() 
{
 return endpoint.getPort();
}

 public int getProcessorCache() 
{
        return this.processorCache;
}

 public String getProtocol() 
{
        return protocol;
}

 public String getRestrictedUserAgents() 
{
        return restrictedUserAgents;
}

 public String getSSLCACertificateFile() 
{
 return endpoint.getSSLCACertificateFile();
}

SSL CA certificate file.

 public String getSSLCACertificatePath() 
{
 return endpoint.getSSLCACertificatePath();
}

SSL CA certificate path.

 public String getSSLCARevocationFile() 
{
 return endpoint.getSSLCARevocationFile();
}

SSL CA revocation file.

 public String getSSLCARevocationPath() 
{
 return endpoint.getSSLCARevocationPath();
}

SSL CA revocation path.

 public String getSSLCertificateChainFile() 
{
 return endpoint.getSSLCertificateChainFile();
}

SSL certificate chain file.

 public String getSSLCertificateFile() 
{
 return endpoint.getSSLCertificateFile();
}

SSL certificate file.

 public String getSSLCertificateKeyFile() 
{
 return endpoint.getSSLCertificateKeyFile();
}

SSL certificate key file.

 public String getSSLCipherSuite() 
{
 return endpoint.getSSLCipherSuite();
}

SSL cipher suite.

 public String getSSLPassword() 
{
 return endpoint.getSSLPassword();
}

SSL password (if a cert is encrypted, and no password has been provided, a callback will ask for a password).

 public String getSSLProtocol() 
{
 return endpoint.getSSLProtocol();
}

SSL protocol.

 public String getSSLVerifyClient() 
{
 return endpoint.getSSLVerifyClient();
}

SSL verify client.

 public int getSSLVerifyDepth() 
{
 return endpoint.getSSLVerifyDepth();
}

SSL verify depth.

 public boolean getSecure() 
{
 return secure;
}

 public int getSendfileSize() 
{
 return endpoint.getSendfileSize();
}

 public String getServer() 
{
 return server;
}

 public int getSoLinger() 
{
 return endpoint.getSoLinger();
}

 public int getSoTimeout() 
{
 return endpoint.getSoTimeout();
}

 public int getSocketBuffer() 
{
        return socketBuffer;
}

 public boolean getTcpNoDelay() 
{
 return endpoint.getTcpNoDelay();
}

 public int getThreadPriority() 
{
 return endpoint.getThreadPriority();
}

 public int getTimeout() 
{
        return timeout;
}

 public boolean getUseSendfile() 
{
 return endpoint.getUseSendfile();
}

 public  void init() throws Exception 
{
        endpoint.setName(getName());
        endpoint.setHandler(cHandler);
        try {
            endpoint.init();
        } catch (Exception ex) {
            log.error(sm.getString("http11protocol.endpoint.initerror"), ex);
            throw ex;
        }
        if(log.isInfoEnabled())
            log.info(sm.getString("http11protocol.init", getName()));
}

Start the protocol

 public boolean isSSLEnabled() 
{
 return endpoint.isSSLEnabled();
}

SSL engine.

 public  void pause() throws Exception 
{
        try {
            endpoint.pause();
        } catch (Exception ex) {
            log.error(sm.getString("http11protocol.endpoint.pauseerror"), ex);
            throw ex;
        }
        if(log.isInfoEnabled())
            log.info(sm.getString("http11protocol.pause", getName()));
}

 public  void postDeregister() 
{

}

 public  void postRegister(Boolean registrationDone) 
{

}

 public  void preDeregister() throws Exception 
{

}

 public ObjectName preRegister(MBeanServer server,
    ObjectName name) throws Exception 
{
        oname=name;
        mserver=server;
        domain=name.getDomain();
        return name;
}

 public  void resume() throws Exception 
{
        try {
            endpoint.resume();
        } catch (Exception ex) {
            log.error(sm.getString("http11protocol.endpoint.resumeerror"), ex);
            throw ex;
        }
        if(log.isInfoEnabled())
            log.info(sm.getString("http11protocol.resume", getName()));
}

 public  void setAdapter(Adapter adapter) 
{
 this.adapter = adapter;
}

 public  void setAddress(InetAddress ia) 
{
 endpoint.setAddress(ia);
}

 public  void setAttribute(String name,
    Object value) 
{
        if( log.isTraceEnabled())
            log.trace(sm.getString("http11protocol.setattribute", name, value));
        attributes.put(name, value);
}

Pass config info

 public  void setBacklog(int backlog) 
{
 endpoint.setBacklog(backlog);
}

 public  void setCompressableMimeType(String valueS) 
{
 compressableMimeTypes = valueS;
}

 public  void setCompression(String valueS) 
{
 compression = valueS;
}

 public  void setCompressionMinSize(int valueI) 
{
 compressionMinSize = valueI;
}

 public  void setDisableUploadTimeout(boolean isDisabled) 
{
 disableUploadTimeout = isDisabled;
}

 public  void setExecutor(Executor executor) 
{
 endpoint.setExecutor(executor);
}

 public  void setKeepAlive(boolean keepAlive) 
{
        if (!keepAlive) {
            setMaxKeepAliveRequests(1);
        }
}

Set the keep-alive policy for this connection.

 public  void setKeepAliveTimeout(int timeout) 
{
 endpoint.setKeepAliveTimeout(timeout);
}

 public  void setMaxHttpHeaderSize(int valueI) 
{
 maxHttpHeaderSize = valueI;
}

 public  void setMaxKeepAliveRequests(int mkar) 
{
 maxKeepAliveRequests = mkar;
}

 public  void setMaxSavePostSize(int valueI) 
{
 maxSavePostSize = valueI;
}

 public  void setMaxThreads(int maxThreads) 
{
 endpoint.setMaxThreads(maxThreads);
}

 public  void setNoCompressionUserAgents(String valueS) 
{
 noCompressionUserAgents = valueS;
}

 public  void setPollTime(int pollTime) 
{
 endpoint.setPollTime(pollTime);
}

 public  void setPollerSize(int pollerSize) 
{
 endpoint.setPollerSize(pollerSize);
}

 public  void setPort(int port) 
{
 endpoint.setPort(port);
}

 public  void setProcessorCache(int processorCache) 
{
 this.processorCache = processorCache;
}

 public  void setProtocol(String protocol) 
{
 setSecure(true); this.protocol = protocol;
}

 public  void setRestrictedUserAgents(String valueS) 
{
 restrictedUserAgents = valueS;
}

 public  void setSSLCACertificateFile(String SSLCACertificateFile) 
{
 endpoint.setSSLCACertificateFile(SSLCACertificateFile);
}

 public  void setSSLCACertificatePath(String SSLCACertificatePath) 
{
 endpoint.setSSLCACertificatePath(SSLCACertificatePath);
}

 public  void setSSLCARevocationFile(String SSLCARevocationFile) 
{
 endpoint.setSSLCARevocationFile(SSLCARevocationFile);
}

 public  void setSSLCARevocationPath(String SSLCARevocationPath) 
{
 endpoint.setSSLCARevocationPath(SSLCARevocationPath);
}

 public  void setSSLCertificateChainFile(String SSLCertificateChainFile) 
{
 endpoint.setSSLCertificateChainFile(SSLCertificateChainFile);
}

 public  void setSSLCertificateFile(String SSLCertificateFile) 
{
 endpoint.setSSLCertificateFile(SSLCertificateFile);
}

 public  void setSSLCertificateKeyFile(String SSLCertificateKeyFile) 
{
 endpoint.setSSLCertificateKeyFile(SSLCertificateKeyFile);
}

 public  void setSSLCipherSuite(String SSLCipherSuite) 
{
 endpoint.setSSLCipherSuite(SSLCipherSuite);
}

 public  void setSSLEnabled(boolean SSLEnabled) 
{
 endpoint.setSSLEnabled(SSLEnabled);
}

 public  void setSSLPassword(String SSLPassword) 
{
 endpoint.setSSLPassword(SSLPassword);
}

 public  void setSSLProtocol(String SSLProtocol) 
{
 endpoint.setSSLProtocol(SSLProtocol);
}

 public  void setSSLVerifyClient(String SSLVerifyClient) 
{
 endpoint.setSSLVerifyClient(SSLVerifyClient);
}

 public  void setSSLVerifyDepth(int SSLVerifyDepth) 
{
 endpoint.setSSLVerifyDepth(SSLVerifyDepth);
}

 public  void setSecure(boolean b) 
{
 secure = b;
}

 public  void setSendfileSize(int sendfileSize) 
{
 endpoint.setSendfileSize(sendfileSize);
}

 public  void setServer(String server) 
{
 this.server = server;
}

 public  void setSoLinger(int soLinger) 
{
 endpoint.setSoLinger(soLinger);
}

 public  void setSoTimeout(int soTimeout) 
{
 endpoint.setSoTimeout(soTimeout);
}

 public  void setSocketBuffer(int socketBuffer) 
{
 this.socketBuffer = socketBuffer;
}

 public  void setTcpNoDelay(boolean tcpNoDelay) 
{
 endpoint.setTcpNoDelay(tcpNoDelay);
}

 public  void setThreadPriority(int threadPriority) 
{
 endpoint.setThreadPriority(threadPriority);
}

 public  void setTimeout(int timeout) 
{
 this.timeout = timeout;
}

 public  void setUseSendfile(boolean useSendfile) 
{
 endpoint.setUseSendfile(useSendfile);
}

 public  void start() throws Exception 
{
        if( this.domain != null ) {
            try {
                tpOname=new ObjectName
                    (domain + ":" + "type=ThreadPool,name=" + getName());
                Registry.getRegistry(null, null)
                .registerComponent(endpoint, tpOname, null );
            } catch (Exception e) {
                log.error("Can't register threadpool" );
            }
            rgOname=new ObjectName
                (domain + ":type=GlobalRequestProcessor,name=" + getName());
            Registry.getRegistry(null, null).registerComponent
                ( cHandler.global, rgOname, null );
        }
        try {
            endpoint.start();
        } catch (Exception ex) {
            log.error(sm.getString("http11protocol.endpoint.starterror"), ex);
            throw ex;
        }
        if(log.isInfoEnabled())
            log.info(sm.getString("http11protocol.start", getName()));
}