public Http11NioProtocol() 
{
    
        cHandler = new Http11ConnectionHandler( this );
        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()));
        ep.destroy();
        if( tpOname!=null )
            Registry.getRegistry(null, null).unregisterComponent(tpOname);
        if( rgOname != null )
            Registry.getRegistry(null, null).unregisterComponent(rgOname);
}

 public int getAcceptorThreadPriority() 
{
      return ep.getAcceptorThreadPriority();
}

 public Adapter getAdapter() 
{
        return adapter;
}

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

 public String getAlgorithm() 
{
 return ep.getAlgorithm();
}

 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 ep.getBacklog();
}

 public String getCiphers() 
{
 return ep.getCiphers();
}

 public String getClientAuth() 
{
 return ep.getClientAuth();
}

 public String getClientauth() 
{
 return getClientAuth();
}

 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 ep.getExecutor();
}

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

Return the Keep-Alive policy for the connection.

 public String getKeypass() 
{
 return getKeystorePass();
}

 public String getKeystore() 
{
 return getKeystoreFile();
}

 public String getKeystoreFile() 
{
 return ep.getKeystoreFile();
}

 public String getKeystorePass() 
{
 return ep.getKeystorePass();
}

 public String getKeystoreType() 
{
 return ep.getKeystoreType();
}

 public String getKeytype() 
{
 return getKeystoreType();
}

 public int getMaxHttpHeaderSize() 
{
        return maxHttpHeaderSize;
}

 public int getMaxKeepAliveRequests() 
{
        return maxKeepAliveRequests;
}

 public int getMaxSavePostSize() 
{
        return maxSavePostSize;
}

 public int getMaxThreads() 
{
        return ep.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 + ep.getPort());
}

 public String getNoCompressionUserAgents() 
{
        return noCompressionUserAgents;
}

 public ObjectName getObjectName() 
{
       
        return oname;
}

 public int getOomParachute() 
{
        return ep.getOomParachute();
}

 public int getPollerThreadCount() 
{
        return ep.getPollerThreadCount();
}

 public int getPollerThreadPriority() 
{
      return ep.getThreadPriority();
}

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

 public int getProcessorCache() 
{
        return processorCache;
}

 public String getProperty(String name) 
{
        return (String)getAttribute(name);
}

Get a property

 public String getProtocol() 
{
        return getProperty("protocol");
}

 public String getRestrictedUserAgents() 
{
        return restrictedUserAgents;
}

 public boolean getSSLEnabled() 
{
 return ep.isSSLEnabled();
}

 public boolean getSecure() 
{
        return secure;
}

 public long getSelectorTimeout() 
{
        return ep.getSelectorTimeout();
}

 public String getServer() 
{
        return server;
}

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

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

 public int getSocketBuffer() 
{
        return socketBuffer;
}

 public int getSocketCloseDelay() 
{
        return socketCloseDelay;
}

 public String getSslProtocol() 
{
 return ep.getSslProtocol();
}

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

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

 public int getTimeout() 
{
        return timeout;
}

 public String getTruststoreFile() 
{
return ep.getTruststoreFile();
}

 public String getTruststorePass() 
{
return ep.getTruststorePass();
}

 public String getTruststoreType() 
{
 return ep.getTruststoreType();
}

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

 public  void init() throws Exception 
{
        ep.setName(getName());
        ep.setHandler(cHandler);
        //todo, determine if we even need these
        ep.getSocketProperties().setRxBufSize(Math.max(ep.getSocketProperties().getRxBufSize(),getMaxHttpHeaderSize()));
        ep.getSocketProperties().setTxBufSize(Math.max(ep.getSocketProperties().getTxBufSize(),getMaxHttpHeaderSize()));
        try {
            ep.init();
            sslImplementation = SSLImplementation.getInstance("org.apache.tomcat.util.net.jsse.JSSEImplementation");
        } 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  void pause() throws Exception 
{
        try {
            ep.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 {
            ep.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 setAcceptorThreadPriority(int threadPriority) 
{
      ep.setAcceptorThreadPriority(threadPriority);
      setAttribute("acceptorThreadPriority", "" + threadPriority);
}

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

The adapter, used to call the connector

 public  void setAddress(InetAddress ia) 
{
        ep.setAddress( ia );
        setAttribute("address", "" + ia);
}

 public  void setAlgorithm(String s) 
{
 ep.setAlgorithm(s);
}

 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 i) 
{
        ep.setBacklog(i);
        setAttribute("backlog", "" + i);
}

 public  void setCiphers(String s) 
{
 ep.setCiphers(s);
}

 public  void setClientAuth(String s) 
{
 ep.setClientAuth(s);
}

 public  void setClientauth(String s) 
{
setClientAuth(s);
}

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

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

 public  void setCompressionMinSize(int valueI) 
{
        compressionMinSize = valueI;
        setAttribute("compressionMinSize", "" + valueI);
}

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

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

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

Set the keep-alive policy for this connection.

 public  void setKeypass(String s) 
{
 setKeystorePass(s);
}

 public  void setKeystore(String s) 
{
 setKeystoreFile(s);
}

 public  void setKeystoreFile(String s) 
{
 ep.setKeystoreFile(s);
}

 public  void setKeystorePass(String s) 
{
 ep.setKeystorePass(s);
}

 public  void setKeystoreType(String s) 
{
 ep.setKeystoreType(s);
}

 public  void setKeytype(String s) 
{
 setKeystoreType(s);
}

 public  void setMaxHttpHeaderSize(int valueI) 
{
        maxHttpHeaderSize = valueI;
        setAttribute("maxHttpHeaderSize", "" + valueI);
}

 public  void setMaxKeepAliveRequests(int mkar) 
{
        maxKeepAliveRequests = mkar;
        setAttribute("maxKeepAliveRequests", "" + mkar);
}

Set the maximum number of Keep-Alive requests that we will honor.

 public  void setMaxSavePostSize(int valueI) 
{
        maxSavePostSize = valueI;
        setAttribute("maxSavePostSize", "" + valueI);
}

 public  void setMaxThreads(int maxThreads) 
{
        ep.setMaxThreads(maxThreads);
        setAttribute("maxThreads", "" + maxThreads);
}

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

 public  void setOomParachute(int oomParachute) 
{
        ep.setOomParachute(oomParachute);
        setAttribute("oomParachute",oomParachute);
}

 public  void setPollerThreadCount(int count) 
{
    // -------------------- Pool setup --------------------
        ep.setPollerThreadCount(count);
}

 public  void setPollerThreadPriority(int threadPriority) 
{
      ep.setPollerThreadPriority(threadPriority);
      setAttribute("pollerThreadPriority", "" + threadPriority);
}

 public  void setPort(int port) 
{
        ep.setPort(port);
        setAttribute("port", "" + port);
}

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

 public boolean setProperty(String name,
    String value) 
{
        setAttribute(name, value); //store all settings
        if ( name!=null && (name.startsWith("socket.") ||name.startsWith("selectorPool.")) ){
            return ep.setProperty(name, value);
        } else {
            return ep.setProperty(name,value); //make sure we at least try to set all properties
        }
}

Set a property.

 public  void setProtocol(String k) 
{
        setSecure(true);
        setAttribute("protocol", k);
}

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

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

 public  void setSecure(boolean b) 
{
        ep.setSecure(b);
        secure=b;
        setAttribute("secure", "" + b);
}

 public  void setSelectorTimeout(long timeout) 
{
        ep.setSelectorTimeout(timeout);
}

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

 public  void setSoLinger(int i) 
{
        ep.setSoLinger( i );
        setAttribute("soLinger", "" + i);
}

 public  void setSoTimeout(int i) 
{
        ep.setSoTimeout(i);
        setAttribute("soTimeout", "" + i);
}

 public  void setSocketBuffer(int valueI) 
{
        socketBuffer = valueI;
}

 public  void setSocketCloseDelay(int d) 
{
        socketCloseDelay=d;
        setAttribute("socketCloseDelay", "" + d);
}

 public  void setSslProtocol(String s) 
{
 ep.setSslProtocol(s);
}

 public  void setTcpNoDelay(boolean b) 
{
        ep.setTcpNoDelay( b );
        setAttribute("tcpNoDelay", "" + b);
}

 public  void setThreadPriority(int threadPriority) 
{
      ep.setThreadPriority(threadPriority);
      setAttribute("threadPriority", "" + threadPriority);
}

 public  void setTimeout(int timeouts) 
{
        timeout = timeouts;
        setAttribute("timeout", "" + timeouts);
}

 public  void setTruststoreFile(String f) 
{
ep.setTruststoreFile(f);
}

 public  void setTruststorePass(String p) 
{
ep.setTruststorePass(p);
}

 public  void setTruststoreType(String t) 
{
ep.setTruststoreType(t);
}

 public  void setUseExecutor(boolean useexec) 
{
        ep.setUseExecutor(useexec);
}

 public  void setUseSendfile(boolean useSendfile) 
{
        ep.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(ep, 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 {
            ep.start();
        } catch (Exception ex) {
            log.error(sm.getString("http11protocol.endpoint.starterror"), ex);
            throw ex;
        }
        if(log.isInfoEnabled())
            log.info(sm.getString("http11protocol.start", getName()));
}