Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright 1997-2008 Sun Microsystems, Inc. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License. You can obtain
  * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
  * or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
  * Sun designates this particular file as subject to the "Classpath" exception
  * as provided by Sun in the GPL Version 2 section of the License file that
  * accompanied this code.  If applicable, add the following below the License
  * Header, with the fields enclosed by brackets [] replaced by your own
  * identifying information: "Portions Copyrighted [year]
  * [name of copyright owner]"
  *
  * Contributor(s):
  *
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  *
  *
  * This file incorporates work covered by the following copyright and
  * permission notice:
  *
  * Copyright 2004 The Apache Software Foundation
  *
  * Licensed 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.io.*;
 import java.net.*;
 import java.util.*;
Abstract the protocol implementation, including threading, etc. Processor is single threaded and specific to stream-based protocols, will not fit Jk protocols like JNI.

Author(s):
Remy Maucherat
Costin Manolache
 
 public class Http11Protocol implements ProtocolHandlerMBeanRegistration
 {
     // START SJSAS 6439313     
     protected boolean blocking = false;
     // END SJSAS 6439313     
 
    
The SelectorThread implementation class. Not used when Coyote is used.
 
     protected String selectorThreadImpl = null
     
     
     public Http11Protocol() {
         // START SJSAS 6439313 
        this(false,false,null);
    }
    
    public Http11Protocol(boolean secureboolean blocking
                          String selectorThreadImpl) {
        this. = secure;
        this. = blocking
        this. = selectorThreadImpl;
        // END SJSAS 6439313
        create();
    }
   
    protected void create() {
         = new Http11ConnectionHandlerthis );
    }
    public int getMaxHttpHeaderSize() {
        return ;
    }
    
    public void setMaxHttpHeaderSize(int valueI) {
         = valueI;
        setAttribute("maxHttpHeaderSize""" + valueI);
    }
    

    
The string manager for this package.
    protected static final StringManager sm =
        StringManager.getManager(.);

    
Pass config info
    public void setAttributeString nameObject value ) {
        if.isTraceEnabled())
            .trace(.getString("http11protocol.setattribute"namevalue));
        .put(namevalue);
/*
        if ("maxKeepAliveRequests".equals(name)) {
            maxKeepAliveRequests = Integer.parseInt((String) value.toString());
        } else if ("port".equals(name)) {
            setPort(Integer.parseInt((String) value.toString()));
        }
*/
    }
    public Object getAttributeString key ) {
        return .get(key);
    }

    
Set a property.
    public void setProperty(String nameString value) {
        setAttribute(namevalue);
    }

    
Get a property
    public String getProperty(String name) {
        return (String)getAttribute(name);
    }

    
The adapter, used to call the connector
    public void setAdapter(Adapter adapter) {
        this.=adapter;
    }
    public Adapter getAdapter() {
        return ;
    }

    
    
Start the protocol
    public void init() throws Exception {
        .setConnectionHandler );
	try {
            checkSocketFactory();
        } catchException ex ) {
            .error(.getString("http11protocol.socketfactory.initerror"),
                      ex);
            throw ex;
        }
        if!=null ) {
            Enumeration attE=.keys();
            whileattE.hasMoreElements() ) {
                String key=(String)attE.nextElement();
                Object v=.getkey );
                .setAttributekeyv );
            }
        }
        // XXX get domain from registration
        try {
            .initEndpoint();
        } catch (Exception ex) {
            .error(.getString("http11protocol.endpoint.initerror"), ex);
            throw ex;
        }
        .info(.getString("http11protocol.init""" + .getPort(),
                 ServerInfo.getServerInfo()));
    }
    
    
    public void start() throws Exception {
        ifthis. != null ) {
            try {
                // XXX We should be able to configure it separately
                // XXX It should be possible to use a single TP
                =new ObjectName( + ":" + "type=ThreadPool,name=http" + .getPort());
                Registry.getRegistry().registerComponent(null );
                .setName("http" + .getPort());
                .addThreadPoolListener(new MXPoolListener(this));
            } catch (Exception e) {
                .error("Can't register threadpool" );
            }
            =new ObjectName + 
                    ":type=GlobalRequestProcessor,name=http" +
                    .getPort());
            Registry.getRegistry().registerComponent.,
                    null );
        }
        try {
            .startEndpoint();
        } catch (Exception ex) {
            .error(.getString("http11protocol.endpoint.starterror"), ex);
            throw ex;
        }
        .info(.getString("http11protocol.start""" + .getPort(),
                 ServerInfo.getServerInfo()));
    }
    public void destroy() throws Exception {
        .info("Stoping http11 protocol on " + .getPort() + " " + );
        .stopEndpoint();
        if!=null ) 
            Registry.getRegistry().unregisterComponent();
        if != null ) 
            Registry.getRegistry().unregisterComponent();
    }
    
    // -------------------- Properties--------------------
    protected ThreadPool tp=ThreadPool.createThreadPool(true);
    protected PoolTcpEndpoint ep=new PoolTcpEndpoint();
    protected boolean secure;
    
    // socket factory attriubtes ( XXX replace with normal setters ) 
    protected Hashtable attributes = new Hashtable();
    protected String socketFactoryName=null;
    protected String sslImplementationName=null;
    private int maxKeepAliveRequests=100; // as in Apache HTTPD server
    protected int timeout = 300000;	// 5 minutes as in Apache HTTPD server
    protected int maxPostSize = 2 * 1024 * 1024;
    protected int maxHttpHeaderSize = 4 * 1024;
    private String reportedname;
    protected int socketCloseDelay=-1;
    protected boolean disableUploadTimeout = true;
    protected Adapter adapter;
    
    // START OF SJSAS PE 8.1 6172948
    
The input request buffer size.
    protected int requestBufferSize = 4096;
    // END OF SJSAS PE 8.1 6172948
    
    
Compression value.
    protected String compression = "off";
    // -------------------- Pool setup --------------------
    public boolean getPools() {
        return .isPoolOn();
    }
    public void setPoolsboolean t ) {
        setAttribute("pools""" + t);
    }
    public int getMaxThreads() {
        return .getMaxThreads();
    }
    public void setMaxThreadsint maxThreads ) {
	.setMaxThreads(maxThreads);
        setAttribute("maxThreads""" + maxThreads);
    }
    public int getMaxSpareThreads() {
        return .getMaxSpareThreads();
    }
    public void setMaxSpareThreadsint maxThreads ) {
        setAttribute("maxSpareThreads""" + maxThreads);
    }
    public int getMinSpareThreads() {
        return .getMinSpareThreads();
    }
    public void setMinSpareThreadsint minSpareThreads ) {
	.setMinSpareThreads(minSpareThreads);
        setAttribute("minSpareThreads""" + minSpareThreads);
    }
    // -------------------- Tcp setup --------------------
    public int getBacklog() {
        return .getBacklog();
    }
    public void setBacklogint i ) {
        setAttribute("backlog""" + i);
    }
    
    public int getPort() {
        return .getPort();
    }
    public void setPortint port ) {
	.setPort(port);
        setAttribute("port""" + port);
    	//this.port=port;
    }
    public InetAddress getAddress() {
        return .getAddress();
    }
    public void setAddress(InetAddress ia) {
	.setAddressia );
        setAttribute("address""" + ia);
    }
    //public void setHostName( String name ) {
	// ??? Doesn't seem to be used in existing or prev code
	// vhost=name;
    //}
    public String getSocketFactory() {
        return ;
    }
    public void setSocketFactoryString valueS ) {
        setAttribute("socketFactory"valueS);
    }
    public String getSSLImplementation() {
        return ;
    }
    public void setSSLImplementationString valueS) {
        setAttribute("sslImplementation"valueS);
    }
 	
    public boolean getTcpNoDelay() {
        return .getTcpNoDelay();
    }
    public void setTcpNoDelayboolean b ) {
        setAttribute("tcpNoDelay""" + b);
    }
    public boolean getDisableUploadTimeout() {
        return ;
    }
    public void setDisableUploadTimeout(boolean isDisabled) {
         = isDisabled;
    }
    public String getCompression() {
        return ;
    }
    public void setCompression(String valueS) {
         = valueS;
        setAttribute("compression"valueS);
    }
    public int getMaxPostSize() {
        return ;
    }
    public void setMaxPostSize(int valueI) {
         = valueI;
        setAttribute("maxPostSize""" + valueI);
    }
  
    public int getSoLinger() {
        return .getSoLinger();
    }
    public void setSoLingerint i ) {
        setAttribute("soLinger""" + i);
    }
    public int getSoTimeout() {
        return .getSoTimeout();
    }
    public void setSoTimeoutint i ) {
        setAttribute("soTimeout""" + i);
    }
    
    public int getServerSoTimeout() {
        return .getServerSoTimeout();
    }
    public void setServerSoTimeoutint i ) {
        setAttribute("serverSoTimeout""" + i);
    }
    
    public String getKeystore() {
        return getProperty("keystore");
    }
    public void setKeystoreString k ) {
        setAttribute("keystore"k);
    }
    public String getKeypass() {
        return getProperty("keypass");
    }
    public void setKeypassString k ) {
        .put("keypass"k);
        //setAttribute("keypass", k);
    }
    public String getKeytype() {
        return getProperty("keystoreType");
    } 
    public void setKeytypeString k ) {
        setAttribute("keystoreType"k);
    }
    // START GlassFish Issue 657
    public void setTruststore(String truststore) {
        setAttribute("truststore"truststore);
    }
    public void setTruststoreType(String truststoreType) {
        setAttribute("truststoreType"truststoreType);
    }    
    // END GlassFish Issue 657
    public String getClientauth() {
        return getProperty("clientauth");
    }
    public void setClientauthString k ) {
        setAttribute("clientauth"k);
    }
    
    public String getProtocol() {
        return getProperty("protocol");
    }
    public void setProtocolString k ) {
        setAttribute("protocol"k);
    }
    public String getProtocols() {
        return getProperty("protocols");
    }
    public void setProtocols(String k) {
        setAttribute("protocols"k);
    }
    public String getAlgorithm() {
        return getProperty("algorithm");
    }
    public void setAlgorithmString k ) {
        setAttribute("algorithm"k);
    }
    public boolean getSecure() {
        return ;
    }
    public void setSecureboolean b ) {
    	=b;
        setAttribute("secure""" + b);
    }
    
    // START SJSAS 6439313     
    public boolean getBlocking() {
        return ;
    }
    public void setBlockingboolean b ) {
    	=b;
        setAttribute("blocking""" + b);
    }
    // END SJSAS 6439313     
    
    public String getCiphers() {
        return getProperty("ciphers");
    }
    public void setCiphers(String ciphers) {
        setAttribute("ciphers"ciphers);
    }
    public String getKeyAlias() {
        return getProperty("keyAlias");
    }
    public void setKeyAlias(String keyAlias) {
        setAttribute("keyAlias"keyAlias);
    }
    public int getMaxKeepAliveRequests() {
        return ;
    }

    
Set the maximum number of Keep-Alive requests that we will honor.
    public void setMaxKeepAliveRequests(int mkar) {
        setAttribute("maxKeepAliveRequests""" + mkar);
    }
    public int getSocketCloseDelay() {
        return ;
    }
    public void setSocketCloseDelayint d ) {
        =d;
        setAttribute("socketCloseDelay""" + d);
    }
    protected static ServerSocketFactory string2SocketFactoryString val)
    {
	Class chC=Class.forNameval );
    }
    public int getTimeout() {
        return ;
    }
    public void setTimeoutint timeouts ) {
	 = timeouts * 1000;
        setAttribute("timeout""" + timeouts);
    }
 
    public String getReportedname() {
        return ;
    }
    public void setReportednameString reportedName) {
	 = reportedName;
    }
    
    // --------------------  Connection handler --------------------
    public static final int THREAD_DATA_PROCESSOR=1;
    public static final int THREAD_DATA_OBJECT_NAME=2;
    
    
    static class MXPoolListener implements ThreadPool.ThreadPoolListener {
        MXPoolListenerHttp11Protocol protoThreadPool control ) {
            
        }
        public void threadStart(ThreadPool tpThread t) {
        }
        public void threadEnd(ThreadPool tpThread t) {
            // Register our associated processor
            // TP uses only TWA
            ThreadWithAttributes ta=(ThreadWithAttributes)t;
            Object tpData[]=ta.getThreadData(tp);
            iftpData==null ) return;
            // Weird artifact - it should be cleaned up, but that may break something
            // and it won't gain us too much
            iftpData[1] instanceof Object[] ) {
                tpData=(Object [])tpData[1];
            }
            ObjectName oname=(ObjectName)tpData[.];
            ifoname==null ) return;
            Registry.getRegistry().unregisterComponent(oname);
            Http11Processor processor = 
                (Http11ProcessortpData[.];
            RequestInfo rp=processor.getRequest().getRequestProcessor();
            rp.setGlobalProcessor(null);
        }
    }
    static class Http11ConnectionHandler implements TcpConnectionHandler {
        Http11Protocol proto;
        static int count=0;
        Http11ConnectionHandlerHttp11Protocol proto ) {
            this.=proto;
        }
        
        public void setAttributeString nameObject value ) {
        }
        
        public void setServerObject o ) {
        }
    
        public Object[] init() {
            Object thData[]=new Object[3];
            
            Http11Processor  processor = 
                new Http11Processor(.);
            processor.setAdapter. );
            processor.setThreadPool. );
            processor.setMaxKeepAliveRequests. );
            processor.setTimeout. );
            processor.setDisableUploadTimeout. );
            processor.setCompression. );
            processor.setMaxPostSize. );
            // START OF SJSAS PE 8.1 6172948
            processor.setBufferSize(.);
            // END OF SJSAS PE 8.1 6172948
            thData[.]=processor;
            
            if.getDomain() != null ) {
                try {
                    RequestInfo rp=processor.getRequest().getRequestProcessor();
                    rp.setGlobalProcessor();
                    ObjectName rpName=new ObjectName(.getDomain() + 
                            ":type=RequestProcessor,worker=http" +
                            ..getPort() +",name=HttpRequest" + ++ );
                    Registry.getRegistry().registerComponentrprpNamenull);
                    thData[.]=rpName;
                } catchException ex ) {
                    .warn("Error registering request");
                }
            }
            return  thData;
        }
        public void processConnection(TcpConnection connection,
				      Object thData[]) {
            Socket socket=null;
            Http11Processor  processor=null;
            try {
                processor=(Http11Processor)thData[.];
                
                if (processor instanceof ActionHook) {
                    ((ActionHookprocessor).action(.null);
                }
                socket=connection.getSocket();
                
                InputStream in = socket.getInputStream();
                OutputStream out = socket.getOutputStream();
                if. ) {
                    SSLSupport sslSupport=null;
                    if(. != null)
                        sslSupport = ..getSSLSupport(socket);
                    processor.setSSLSupport(sslSupport);
                } else {
                    processor.setSSLSupportnull );
                }
                processor.setSocketsocket );
                
                processor.process(inout);
                
                // If unread input arrives after the shutdownInput() call
                // below and before or during the socket.close(), an error
                // may be reported to the client.  To help troubleshoot this
                // type of error, provide a configurable delay to give the
                // unread input time to arrive so it can be successfully read
                // and discarded by shutdownInput().
                if. >= 0 ) {
                    try {
                        Thread.sleep(.);
                    } catch (InterruptedException ie) { /* ignore */ }
                }
                
                TcpConnection.shutdownInputsocket );
            } catch(java.net.SocketException e) {
                // SocketExceptions are normal
                ..debug
                    (.getString
                     ("http11protocol.proto.socketexception.debug"), e);
            } catch (java.io.IOException e) {
                // IOExceptions are normal 
                ..debug
                    (.getString
                     ("http11protocol.proto.ioexception.debug"), e);
            }
            // Future developers: if you discover any other
            // rare-but-nonfatal exceptions, catch them here, and log as
            // above.
            catch (Throwable e) {
                // any other exception or error is odd. Here we log it
                // with "ERROR" level, so it will show up even on
                // less-than-verbose logs.
                ..error(.getString("http11protocol.proto.error"), e);
            } finally {
                //       if(proto.adapter != null) proto.adapter.recycle();
                //                processor.recycle();
                
                if (processor instanceof ActionHook) {
                    ((ActionHookprocessor).action(.null);
                }
                // recycle kernel sockets ASAP
                try { if (socket != nullsocket.close (); }
                catch (IOException e) { /* ignore */ }
            }
        }
    }
    protected static final com.sun.org.apache.commons.logging.Log log 
        = com.sun.org.apache.commons.logging.LogFactory.getLog(Http11Protocol.class);
    // -------------------- Various implementation classes --------------------

    
Sanity check and socketFactory setup. IMHO it is better to stop the show on a broken connector, then leave Tomcat running and broken.

Throws:
TomcatException Unable to resolve classes
    private void checkSocketFactory() throws Exception {
	if() {
 	    try {
 		// The SSL setup code has been moved into
 		// SSLImplementation since SocketFactory doesn't
 		// provide a wide enough interface
 		=SSLImplementation.getInstance
                 = 
                        .getServerSocketFactory();
 	    } catch (ClassNotFoundException e){
 		throw e;
  	    }
  	}
 	else {
 	    if ( != null) {
 		try {
 		} catch(Exception sfex) {
 		    throw sfex;
 		}
	    }
	}
    }
    /*
    public boolean isKeystoreSet() {
        return (attributes.get("keystore") != null);
    }
    public boolean isKeypassSet() {
        return (attributes.get("keypass") != null);
    }
    public boolean isClientauthSet() {
        return (attributes.get("clientauth") != null);
    }
    public boolean isAttributeSet( String attr ) {
        return (attributes.get(attr) != null);
    }
    public boolean isSecure() {
        return secure;
    }
   
    public PoolTcpEndpoint getEndpoint() {
	return ep;
    }
    
    */
    protected String domain;
    protected ObjectName oname;
    protected MBeanServer mserver;
    public ObjectName getObjectName() {
        return ;
    }
    public String getDomain() {
        return ;
    }
    public ObjectName preRegister(MBeanServer server,
                                  ObjectName namethrows Exception {
        =name;
        =server;
        =name.getDomain();
        return name;
    }
    public void postRegister(Boolean registrationDone) {
    }
    public void preDeregister() throws Exception {
    }
    public void postDeregister() {
    }
    
    // START OF SJSAS PE 8.1 6172948
    
Set the request input buffer size
    public void setBufferSize(int requestBufferSize){
        this. = requestBufferSize;
    }
    

    
Return the request input buffer size
    public int getBufferSize(){
        return ;
    }    
    // END OF SJSAS PE 8.1 6172948 
New to GrepCode? Check out our FAQ X