public Http11BaseProtocol() 
{

}

 protected Http11ConnectionHandler createConnectionHandler() 
{
        Http11ConnectionHandler 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);
        return cHandler ;
}

 public  void destroy() throws Exception 
{
        if(log.isInfoEnabled())
            log.info(sm.getString("http11protocol.stop", getName()));
        ep.stopEndpoint();
}

 public Adapter getAdapter() 
{
        return adapter;
}

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

 public String getAlgorithm() 
{
        return getProperty("algorithm");
}

 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 getProperty("ciphers");
}

 public String getClientauth() 
{
        return getProperty("clientauth");
}

 public String getCompressableMimeType() 
{
        return compressableMimeTypes;
}

 public String getCompression() 
{
        return compression;
}

 public int getCompressionMinSize() 
{
        return compressionMinSize;
}

 public boolean getDisableUploadTimeout() 
{
        return disableUploadTimeout;
}

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

Return the Keep-Alive policy for the connection.

 public String getKeyAlias() 
{
        return getProperty("keyAlias");
}

 public String getKeypass() 
{
        return getProperty("keypass");
}

 public String getKeystore() 
{
        return getProperty("keystore");
}

 public String getKeytype() 
{
        return getProperty("keystoreType");
}

 public int getMaxHttpHeaderSize() 
{
        return maxHttpHeaderSize;
}

 public int getMaxKeepAliveRequests() 
{
        return maxKeepAliveRequests;
}

 public int getMaxSavePostSize() 
{
        return maxSavePostSize;
}

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

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

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

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

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

Get a property

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

 public String getProtocols() 
{
        return getProperty("protocols");
}

 public String getReportedname() 
{
        return reportedname;
}

 public String getRestrictedUserAgents() 
{
        return restrictedUserAgents;
}

 public String getSSLImplementation() 
{
        return sslImplementationName;
}

 public boolean getSecure() 
{
        return secure;
}

 public String getServer() 
{
        return server;
}

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

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

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

 public int getSocketBuffer() 
{
        return socketBuffer;
}

 public int getSocketCloseDelay() 
{
        return socketCloseDelay;
}

 public String getSocketFactory() 
{
        return socketFactoryName;
}

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

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

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

 public int getTimeout() 
{
        return timeout;
}

 public  void init() throws Exception 
{
        cHandler = createConnectionHandler() ;
        ep.setConnectionHandler( cHandler );
        try {
            checkSocketFactory();
        } catch( Exception ex ) {
            log.error(sm.getString("http11protocol.socketfactory.initerror"),
                      ex);
            throw ex;
        }
        if( socketFactory!=null ) {
            Enumeration attE=attributes.keys();
            while( attE.hasMoreElements() ) {
                String key=(String)attE.nextElement();
                Object v=attributes.get( key );
                socketFactory.setAttribute( key, v );
            }
        }
        // XXX get domain from registration
        try {
            ep.initEndpoint();
        } 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.pauseEndpoint();
        } 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 resume() throws Exception 
{
        try {
            ep.resumeEndpoint();
        } 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;
}

The adapter, used to call the connector

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

 public  void setAlgorithm(String k) 
{
        setAttribute("algorithm", k);
}

 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 ciphers) 
{
        setAttribute("ciphers", ciphers);
}

 public  void setClientauth(String k) 
{
        setAttribute("clientauth", k);
}

 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 setKeepAlive(boolean keepAlive) 
{
        if (!keepAlive) {
            setMaxKeepAliveRequests(1);
        }
}

Set the keep-alive policy for this connection.

 public  void setKeyAlias(String keyAlias) 
{
        setAttribute("keyAlias", keyAlias);
}

 public  void setKeypass(String k) 
{
        attributes.put("keypass", k);
        //setAttribute("keypass", k);
}

 public  void setKeystore(String k) 
{
        setAttribute("keystore", k);
}

 public  void setKeytype(String k) 
{
        setAttribute("keystoreType", k);
}

 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 setMaxSpareThreads(int maxThreads) 
{
        ep.setMaxSpareThreads(maxThreads);
        setAttribute("maxSpareThreads", "" + maxThreads);
}

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

 public  void setMinSpareThreads(int minSpareThreads) 
{
        ep.setMinSpareThreads(minSpareThreads);
        setAttribute("minSpareThreads", "" + minSpareThreads);
}

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

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

 public  void setProperty(String name,
    String value) 
{
        setAttribute(name, value);
}

Set a property.

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

 public  void setProtocols(String k) 
{
        setAttribute("protocols", k);
}

 public  void setReportedname(String reportedName) 
{
        reportedname = reportedName;
}

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

 public  void setSSLImplementation(String valueS) 
{
        sslImplementationName = valueS;
        setSecure(true);
        setAttribute("sslImplementation", valueS);
}

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

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

 public  void setServerSoTimeout(int i) 
{
        ep.setServerSoTimeout(i);
        setAttribute("serverSoTimeout", "" + i);
}

 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 setSocketFactory(String valueS) 
{
        socketFactoryName = valueS;
        setAttribute("socketFactory", valueS);
}

 public  void setStrategy(String strategy) 
{
        ep.setStrategy(strategy);
        setAttribute("strategy", strategy);
}

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