[jbossweb-commits] JBossWeb SVN: r2087 - in branches/7.2.x: src/main/java/org/apache/catalina/connector and 7 other directories.
jbossweb-commits at lists.jboss.org
jbossweb-commits at lists.jboss.org
Wed Sep 26 09:54:12 EDT 2012
Author: remy.maucherat at jboss.com
Date: 2012-09-26 09:54:12 -0400 (Wed, 26 Sep 2012)
New Revision: 2087
Added:
branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpProcessor.java
branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpProtocol.java
branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11Processor.java
branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11Protocol.java
branches/7.2.x/src/main/java/org/apache/coyote/http11/InternalInputBuffer.java
branches/7.2.x/src/main/java/org/apache/coyote/http11/InternalOutputBuffer.java
branches/7.2.x/src/main/java/org/apache/tomcat/util/net/DefaultServerSocketFactory.java
branches/7.2.x/src/main/java/org/apache/tomcat/util/net/JIoEndpoint.java
branches/7.2.x/src/main/java/org/apache/tomcat/util/net/ServerSocketFactory.java
branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSEFactory.java
branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSEImplementation.java
branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSESocketFactory.java
branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSESupport.java
Modified:
branches/7.2.x/pom.xml
branches/7.2.x/src/main/java/org/apache/catalina/connector/Connector.java
branches/7.2.x/src/main/java/org/apache/catalina/util/ConcurrentMessageDigest.java
branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpAprProtocol.java
branches/7.2.x/src/main/java/org/apache/coyote/ajp/Constants.java
branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11NioProtocol.java
branches/7.2.x/src/main/java/org/apache/tomcat/util/net/NioEndpoint.java
branches/7.2.x/src/main/java/org/apache/tomcat/util/net/SSLImplementation.java
branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/NioJSSESocketChannelFactory.java
branches/7.2.x/src/main/java/org/jboss/web/CatalinaLogger.java
branches/7.2.x/webapps/docs/changelog.xml
Log:
- Add back java.io AJP and HTTP, with i18n.
- Compile for Java 6.
- Try to run NIO 2 HTTP if possible.
- Done ?
Modified: branches/7.2.x/pom.xml
===================================================================
(Binary files differ)
Modified: branches/7.2.x/src/main/java/org/apache/catalina/connector/Connector.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/catalina/connector/Connector.java 2012-09-25 12:49:25 UTC (rev 2086)
+++ branches/7.2.x/src/main/java/org/apache/catalina/connector/Connector.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -549,6 +549,8 @@
if ("org.apache.coyote.http11.Http11Protocol".equals
(getProtocolHandlerClassName())
|| "org.apache.coyote.http11.Http11AprProtocol".equals
+ (getProtocolHandlerClassName())
+ || "org.apache.coyote.http11.Http11NioProtocol".equals
(getProtocolHandlerClassName())) {
return "HTTP/1.1";
} else if ("org.apache.coyote.ajp.AjpProtocol".equals
@@ -583,8 +585,19 @@
}
} else {
if ("HTTP/1.1".equals(protocol) || "http".equals(protocol)) {
+ try {
+ Class.forName("java.nio.channels.CompletionHandler");
+ setProtocolHandlerClassName
+ ("org.apache.coyote.http11.Http11NioProtocol");
+ } catch (Exception e) {
+ // NIO 2 is not available
+ setProtocolHandlerClassName
+ ("org.apache.coyote.http11.Http11Protocol");
+ CatalinaLogger.CONNECTOR_LOGGER.usingJavaIoConnector();
+ }
+ } else if ("AJP/1.3".equals(protocol) || "ajp".equals(protocol)) {
setProtocolHandlerClassName
- ("org.apache.coyote.http11.Http11NioProtocol");
+ ("org.apache.coyote.ajp.AjpProtocol");
} else if (protocol != null) {
setProtocolHandlerClassName(protocol);
}
Modified: branches/7.2.x/src/main/java/org/apache/catalina/util/ConcurrentMessageDigest.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/catalina/util/ConcurrentMessageDigest.java 2012-09-25 12:49:25 UTC (rev 2086)
+++ branches/7.2.x/src/main/java/org/apache/catalina/util/ConcurrentMessageDigest.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -33,7 +33,7 @@
private static final String MD5 = "MD5";
private static final Map<String,Queue<MessageDigest>> queues =
- new HashMap<>();
+ new HashMap<String,Queue<MessageDigest>>();
private ConcurrentMessageDigest() {
@@ -95,7 +95,7 @@
synchronized (queues) {
if (!queues.containsKey(algorithm)) {
MessageDigest md = MessageDigest.getInstance(algorithm);
- Queue<MessageDigest> queue = new ConcurrentLinkedQueue<>();
+ Queue<MessageDigest> queue = new ConcurrentLinkedQueue<MessageDigest>();
queue.add(md);
queues.put(algorithm, queue);
}
Modified: branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpAprProtocol.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpAprProtocol.java 2012-09-25 12:49:25 UTC (rev 2086)
+++ branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpAprProtocol.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -321,7 +321,7 @@
* Should authentication be done in the native webserver layer,
* or in the Servlet container ?
*/
- protected boolean tomcatAuthentication = true;
+ protected boolean tomcatAuthentication = Constants.DEFAULT_TOMCAT_AUTHENTICATION;
public boolean getTomcatAuthentication() { return tomcatAuthentication; }
public void setTomcatAuthentication(boolean tomcatAuthentication) { this.tomcatAuthentication = tomcatAuthentication; }
Added: branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpProcessor.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpProcessor.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpProcessor.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,1337 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2009, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.apache.coyote.ajp;
+
+import static org.jboss.web.CoyoteMessages.MESSAGES;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InterruptedIOException;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+
+import org.apache.coyote.ActionCode;
+import org.apache.coyote.ActionHook;
+import org.apache.coyote.Adapter;
+import org.apache.coyote.InputBuffer;
+import org.apache.coyote.OutputBuffer;
+import org.apache.coyote.Request;
+import org.apache.coyote.RequestInfo;
+import org.apache.coyote.Response;
+import org.apache.tomcat.util.buf.ByteChunk;
+import org.apache.tomcat.util.buf.HexUtils;
+import org.apache.tomcat.util.buf.MessageBytes;
+import org.apache.tomcat.util.http.HttpMessages;
+import org.apache.tomcat.util.http.MimeHeaders;
+import org.apache.tomcat.util.net.JIoEndpoint;
+import org.apache.tomcat.util.net.SocketStatus;
+import org.apache.tomcat.util.net.JIoEndpoint.Handler.SocketState;
+import org.jboss.web.CoyoteLogger;
+
+
+/**
+ * Processes HTTP requests.
+ *
+ * @author Remy Maucherat
+ * @author Henri Gomez
+ * @author Dan Milstein
+ * @author Keith Wannamaker
+ * @author Kevin Seguin
+ * @author Costin Manolache
+ * @author Bill Barker
+ */
+public class AjpProcessor implements ActionHook {
+
+
+ // ----------------------------------------------------------- Constructors
+
+
+ public AjpProcessor(int packetSize, JIoEndpoint endpoint) {
+
+ this.endpoint = endpoint;
+
+ request = new Request();
+ request.setInputBuffer(new SocketInputBuffer());
+
+ response = new Response();
+ response.setHook(this);
+ response.setOutputBuffer(new SocketOutputBuffer());
+ request.setResponse(response);
+
+ requestHeaderMessage = new AjpMessage(packetSize);
+ responseHeaderMessage = new AjpMessage(packetSize);
+ bodyMessage = new AjpMessage(packetSize);
+
+ // Set the get body message buffer
+ AjpMessage getBodyMessage = new AjpMessage(16);
+ getBodyMessage.reset();
+ getBodyMessage.appendByte(Constants.JK_AJP13_GET_BODY_CHUNK);
+ getBodyMessage.appendInt(packetSize - Constants.READ_HEAD_LEN);
+ getBodyMessage.end();
+ getBodyMessageArray = new byte[getBodyMessage.getLen()];
+ System.arraycopy(getBodyMessage.getBuffer(), 0, getBodyMessageArray,
+ 0, getBodyMessage.getLen());
+
+ // Cause loading of HexUtils
+ int foo = HexUtils.DEC[0];
+
+ // Cause loading of HttpMessages
+ HttpMessages.getMessage(200);
+
+ }
+
+
+ // ----------------------------------------------------- Instance Variables
+
+
+ /**
+ * Associated adapter.
+ */
+ protected Adapter adapter = null;
+
+
+ /**
+ * Request object.
+ */
+ protected Request request = null;
+
+
+ /**
+ * Response object.
+ */
+ protected Response response = null;
+
+
+ /**
+ * Header message. Note that this header is merely the one used during the
+ * processing of the first message of a "request", so it might not be a request
+ * header. It will stay unchanged during the processing of the whole request.
+ */
+ protected AjpMessage requestHeaderMessage = null;
+
+
+ /**
+ * Message used for response header composition.
+ */
+ protected AjpMessage responseHeaderMessage = null;
+
+
+ /**
+ * Body message.
+ */
+ protected AjpMessage bodyMessage = null;
+
+
+ /**
+ * Body message.
+ */
+ protected MessageBytes bodyBytes = MessageBytes.newInstance();
+
+
+ /**
+ * Error flag.
+ */
+ protected boolean error = false;
+
+
+ /**
+ * Socket associated with the current connection.
+ */
+ protected Socket socket;
+
+
+ /**
+ * Input stream.
+ */
+ protected InputStream input;
+
+
+ /**
+ * Output stream.
+ */
+ protected OutputStream output;
+
+
+ /**
+ * Host name (used to avoid useless B2C conversion on the host name).
+ */
+ protected char[] hostNameC = new char[0];
+
+
+ /**
+ * Associated endpoint.
+ */
+ protected JIoEndpoint endpoint;
+
+
+ /**
+ * The socket timeout used when reading the first block of the request
+ * header.
+ */
+ protected long readTimeout;
+
+
+ /**
+ * Temp message bytes used for processing.
+ */
+ protected MessageBytes tmpMB = MessageBytes.newInstance();
+
+
+ /**
+ * Byte chunk for certs.
+ */
+ protected MessageBytes certificates = MessageBytes.newInstance();
+
+
+ /**
+ * End of stream flag.
+ */
+ protected boolean endOfStream = false;
+
+
+ /**
+ * Body empty flag.
+ */
+ protected boolean empty = true;
+
+
+ /**
+ * First read.
+ */
+ protected boolean first = true;
+
+
+ /**
+ * Replay read.
+ */
+ protected boolean replay = false;
+
+
+ /**
+ * Finished response.
+ */
+ protected boolean finished = false;
+
+
+ /**
+ * Direct buffer used for sending right away a get body message.
+ */
+ protected final byte[] getBodyMessageArray;
+
+
+ /**
+ * Direct buffer used for sending right away a pong message.
+ */
+ protected static final byte[] pongMessageArray;
+
+
+ /**
+ * End message array.
+ */
+ protected static final byte[] endMessageArray;
+
+ /**
+ * Flush message array.
+ */
+ protected static final byte[] flushMessageArray;
+
+
+ /**
+ * Event used.
+ */
+ protected boolean event = false;
+
+
+ /**
+ * Event processing.
+ */
+ protected boolean eventProcessing = true;
+ public void startProcessing() { eventProcessing = true; }
+ public void endProcessing() { eventProcessing = false; }
+
+
+ // ----------------------------------------------------- Static Initializer
+
+
+ static {
+
+ // Set the read body message buffer
+ AjpMessage pongMessage = new AjpMessage(16);
+ pongMessage.reset();
+ pongMessage.appendByte(Constants.JK_AJP13_CPONG_REPLY);
+ pongMessage.end();
+ pongMessageArray = new byte[pongMessage.getLen()];
+ System.arraycopy(pongMessage.getBuffer(), 0, pongMessageArray,
+ 0, pongMessage.getLen());
+
+ // Allocate the end message array
+ AjpMessage endMessage = new AjpMessage(16);
+ endMessage.reset();
+ endMessage.appendByte(Constants.JK_AJP13_END_RESPONSE);
+ endMessage.appendByte(1);
+ endMessage.end();
+ endMessageArray = new byte[endMessage.getLen()];
+ System.arraycopy(endMessage.getBuffer(), 0, endMessageArray, 0,
+ endMessage.getLen());
+
+ // Allocate the flush message array
+ AjpMessage flushMessage = new AjpMessage(16);
+ flushMessage.reset();
+ flushMessage.appendByte(Constants.JK_AJP13_SEND_BODY_CHUNK);
+ flushMessage.appendInt(0);
+ flushMessage.appendByte(0);
+ flushMessage.end();
+ flushMessageArray = new byte[flushMessage.getLen()];
+ System.arraycopy(flushMessage.getBuffer(), 0, flushMessageArray, 0,
+ flushMessage.getLen());
+
+ }
+
+
+ // ------------------------------------------------------------- Properties
+
+
+ /**
+ * Use Tomcat authentication ?
+ */
+ protected boolean tomcatAuthentication = true;
+ public boolean getTomcatAuthentication() { return tomcatAuthentication; }
+ public void setTomcatAuthentication(boolean tomcatAuthentication) { this.tomcatAuthentication = tomcatAuthentication; }
+
+
+ /**
+ * Required secret.
+ */
+ protected String requiredSecret = null;
+ public void setRequiredSecret(String requiredSecret) { this.requiredSecret = requiredSecret; }
+
+
+ /**
+ * The number of milliseconds Tomcat will wait for a subsequent request
+ * before closing the connection. The default is the same as for
+ * Apache HTTP Server (15 000 milliseconds).
+ */
+ protected int keepAliveTimeout = -1;
+ public int getKeepAliveTimeout() { return keepAliveTimeout; }
+ public void setKeepAliveTimeout(int timeout) { keepAliveTimeout = timeout; }
+
+
+ /**
+ * Timeout.
+ */
+ protected int timeout = -1;
+ public void setTimeout(int timeout) { this.timeout = timeout; }
+ public int getTimeout() { return timeout; }
+
+
+ /**
+ * A resume has been requested.
+ */
+ protected boolean resumeNotification = false;
+ public boolean getResumeNotification() { return resumeNotification; }
+
+
+ // --------------------------------------------------------- Public Methods
+
+
+ /** Get the request associated with this processor.
+ *
+ * @return The request
+ */
+ public Request getRequest() {
+ return request;
+ }
+
+
+ public SocketState event(SocketStatus status)
+ throws IOException {
+
+ RequestInfo rp = request.getRequestProcessor();
+ try {
+ if (status == SocketStatus.OPEN_CALLBACK) {
+ // The resume notification is now done
+ resumeNotification = false;
+ } else if (status == SocketStatus.ERROR) {
+ // Set error flag right away
+ error = true;
+ }
+ rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
+ error = !adapter.event(request, response, status);
+ } catch (InterruptedIOException e) {
+ error = true;
+ } catch (Throwable t) {
+ CoyoteLogger.AJP_LOGGER.errorProcessingRequest(t);
+ // 500 - Internal Server Error
+ response.setStatus(500);
+ error = true;
+ }
+
+ rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);
+
+ if (error) {
+ recycle();
+ return SocketState.CLOSED;
+ } else if (!event) {
+ finish();
+ recycle();
+ return SocketState.OPEN;
+ } else {
+ return SocketState.LONG;
+ }
+ }
+
+
+ /**
+ * Process pipelined HTTP requests using the specified input and output
+ * streams.
+ *
+ * @throws IOException error during an I/O operation
+ */
+ public SocketState process(Socket socket)
+ throws IOException {
+ RequestInfo rp = request.getRequestProcessor();
+ rp.setStage(org.apache.coyote.Constants.STAGE_PARSE);
+
+ // Setting up the socket
+ this.socket = socket;
+ input = socket.getInputStream();
+ output = socket.getOutputStream();
+ int soTimeout = -1;
+ if (keepAliveTimeout > 0) {
+ soTimeout = socket.getSoTimeout();
+ }
+
+ // Error flag
+ error = false;
+
+ while (!error && !event) {
+
+ // Parsing the request header
+ try {
+ // Set keep alive timeout if enabled
+ if (keepAliveTimeout > 0) {
+ socket.setSoTimeout(keepAliveTimeout);
+ }
+ // Get first message of the request
+ if (!readMessage(requestHeaderMessage)) {
+ // This means a connection timeout
+ rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);
+ break;
+ }
+ // Set back timeout if keep alive timeout is enabled
+ if (keepAliveTimeout > 0) {
+ socket.setSoTimeout(soTimeout);
+ }
+ // Check message type, process right away and break if
+ // not regular request processing
+ int type = requestHeaderMessage.getByte();
+ if (type == Constants.JK_AJP13_CPING_REQUEST) {
+ try {
+ output.write(pongMessageArray);
+ } catch (IOException e) {
+ error = true;
+ }
+ continue;
+ } else if(type != Constants.JK_AJP13_FORWARD_REQUEST) {
+ // Usually the servlet didn't read the previous request body
+ CoyoteLogger.AJP_LOGGER.unexpectedAjpMessage(type);
+ error = true;
+ break;
+ }
+
+ request.setStartTime(System.currentTimeMillis());
+ } catch (IOException e) {
+ error = true;
+ break;
+ } catch (Throwable t) {
+ CoyoteLogger.AJP_LOGGER.errorParsingAjpHeaderMessage(t);
+ // 400 - Bad Request
+ response.setStatus(400);
+ error = true;
+ }
+
+ // Setting up filters, and parse some request headers
+ rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);
+ try {
+ prepareRequest();
+ } catch (Throwable t) {
+ CoyoteLogger.AJP_LOGGER.errorPreparingAjpRequest(t);
+ // 400 - Internal Server Error
+ response.setStatus(400);
+ error = true;
+ }
+
+ // Process the request in the adapter
+ if (!error) {
+ try {
+ rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
+ adapter.service(request, response);
+ } catch (InterruptedIOException e) {
+ error = true;
+ } catch (Throwable t) {
+ CoyoteLogger.AJP_LOGGER.errorProcessingRequest(t);
+ // 500 - Internal Server Error
+ response.setStatus(500);
+ error = true;
+ }
+ }
+
+ // Finish the response if not done yet
+ if (!event && !finished) {
+ try {
+ finish();
+ } catch (Throwable t) {
+ error = true;
+ }
+ }
+
+ // If there was an error, make sure the request is counted as
+ // and error, and update the statistics counter
+ if (error) {
+ response.setStatus(500);
+ }
+ request.updateCounters();
+
+ if (!event) {
+ recycle();
+ }
+
+ rp.setStage(org.apache.coyote.Constants.STAGE_KEEPALIVE);
+
+ }
+
+ rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);
+
+ if (event) {
+ if (error) {
+ input = null;
+ output = null;
+ recycle();
+ return SocketState.CLOSED;
+ } else {
+ eventProcessing = false;
+ return SocketState.LONG;
+ }
+ } else {
+ input = null;
+ output = null;
+ recycle();
+ return SocketState.CLOSED;
+ }
+ }
+
+
+ // ----------------------------------------------------- ActionHook Methods
+
+
+ /**
+ * Send an action to the connector.
+ *
+ * @param actionCode Type of the action
+ * @param param Action parameter
+ */
+ public void action(ActionCode actionCode, Object param) {
+
+ if (actionCode == ActionCode.ACTION_COMMIT) {
+
+ if (response.isCommitted())
+ return;
+
+ // Validate and write response headers
+ try {
+ prepareResponse();
+ } catch (IOException e) {
+ // Set error flag
+ error = true;
+ }
+
+ } else if (actionCode == ActionCode.ACTION_CLIENT_FLUSH) {
+
+ if (!response.isCommitted()) {
+ // Validate and write response headers
+ try {
+ prepareResponse();
+ } catch (IOException e) {
+ // Set error flag
+ error = true;
+ return;
+ }
+ }
+
+ try {
+ flush();
+ } catch (IOException e) {
+ // Set error flag
+ error = true;
+ }
+
+ } else if (actionCode == ActionCode.ACTION_CLOSE) {
+ // Close
+
+ // End the processing of the current request, and stop any further
+ // transactions with the client
+
+ try {
+ finish();
+ } catch (IOException e) {
+ // Set error flag
+ error = true;
+ }
+
+ } else if (actionCode == ActionCode.ACTION_REQ_SSL_ATTRIBUTE ) {
+
+ if (!certificates.isNull()) {
+ ByteChunk certData = certificates.getByteChunk();
+ X509Certificate jsseCerts[] = null;
+ ByteArrayInputStream bais =
+ new ByteArrayInputStream(certData.getBytes(),
+ certData.getStart(),
+ certData.getLength());
+ // Fill the elements.
+ try {
+ CertificateFactory cf =
+ CertificateFactory.getInstance("X.509");
+ while(bais.available() > 0) {
+ X509Certificate cert = (X509Certificate)
+ cf.generateCertificate(bais);
+ if(jsseCerts == null) {
+ jsseCerts = new X509Certificate[1];
+ jsseCerts[0] = cert;
+ } else {
+ X509Certificate [] temp = new X509Certificate[jsseCerts.length+1];
+ System.arraycopy(jsseCerts,0,temp,0,jsseCerts.length);
+ temp[jsseCerts.length] = cert;
+ jsseCerts = temp;
+ }
+ }
+ } catch (java.security.cert.CertificateException e) {
+ CoyoteLogger.AJP_LOGGER.errorProcessingCertificates(e);
+ return;
+ }
+ request.setAttribute(org.apache.tomcat.util.net.Constants.CERTIFICATE_KEY, jsseCerts);
+ }
+
+ } else if (actionCode == ActionCode.ACTION_REQ_HOST_ATTRIBUTE) {
+
+ // Get remote host name using a DNS resolution
+ if (request.remoteHost().isNull()) {
+ try {
+ request.remoteHost().setString(InetAddress.getByName
+ (request.remoteAddr().toString()).getHostName());
+ } catch (IOException iex) {
+ // Ignore
+ }
+ }
+
+ } else if (actionCode == ActionCode.ACTION_REQ_LOCAL_ADDR_ATTRIBUTE) {
+
+ // Copy from local name for now, which should simply be an address
+ request.localAddr().setString(request.localName().toString());
+
+ } else if (actionCode == ActionCode.ACTION_REQ_SET_BODY_REPLAY) {
+
+ // Set the given bytes as the content
+ ByteChunk bc = (ByteChunk) param;
+ int length = bc.getLength();
+ bodyBytes.setBytes(bc.getBytes(), bc.getStart(), length);
+ request.setContentLength(length);
+ first = false;
+ empty = false;
+ replay = true;
+ endOfStream = false;
+
+ } else if (actionCode == ActionCode.ACTION_EVENT_BEGIN) {
+ event = true;
+ } else if (actionCode == ActionCode.ACTION_EVENT_END) {
+ event = false;
+ } else if (actionCode == ActionCode.ACTION_EVENT_SUSPEND) {
+ // No action needed
+ } else if (actionCode == ActionCode.ACTION_EVENT_RESUME) {
+ // An event is being processed already: adding for resume will be done
+ // when the socket gets back to the poller
+ if (!eventProcessing && !resumeNotification) {
+ endpoint.getEventPoller().add(socket, timeout, true, true);
+ }
+ resumeNotification = true;
+ } else if (actionCode == ActionCode.ACTION_EVENT_TIMEOUT) {
+ timeout = ((Integer) param).intValue();
+ }
+
+
+ }
+
+
+ // ------------------------------------------------------ Connector Methods
+
+
+ /**
+ * Set the associated adapter.
+ *
+ * @param adapter the new adapter
+ */
+ public void setAdapter(Adapter adapter) {
+ this.adapter = adapter;
+ }
+
+
+ /**
+ * Get the associated adapter.
+ *
+ * @return the associated adapter
+ */
+ public Adapter getAdapter() {
+ return adapter;
+ }
+
+
+ // ------------------------------------------------------ Protected Methods
+
+
+ /**
+ * After reading the request headers, we have to setup the request filters.
+ */
+ protected void prepareRequest() {
+
+ // Translate the HTTP method code to a String.
+ byte methodCode = requestHeaderMessage.getByte();
+ if (methodCode != Constants.SC_M_JK_STORED) {
+ String methodName = Constants.methodTransArray[(int)methodCode - 1];
+ request.method().setString(methodName);
+ }
+
+ requestHeaderMessage.getBytes(request.protocol());
+ requestHeaderMessage.getBytes(request.requestURI());
+
+ requestHeaderMessage.getBytes(request.remoteAddr());
+ requestHeaderMessage.getBytes(request.remoteHost());
+ requestHeaderMessage.getBytes(request.localName());
+ request.setLocalPort(requestHeaderMessage.getInt());
+
+ boolean isSSL = requestHeaderMessage.getByte() != 0;
+ if (isSSL) {
+ request.scheme().setString("https");
+ }
+
+ // Decode headers
+ MimeHeaders headers = request.getMimeHeaders();
+
+ int hCount = requestHeaderMessage.getInt();
+ for(int i = 0 ; i < hCount ; i++) {
+ String hName = null;
+
+ // Header names are encoded as either an integer code starting
+ // with 0xA0, or as a normal string (in which case the first
+ // two bytes are the length).
+ int isc = requestHeaderMessage.peekInt();
+ int hId = isc & 0xFF;
+
+ MessageBytes vMB = null;
+ isc &= 0xFF00;
+ if(0xA000 == isc) {
+ requestHeaderMessage.getInt(); // To advance the read position
+ hName = Constants.headerTransArray[hId - 1];
+ vMB = headers.addValue(hName);
+ } else {
+ // reset hId -- if the header currently being read
+ // happens to be 7 or 8 bytes long, the code below
+ // will think it's the content-type header or the
+ // content-length header - SC_REQ_CONTENT_TYPE=7,
+ // SC_REQ_CONTENT_LENGTH=8 - leading to unexpected
+ // behaviour. see bug 5861 for more information.
+ hId = -1;
+ requestHeaderMessage.getBytes(tmpMB);
+ ByteChunk bc = tmpMB.getByteChunk();
+ vMB = headers.addValue(bc.getBuffer(),
+ bc.getStart(), bc.getLength());
+ }
+
+ requestHeaderMessage.getBytes(vMB);
+
+ if (hId == Constants.SC_REQ_CONTENT_LENGTH ||
+ (hId == -1 && tmpMB.equalsIgnoreCase("Content-Length"))) {
+ // just read the content-length header, so set it
+ request.setContentLength( vMB.getInt() );
+ } else if (hId == Constants.SC_REQ_CONTENT_TYPE ||
+ (hId == -1 && tmpMB.equalsIgnoreCase("Content-Type"))) {
+ // just read the content-type header, so set it
+ ByteChunk bchunk = vMB.getByteChunk();
+ request.contentType().setBytes(bchunk.getBytes(),
+ bchunk.getOffset(),
+ bchunk.getLength());
+ }
+ }
+
+ // Decode extra attributes
+ boolean secret = false;
+ byte attributeCode;
+ while ((attributeCode = requestHeaderMessage.getByte())
+ != Constants.SC_A_ARE_DONE) {
+
+ switch (attributeCode) {
+
+ case Constants.SC_A_REQ_ATTRIBUTE :
+ requestHeaderMessage.getBytes(tmpMB);
+ String n = tmpMB.toString();
+ requestHeaderMessage.getBytes(tmpMB);
+ String v = tmpMB.toString();
+ request.setAttribute(n, v);
+ break;
+
+ case Constants.SC_A_CONTEXT :
+ requestHeaderMessage.getBytes(tmpMB);
+ // nothing
+ break;
+
+ case Constants.SC_A_SERVLET_PATH :
+ requestHeaderMessage.getBytes(tmpMB);
+ // nothing
+ break;
+
+ case Constants.SC_A_REMOTE_USER :
+ if (tomcatAuthentication) {
+ // ignore server
+ requestHeaderMessage.getBytes(tmpMB);
+ } else {
+ requestHeaderMessage.getBytes(request.getRemoteUser());
+ }
+ break;
+
+ case Constants.SC_A_AUTH_TYPE :
+ if (tomcatAuthentication) {
+ // ignore server
+ requestHeaderMessage.getBytes(tmpMB);
+ } else {
+ requestHeaderMessage.getBytes(request.getAuthType());
+ }
+ break;
+
+ case Constants.SC_A_QUERY_STRING :
+ requestHeaderMessage.getBytes(request.queryString());
+ break;
+
+ case Constants.SC_A_JVM_ROUTE :
+ requestHeaderMessage.getBytes(request.instanceId());
+ break;
+
+ case Constants.SC_A_SSL_CERT :
+ request.scheme().setString("https");
+ // SSL certificate extraction is lazy, moved to JkCoyoteHandler
+ requestHeaderMessage.getBytes(certificates);
+ break;
+
+ case Constants.SC_A_SSL_CIPHER :
+ request.scheme().setString("https");
+ requestHeaderMessage.getBytes(tmpMB);
+ request.setAttribute(org.apache.tomcat.util.net.Constants.CIPHER_SUITE_KEY,
+ tmpMB.toString());
+ break;
+
+ case Constants.SC_A_SSL_SESSION :
+ request.scheme().setString("https");
+ requestHeaderMessage.getBytes(tmpMB);
+ request.setAttribute(org.apache.tomcat.util.net.Constants.SESSION_ID_KEY,
+ tmpMB.toString());
+ break;
+
+ case Constants.SC_A_SSL_KEY_SIZE :
+ request.setAttribute(org.apache.tomcat.util.net.Constants.KEY_SIZE_KEY,
+ new Integer(requestHeaderMessage.getInt()));
+ break;
+
+ case Constants.SC_A_STORED_METHOD:
+ requestHeaderMessage.getBytes(request.method());
+ break;
+
+ case Constants.SC_A_SECRET:
+ requestHeaderMessage.getBytes(tmpMB);
+ if (requiredSecret != null) {
+ secret = true;
+ if (!tmpMB.equals(requiredSecret)) {
+ response.setStatus(403);
+ error = true;
+ }
+ }
+ break;
+
+ default:
+ // Ignore unknown attribute for backward compatibility
+ break;
+
+ }
+
+ }
+
+ // Check if secret was submitted if required
+ if ((requiredSecret != null) && !secret) {
+ response.setStatus(403);
+ error = true;
+ }
+
+ // Check for a full URI (including protocol://host:port/)
+ ByteChunk uriBC = request.requestURI().getByteChunk();
+ if (uriBC.startsWithIgnoreCase("http", 0)) {
+
+ int pos = uriBC.indexOf("://", 0, 3, 4);
+ int uriBCStart = uriBC.getStart();
+ int slashPos = -1;
+ if (pos != -1) {
+ byte[] uriB = uriBC.getBytes();
+ slashPos = uriBC.indexOf('/', pos + 3);
+ if (slashPos == -1) {
+ slashPos = uriBC.getLength();
+ // Set URI as "/"
+ request.requestURI().setBytes
+ (uriB, uriBCStart + pos + 1, 1);
+ } else {
+ request.requestURI().setBytes
+ (uriB, uriBCStart + slashPos,
+ uriBC.getLength() - slashPos);
+ }
+ MessageBytes hostMB = headers.setValue("host");
+ hostMB.setBytes(uriB, uriBCStart + pos + 3,
+ slashPos - pos - 3);
+ }
+
+ }
+
+ MessageBytes valueMB = request.getMimeHeaders().getValue("host");
+ parseHost(valueMB);
+
+ }
+
+
+ /**
+ * Parse host.
+ */
+ public void parseHost(MessageBytes valueMB) {
+
+ if (valueMB == null || (valueMB != null && valueMB.isNull()) ) {
+ // HTTP/1.0
+ request.setServerPort(request.getLocalPort());
+ try {
+ request.serverName().duplicate(request.localName());
+ } catch (IOException e) {
+ response.setStatus(400);
+ error = true;
+ }
+ return;
+ }
+
+ ByteChunk valueBC = valueMB.getByteChunk();
+ byte[] valueB = valueBC.getBytes();
+ int valueL = valueBC.getLength();
+ int valueS = valueBC.getStart();
+ int colonPos = -1;
+ if (hostNameC.length < valueL) {
+ hostNameC = new char[valueL];
+ }
+
+ boolean ipv6 = (valueB[valueS] == '[');
+ boolean bracketClosed = false;
+ for (int i = 0; i < valueL; i++) {
+ char b = (char) valueB[i + valueS];
+ hostNameC[i] = b;
+ if (b == ']') {
+ bracketClosed = true;
+ } else if (b == ':') {
+ if (!ipv6 || bracketClosed) {
+ colonPos = i;
+ break;
+ }
+ }
+ }
+
+ if (colonPos < 0) {
+ if (request.scheme().equalsIgnoreCase("https")) {
+ // 443 - Default HTTPS port
+ request.setServerPort(443);
+ } else {
+ // 80 - Default HTTTP port
+ request.setServerPort(80);
+ }
+ request.serverName().setChars(hostNameC, 0, valueL);
+ } else {
+
+ request.serverName().setChars(hostNameC, 0, colonPos);
+
+ int port = 0;
+ int mult = 1;
+ for (int i = valueL - 1; i > colonPos; i--) {
+ int charValue = HexUtils.DEC[valueB[i + valueS] & 0xff];
+ if (charValue == -1) {
+ // Invalid character
+ error = true;
+ // 400 - Bad request
+ response.setStatus(400);
+ break;
+ }
+ port = port + (charValue * mult);
+ mult = 10 * mult;
+ }
+ request.setServerPort(port);
+
+ }
+
+ }
+
+
+ /**
+ * When committing the response, we have to validate the set of headers, as
+ * well as setup the response filters.
+ */
+ protected void prepareResponse()
+ throws IOException {
+
+ response.setCommitted(true);
+
+ responseHeaderMessage.reset();
+ responseHeaderMessage.appendByte(Constants.JK_AJP13_SEND_HEADERS);
+
+ // HTTP header contents
+ responseHeaderMessage.appendInt(response.getStatus());
+ String message = null;
+ if (org.apache.coyote.Constants.USE_CUSTOM_STATUS_MSG_IN_HEADER) {
+ message = response.getMessage();
+ }
+ if (message == null){
+ message = HttpMessages.getMessage(response.getStatus());
+ } else {
+ message = message.replace('\n', ' ').replace('\r', ' ');
+ }
+ if (message == null) {
+ // Many httpd 2.x wants a non empty status message
+ message = Integer.toString(response.getStatus());
+ }
+ tmpMB.setString(message);
+ responseHeaderMessage.appendBytes(tmpMB);
+
+ // Special headers
+ MimeHeaders headers = response.getMimeHeaders();
+ String contentType = response.getContentType();
+ if (contentType != null) {
+ headers.setValue("Content-Type").setString(contentType);
+ }
+ String contentLanguage = response.getContentLanguage();
+ if (contentLanguage != null) {
+ headers.setValue("Content-Language").setString(contentLanguage);
+ }
+ int contentLength = response.getContentLength();
+ if (contentLength >= 0) {
+ headers.setValue("Content-Length").setInt(contentLength);
+ }
+
+ // Other headers
+ int numHeaders = headers.size();
+ responseHeaderMessage.appendInt(numHeaders);
+ for (int i = 0; i < numHeaders; i++) {
+ MessageBytes hN = headers.getName(i);
+ MessageBytes hV=headers.getValue(i);
+ if (hN.getLength() > 0 && !hV.isNull()) {
+ int hC = Constants.getResponseAjpIndex(hN.toString());
+ if (hC > 0) {
+ responseHeaderMessage.appendInt(hC);
+ }
+ else {
+ responseHeaderMessage.appendBytes(hN);
+ }
+ responseHeaderMessage.appendBytes(hV);
+ }
+ }
+
+ // Write to buffer
+ responseHeaderMessage.end();
+ output.write(responseHeaderMessage.getBuffer(), 0, responseHeaderMessage.getLen());
+
+ }
+
+
+ /**
+ * Finish AJP response.
+ */
+ protected void finish()
+ throws IOException {
+
+ if (!response.isCommitted()) {
+ // Validate and write response headers
+ try {
+ prepareResponse();
+ } catch (IOException e) {
+ // Set error flag
+ error = true;
+ }
+ }
+
+ if (finished)
+ return;
+
+ finished = true;
+
+ // Add the end message
+ output.write(endMessageArray);
+
+
+ // read remaining data from the special first-body-chunk
+ if (first && request.getContentLengthLong() > 0) {
+ try {
+ receive();
+ } catch (IOException e) {
+ }
+ }
+
+ }
+
+
+ /**
+ * Read at least the specified amount of bytes, and place them
+ * in the input buffer.
+ */
+ protected boolean read(byte[] buf, int pos, int n)
+ throws IOException {
+
+ int read = 0;
+ int res = 0;
+ while (read < n) {
+ res = input.read(buf, read + pos, n - read);
+ if (res > 0) {
+ read += res;
+ } else {
+ throw new IOException(MESSAGES.failedRead());
+ }
+ }
+
+ return true;
+
+ }
+
+
+ /** Receive a chunk of data. Called to implement the
+ * 'special' packet in ajp13 and to receive the data
+ * after we send a GET_BODY packet
+ */
+ public boolean receive() throws IOException {
+
+ first = false;
+ bodyMessage.reset();
+ readMessage(bodyMessage);
+
+ // No data received.
+ if (bodyMessage.getLen() == 0) {
+ // just the header
+ // Don't mark 'end of stream' for the first chunk.
+ return false;
+ }
+ int blen = bodyMessage.peekInt();
+ if (blen == 0) {
+ return false;
+ }
+
+ bodyMessage.getBytes(bodyBytes);
+ empty = false;
+ return true;
+ }
+
+ /**
+ * Get more request body data from the web server and store it in the
+ * internal buffer.
+ *
+ * @return true if there is more data, false if not.
+ */
+ private boolean refillReadBuffer() throws IOException {
+ // If the server returns an empty packet, assume that that end of
+ // the stream has been reached (yuck -- fix protocol??).
+ // FORM support
+ if (replay) {
+ endOfStream = true; // we've read everything there is
+ }
+ if (endOfStream) {
+ return false;
+ }
+ if (finished) {
+ return false;
+ }
+
+ // Request more data immediately
+ output.write(getBodyMessageArray);
+
+ boolean moreData = receive();
+ if( !moreData ) {
+ endOfStream = true;
+ }
+ return moreData;
+ }
+
+
+ /**
+ * Read an AJP message.
+ *
+ * @return true if the message has been read, false if the short read
+ * didn't return anything
+ * @throws IOException any other failure, including incomplete reads
+ */
+ protected boolean readMessage(AjpMessage message)
+ throws IOException {
+
+ byte[] buf = message.getBuffer();
+
+ read(buf, 0, message.getHeaderLength());
+
+ if (message.processHeader() < 0) {
+ throw new IOException(MESSAGES.invalidAjpMessage());
+ }
+ read(buf, message.getHeaderLength(), message.getLen());
+
+ return true;
+
+ }
+
+
+ /**
+ * Recycle the processor.
+ */
+ public void recycle() {
+
+ // Recycle Request object
+ first = true;
+ endOfStream = false;
+ empty = true;
+ replay = false;
+ finished = false;
+ timeout = -1;
+ resumeNotification = false;
+ eventProcessing = true;
+ request.recycle();
+ response.recycle();
+ certificates.recycle();
+
+ }
+
+
+ /**
+ * Callback to write data from the buffer.
+ */
+ protected void flush()
+ throws IOException {
+ // Send the flush message
+ output.write(flushMessageArray);
+ }
+
+
+ // ------------------------------------- InputStreamInputBuffer Inner Class
+
+
+ /**
+ * This class is an input buffer which will read its data from an input
+ * stream.
+ */
+ protected class SocketInputBuffer
+ implements InputBuffer {
+
+
+ /**
+ * Read bytes into the specified chunk.
+ */
+ public int doRead(ByteChunk chunk, Request req )
+ throws IOException {
+
+ if (endOfStream) {
+ return -1;
+ }
+ if (first && req.getContentLength() > 0) {
+ // Handle special first-body-chunk
+ if (!receive()) {
+ return 0;
+ }
+ } else if (empty) {
+ if (!refillReadBuffer()) {
+ return -1;
+ }
+ }
+ ByteChunk bc = bodyBytes.getByteChunk();
+ chunk.setBytes(bc.getBuffer(), bc.getStart(), bc.getLength());
+ empty = true;
+ return chunk.getLength();
+
+ }
+
+ }
+
+
+ // ----------------------------------- OutputStreamOutputBuffer Inner Class
+
+
+ /**
+ * This class is an output buffer which will write data to an output
+ * stream.
+ */
+ protected class SocketOutputBuffer
+ implements OutputBuffer {
+
+
+ /**
+ * Write chunk.
+ */
+ public int doWrite(ByteChunk chunk, Response res)
+ throws IOException {
+
+ if (!response.isCommitted()) {
+ // Validate and write response headers
+ try {
+ prepareResponse();
+ } catch (IOException e) {
+ // Set error flag
+ error = true;
+ }
+ }
+
+ int len = chunk.getLength();
+ // 4 - hardcoded, byte[] marshalling overhead
+ int chunkSize = Constants.MAX_SEND_SIZE;
+ int off = 0;
+ while (len > 0) {
+ int thisTime = len;
+ if (thisTime > chunkSize) {
+ thisTime = chunkSize;
+ }
+ len -= thisTime;
+ responseHeaderMessage.reset();
+ responseHeaderMessage.appendByte(Constants.JK_AJP13_SEND_BODY_CHUNK);
+ responseHeaderMessage.appendBytes(chunk.getBytes(), chunk.getOffset() + off, thisTime);
+ responseHeaderMessage.end();
+ output.write(responseHeaderMessage.getBuffer(), 0, responseHeaderMessage.getLen());
+
+ off += thisTime;
+ }
+
+ return chunk.getLength();
+
+ }
+
+
+ }
+
+
+}
Added: branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpProtocol.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpProtocol.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/coyote/ajp/AjpProtocol.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,538 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2009, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.apache.coyote.ajp;
+
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.URLEncoder;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+import javax.management.MBeanRegistration;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+
+import org.apache.coyote.Adapter;
+import org.apache.coyote.ProtocolHandler;
+import org.apache.coyote.RequestGroupInfo;
+import org.apache.coyote.RequestInfo;
+import org.apache.tomcat.util.modeler.Registry;
+import org.apache.tomcat.util.net.JIoEndpoint;
+import org.apache.tomcat.util.net.SocketStatus;
+import org.apache.tomcat.util.net.JIoEndpoint.Handler;
+import org.jboss.web.CoyoteLogger;
+
+
+/**
+ * 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 Remy Maucherat
+ * @author Costin Manolache
+ */
+public class AjpProtocol
+ implements ProtocolHandler, MBeanRegistration {
+
+
+ // ------------------------------------------------------------ Constructor
+
+
+ public AjpProtocol() {
+ cHandler = new AjpConnectionHandler(this);
+ setSoLinger(Constants.DEFAULT_CONNECTION_LINGER);
+ setSoTimeout(Constants.DEFAULT_CONNECTION_TIMEOUT);
+ //setServerSoTimeout(Constants.DEFAULT_SERVER_SOCKET_TIMEOUT);
+ setTcpNoDelay(Constants.DEFAULT_TCP_NO_DELAY);
+ }
+
+
+ // ----------------------------------------------------- Instance Variables
+
+
+ protected ObjectName tpOname;
+
+
+ protected ObjectName rgOname;
+
+
+ /**
+ * Associated java.io endpoint.
+ */
+ protected JIoEndpoint endpoint = new JIoEndpoint();
+
+
+ /**
+ * Configuration attributes.
+ */
+ protected Hashtable attributes = new Hashtable();
+
+
+ /**
+ * Adapter which will process the requests recieved by this endpoint.
+ */
+ private Adapter adapter;
+
+
+ /**
+ * Connection handler for AJP.
+ */
+ private AjpConnectionHandler cHandler;
+
+
+ // --------------------------------------------------------- Public Methods
+
+
+ /**
+ * Pass config info
+ */
+ public void setAttribute(String name, Object value) {
+ attributes.put(name, value);
+ }
+
+ public Object getAttribute(String key) {
+ return attributes.get(key);
+ }
+
+
+ public Iterator getAttributeNames() {
+ return attributes.keySet().iterator();
+ }
+
+
+ /**
+ * The adapter, used to call the connector
+ */
+ public void setAdapter(Adapter adapter) {
+ this.adapter = adapter;
+ }
+
+
+ public Adapter getAdapter() {
+ return adapter;
+ }
+
+
+ public boolean hasIoEvents() {
+ return false;
+ }
+
+ public RequestGroupInfo getRequestGroupInfo() {
+ return cHandler.global;
+ }
+
+
+ /** Start the protocol
+ */
+ public void init() throws Exception {
+ endpoint.setName(getName());
+ endpoint.setHandler(cHandler);
+
+ try {
+ endpoint.init();
+ } catch (Exception ex) {
+ CoyoteLogger.AJP_LOGGER.errorInitializingEndpoint(ex);
+ throw ex;
+ }
+ }
+
+
+ public void start() throws Exception {
+ if (org.apache.tomcat.util.Constants.ENABLE_MODELER) {
+ if (this.domain != null ) {
+ try {
+ tpOname = new ObjectName
+ (domain + ":" + "type=ThreadPool,name=" + getJmxName());
+ Registry.getRegistry(null, null)
+ .registerComponent(endpoint, tpOname, null );
+ } catch (Exception e) {
+ CoyoteLogger.AJP_LOGGER.errorRegisteringPool(e);
+ }
+ rgOname = new ObjectName
+ (domain + ":type=GlobalRequestProcessor,name=" + getJmxName());
+ Registry.getRegistry(null, null).registerComponent
+ (cHandler.global, rgOname, null);
+ }
+ }
+ try {
+ endpoint.start();
+ } catch (Exception ex) {
+ CoyoteLogger.AJP_LOGGER.errorStartingEndpoint(ex);
+ throw ex;
+ }
+ CoyoteLogger.AJP_LOGGER.startingAjpProtocol(getName());
+ }
+
+ public void pause() throws Exception {
+ try {
+ endpoint.pause();
+ } catch (Exception ex) {
+ CoyoteLogger.AJP_LOGGER.errorPausingEndpoint(ex);
+ throw ex;
+ }
+ // Wait for a while until all the processors are idle
+ RequestInfo[] states = cHandler.global.getRequestProcessors();
+ int retry = 0;
+ boolean done = false;
+ while (!done && retry < org.apache.coyote.Constants.MAX_PAUSE_WAIT) {
+ retry++;
+ done = true;
+ for (int i = 0; i < states.length; i++) {
+ if (states[i].getStage() == org.apache.coyote.Constants.STAGE_SERVICE) {
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ ;
+ }
+ done = false;
+ break;
+ }
+ }
+ }
+ CoyoteLogger.AJP_LOGGER.pausingAjpProtocol(getName());
+ }
+
+ public void resume() throws Exception {
+ try {
+ endpoint.resume();
+ } catch (Exception ex) {
+ CoyoteLogger.AJP_LOGGER.errorResumingEndpoint(ex);
+ throw ex;
+ }
+ CoyoteLogger.AJP_LOGGER.resumingAjpProtocol(getName());
+ }
+
+ public void destroy() throws Exception {
+ CoyoteLogger.AJP_LOGGER.stoppingAjpProtocol(getName());
+ endpoint.destroy();
+ if (org.apache.tomcat.util.Constants.ENABLE_MODELER) {
+ if (tpOname!=null)
+ Registry.getRegistry(null, null).unregisterComponent(tpOname);
+ if (rgOname != null)
+ Registry.getRegistry(null, null).unregisterComponent(rgOname);
+ }
+ }
+
+ public String getJmxName() {
+ String encodedAddr = "";
+ if (getAddress() != null) {
+ encodedAddr = "" + getAddress();
+ encodedAddr = URLEncoder.encode(encodedAddr.replace('/', '-').replace(':', '_').replace('%', '-')) + "-";
+ }
+ return ("ajp-" + encodedAddr + endpoint.getPort());
+ }
+
+ public String getName() {
+ String encodedAddr = "";
+ if (getAddress() != null) {
+ encodedAddr = getAddress() + ":";
+ }
+ return ("ajp-" + encodedAddr + endpoint.getPort());
+ }
+
+ /**
+ * Processor cache.
+ */
+ protected int processorCache = -1;
+ public int getProcessorCache() { return this.processorCache; }
+ public void setProcessorCache(int processorCache) { this.processorCache = processorCache; }
+
+ public Executor getExecutor() { return endpoint.getExecutor(); }
+ public void setExecutor(Executor executor) { endpoint.setExecutor(executor); }
+
+ public int getMaxThreads() { return endpoint.getMaxThreads(); }
+ public void setMaxThreads(int maxThreads) { endpoint.setMaxThreads(maxThreads); }
+
+ public int getThreadPriority() { return endpoint.getThreadPriority(); }
+ public void setThreadPriority(int threadPriority) { endpoint.setThreadPriority(threadPriority); }
+
+ public int getBacklog() { return endpoint.getBacklog(); }
+ public void setBacklog(int backlog) { endpoint.setBacklog(backlog); }
+
+ public int getPort() { return endpoint.getPort(); }
+ public void setPort(int port) { endpoint.setPort(port); }
+
+ public InetAddress getAddress() { return endpoint.getAddress(); }
+ public void setAddress(InetAddress ia) { endpoint.setAddress(ia); }
+
+ public boolean getTcpNoDelay() { return endpoint.getTcpNoDelay(); }
+ public void setTcpNoDelay(boolean tcpNoDelay) { endpoint.setTcpNoDelay(tcpNoDelay); }
+
+ public int getSoLinger() { return endpoint.getSoLinger(); }
+ public void setSoLinger(int soLinger) { endpoint.setSoLinger(soLinger); }
+
+ public int getSoTimeout() { return endpoint.getSoTimeout(); }
+ public void setSoTimeout(int soTimeout) { endpoint.setSoTimeout(soTimeout); }
+
+ public void setPollerSize(int pollerSize) { endpoint.setPollerSize(pollerSize); }
+ public int getPollerSize() { return endpoint.getPollerSize(); }
+
+ /**
+ * Should authentication be done in the native webserver layer,
+ * or in the Servlet container ?
+ */
+ protected boolean tomcatAuthentication = Constants.DEFAULT_TOMCAT_AUTHENTICATION;
+ public boolean getTomcatAuthentication() { return tomcatAuthentication; }
+ public void setTomcatAuthentication(boolean tomcatAuthentication) { this.tomcatAuthentication = tomcatAuthentication; }
+
+ /**
+ * Required secret.
+ */
+ protected String requiredSecret = null;
+ public void setRequiredSecret(String requiredSecret) { this.requiredSecret = requiredSecret; }
+
+ /**
+ * AJP packet size.
+ */
+ protected int packetSize = Constants.MAX_PACKET_SIZE;
+ public int getPacketSize() { return packetSize; }
+ public void setPacketSize(int packetSize) { this.packetSize = packetSize; }
+
+
+ /**
+ * The number of seconds Tomcat will wait for a subsequent request
+ * before closing the connection.
+ */
+ protected int keepAliveTimeout = -1;
+ public int getKeepAliveTimeout() { return keepAliveTimeout; }
+ public void setKeepAliveTimeout(int timeout) { keepAliveTimeout = timeout; }
+
+
+ // -------------------------------------- AjpConnectionHandler Inner Class
+
+
+ protected static class AjpConnectionHandler implements Handler {
+
+ protected AjpProtocol proto;
+ protected AtomicLong registerCount = new AtomicLong(0);
+ protected RequestGroupInfo global = new RequestGroupInfo();
+
+ protected ConcurrentHashMap<Socket, AjpProcessor> connections =
+ new ConcurrentHashMap<Socket, AjpProcessor>();
+ protected ConcurrentLinkedQueue<AjpProcessor> recycledProcessors =
+ new ConcurrentLinkedQueue<AjpProcessor>() {
+ protected AtomicInteger size = new AtomicInteger(0);
+ public boolean offer(AjpProcessor processor) {
+ boolean offer = (proto.processorCache == -1) ? true : (size.get() < proto.processorCache);
+ //avoid over growing our cache or add after we have stopped
+ boolean result = false;
+ if ( offer ) {
+ result = super.offer(processor);
+ if ( result ) {
+ size.incrementAndGet();
+ }
+ }
+ if (!result) unregister(processor);
+ return result;
+ }
+
+ public AjpProcessor poll() {
+ AjpProcessor result = super.poll();
+ if ( result != null ) {
+ size.decrementAndGet();
+ }
+ return result;
+ }
+
+ public void clear() {
+ AjpProcessor next = poll();
+ while ( next != null ) {
+ unregister(next);
+ next = poll();
+ }
+ super.clear();
+ size.set(0);
+ }
+ };
+
+ public AjpConnectionHandler(AjpProtocol proto) {
+ this.proto = proto;
+ }
+
+ public SocketState event(Socket socket, SocketStatus status) {
+ AjpProcessor result = connections.get(socket);
+ SocketState state = SocketState.CLOSED;
+ if (result != null) {
+ result.startProcessing();
+ // Call the appropriate event
+ try {
+ state = result.event(status);
+ } catch (java.net.SocketException e) {
+ // SocketExceptions are normal
+ CoyoteLogger.AJP_LOGGER.socketException(e);
+ } catch (java.io.IOException e) {
+ // IOExceptions are normal
+ CoyoteLogger.AJP_LOGGER.socketException(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.
+ CoyoteLogger.AJP_LOGGER.socketError(e);
+ } finally {
+ if (state != SocketState.LONG) {
+ connections.remove(socket);
+ recycledProcessors.offer(result);
+ } else {
+ if (proto.endpoint.isRunning()) {
+ proto.endpoint.getEventPoller().add(socket, result.getTimeout(),
+ result.getResumeNotification(), false);
+ }
+ }
+ result.endProcessing();
+ }
+ }
+ return state;
+ }
+
+ public SocketState process(Socket socket) {
+ AjpProcessor processor = recycledProcessors.poll();
+ try {
+
+ if (processor == null) {
+ processor = createProcessor();
+ }
+
+ SocketState state = processor.process(socket);
+ if (state == SocketState.LONG) {
+ // Associate the connection with the processor. The next request
+ // processed by this thread will use either a new or a recycled
+ // processor.
+ connections.put(socket, processor);
+ proto.endpoint.getEventPoller().add(socket, processor.getTimeout(),
+ processor.getResumeNotification(), false);
+ } else {
+ recycledProcessors.offer(processor);
+ }
+ return state;
+
+ } catch(java.net.SocketException e) {
+ // SocketExceptions are normal
+ CoyoteLogger.AJP_LOGGER.socketException(e);
+ } catch (java.io.IOException e) {
+ // IOExceptions are normal
+ CoyoteLogger.AJP_LOGGER.socketException(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.
+ CoyoteLogger.AJP_LOGGER.socketError(e);
+ }
+ recycledProcessors.offer(processor);
+ return SocketState.CLOSED;
+ }
+
+ protected AjpProcessor createProcessor() {
+ AjpProcessor processor = new AjpProcessor(proto.packetSize, proto.endpoint);
+ processor.setAdapter(proto.adapter);
+ processor.setTomcatAuthentication(proto.tomcatAuthentication);
+ processor.setRequiredSecret(proto.requiredSecret);
+ processor.setKeepAliveTimeout(proto.keepAliveTimeout);
+ register(processor);
+ return processor;
+ }
+
+ protected void register(AjpProcessor processor) {
+ RequestInfo rp = processor.getRequest().getRequestProcessor();
+ rp.setGlobalProcessor(global);
+ if (org.apache.tomcat.util.Constants.ENABLE_MODELER && proto.getDomain() != null) {
+ synchronized (this) {
+ try {
+ long count = registerCount.incrementAndGet();
+ ObjectName rpName = new ObjectName
+ (proto.getDomain() + ":type=RequestProcessor,worker="
+ + proto.getJmxName() + ",name=AjpRequest" + count);
+ Registry.getRegistry(null, null).registerComponent(rp, rpName, null);
+ rp.setRpName(rpName);
+ } catch (Exception e) {
+ CoyoteLogger.AJP_LOGGER.errorRegisteringRequest(e);
+ }
+ }
+ }
+ }
+
+ protected void unregister(AjpProcessor processor) {
+ RequestInfo rp = processor.getRequest().getRequestProcessor();
+ rp.setGlobalProcessor(null);
+ if (org.apache.tomcat.util.Constants.ENABLE_MODELER && proto.getDomain() != null) {
+ synchronized (this) {
+ try {
+ ObjectName rpName = rp.getRpName();
+ Registry.getRegistry(null, null).unregisterComponent(rpName);
+ rp.setRpName(null);
+ } catch (Exception e) {
+ CoyoteLogger.AJP_LOGGER.errorUnregisteringRequest(e);
+ }
+ }
+ }
+ }
+
+ }
+
+
+ // -------------------- Various implementation classes --------------------
+
+
+ protected String domain;
+ protected ObjectName oname;
+ protected MBeanServer mserver;
+
+ public ObjectName getObjectName() {
+ return oname;
+ }
+
+ public String getDomain() {
+ return domain;
+ }
+
+ public ObjectName preRegister(MBeanServer server,
+ ObjectName name) throws Exception {
+ oname=name;
+ mserver=server;
+ domain=name.getDomain();
+ return name;
+ }
+
+ public void postRegister(Boolean registrationDone) {
+ }
+
+ public void preDeregister() throws Exception {
+ }
+
+ public void postDeregister() {
+ }
+
+
+}
Modified: branches/7.2.x/src/main/java/org/apache/coyote/ajp/Constants.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/coyote/ajp/Constants.java 2012-09-25 12:49:25 UTC (rev 2086)
+++ branches/7.2.x/src/main/java/org/apache/coyote/ajp/Constants.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -44,6 +44,8 @@
public static final int DEFAULT_CONNECTION_UPLOAD_TIMEOUT = 300000;
public static final int DEFAULT_SERVER_SOCKET_TIMEOUT = 0;
public static final boolean DEFAULT_TCP_NO_DELAY = true;
+ public static final boolean DEFAULT_TOMCAT_AUTHENTICATION =
+ Boolean.valueOf(System.getProperty("org.apache.coyote.ajp.DEFAULT_TOMCAT_AUTHENTICATION", "true")).booleanValue();
// Prefix codes for message types from server to container
public static final byte JK_AJP13_FORWARD_REQUEST = 2;
Modified: branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11NioProtocol.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11NioProtocol.java 2012-09-25 12:49:25 UTC (rev 2086)
+++ branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11NioProtocol.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -41,7 +41,6 @@
import org.apache.tomcat.util.modeler.Registry;
import org.apache.tomcat.util.net.NioChannel;
import org.apache.tomcat.util.net.NioEndpoint;
-import org.apache.tomcat.util.net.SSLImplementation;
import org.apache.tomcat.util.net.SocketStatus;
import org.apache.tomcat.util.net.jsse.NioJSSEImplementation;
import org.apache.tomcat.util.net.jsse.NioJSSESocketChannelFactory;
@@ -92,9 +91,9 @@
// Verify the validity of the configured socket factory
try {
if (isSSLEnabled()) {
- sslImplementation = SSLImplementation.getInstance(NioJSSEImplementation.class
- .getName());
- socketFactory = sslImplementation.getServerSocketChannelFactory();
+ sslImplementation = new NioJSSEImplementation();
+ //Possible pluggability ? SSLImplementation.getInstance(NioJSSEImplementation.class.getName());
+ socketFactory = ((NioJSSEImplementation) sslImplementation).getServerSocketChannelFactory();
endpoint.setServerSocketChannelFactory(socketFactory);
}
} catch (Exception ex) {
@@ -896,7 +895,7 @@
}
if (proto.secure && (proto.sslImplementation != null)) {
- processor.setSSLSupport(proto.sslImplementation.getSSLSupport(channel));
+ processor.setSSLSupport(((NioJSSEImplementation) proto.sslImplementation).getSSLSupport(channel));
} else {
processor.setSSLSupport(null);
}
Added: branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11Processor.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11Processor.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11Processor.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,1721 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2009, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.apache.coyote.http11;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.util.Locale;
+import java.util.StringTokenizer;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+import org.apache.coyote.ActionCode;
+import org.apache.coyote.ActionHook;
+import org.apache.coyote.Adapter;
+import org.apache.coyote.Request;
+import org.apache.coyote.RequestInfo;
+import org.apache.coyote.Response;
+import org.apache.coyote.http11.filters.BufferedInputFilter;
+import org.apache.coyote.http11.filters.ChunkedInputFilter;
+import org.apache.coyote.http11.filters.ChunkedOutputFilter;
+import org.apache.coyote.http11.filters.GzipOutputFilter;
+import org.apache.coyote.http11.filters.IdentityInputFilter;
+import org.apache.coyote.http11.filters.IdentityOutputFilter;
+import org.apache.coyote.http11.filters.SavedRequestInputFilter;
+import org.apache.coyote.http11.filters.VoidInputFilter;
+import org.apache.coyote.http11.filters.VoidOutputFilter;
+import org.apache.tomcat.util.buf.Ascii;
+import org.apache.tomcat.util.buf.ByteChunk;
+import org.apache.tomcat.util.buf.HexUtils;
+import org.apache.tomcat.util.buf.MessageBytes;
+import org.apache.tomcat.util.http.FastHttpDateFormat;
+import org.apache.tomcat.util.http.MimeHeaders;
+import org.apache.tomcat.util.net.JIoEndpoint;
+import org.apache.tomcat.util.net.SSLSupport;
+import org.apache.tomcat.util.net.SocketStatus;
+import org.apache.tomcat.util.net.JIoEndpoint.Handler.SocketState;
+import org.jboss.web.CoyoteLogger;
+
+
+/**
+ * Processes HTTP requests.
+ *
+ * @author Remy Maucherat
+ */
+public class Http11Processor implements ActionHook {
+
+
+ protected static final boolean CHUNK_ON_CLOSE =
+ Boolean.valueOf(System.getProperty("org.apache.coyote.http11.Http11Processor.CHUNK_ON_CLOSE", "false")).booleanValue();
+
+
+ // ------------------------------------------------------------ Constructor
+
+
+ public Http11Processor(int headerBufferSize, JIoEndpoint endpoint) {
+
+ this.endpoint = endpoint;
+
+ request = new Request();
+ inputBuffer = new InternalInputBuffer(request, headerBufferSize);
+ request.setInputBuffer(inputBuffer);
+
+ response = new Response();
+ response.setHook(this);
+ outputBuffer = new InternalOutputBuffer(response, headerBufferSize);
+ response.setOutputBuffer(outputBuffer);
+ request.setResponse(response);
+
+ initializeFilters();
+
+ // Cause loading of HexUtils
+ int foo = HexUtils.DEC[0];
+
+ // Cause loading of FastHttpDateFormat
+ FastHttpDateFormat.getCurrentDate();
+
+ }
+
+
+ // ----------------------------------------------------- Instance Variables
+
+
+ /**
+ * Associated adapter.
+ */
+ protected Adapter adapter = null;
+
+
+ /**
+ * Request object.
+ */
+ protected Request request = null;
+
+
+ /**
+ * Response object.
+ */
+ protected Response response = null;
+
+
+ /**
+ * Input.
+ */
+ protected InternalInputBuffer inputBuffer = null;
+
+
+ /**
+ * Output.
+ */
+ protected InternalOutputBuffer outputBuffer = null;
+
+
+ /**
+ * Error flag.
+ */
+ protected boolean error = false;
+
+
+ /**
+ * Keep-alive.
+ */
+ protected boolean keepAlive = true;
+
+
+ /**
+ * HTTP/1.1 flag.
+ */
+ protected boolean http11 = true;
+
+
+ /**
+ * HTTP/0.9 flag.
+ */
+ protected boolean http09 = false;
+
+
+ /**
+ * Content delimitator for the request (if false, the connection will
+ * be closed at the end of the request).
+ */
+ protected boolean contentDelimitation = true;
+
+
+ /**
+ * Is there an expectation ?
+ */
+ protected boolean expectation = false;
+
+
+ /**
+ * List of restricted user agents.
+ */
+ protected Pattern[] restrictedUserAgents = null;
+
+
+ /**
+ * Maximum number of Keep-Alive requests to honor.
+ */
+ protected int maxKeepAliveRequests = -1;
+
+ /**
+ * The number of seconds Tomcat will wait for a subsequent request
+ * before closing the connection.
+ */
+ protected int keepAliveTimeout = -1;
+
+
+ /**
+ * SSL information.
+ */
+ protected SSLSupport sslSupport;
+
+
+ /**
+ * Socket associated with the current connection.
+ */
+ protected Socket socket;
+
+
+ /**
+ * Remote Address associated with the current connection.
+ */
+ protected String remoteAddr = null;
+
+
+ /**
+ * Remote Host associated with the current connection.
+ */
+ protected String remoteHost = null;
+
+
+ /**
+ * Local Host associated with the current connection.
+ */
+ protected String localName = null;
+
+
+
+ /**
+ * Local port to which the socket is connected
+ */
+ protected int localPort = -1;
+
+
+ /**
+ * Remote port to which the socket is connected
+ */
+ protected int remotePort = -1;
+
+
+ /**
+ * The local Host address.
+ */
+ protected String localAddr = null;
+
+
+ /**
+ * Flag to disable setting a different time-out on uploads.
+ */
+ protected boolean disableUploadTimeout = false;
+
+
+ /**
+ * Allowed compression level.
+ */
+ protected int compressionLevel = 0;
+
+
+ /**
+ * Minimum contentsize to make compression.
+ */
+ protected int compressionMinSize = 2048;
+
+
+ /**
+ * Socket buffering.
+ */
+ protected int socketBuffer = -1;
+
+
+ /**
+ * Max saved post size.
+ */
+ protected int maxSavePostSize = 4 * 1024;
+
+
+ /**
+ * List of user agents to not use gzip with
+ */
+ protected Pattern noCompressionUserAgents[] = null;
+
+ /**
+ * List of MIMES which could be gzipped
+ */
+ protected String[] compressableMimeTypes =
+ { "text/html", "text/xml", "text/plain" };
+
+
+ /**
+ * Host name (used to avoid useless B2C conversion on the host name).
+ */
+ protected char[] hostNameC = new char[0];
+
+
+ /**
+ * Associated endpoint.
+ */
+ protected JIoEndpoint endpoint;
+
+
+ /**
+ * Allow a customized the server header for the tin-foil hat folks.
+ */
+ protected String server = null;
+
+
+ /**
+ * Event used.
+ */
+ protected boolean event = false;
+
+
+ /**
+ * True if a resume has been requested.
+ */
+ protected boolean resumeNotification = false;
+
+
+ /**
+ * Event processing.
+ */
+ protected boolean eventProcessing = true;
+ public void startProcessing() { eventProcessing = true; }
+ public void endProcessing() { eventProcessing = false; }
+
+
+ // ------------------------------------------------------------- Properties
+
+
+ /**
+ * Return compression level.
+ */
+ public String getCompression() {
+ switch (compressionLevel) {
+ case 0:
+ return "off";
+ case 1:
+ return "on";
+ case 2:
+ return "force";
+ }
+ return "off";
+ }
+
+
+ /**
+ * Set compression level.
+ */
+ public void setCompression(String compression) {
+ if (compression.equals("on")) {
+ this.compressionLevel = 1;
+ } else if (compression.equals("force")) {
+ this.compressionLevel = 2;
+ } else if (compression.equals("off")) {
+ this.compressionLevel = 0;
+ } else {
+ try {
+ // Try to parse compression as an int, which would give the
+ // minimum compression size
+ compressionMinSize = Integer.parseInt(compression);
+ this.compressionLevel = 1;
+ } catch (Exception e) {
+ this.compressionLevel = 0;
+ }
+ }
+ }
+
+ /**
+ * Set Minimum size to trigger compression.
+ */
+ public void setCompressionMinSize(int compressionMinSize) {
+ this.compressionMinSize = compressionMinSize;
+ }
+
+
+ /**
+ * Add user-agent for which gzip compression didn't works
+ * The user agent String given will be exactly matched
+ * to the user-agent header submitted by the client.
+ *
+ * @param userAgent user-agent string
+ */
+ public void addNoCompressionUserAgent(String userAgent) {
+ try {
+ Pattern nRule = Pattern.compile(userAgent);
+ noCompressionUserAgents =
+ addREArray(noCompressionUserAgents, nRule);
+ } catch (PatternSyntaxException pse) {
+ CoyoteLogger.HTTP_LOGGER.errorParsingRegexp(userAgent, pse);
+ }
+ }
+
+
+ /**
+ * Set no compression user agent list (this method is best when used with
+ * a large number of connectors, where it would be better to have all of
+ * them referenced a single array).
+ */
+ public void setNoCompressionUserAgents(Pattern[] noCompressionUserAgents) {
+ this.noCompressionUserAgents = noCompressionUserAgents;
+ }
+
+
+ /**
+ * Set no compression user agent list.
+ * List contains users agents separated by ',' :
+ *
+ * ie: "gorilla,desesplorer,tigrus"
+ */
+ public void setNoCompressionUserAgents(String noCompressionUserAgents) {
+ if (noCompressionUserAgents != null) {
+ StringTokenizer st = new StringTokenizer(noCompressionUserAgents, ",");
+
+ while (st.hasMoreTokens()) {
+ addNoCompressionUserAgent(st.nextToken().trim());
+ }
+ }
+ }
+
+ /**
+ * Add a mime-type which will be compressable
+ * The mime-type String will be exactly matched
+ * in the response mime-type header .
+ *
+ * @param mimeType mime-type string
+ */
+ public void addCompressableMimeType(String mimeType) {
+ compressableMimeTypes =
+ addStringArray(compressableMimeTypes, mimeType);
+ }
+
+
+ /**
+ * Set compressable mime-type list (this method is best when used with
+ * a large number of connectors, where it would be better to have all of
+ * them referenced a single array).
+ */
+ public void setCompressableMimeTypes(String[] compressableMimeTypes) {
+ this.compressableMimeTypes = compressableMimeTypes;
+ }
+
+
+ /**
+ * Set compressable mime-type list
+ * List contains users agents separated by ',' :
+ *
+ * ie: "text/html,text/xml,text/plain"
+ */
+ public void setCompressableMimeTypes(String compressableMimeTypes) {
+ if (compressableMimeTypes != null) {
+ this.compressableMimeTypes = null;
+ StringTokenizer st = new StringTokenizer(compressableMimeTypes, ",");
+ while (st.hasMoreTokens()) {
+ addCompressableMimeType(st.nextToken().trim());
+ }
+ }
+ }
+
+
+ /**
+ * Return the list of restricted user agents.
+ */
+ public String[] findCompressableMimeTypes() {
+ return (compressableMimeTypes);
+ }
+
+
+ /**
+ * Timeout.
+ */
+ protected int timeout = -1;
+ public void setTimeout(int timeout) { this.timeout = timeout; }
+ public int getTimeout() { return timeout; }
+
+
+ // --------------------------------------------------------- Public Methods
+
+
+ /**
+ * Add input or output filter.
+ *
+ * @param className class name of the filter
+ */
+ protected void addFilter(String className) {
+ try {
+ Class<?> clazz = Class.forName(className);
+ Object obj = clazz.newInstance();
+ if (obj instanceof InputFilter) {
+ inputBuffer.addFilter((InputFilter) obj);
+ } else if (obj instanceof OutputFilter) {
+ outputBuffer.addFilter((OutputFilter) obj);
+ } else {
+ CoyoteLogger.HTTP_LOGGER.unknownFilter(className);
+ }
+ } catch (Exception e) {
+ CoyoteLogger.HTTP_LOGGER.errorInitializingFilter(className, e);
+ }
+ }
+
+
+ /**
+ * General use method
+ *
+ * @param sArray the StringArray
+ * @param value string
+ */
+ private String[] addStringArray(String sArray[], String value) {
+ String[] result = null;
+ if (sArray == null) {
+ result = new String[1];
+ result[0] = value;
+ }
+ else {
+ result = new String[sArray.length + 1];
+ for (int i = 0; i < sArray.length; i++)
+ result[i] = sArray[i];
+ result[sArray.length] = value;
+ }
+ return result;
+ }
+
+
+ /**
+ * General use method
+ *
+ * @param rArray the REArray
+ * @param value Obj
+ */
+ private Pattern[] addREArray(Pattern rArray[], Pattern value) {
+ Pattern[] result = null;
+ if (rArray == null) {
+ result = new Pattern[1];
+ result[0] = value;
+ }
+ else {
+ result = new Pattern[rArray.length + 1];
+ for (int i = 0; i < rArray.length; i++)
+ result[i] = rArray[i];
+ result[rArray.length] = value;
+ }
+ return result;
+ }
+
+
+ /**
+ * Checks if any entry in the string array starts with the specified value
+ *
+ * @param sArray the StringArray
+ * @param value string
+ */
+ private boolean startsWithStringArray(String sArray[], String value) {
+ if (value == null)
+ return false;
+ for (int i = 0; i < sArray.length; i++) {
+ if (value.startsWith(sArray[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+
+ /**
+ * Add restricted user-agent (which will downgrade the connector
+ * to HTTP/1.0 mode). The user agent String given will be matched
+ * via regexp to the user-agent header submitted by the client.
+ *
+ * @param userAgent user-agent string
+ */
+ public void addRestrictedUserAgent(String userAgent) {
+ try {
+ Pattern nRule = Pattern.compile(userAgent);
+ restrictedUserAgents = addREArray(restrictedUserAgents, nRule);
+ } catch (PatternSyntaxException pse) {
+ CoyoteLogger.HTTP_LOGGER.errorParsingRegexp(userAgent, pse);
+ }
+ }
+
+
+ /**
+ * Set restricted user agent list (this method is best when used with
+ * a large number of connectors, where it would be better to have all of
+ * them referenced a single array).
+ */
+ public void setRestrictedUserAgents(Pattern[] restrictedUserAgents) {
+ this.restrictedUserAgents = restrictedUserAgents;
+ }
+
+
+ /**
+ * Set restricted user agent list (which will downgrade the connector
+ * to HTTP/1.0 mode). List contains users agents separated by ',' :
+ *
+ * ie: "gorilla,desesplorer,tigrus"
+ */
+ public void setRestrictedUserAgents(String restrictedUserAgents) {
+ if (restrictedUserAgents != null) {
+ StringTokenizer st =
+ new StringTokenizer(restrictedUserAgents, ",");
+ while (st.hasMoreTokens()) {
+ addRestrictedUserAgent(st.nextToken().trim());
+ }
+ }
+ }
+
+
+ /**
+ * Return the list of restricted user agents.
+ */
+ public String[] findRestrictedUserAgents() {
+ String[] sarr = new String [restrictedUserAgents.length];
+
+ for (int i = 0; i < restrictedUserAgents.length; i++)
+ sarr[i] = restrictedUserAgents[i].toString();
+
+ return (sarr);
+ }
+
+
+ /**
+ * Set the maximum number of Keep-Alive requests to honor.
+ * This is to safeguard from DoS attacks. Setting to a negative
+ * value disables the check.
+ */
+ public void setMaxKeepAliveRequests(int mkar) {
+ maxKeepAliveRequests = mkar;
+ }
+
+
+ /**
+ * Return the number of Keep-Alive requests that we will honor.
+ */
+ public int getMaxKeepAliveRequests() {
+ return maxKeepAliveRequests;
+ }
+
+ /**
+ * Set the Keep-Alive timeout.
+ */
+ public void setKeepAliveTimeout(int timeout) {
+ keepAliveTimeout = timeout;
+ }
+
+
+ /**
+ * Return the number Keep-Alive timeout.
+ */
+ public int getKeepAliveTimeout() {
+ return keepAliveTimeout;
+ }
+
+
+ /**
+ * Set the maximum size of a POST which will be buffered in SSL mode.
+ */
+ public void setMaxSavePostSize(int msps) {
+ maxSavePostSize = msps;
+ }
+
+
+ /**
+ * Return the maximum size of a POST which will be buffered in SSL mode.
+ */
+ public int getMaxSavePostSize() {
+ return maxSavePostSize;
+ }
+
+
+ /**
+ * Set the SSL information for this HTTP connection.
+ */
+ public void setSSLSupport(SSLSupport sslSupport) {
+ this.sslSupport = sslSupport;
+ }
+
+
+ /**
+ * Set the flag to control upload time-outs.
+ */
+ public void setDisableUploadTimeout(boolean isDisabled) {
+ disableUploadTimeout = isDisabled;
+ }
+
+ /**
+ * Get the flag that controls upload time-outs.
+ */
+ public boolean getDisableUploadTimeout() {
+ return disableUploadTimeout;
+ }
+
+ public boolean getResumeNotification() {
+ return resumeNotification;
+ }
+
+
+ /**
+ * Set the socket buffer flag.
+ */
+ public void setSocketBuffer(int socketBuffer) {
+ this.socketBuffer = socketBuffer;
+ outputBuffer.setSocketBuffer(socketBuffer);
+ }
+
+ /**
+ * Get the socket buffer flag.
+ */
+ public int getSocketBuffer() {
+ return socketBuffer;
+ }
+
+
+ /**
+ * Set the server header name.
+ */
+ public void setServer( String server ) {
+ if (server==null || server.equals("")) {
+ this.server = null;
+ } else {
+ this.server = server;
+ }
+ }
+
+ /**
+ * Get the server header name.
+ */
+ public String getServer() {
+ return server;
+ }
+
+
+ /** Get the request associated with this processor.
+ *
+ * @return The request
+ */
+ public Request getRequest() {
+ return request;
+ }
+
+ public SocketState event(SocketStatus status)
+ throws IOException {
+
+ RequestInfo rp = request.getRequestProcessor();
+ try {
+ if (status == SocketStatus.OPEN_CALLBACK) {
+ // The resume notification is now done
+ resumeNotification = false;
+ } else if (status == SocketStatus.ERROR) {
+ // Set error flag right away
+ error = true;
+ }
+ rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
+ error = !adapter.event(request, response, status);
+ } catch (InterruptedIOException e) {
+ error = true;
+ } catch (Throwable t) {
+ CoyoteLogger.HTTP_LOGGER.errorProcessingRequest(t);
+ // 500 - Internal Server Error
+ response.setStatus(500);
+ error = true;
+ }
+
+ rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);
+
+ if (error) {
+ inputBuffer.nextRequest();
+ outputBuffer.nextRequest();
+ recycle();
+ return SocketState.CLOSED;
+ } else if (!event) {
+ endRequest();
+ boolean pipelined = inputBuffer.nextRequest();
+ outputBuffer.nextRequest();
+ recycle();
+ return (pipelined || !keepAlive) ? SocketState.CLOSED : SocketState.OPEN;
+ } else {
+ return SocketState.LONG;
+ }
+ }
+
+ /**
+ * Process pipelined HTTP requests on the specified socket.
+ *
+ * @param socket Socket from which the HTTP requests will be read
+ * and the HTTP responses will be written.
+ *
+ * @throws IOException error during an I/O operation
+ */
+ public SocketState process(Socket socket)
+ throws IOException {
+ RequestInfo rp = request.getRequestProcessor();
+ rp.setStage(org.apache.coyote.Constants.STAGE_PARSE);
+
+ // Set the remote address
+ remoteAddr = null;
+ remoteHost = null;
+ localAddr = null;
+ localName = null;
+ remotePort = -1;
+ localPort = -1;
+
+ // Setting up the I/O
+ this.socket = socket;
+ inputBuffer.setInputStream(socket.getInputStream());
+ outputBuffer.setOutputStream(socket.getOutputStream());
+
+ // Error flag
+ error = false;
+ keepAlive = true;
+
+ int keepAliveLeft = maxKeepAliveRequests;
+ int soTimeout = socket.getSoTimeout();
+
+ int threadRatio = (endpoint.getCurrentThreadsBusy() * 100)
+ / endpoint.getMaxThreads();
+ if (threadRatio > 75) {
+ keepAliveLeft = 1;
+ }
+
+ boolean keptAlive = false;
+
+ while (!error && keepAlive && !event) {
+
+ // Parsing the request header
+ try {
+ if (!disableUploadTimeout && keptAlive) {
+ if (keepAliveTimeout > 0) {
+ socket.setSoTimeout(keepAliveTimeout);
+ }
+ else if (soTimeout > 0) {
+ socket.setSoTimeout(soTimeout);
+ }
+ }
+ inputBuffer.parseRequestLine();
+ request.setStartTime(System.currentTimeMillis());
+ keptAlive = true;
+ if (!disableUploadTimeout) {
+ socket.setSoTimeout(timeout);
+ }
+ inputBuffer.parseHeaders();
+ } catch (IOException e) {
+ error = true;
+ break;
+ } catch (Throwable t) {
+ CoyoteLogger.HTTP_LOGGER.errorParsingHeader(t);
+ // 400 - Bad Request
+ response.setStatus(400);
+ error = true;
+ }
+
+ // Setting up filters, and parse some request headers
+ rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);
+ try {
+ prepareRequest();
+ } catch (Throwable t) {
+ CoyoteLogger.HTTP_LOGGER.errorPreparingRequest(t);
+ // 400 - Internal Server Error
+ response.setStatus(400);
+ error = true;
+ }
+
+ if (maxKeepAliveRequests > 0 && --keepAliveLeft == 0)
+ keepAlive = false;
+
+ // Process the request in the adapter
+ if (!error) {
+ try {
+ rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
+ adapter.service(request, response);
+ // Handle when the response was committed before a serious
+ // error occurred. Throwing a ServletException should both
+ // set the status to 500 and set the errorException.
+ // If we fail here, then the response is likely already
+ // committed, so we can't try and set headers.
+ if(keepAlive && !error) { // Avoid checking twice.
+ error = response.getErrorException() != null ||
+ statusDropsConnection(response.getStatus());
+ }
+
+ } catch (InterruptedIOException e) {
+ error = true;
+ } catch (Throwable t) {
+ CoyoteLogger.HTTP_LOGGER.errorProcessingRequest(t);
+ // 500 - Internal Server Error
+ response.setStatus(500);
+ error = true;
+ }
+ }
+
+ // Finish the handling of the request
+ if (error) {
+ // If there is an unspecified error, the connection will be closed
+ inputBuffer.setSwallowInput(false);
+ }
+ if (!event) {
+ endRequest();
+ }
+
+ // If there was an error, make sure the request is counted as
+ // and error, and update the statistics counter
+ if (error) {
+ response.setStatus(500);
+ }
+ request.updateCounters();
+
+ if (!event) {
+ // Next request
+ inputBuffer.nextRequest();
+ outputBuffer.nextRequest();
+ }
+
+ rp.setStage(org.apache.coyote.Constants.STAGE_KEEPALIVE);
+
+ }
+
+ rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);
+
+ if (event) {
+ if (error) {
+ inputBuffer.nextRequest();
+ outputBuffer.nextRequest();
+ recycle();
+ return SocketState.CLOSED;
+ } else {
+ eventProcessing = false;
+ return SocketState.LONG;
+ }
+ } else {
+ recycle();
+ return SocketState.CLOSED;
+ }
+
+ }
+
+
+ public void endRequest() {
+
+ // Finish the handling of the request
+ try {
+ inputBuffer.endRequest();
+ } catch (IOException e) {
+ error = true;
+ } catch (Throwable t) {
+ CoyoteLogger.HTTP_LOGGER.errorFinishingRequest(t);
+ // 500 - Internal Server Error
+ response.setStatus(500);
+ error = true;
+ }
+ try {
+ outputBuffer.endRequest();
+ } catch (IOException e) {
+ error = true;
+ } catch (Throwable t) {
+ CoyoteLogger.HTTP_LOGGER.errorFinishingResponse(t);
+ error = true;
+ }
+
+ }
+
+
+ public void recycle() {
+ inputBuffer.recycle();
+ outputBuffer.recycle();
+ this.socket = null;
+ sslSupport = null;
+ timeout = -1;
+ resumeNotification = false;
+ eventProcessing = true;
+ }
+
+
+ // ----------------------------------------------------- ActionHook Methods
+
+
+ /**
+ * Send an action to the connector.
+ *
+ * @param actionCode Type of the action
+ * @param param Action parameter
+ */
+ public void action(ActionCode actionCode, Object param) {
+
+ if (actionCode == ActionCode.ACTION_COMMIT) {
+ // Commit current response
+
+ if (response.isCommitted())
+ return;
+
+ // Validate and write response headers
+ prepareResponse();
+ try {
+ outputBuffer.commit();
+ } catch (IOException e) {
+ // Set error flag
+ error = true;
+ }
+
+ } else if (actionCode == ActionCode.ACTION_ACK) {
+
+ // Acknowlege request
+
+ // Send a 100 status back if it makes sense (response not committed
+ // yet, and client specified an expectation for 100-continue)
+
+ if ((response.isCommitted()) || !expectation)
+ return;
+
+ inputBuffer.setSwallowInput(true);
+ try {
+ outputBuffer.sendAck();
+ } catch (IOException e) {
+ // Set error flag
+ error = true;
+ }
+
+ } else if (actionCode == ActionCode.ACTION_CLIENT_FLUSH) {
+
+ try {
+ outputBuffer.flush();
+ } catch (IOException e) {
+ // Set error flag
+ error = true;
+ response.setErrorException(e);
+ }
+
+ } else if (actionCode == ActionCode.ACTION_CLOSE) {
+ // Close
+
+ // End the processing of the current request, and stop any further
+ // transactions with the client
+
+ try {
+ outputBuffer.endRequest();
+ } catch (IOException e) {
+ // Set error flag
+ error = true;
+ }
+
+ } else if (actionCode == ActionCode.ACTION_CUSTOM) {
+
+ // Do nothing
+
+ } else if (actionCode == ActionCode.ACTION_REQ_SSL_ATTRIBUTE ) {
+
+ try {
+ if (sslSupport != null) {
+ Object sslO = sslSupport.getCipherSuite();
+ if (sslO != null)
+ request.setAttribute
+ (org.apache.tomcat.util.net.Constants.CIPHER_SUITE_KEY, sslO);
+ sslO = sslSupport.getPeerCertificateChain(false);
+ if (sslO != null)
+ request.setAttribute
+ (org.apache.tomcat.util.net.Constants.CERTIFICATE_KEY, sslO);
+ sslO = sslSupport.getKeySize();
+ if (sslO != null)
+ request.setAttribute
+ (org.apache.tomcat.util.net.Constants.KEY_SIZE_KEY, sslO);
+ sslO = sslSupport.getSessionId();
+ if (sslO != null)
+ request.setAttribute
+ (org.apache.tomcat.util.net.Constants.SESSION_ID_KEY, sslO);
+ }
+ } catch (Exception e) {
+ CoyoteLogger.HTTP_LOGGER.errorGettingSslAttributes(e);
+ }
+
+ } else if (actionCode == ActionCode.ACTION_REQ_HOST_ADDR_ATTRIBUTE) {
+
+ if ((remoteAddr == null) && (socket != null)) {
+ InetAddress inetAddr = socket.getInetAddress();
+ if (inetAddr != null) {
+ remoteAddr = inetAddr.getHostAddress();
+ }
+ }
+ request.remoteAddr().setString(remoteAddr);
+
+ } else if (actionCode == ActionCode.ACTION_REQ_LOCAL_NAME_ATTRIBUTE) {
+
+ if ((localName == null) && (socket != null)) {
+ InetAddress inetAddr = socket.getLocalAddress();
+ if (inetAddr != null) {
+ localName = inetAddr.getHostName();
+ }
+ }
+ request.localName().setString(localName);
+
+ } else if (actionCode == ActionCode.ACTION_REQ_HOST_ATTRIBUTE) {
+
+ if ((remoteHost == null) && (socket != null)) {
+ InetAddress inetAddr = socket.getInetAddress();
+ if (inetAddr != null) {
+ remoteHost = inetAddr.getHostName();
+ }
+ if(remoteHost == null) {
+ if(remoteAddr != null) {
+ remoteHost = remoteAddr;
+ } else { // all we can do is punt
+ request.remoteHost().recycle();
+ }
+ }
+ }
+ request.remoteHost().setString(remoteHost);
+
+ } else if (actionCode == ActionCode.ACTION_REQ_LOCAL_ADDR_ATTRIBUTE) {
+
+ if (localAddr == null)
+ localAddr = socket.getLocalAddress().getHostAddress();
+
+ request.localAddr().setString(localAddr);
+
+ } else if (actionCode == ActionCode.ACTION_REQ_REMOTEPORT_ATTRIBUTE) {
+
+ if ((remotePort == -1 ) && (socket !=null)) {
+ remotePort = socket.getPort();
+ }
+ request.setRemotePort(remotePort);
+
+ } else if (actionCode == ActionCode.ACTION_REQ_LOCALPORT_ATTRIBUTE) {
+
+ if ((localPort == -1 ) && (socket !=null)) {
+ localPort = socket.getLocalPort();
+ }
+ request.setLocalPort(localPort);
+
+ } else if (actionCode == ActionCode.ACTION_REQ_SSL_CERTIFICATE) {
+ if( sslSupport != null) {
+ // Consume and buffer the request body, so that it does not
+ // interfere with the client's handshake messages
+ if (maxSavePostSize != 0) {
+ BufferedInputFilter buffredInputFilter = new BufferedInputFilter();
+ buffredInputFilter.setLimit(maxSavePostSize);
+ inputBuffer.addActiveFilter(buffredInputFilter);
+ }
+ try {
+ Object sslO = sslSupport.getPeerCertificateChain(true);
+ if( sslO != null) {
+ request.setAttribute
+ (org.apache.tomcat.util.net.Constants.CERTIFICATE_KEY, sslO);
+ }
+ } catch (Exception e) {
+ CoyoteLogger.HTTP_LOGGER.errorGettingSslAttributes(e);
+ }
+ }
+ } else if (actionCode == ActionCode.ACTION_REQ_SET_BODY_REPLAY) {
+ ByteChunk body = (ByteChunk) param;
+
+ InputFilter savedBody = new SavedRequestInputFilter(body);
+ savedBody.setRequest(request);
+
+ InternalInputBuffer internalBuffer = (InternalInputBuffer)
+ request.getInputBuffer();
+ internalBuffer.addActiveFilter(savedBody);
+ } else if (actionCode == ActionCode.ACTION_EVENT_BEGIN) {
+ event = true;
+ } else if (actionCode == ActionCode.ACTION_EVENT_END) {
+ event = false;
+ } else if (actionCode == ActionCode.ACTION_EVENT_SUSPEND) {
+ // No action needed
+ } else if (actionCode == ActionCode.ACTION_EVENT_RESUME) {
+ // An event is being processed already: adding for resume will be done
+ // when the socket gets back to the poller
+ if (!eventProcessing && !resumeNotification) {
+ endpoint.getEventPoller().add(socket, timeout, true, true);
+ }
+ resumeNotification = true;
+ } else if (actionCode == ActionCode.ACTION_EVENT_TIMEOUT) {
+ timeout = ((Integer) param).intValue();
+ }
+
+ }
+
+
+ // ------------------------------------------------------ Connector Methods
+
+
+ /**
+ * Set the associated adapter.
+ *
+ * @param adapter the new adapter
+ */
+ public void setAdapter(Adapter adapter) {
+ this.adapter = adapter;
+ }
+
+
+ /**
+ * Get the associated adapter.
+ *
+ * @return the associated adapter
+ */
+ public Adapter getAdapter() {
+ return adapter;
+ }
+
+
+ // ------------------------------------------------------ Protected Methods
+
+
+ /**
+ * After reading the request headers, we have to setup the request filters.
+ */
+ protected void prepareRequest() {
+
+ http11 = true;
+ http09 = false;
+ contentDelimitation = false;
+ expectation = false;
+ if (sslSupport != null) {
+ request.scheme().setString("https");
+ }
+ MessageBytes protocolMB = request.protocol();
+ if (protocolMB.equals(Constants.HTTP_11)) {
+ http11 = true;
+ protocolMB.setString(Constants.HTTP_11);
+ } else if (protocolMB.equals(Constants.HTTP_10)) {
+ http11 = false;
+ keepAlive = false;
+ protocolMB.setString(Constants.HTTP_10);
+ } else if (protocolMB.equals("")) {
+ // HTTP/0.9
+ http09 = true;
+ http11 = false;
+ keepAlive = false;
+ } else {
+ // Unsupported protocol
+ http11 = false;
+ error = true;
+ // Send 505; Unsupported HTTP version
+ response.setStatus(505);
+ }
+
+ MessageBytes methodMB = request.method();
+ if (methodMB.equals(Constants.GET)) {
+ methodMB.setString(Constants.GET);
+ } else if (methodMB.equals(Constants.POST)) {
+ methodMB.setString(Constants.POST);
+ }
+
+ MimeHeaders headers = request.getMimeHeaders();
+
+ // Check connection header
+ MessageBytes connectionValueMB = headers.getValue("connection");
+ if (connectionValueMB != null) {
+ ByteChunk connectionValueBC = connectionValueMB.getByteChunk();
+ if (findBytes(connectionValueBC, Constants.CLOSE_BYTES) != -1) {
+ keepAlive = false;
+ } else if (findBytes(connectionValueBC,
+ Constants.KEEPALIVE_BYTES) != -1) {
+ keepAlive = true;
+ }
+ }
+
+ MessageBytes expectMB = null;
+ if (http11)
+ expectMB = headers.getValue("expect");
+ if ((expectMB != null)
+ && (expectMB.indexOfIgnoreCase("100-continue", 0) != -1)) {
+ inputBuffer.setSwallowInput(false);
+ expectation = true;
+ }
+
+ // Check user-agent header
+ if ((restrictedUserAgents != null) && ((http11) || (keepAlive))) {
+ MessageBytes userAgentValueMB = headers.getValue("user-agent");
+ // Check in the restricted list, and adjust the http11
+ // and keepAlive flags accordingly
+ if(userAgentValueMB != null) {
+ String userAgentValue = userAgentValueMB.toString();
+ for (int i = 0; i < restrictedUserAgents.length; i++) {
+ if (restrictedUserAgents[i].matcher(userAgentValue).matches()) {
+ http11 = false;
+ keepAlive = false;
+ break;
+ }
+ }
+ }
+ }
+
+ // Check for a full URI (including protocol://host:port/)
+ ByteChunk uriBC = request.requestURI().getByteChunk();
+ if (uriBC.startsWithIgnoreCase("http", 0)) {
+
+ int pos = uriBC.indexOf("://", 0, 3, 4);
+ int uriBCStart = uriBC.getStart();
+ int slashPos = -1;
+ if (pos != -1) {
+ byte[] uriB = uriBC.getBytes();
+ slashPos = uriBC.indexOf('/', pos + 3);
+ if (slashPos == -1) {
+ slashPos = uriBC.getLength();
+ // Set URI as "/"
+ request.requestURI().setBytes
+ (uriB, uriBCStart + pos + 1, 1);
+ } else {
+ request.requestURI().setBytes
+ (uriB, uriBCStart + slashPos,
+ uriBC.getLength() - slashPos);
+ }
+ MessageBytes hostMB = headers.setValue("host");
+ hostMB.setBytes(uriB, uriBCStart + pos + 3,
+ slashPos - pos - 3);
+ }
+
+ }
+
+ // Input filter setup
+ InputFilter[] inputFilters = inputBuffer.getFilters();
+
+ // Parse transfer-encoding header
+ MessageBytes transferEncodingValueMB = null;
+ if (http11)
+ transferEncodingValueMB = headers.getValue("transfer-encoding");
+ if (transferEncodingValueMB != null) {
+ String transferEncodingValue = transferEncodingValueMB.toString();
+ // Parse the comma separated list. "identity" codings are ignored
+ int startPos = 0;
+ int commaPos = transferEncodingValue.indexOf(',');
+ String encodingName = null;
+ while (commaPos != -1) {
+ encodingName = transferEncodingValue.substring
+ (startPos, commaPos).toLowerCase(Locale.ENGLISH).trim();
+ if (!addInputFilter(inputFilters, encodingName)) {
+ // Unsupported transfer encoding
+ error = true;
+ // 501 - Unimplemented
+ response.setStatus(501);
+ }
+ startPos = commaPos + 1;
+ commaPos = transferEncodingValue.indexOf(',', startPos);
+ }
+ encodingName = transferEncodingValue.substring(startPos)
+ .toLowerCase(Locale.ENGLISH).trim();
+ if (!addInputFilter(inputFilters, encodingName)) {
+ // Unsupported transfer encoding
+ error = true;
+ // 501 - Unimplemented
+ response.setStatus(501);
+ }
+ }
+
+ // Parse content-length header
+ long contentLength = request.getContentLengthLong();
+ if (contentLength >= 0 && !contentDelimitation) {
+ inputBuffer.addActiveFilter
+ (inputFilters[Constants.IDENTITY_FILTER]);
+ contentDelimitation = true;
+ }
+
+ MessageBytes valueMB = headers.getValue("host");
+
+ // Check host header
+ if (http11 && (valueMB == null)) {
+ error = true;
+ // 400 - Bad request
+ response.setStatus(400);
+ }
+
+ parseHost(valueMB);
+
+ if (!contentDelimitation) {
+ // If there's no content length
+ // (broken HTTP/1.0 or HTTP/1.1), assume
+ // the client is not broken and didn't send a body
+ inputBuffer.addActiveFilter
+ (inputFilters[Constants.VOID_FILTER]);
+ contentDelimitation = true;
+ }
+
+ }
+
+
+ /**
+ * Parse host.
+ */
+ protected void parseHost(MessageBytes valueMB) {
+
+ if (valueMB == null || valueMB.isNull()) {
+ // HTTP/1.0
+ // Default is what the socket tells us. Overriden if a host is
+ // found/parsed
+ request.setServerPort(socket.getLocalPort());
+ InetAddress localAddress = socket.getLocalAddress();
+ // Setting the socket-related fields. The adapter doesn't know
+ // about socket.
+ request.serverName().setString(localAddress.getHostName());
+ return;
+ }
+
+ ByteChunk valueBC = valueMB.getByteChunk();
+ byte[] valueB = valueBC.getBytes();
+ int valueL = valueBC.getLength();
+ int valueS = valueBC.getStart();
+ int colonPos = -1;
+ if (hostNameC.length < valueL) {
+ hostNameC = new char[valueL];
+ }
+
+ boolean ipv6 = (valueB[valueS] == '[');
+ boolean bracketClosed = false;
+ for (int i = 0; i < valueL; i++) {
+ char b = (char) valueB[i + valueS];
+ hostNameC[i] = b;
+ if (b == ']') {
+ bracketClosed = true;
+ } else if (b == ':') {
+ if (!ipv6 || bracketClosed) {
+ colonPos = i;
+ break;
+ }
+ }
+ }
+
+ if (colonPos < 0) {
+ if (sslSupport == null) {
+ // 80 - Default HTTP port
+ request.setServerPort(80);
+ } else {
+ // 443 - Default HTTPS port
+ request.setServerPort(443);
+ }
+ request.serverName().setChars(hostNameC, 0, valueL);
+ } else {
+
+ request.serverName().setChars(hostNameC, 0, colonPos);
+
+ int port = 0;
+ int mult = 1;
+ for (int i = valueL - 1; i > colonPos; i--) {
+ int charValue = HexUtils.DEC[valueB[i + valueS] & 0xff];
+ if (charValue == -1) {
+ // Invalid character
+ error = true;
+ // 400 - Bad request
+ response.setStatus(400);
+ break;
+ }
+ port = port + (charValue * mult);
+ mult = 10 * mult;
+ }
+ request.setServerPort(port);
+
+ }
+
+ }
+
+
+ /**
+ * Check for compression
+ */
+ private boolean isCompressable() {
+
+ // Nope Compression could works in HTTP 1.0 also
+ // cf: mod_deflate
+
+ // Compression only since HTTP 1.1
+ // if (! http11)
+ // return false;
+
+ // Check if browser support gzip encoding
+ MessageBytes acceptEncodingMB =
+ request.getMimeHeaders().getValue("accept-encoding");
+
+ if ((acceptEncodingMB == null)
+ || (acceptEncodingMB.indexOf("gzip") == -1))
+ return false;
+
+ // Check if content is not allready gzipped
+ MessageBytes contentEncodingMB =
+ response.getMimeHeaders().getValue("Content-Encoding");
+
+ if ((contentEncodingMB != null)
+ && (contentEncodingMB.indexOf("gzip") != -1))
+ return false;
+
+ // If force mode, allways compress (test purposes only)
+ if (compressionLevel == 2)
+ return true;
+
+ // Check for incompatible Browser
+ if (noCompressionUserAgents != null) {
+ MessageBytes userAgentValueMB =
+ request.getMimeHeaders().getValue("user-agent");
+ if(userAgentValueMB != null) {
+ String userAgentValue = userAgentValueMB.toString();
+
+ // If one Regexp rule match, disable compression
+ for (int i = 0; i < noCompressionUserAgents.length; i++)
+ if (noCompressionUserAgents[i].matcher(userAgentValue).matches())
+ return false;
+ }
+ }
+
+ // Check if suffisant len to trig the compression
+ long contentLength = response.getContentLengthLong();
+ if ((contentLength == -1)
+ || (contentLength > compressionMinSize)) {
+ // Check for compatible MIME-TYPE
+ if (compressableMimeTypes != null) {
+ return (startsWithStringArray(compressableMimeTypes,
+ response.getContentType()));
+ }
+ }
+
+ return false;
+ }
+
+
+ /**
+ * When committing the response, we have to validate the set of headers, as
+ * well as setup the response filters.
+ */
+ protected void prepareResponse() {
+
+ boolean entityBody = true;
+ contentDelimitation = false;
+
+ OutputFilter[] outputFilters = outputBuffer.getFilters();
+
+ if (http09 == true) {
+ // HTTP/0.9
+ outputBuffer.addActiveFilter
+ (outputFilters[Constants.IDENTITY_FILTER]);
+ return;
+ }
+
+ int statusCode = response.getStatus();
+ if ((statusCode == 204) || (statusCode == 205)
+ || (statusCode == 304)) {
+ // No entity body
+ outputBuffer.addActiveFilter
+ (outputFilters[Constants.VOID_FILTER]);
+ entityBody = false;
+ contentDelimitation = true;
+ }
+
+ MessageBytes methodMB = request.method();
+ if (methodMB.equals("HEAD")) {
+ // No entity body
+ outputBuffer.addActiveFilter
+ (outputFilters[Constants.VOID_FILTER]);
+ contentDelimitation = true;
+ }
+
+ // Check for compression
+ boolean useCompression = false;
+ if (entityBody && (compressionLevel > 0)) {
+ useCompression = isCompressable();
+
+ // Change content-length to -1 to force chunking
+ if (useCompression) {
+ response.setContentLength(-1);
+ }
+ }
+
+ MimeHeaders headers = response.getMimeHeaders();
+ if (!entityBody) {
+ response.setContentLength(-1);
+ } else {
+ String contentType = response.getContentType();
+ if (contentType != null) {
+ headers.setValue("Content-Type").setString(contentType);
+ }
+ String contentLanguage = response.getContentLanguage();
+ if (contentLanguage != null) {
+ headers.setValue("Content-Language")
+ .setString(contentLanguage);
+ }
+ }
+
+ long contentLength = response.getContentLengthLong();
+ if (contentLength != -1) {
+ headers.setValue("Content-Length").setLong(contentLength);
+ outputBuffer.addActiveFilter
+ (outputFilters[Constants.IDENTITY_FILTER]);
+ contentDelimitation = true;
+ } else {
+ if (entityBody && http11 && (keepAlive || CHUNK_ON_CLOSE)) {
+ outputBuffer.addActiveFilter
+ (outputFilters[Constants.CHUNKED_FILTER]);
+ contentDelimitation = true;
+ headers.addValue(Constants.TRANSFERENCODING).setString(Constants.CHUNKED);
+ } else {
+ outputBuffer.addActiveFilter
+ (outputFilters[Constants.IDENTITY_FILTER]);
+ }
+ }
+
+ if (useCompression) {
+ outputBuffer.addActiveFilter(outputFilters[Constants.GZIP_FILTER]);
+ headers.setValue("Content-Encoding").setString("gzip");
+ // Make Proxies happy via Vary (from mod_deflate)
+ headers.addValue("Vary").setString("Accept-Encoding");
+ }
+
+ // Add date header
+ headers.setValue("Date").setString(FastHttpDateFormat.getCurrentDate());
+
+ // FIXME: Add transfer encoding header
+
+ if ((entityBody) && (!contentDelimitation)) {
+ // Mark as close the connection after the request, and add the
+ // connection: close header
+ keepAlive = false;
+ }
+
+ // If we know that the request is bad this early, add the
+ // Connection: close header.
+ keepAlive = keepAlive && !statusDropsConnection(statusCode);
+ if (!keepAlive) {
+ headers.addValue(Constants.CONNECTION).setString(Constants.CLOSE);
+ } else if (!http11 && !error) {
+ headers.addValue(Constants.CONNECTION).setString(Constants.KEEPALIVE);
+ }
+
+ // Build the response header
+ outputBuffer.sendStatus();
+
+ // Add server header
+ if (server != null) {
+ headers.setValue("Server").setString(server);
+ } else {
+ outputBuffer.write(Constants.SERVER_BYTES);
+ }
+
+ int size = headers.size();
+ for (int i = 0; i < size; i++) {
+ outputBuffer.sendHeader(headers.getName(i), headers.getValue(i));
+ }
+ outputBuffer.endHeaders();
+
+ }
+
+
+ /**
+ * Initialize standard input and output filters.
+ */
+ protected void initializeFilters() {
+
+ // Create and add the identity filters.
+ inputBuffer.addFilter(new IdentityInputFilter());
+ outputBuffer.addFilter(new IdentityOutputFilter());
+
+ // Create and add the chunked filters.
+ inputBuffer.addFilter(new ChunkedInputFilter());
+ outputBuffer.addFilter(new ChunkedOutputFilter());
+
+ // Create and add the void filters.
+ inputBuffer.addFilter(new VoidInputFilter());
+ outputBuffer.addFilter(new VoidOutputFilter());
+
+ // Create and add the chunked filters.
+ //inputBuffer.addFilter(new GzipInputFilter());
+ outputBuffer.addFilter(new GzipOutputFilter());
+
+ }
+
+
+ /**
+ * Add an input filter to the current request.
+ *
+ * @return false if the encoding was not found (which would mean it is
+ * unsupported)
+ */
+ protected boolean addInputFilter(InputFilter[] inputFilters,
+ String encodingName) {
+ if (encodingName.equals("identity")) {
+ // Skip
+ } else if (encodingName.equals("chunked")) {
+ inputBuffer.addActiveFilter
+ (inputFilters[Constants.CHUNKED_FILTER]);
+ contentDelimitation = true;
+ } else {
+ for (int i = 2; i < inputFilters.length; i++) {
+ if (inputFilters[i].getEncodingName()
+ .toString().equals(encodingName)) {
+ inputBuffer.addActiveFilter(inputFilters[i]);
+ return true;
+ }
+ }
+ return false;
+ }
+ return true;
+ }
+
+
+ /**
+ * Specialized utility method: find a sequence of lower case bytes inside
+ * a ByteChunk.
+ */
+ protected int findBytes(ByteChunk bc, byte[] b) {
+
+ byte first = b[0];
+ byte[] buff = bc.getBuffer();
+ int start = bc.getStart();
+ int end = bc.getEnd();
+
+ // Look for first char
+ int srcEnd = b.length;
+
+ for (int i = start; i <= (end - srcEnd); i++) {
+ if (Ascii.toLower(buff[i]) != first) continue;
+ // found first char, now look for a match
+ int myPos = i+1;
+ for (int srcPos = 1; srcPos < srcEnd; ) {
+ if (Ascii.toLower(buff[myPos++]) != b[srcPos++])
+ break;
+ if (srcPos == srcEnd) return i - start; // found it
+ }
+ }
+ return -1;
+
+ }
+
+ /**
+ * Determine if we must drop the connection because of the HTTP status
+ * code. Use the same list of codes as Apache/httpd.
+ */
+ protected boolean statusDropsConnection(int status) {
+ return status == 400 /* SC_BAD_REQUEST */ ||
+ status == 408 /* SC_REQUEST_TIMEOUT */ ||
+ status == 411 /* SC_LENGTH_REQUIRED */ ||
+ status == 413 /* SC_REQUEST_ENTITY_TOO_LARGE */ ||
+ status == 414 /* SC_REQUEST_URI_TOO_LARGE */ ||
+ status == 500 /* SC_INTERNAL_SERVER_ERROR */ ||
+ status == 503 /* SC_SERVICE_UNAVAILABLE */ ||
+ status == 501 /* SC_NOT_IMPLEMENTED */;
+ }
+
+}
Added: branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11Protocol.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11Protocol.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/coyote/http11/Http11Protocol.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,778 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2009, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.apache.coyote.http11;
+
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.URLEncoder;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+import javax.management.MBeanRegistration;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+import javax.net.ssl.SSLContext;
+
+import org.apache.coyote.Adapter;
+import org.apache.coyote.ProtocolHandler;
+import org.apache.coyote.RequestGroupInfo;
+import org.apache.coyote.RequestInfo;
+import org.apache.tomcat.util.modeler.Registry;
+import org.apache.tomcat.util.net.JIoEndpoint;
+import org.apache.tomcat.util.net.SSLImplementation;
+import org.apache.tomcat.util.net.ServerSocketFactory;
+import org.apache.tomcat.util.net.SocketStatus;
+import org.apache.tomcat.util.net.JIoEndpoint.Handler;
+import org.apache.tomcat.util.net.jsse.JSSEImplementation;
+import org.jboss.web.CoyoteLogger;
+
+
+/**
+ * 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 Remy Maucherat
+ * @author Costin Manolache
+ */
+public class Http11Protocol
+ implements ProtocolHandler, MBeanRegistration {
+
+
+ // ------------------------------------------------------------ Constructor
+
+
+ public Http11Protocol() {
+ setSoLinger(Constants.DEFAULT_CONNECTION_LINGER);
+ setSoTimeout(Constants.DEFAULT_CONNECTION_TIMEOUT);
+ //setServerSoTimeout(Constants.DEFAULT_SERVER_SOCKET_TIMEOUT);
+ setTcpNoDelay(Constants.DEFAULT_TCP_NO_DELAY);
+ }
+
+
+ // ----------------------------------------------------------------- Fields
+
+
+ protected Http11ConnectionHandler cHandler = new Http11ConnectionHandler(this);
+ protected JIoEndpoint endpoint = new JIoEndpoint();
+
+
+ // *
+ protected ObjectName tpOname = null;
+ // *
+ protected ObjectName rgOname = null;
+
+
+ protected ServerSocketFactory socketFactory = null;
+ protected JSSEImplementation sslImplementation = null;
+
+
+ // ----------------------------------------- ProtocolHandler Implementation
+ // *
+
+
+ protected HashMap<String, Object> attributes = new HashMap<String, Object>();
+
+
+ /**
+ * Pass config info
+ */
+ public void setAttribute(String name, Object value) {
+ attributes.put(name, value);
+ }
+
+ public Object getAttribute(String key) {
+ return attributes.get(key);
+ }
+
+ public Iterator getAttributeNames() {
+ return attributes.keySet().iterator();
+ }
+
+ /**
+ * Set a property.
+ */
+ public void setProperty(String name, String value) {
+ setAttribute(name, value);
+ }
+
+ /**
+ * Get a property
+ */
+ public String getProperty(String name) {
+ return (String)getAttribute(name);
+ }
+
+ /**
+ * The adapter, used to call the connector.
+ */
+ protected Adapter adapter;
+ public void setAdapter(Adapter adapter) { this.adapter = adapter; }
+ public Adapter getAdapter() { return adapter; }
+
+
+ public boolean hasIoEvents() {
+ return false;
+ }
+
+ public RequestGroupInfo getRequestGroupInfo() {
+ return cHandler.global;
+ }
+
+ public void init() throws Exception {
+ endpoint.setName(getName());
+ endpoint.setHandler(cHandler);
+
+ // Verify the validity of the configured socket factory
+ try {
+ if (isSSLEnabled()) {
+ sslImplementation =
+ (JSSEImplementation) SSLImplementation.getInstance(sslImplementationName);
+ socketFactory = sslImplementation.getServerSocketFactory();
+ endpoint.setServerSocketFactory(socketFactory);
+ } else if (socketFactoryName != null) {
+ socketFactory = (ServerSocketFactory) Class.forName(socketFactoryName).newInstance();
+ endpoint.setServerSocketFactory(socketFactory);
+ }
+ } catch (Exception ex) {
+ CoyoteLogger.HTTP_LOGGER.errorInitializingSocketFactory(ex);
+ throw ex;
+ }
+
+ if (socketFactory!=null) {
+ Iterator<String> attE = attributes.keySet().iterator();
+ while( attE.hasNext() ) {
+ String key = attE.next();
+ Object v=attributes.get(key);
+ socketFactory.setAttribute(key, v);
+ }
+ }
+
+ try {
+ endpoint.init();
+ } catch (Exception ex) {
+ CoyoteLogger.HTTP_LOGGER.errorInitializingEndpoint(ex);
+ throw ex;
+ }
+ CoyoteLogger.HTTP_LOGGER.initHttpConnector(getName());
+
+ }
+
+ public void start() throws Exception {
+ if (org.apache.tomcat.util.Constants.ENABLE_MODELER) {
+ if (this.domain != null) {
+ try {
+ tpOname = new ObjectName
+ (domain + ":" + "type=ThreadPool,name=" + getJmxName());
+ Registry.getRegistry(null, null)
+ .registerComponent(endpoint, tpOname, null );
+ } catch (Exception e) {
+ CoyoteLogger.HTTP_LOGGER.errorRegisteringPool(e);
+ }
+ rgOname=new ObjectName
+ (domain + ":type=GlobalRequestProcessor,name=" + getJmxName());
+ Registry.getRegistry(null, null).registerComponent
+ ( cHandler.global, rgOname, null );
+ }
+ }
+ try {
+ endpoint.start();
+ } catch (Exception ex) {
+ CoyoteLogger.HTTP_LOGGER.errorStartingEndpoint(ex);
+ throw ex;
+ }
+ CoyoteLogger.HTTP_LOGGER.startHttpConnector(getName());
+ }
+
+ public void pause() throws Exception {
+ try {
+ endpoint.pause();
+ } catch (Exception ex) {
+ CoyoteLogger.HTTP_LOGGER.errorPausingEndpoint(ex);
+ throw ex;
+ }
+ // Wait for a while until all the processors are no longer processing requests
+ RequestInfo[] states = cHandler.global.getRequestProcessors();
+ int retry = 0;
+ boolean done = false;
+ while (!done && retry < org.apache.coyote.Constants.MAX_PAUSE_WAIT) {
+ retry++;
+ done = true;
+ for (int i = 0; i < states.length; i++) {
+ if (states[i].getStage() == org.apache.coyote.Constants.STAGE_SERVICE) {
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ ;
+ }
+ done = false;
+ break;
+ }
+ }
+ }
+ CoyoteLogger.HTTP_LOGGER.pauseHttpConnector(getName());
+ }
+
+ public void resume() throws Exception {
+ try {
+ endpoint.resume();
+ } catch (Exception ex) {
+ CoyoteLogger.HTTP_LOGGER.errorResumingEndpoint(ex);
+ throw ex;
+ }
+ CoyoteLogger.HTTP_LOGGER.resumeHttpConnector(getName());
+ }
+
+ public void destroy() throws Exception {
+ CoyoteLogger.HTTP_LOGGER.stopHttpConnector(getName());
+ endpoint.destroy();
+ if (org.apache.tomcat.util.Constants.ENABLE_MODELER) {
+ if (tpOname!=null)
+ Registry.getRegistry(null, null).unregisterComponent(tpOname);
+ if (rgOname != null)
+ Registry.getRegistry(null, null).unregisterComponent(rgOname);
+ }
+ }
+
+ public String getJmxName() {
+ String encodedAddr = "";
+ if (getAddress() != null) {
+ encodedAddr = "" + getAddress();
+ encodedAddr = URLEncoder.encode(encodedAddr.replace('/', '-').replace(':', '_').replace('%', '-')) + "-";
+ }
+ return ("http-" + encodedAddr + endpoint.getPort());
+ }
+
+ public String getName() {
+ String encodedAddr = "";
+ if (getAddress() != null) {
+ encodedAddr = getAddress() + ":";
+ }
+ return ("http-" + encodedAddr + endpoint.getPort());
+ }
+
+ // ------------------------------------------------------------- Properties
+
+
+ /**
+ * Processor cache.
+ */
+ protected int processorCache = -1;
+ public int getProcessorCache() { return this.processorCache; }
+ public void setProcessorCache(int processorCache) { this.processorCache = processorCache; }
+
+ protected int socketBuffer = 9000;
+ public int getSocketBuffer() { return socketBuffer; }
+ public void setSocketBuffer(int socketBuffer) { this.socketBuffer = socketBuffer; }
+
+ /**
+ * This field indicates if the protocol is secure from the perspective of
+ * the client (= https is used).
+ */
+ protected boolean secure;
+ public boolean getSecure() { return secure; }
+ public void setSecure(boolean b) { secure = b; }
+
+ protected boolean SSLEnabled = false;
+ public boolean isSSLEnabled() { return SSLEnabled;}
+ public void setSSLEnabled(boolean SSLEnabled) {this.SSLEnabled = SSLEnabled;}
+
+ /**
+ * Name of the socket factory.
+ */
+ protected String socketFactoryName = null;
+ public String getSocketFactory() { return socketFactoryName; }
+ public void setSocketFactory(String valueS) { socketFactoryName = valueS; }
+
+ /**
+ * Name of the SSL implementation.
+ */
+ protected String sslImplementationName=null;
+ public String getSSLImplementation() { return sslImplementationName; }
+ public void setSSLImplementation( String valueS) {
+ sslImplementationName = valueS;
+ setSecure(true);
+ }
+
+
+ // HTTP
+ /**
+ * Maximum number of requests which can be performed over a keepalive
+ * connection. The default is the same as for Apache HTTP Server.
+ */
+ protected int maxKeepAliveRequests = (org.apache.tomcat.util.Constants.LOW_MEMORY) ? 1 :
+ Integer.valueOf(System.getProperty("org.apache.coyote.http11.Http11Protocol.MAX_KEEP_ALIVE_REQUESTS", "-1")).intValue();
+ public int getMaxKeepAliveRequests() { return maxKeepAliveRequests; }
+ public void setMaxKeepAliveRequests(int mkar) { maxKeepAliveRequests = mkar; }
+
+ // HTTP
+ /**
+ * The number of seconds Tomcat will wait for a subsequent request
+ * before closing the connection. The default is the same as for
+ * Apache HTTP Server (15 000 milliseconds).
+ */
+ protected int keepAliveTimeout = -1;
+ public int getKeepAliveTimeout() { return keepAliveTimeout; }
+ public void setKeepAliveTimeout(int timeout) { keepAliveTimeout = timeout; }
+
+ // HTTP
+ /**
+ * This timeout represents the socket timeout which will be used while
+ * the adapter execution is in progress, unless disableUploadTimeout
+ * is set to true. The default is the same as for Apache HTTP Server
+ * (300 000 milliseconds).
+ */
+ protected int timeout = 300000;
+ public int getTimeout() { return timeout; }
+ public void setTimeout(int timeout) { this.timeout = timeout; }
+
+
+ // *
+ /**
+ * Maximum size of the post which will be saved when processing certain
+ * requests, such as a POST.
+ */
+ protected int maxSavePostSize = 4 * 1024;
+ public int getMaxSavePostSize() { return maxSavePostSize; }
+ public void setMaxSavePostSize(int valueI) { maxSavePostSize = valueI; }
+
+
+ // HTTP
+ /**
+ * Maximum size of the HTTP message header.
+ */
+ protected int maxHttpHeaderSize = Integer.valueOf(System.getProperty("org.apache.coyote.http11.Http11Protocol.MAX_HEADER_SIZE", "8192")).intValue();
+ public int getMaxHttpHeaderSize() { return maxHttpHeaderSize; }
+ public void setMaxHttpHeaderSize(int valueI) { maxHttpHeaderSize = valueI; }
+
+
+ // HTTP
+ /**
+ * If true, the regular socket timeout will be used for the full duration
+ * of the connection.
+ */
+ protected boolean disableUploadTimeout = true;
+ public boolean getDisableUploadTimeout() { return disableUploadTimeout; }
+ public void setDisableUploadTimeout(boolean isDisabled) { disableUploadTimeout = isDisabled; }
+
+
+ // HTTP
+ /**
+ * Integrated compression support.
+ */
+ protected String compression = System.getProperty("org.apache.coyote.http11.Http11Protocol.COMPRESSION", "off");
+ public String getCompression() { return compression; }
+ public void setCompression(String valueS) { compression = valueS; }
+
+
+ // HTTP
+ protected String noCompressionUserAgents = System.getProperty("org.apache.coyote.http11.Http11Protocol.COMPRESSION_RESTRICTED_UA");
+ public String getNoCompressionUserAgents() { return noCompressionUserAgents; }
+ public void setNoCompressionUserAgents(String valueS) { noCompressionUserAgents = valueS; }
+
+
+ // HTTP
+ protected String compressableMimeTypes = System.getProperty("org.apache.coyote.http11.Http11Protocol.COMPRESSION_MIME_TYPES", "text/html,text/xml,text/plain");
+ public String getCompressableMimeType() { return compressableMimeTypes; }
+ public void setCompressableMimeType(String valueS) { compressableMimeTypes = valueS; }
+
+
+ // HTTP
+ protected int compressionMinSize = Integer.valueOf(System.getProperty("org.apache.coyote.http11.Http11Protocol.COMPRESSION_MIN_SIZE", "2048")).intValue();
+ public int getCompressionMinSize() { return compressionMinSize; }
+ public void setCompressionMinSize(int valueI) { compressionMinSize = valueI; }
+
+
+ // HTTP
+ /**
+ * User agents regular expressions which should be restricted to HTTP/1.0 support.
+ */
+ protected String restrictedUserAgents = null;
+ public String getRestrictedUserAgents() { return restrictedUserAgents; }
+ public void setRestrictedUserAgents(String valueS) { restrictedUserAgents = valueS; }
+
+ // HTTP
+ /**
+ * Server header.
+ */
+ protected String server = System.getProperty("org.apache.coyote.http11.Http11Protocol.SERVER");
+ public void setServer( String server ) { this.server = server; }
+ public String getServer() { return server; }
+
+ public Executor getExecutor() { return endpoint.getExecutor(); }
+ public void setExecutor(Executor executor) { endpoint.setExecutor(executor); }
+
+ public int getMaxThreads() { return endpoint.getMaxThreads(); }
+ public void setMaxThreads(int maxThreads) { endpoint.setMaxThreads(maxThreads); }
+
+ public int getThreadPriority() { return endpoint.getThreadPriority(); }
+ public void setThreadPriority(int threadPriority) { endpoint.setThreadPriority(threadPriority); }
+
+ public int getBacklog() { return endpoint.getBacklog(); }
+ public void setBacklog(int backlog) { endpoint.setBacklog(backlog); }
+
+ public int getPort() { return endpoint.getPort(); }
+ public void setPort(int port) { endpoint.setPort(port); }
+
+ public InetAddress getAddress() { return endpoint.getAddress(); }
+ public void setAddress(InetAddress ia) { endpoint.setAddress(ia); }
+
+ public boolean getTcpNoDelay() { return endpoint.getTcpNoDelay(); }
+ public void setTcpNoDelay(boolean tcpNoDelay) { endpoint.setTcpNoDelay(tcpNoDelay); }
+
+ public int getSoLinger() { return endpoint.getSoLinger(); }
+ public void setSoLinger(int soLinger) { endpoint.setSoLinger(soLinger); }
+
+ public int getSoTimeout() { return endpoint.getSoTimeout(); }
+ public void setSoTimeout(int soTimeout) { endpoint.setSoTimeout(soTimeout); }
+
+ public void setPollerSize(int pollerSize) { endpoint.setPollerSize(pollerSize); }
+ public int getPollerSize() { return endpoint.getPollerSize(); }
+
+ // HTTP
+ /**
+ * Return the Keep-Alive policy for the connection.
+ */
+ public boolean getKeepAlive() {
+ return ((maxKeepAliveRequests != 0) && (maxKeepAliveRequests != 1));
+ }
+
+ // HTTP
+ /**
+ * Set the keep-alive policy for this connection.
+ */
+ public void setKeepAlive(boolean keepAlive) {
+ if (!keepAlive) {
+ setMaxKeepAliveRequests(1);
+ }
+ }
+
+ /*
+ * Note: All the following are JSSE/java.io specific attributes.
+ */
+
+ public String getKeystore() {
+ return (String) getAttribute("keystore");
+ }
+
+ public void setKeystore( String k ) {
+ setAttribute("keystore", k);
+ }
+
+ public String getKeypass() {
+ return (String) getAttribute("keypass");
+ }
+
+ public void setKeypass( String k ) {
+ attributes.put("keypass", k);
+ //setAttribute("keypass", k);
+ }
+
+ public String getKeytype() {
+ return (String) getAttribute("keystoreType");
+ }
+
+ public void setKeytype( String k ) {
+ setAttribute("keystoreType", k);
+ }
+
+ public String getClientauth() {
+ return (String) getAttribute("clientauth");
+ }
+
+ public void setClientauth( String k ) {
+ setAttribute("clientauth", k);
+ }
+
+ public String getProtocols() {
+ return (String) getAttribute("protocols");
+ }
+
+ public void setProtocols(String k) {
+ setAttribute("protocols", k);
+ }
+
+ public String getAlgorithm() {
+ return (String) getAttribute("algorithm");
+ }
+
+ public void setAlgorithm( String k ) {
+ setAttribute("algorithm", k);
+ }
+
+ public String getCiphers() {
+ return (String) getAttribute("ciphers");
+ }
+
+ public void setCiphers(String ciphers) {
+ setAttribute("ciphers", ciphers);
+ }
+
+ public String getKeyAlias() {
+ return (String) getAttribute("keyAlias");
+ }
+
+ public void setKeyAlias(String keyAlias) {
+ setAttribute("keyAlias", keyAlias);
+ }
+
+ public SSLContext getSSLContext() {
+ return (SSLContext) getAttribute("SSLContext");
+ }
+
+ public void setSSLContext(SSLContext sslContext) {
+ setAttribute("SSLContext", sslContext);
+ }
+
+ // ----------------------------------- Http11ConnectionHandler Inner Class
+
+ protected static class Http11ConnectionHandler implements Handler {
+
+ protected Http11Protocol proto;
+ protected AtomicLong registerCount = new AtomicLong(0);
+ protected RequestGroupInfo global = new RequestGroupInfo();
+
+ protected ConcurrentHashMap<Socket, Http11Processor> connections =
+ new ConcurrentHashMap<Socket, Http11Processor>();
+ protected ConcurrentLinkedQueue<Http11Processor> recycledProcessors =
+ new ConcurrentLinkedQueue<Http11Processor>() {
+ protected AtomicInteger size = new AtomicInteger(0);
+ public boolean offer(Http11Processor processor) {
+ boolean offer = (proto.processorCache == -1) ? true : (size.get() < proto.processorCache);
+ //avoid over growing our cache or add after we have stopped
+ boolean result = false;
+ if ( offer ) {
+ result = super.offer(processor);
+ if ( result ) {
+ size.incrementAndGet();
+ }
+ }
+ if (!result) unregister(processor);
+ return result;
+ }
+
+ public Http11Processor poll() {
+ Http11Processor result = super.poll();
+ if ( result != null ) {
+ size.decrementAndGet();
+ }
+ return result;
+ }
+
+ public void clear() {
+ Http11Processor next = poll();
+ while ( next != null ) {
+ unregister(next);
+ next = poll();
+ }
+ super.clear();
+ size.set(0);
+ }
+ };
+
+ Http11ConnectionHandler(Http11Protocol proto) {
+ this.proto = proto;
+ }
+
+ public SocketState event(Socket socket, SocketStatus status) {
+ Http11Processor result = connections.get(socket);
+ SocketState state = SocketState.CLOSED;
+ if (result != null) {
+ result.startProcessing();
+ // Call the appropriate event
+ try {
+ state = result.event(status);
+ } catch (java.net.SocketException e) {
+ // SocketExceptions are normal
+ CoyoteLogger.HTTP_LOGGER.socketException(e);
+ } catch (java.io.IOException e) {
+ // IOExceptions are normal
+ CoyoteLogger.HTTP_LOGGER.socketException(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.
+ CoyoteLogger.HTTP_LOGGER.socketError(e);
+ } finally {
+ if (state != SocketState.LONG) {
+ connections.remove(socket);
+ recycledProcessors.offer(result);
+ } else {
+ if (proto.endpoint.isRunning()) {
+ proto.endpoint.getEventPoller().add(socket, result.getTimeout(),
+ result.getResumeNotification(), false);
+ }
+ }
+ result.endProcessing();
+ }
+ }
+ return state;
+ }
+
+ public SocketState process(Socket socket) {
+ Http11Processor processor = recycledProcessors.poll();
+ try {
+
+ if (processor == null) {
+ processor = createProcessor();
+ }
+
+ if (proto.secure && (proto.sslImplementation != null)) {
+ processor.setSSLSupport
+ (proto.sslImplementation.getSSLSupport(socket));
+ } else {
+ processor.setSSLSupport(null);
+ }
+
+ SocketState state = processor.process(socket);
+ if (state == SocketState.LONG) {
+ // Associate the connection with the processor. The next request
+ // processed by this thread will use either a new or a recycled
+ // processor.
+ connections.put(socket, processor);
+ proto.endpoint.getEventPoller().add(socket, processor.getTimeout(),
+ processor.getResumeNotification(), false);
+ } else {
+ recycledProcessors.offer(processor);
+ }
+ return state;
+
+ } catch(java.net.SocketException e) {
+ // SocketExceptions are normal
+ CoyoteLogger.HTTP_LOGGER.socketException(e);
+ } catch (java.io.IOException e) {
+ // IOExceptions are normal
+ CoyoteLogger.HTTP_LOGGER.socketException(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.
+ CoyoteLogger.HTTP_LOGGER.socketError(e);
+ }
+ recycledProcessors.offer(processor);
+ return SocketState.CLOSED;
+ }
+
+ protected Http11Processor createProcessor() {
+ Http11Processor processor =
+ new Http11Processor(proto.maxHttpHeaderSize, proto.endpoint);
+ processor.setAdapter(proto.adapter);
+ processor.setMaxKeepAliveRequests(proto.maxKeepAliveRequests);
+ processor.setKeepAliveTimeout(proto.keepAliveTimeout);
+ processor.setTimeout(proto.timeout);
+ processor.setDisableUploadTimeout(proto.disableUploadTimeout);
+ processor.setCompressionMinSize(proto.compressionMinSize);
+ processor.setCompression(proto.compression);
+ processor.setNoCompressionUserAgents(proto.noCompressionUserAgents);
+ processor.setCompressableMimeTypes(proto.compressableMimeTypes);
+ processor.setRestrictedUserAgents(proto.restrictedUserAgents);
+ processor.setSocketBuffer(proto.socketBuffer);
+ processor.setMaxSavePostSize(proto.maxSavePostSize);
+ processor.setServer(proto.server);
+ register(processor);
+ return processor;
+ }
+
+ protected void register(Http11Processor processor) {
+ RequestInfo rp = processor.getRequest().getRequestProcessor();
+ rp.setGlobalProcessor(global);
+ if (org.apache.tomcat.util.Constants.ENABLE_MODELER && proto.getDomain() != null) {
+ synchronized (this) {
+ try {
+ long count = registerCount.incrementAndGet();
+ ObjectName rpName = new ObjectName
+ (proto.getDomain() + ":type=RequestProcessor,worker="
+ + proto.getJmxName() + ",name=HttpRequest" + count);
+ Registry.getRegistry(null, null).registerComponent(rp, rpName, null);
+ rp.setRpName(rpName);
+ } catch (Exception e) {
+ CoyoteLogger.HTTP_LOGGER.errorRegisteringRequest(e);
+ }
+ }
+ }
+ }
+
+ protected void unregister(Http11Processor processor) {
+ RequestInfo rp = processor.getRequest().getRequestProcessor();
+ rp.setGlobalProcessor(null);
+ if (org.apache.tomcat.util.Constants.ENABLE_MODELER && proto.getDomain() != null) {
+ synchronized (this) {
+ try {
+ ObjectName rpName = rp.getRpName();
+ Registry.getRegistry(null, null).unregisterComponent(rpName);
+ rp.setRpName(null);
+ } catch (Exception e) {
+ CoyoteLogger.HTTP_LOGGER.errorUnregisteringRequest(e);
+ }
+ }
+ }
+ }
+
+ }
+
+
+ // -------------------- JMX related methods --------------------
+
+ // *
+ protected String domain;
+ protected ObjectName oname;
+ protected MBeanServer mserver;
+
+ public ObjectName getObjectName() {
+ return oname;
+ }
+
+ public String getDomain() {
+ return domain;
+ }
+
+ public ObjectName preRegister(MBeanServer server,
+ ObjectName name) throws Exception {
+ oname=name;
+ mserver=server;
+ domain=name.getDomain();
+ return name;
+ }
+
+ public void postRegister(Boolean registrationDone) {
+ }
+
+ public void preDeregister() throws Exception {
+ }
+
+ public void postDeregister() {
+ }
+}
Added: branches/7.2.x/src/main/java/org/apache/coyote/http11/InternalInputBuffer.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/coyote/http11/InternalInputBuffer.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/coyote/http11/InternalInputBuffer.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,783 @@
+/*
+ * 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 static org.jboss.web.CoyoteMessages.MESSAGES;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.EOFException;
+
+import org.apache.tomcat.util.buf.ByteChunk;
+import org.apache.tomcat.util.buf.MessageBytes;
+import org.apache.tomcat.util.http.MimeHeaders;
+
+import org.apache.coyote.InputBuffer;
+import org.apache.coyote.Request;
+
+/**
+ * Implementation of InputBuffer which provides HTTP request header parsing as
+ * well as transfer decoding.
+ *
+ * @author <a href="mailto:remm at apache.org">Remy Maucherat</a>
+ */
+public class InternalInputBuffer implements InputBuffer {
+
+
+ // -------------------------------------------------------------- Constants
+
+
+ // ----------------------------------------------------------- Constructors
+
+
+ /**
+ * Default constructor.
+ */
+ public InternalInputBuffer(Request request) {
+ this(request, Constants.DEFAULT_HTTP_HEADER_BUFFER_SIZE);
+ }
+
+
+ /**
+ * Alternate constructor.
+ */
+ public InternalInputBuffer(Request request, int headerBufferSize) {
+
+ this.request = request;
+ headers = request.getMimeHeaders();
+
+ buf = new byte[headerBufferSize];
+
+ inputStreamInputBuffer = new InputStreamInputBuffer();
+
+ filterLibrary = new InputFilter[0];
+ activeFilters = new InputFilter[0];
+ lastActiveFilter = -1;
+
+ parsingHeader = true;
+ swallowInput = true;
+
+ }
+
+
+ // ----------------------------------------------------- Instance Variables
+
+
+ /**
+ * Associated Coyote request.
+ */
+ protected Request request;
+
+
+ /**
+ * Headers of the associated request.
+ */
+ protected MimeHeaders headers;
+
+
+ /**
+ * State.
+ */
+ protected boolean parsingHeader;
+
+
+ /**
+ * Swallow input ? (in the case of an expectation)
+ */
+ protected boolean swallowInput;
+
+
+ /**
+ * Pointer to the current read buffer.
+ */
+ protected byte[] buf;
+
+
+ /**
+ * Last valid byte.
+ */
+ protected int lastValid;
+
+
+ /**
+ * Position in the buffer.
+ */
+ protected int pos;
+
+
+ /**
+ * Pos of the end of the header in the buffer, which is also the
+ * start of the body.
+ */
+ protected int end;
+
+
+ /**
+ * Underlying input stream.
+ */
+ protected InputStream inputStream;
+
+
+ /**
+ * Underlying input buffer.
+ */
+ protected InputBuffer inputStreamInputBuffer;
+
+
+ /**
+ * Filter library.
+ * Note: Filter[0] is always the "chunked" filter.
+ */
+ protected InputFilter[] filterLibrary;
+
+
+ /**
+ * Active filters (in order).
+ */
+ protected InputFilter[] activeFilters;
+
+
+ /**
+ * Index of the last active filter.
+ */
+ protected int lastActiveFilter;
+
+
+ // ------------------------------------------------------------- Properties
+
+
+ /**
+ * Set the underlying socket input stream.
+ */
+ public void setInputStream(InputStream inputStream) {
+
+ // FIXME: Check for null ?
+
+ this.inputStream = inputStream;
+
+ }
+
+
+ /**
+ * Get the underlying socket input stream.
+ */
+ public InputStream getInputStream() {
+
+ return inputStream;
+
+ }
+
+
+ /**
+ * Add an input filter to the filter library.
+ */
+ public void addFilter(InputFilter filter) {
+
+ // FIXME: Check for null ?
+
+ InputFilter[] newFilterLibrary =
+ new InputFilter[filterLibrary.length + 1];
+ for (int i = 0; i < filterLibrary.length; i++) {
+ newFilterLibrary[i] = filterLibrary[i];
+ }
+ newFilterLibrary[filterLibrary.length] = filter;
+ filterLibrary = newFilterLibrary;
+
+ activeFilters = new InputFilter[filterLibrary.length];
+
+ }
+
+
+ /**
+ * Get filters.
+ */
+ public InputFilter[] getFilters() {
+
+ return filterLibrary;
+
+ }
+
+
+ /**
+ * Clear filters.
+ */
+ public void clearFilters() {
+
+ filterLibrary = new InputFilter[0];
+ lastActiveFilter = -1;
+
+ }
+
+
+ /**
+ * Add an input filter to the filter library.
+ */
+ public void addActiveFilter(InputFilter filter) {
+
+ if (lastActiveFilter == -1) {
+ filter.setBuffer(inputStreamInputBuffer);
+ } else {
+ for (int i = 0; i <= lastActiveFilter; i++) {
+ if (activeFilters[i] == filter)
+ return;
+ }
+ filter.setBuffer(activeFilters[lastActiveFilter]);
+ }
+
+ activeFilters[++lastActiveFilter] = filter;
+
+ filter.setRequest(request);
+
+ }
+
+
+ /**
+ * Set the swallow input flag.
+ */
+ public void setSwallowInput(boolean swallowInput) {
+ this.swallowInput = swallowInput;
+ }
+
+
+ // --------------------------------------------------------- Public Methods
+
+
+ /**
+ * Recycle the input buffer. This should be called when closing the
+ * connection.
+ */
+ public void recycle() {
+
+ // Recycle Request object
+ request.recycle();
+
+ inputStream = null;
+ lastValid = 0;
+ pos = 0;
+ lastActiveFilter = -1;
+ parsingHeader = true;
+ swallowInput = true;
+
+ }
+
+
+ /**
+ * End processing of current HTTP request.
+ * Note: All bytes of the current request should have been already
+ * consumed. This method only resets all the pointers so that we are ready
+ * to parse the next HTTP request.
+ */
+ public boolean nextRequest() {
+
+ // Recycle Request object
+ request.recycle();
+
+ // Copy leftover bytes to the beginning of the buffer
+ if (lastValid - pos > 0) {
+ int npos = 0;
+ int opos = pos;
+ while (lastValid - opos > opos - npos) {
+ System.arraycopy(buf, opos, buf, npos, opos - npos);
+ npos += pos;
+ opos += pos;
+ }
+ System.arraycopy(buf, opos, buf, npos, lastValid - opos);
+ }
+
+ // Recycle filters
+ for (int i = 0; i <= lastActiveFilter; i++) {
+ activeFilters[i].recycle();
+ }
+
+ // Reset pointers
+ lastValid = lastValid - pos;
+ pos = 0;
+ lastActiveFilter = -1;
+ parsingHeader = true;
+ swallowInput = true;
+
+ return (lastValid > 0);
+
+ }
+
+
+ /**
+ * End request (consumes leftover bytes).
+ *
+ * @throws IOException an undelying I/O error occured
+ */
+ public void endRequest()
+ throws IOException {
+
+ if (swallowInput && (lastActiveFilter != -1)) {
+ int extraBytes = (int) activeFilters[lastActiveFilter].end();
+ pos = pos - extraBytes;
+ }
+
+ }
+
+
+ /**
+ * Read the request line. This function is meant to be used during the
+ * HTTP request header parsing. Do NOT attempt to read the request body
+ * using it.
+ *
+ * @throws IOException If an exception occurs during the underlying socket
+ * read operations, or if the given buffer is not big enough to accomodate
+ * the whole line.
+ */
+ public void parseRequestLine()
+ throws IOException {
+
+ int start = 0;
+
+ //
+ // Skipping blank lines
+ //
+
+ byte chr = 0;
+ do {
+
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+
+ chr = buf[pos++];
+
+ } while ((chr == Constants.CR) || (chr == Constants.LF));
+
+ pos--;
+
+ // Mark the current buffer position
+ start = pos;
+
+ //
+ // Reading the method name
+ // Method name is always US-ASCII
+ //
+
+ boolean space = false;
+
+ while (!space) {
+
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+
+ // Spec says single SP but it also says be tolerant of HT
+ if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
+ space = true;
+ request.method().setBytes(buf, start, pos - start);
+ }
+
+ pos++;
+
+ }
+
+ // Spec says single SP but also says be tolerant of multiple and/or HT
+ while (space) {
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+ if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
+ pos++;
+ } else {
+ space = false;
+ }
+ }
+
+ // Mark the current buffer position
+ start = pos;
+ int end = 0;
+ int questionPos = -1;
+
+ //
+ // Reading the URI
+ //
+
+ boolean eol = false;
+
+ while (!space) {
+
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+
+ // Spec says single SP but it also says be tolerant of HT
+ if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
+ space = true;
+ end = pos;
+ } else if ((buf[pos] == Constants.CR)
+ || (buf[pos] == Constants.LF)) {
+ // HTTP/0.9 style request
+ eol = true;
+ space = true;
+ end = pos;
+ } else if ((buf[pos] == Constants.QUESTION)
+ && (questionPos == -1)) {
+ questionPos = pos;
+ }
+
+ pos++;
+
+ }
+
+ request.unparsedURI().setBytes(buf, start, end - start);
+ if (questionPos >= 0) {
+ request.queryString().setBytes(buf, questionPos + 1,
+ end - questionPos - 1);
+ request.requestURI().setBytes(buf, start, questionPos - start);
+ } else {
+ request.requestURI().setBytes(buf, start, end - start);
+ }
+
+ // Spec says single SP but also says be tolerant of multiple and/or HT
+ while (space) {
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+ if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
+ pos++;
+ } else {
+ space = false;
+ }
+ }
+
+ // Mark the current buffer position
+ start = pos;
+ end = 0;
+
+ //
+ // Reading the protocol
+ // Protocol is always US-ASCII
+ //
+
+ while (!eol) {
+
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+
+ if (buf[pos] == Constants.CR) {
+ end = pos;
+ } else if (buf[pos] == Constants.LF) {
+ if (end == 0)
+ end = pos;
+ eol = true;
+ }
+
+ pos++;
+
+ }
+
+ if ((end - start) > 0) {
+ request.protocol().setBytes(buf, start, end - start);
+ } else {
+ request.protocol().setString("");
+ }
+
+ }
+
+
+ /**
+ * Parse the HTTP headers.
+ */
+ public void parseHeaders()
+ throws IOException {
+
+ while (parseHeader()) {
+ }
+
+ parsingHeader = false;
+ end = pos;
+
+ }
+
+
+ /**
+ * Parse an HTTP header.
+ *
+ * @return false after reading a blank line (which indicates that the
+ * HTTP header parsing is done
+ */
+ public boolean parseHeader()
+ throws IOException {
+
+ //
+ // Check for blank line
+ //
+
+ byte chr = 0;
+ while (true) {
+
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+
+ chr = buf[pos];
+
+ if ((chr == Constants.CR) || (chr == Constants.LF)) {
+ if (chr == Constants.LF) {
+ pos++;
+ return false;
+ }
+ } else {
+ break;
+ }
+
+ pos++;
+
+ }
+
+ // Mark the current buffer position
+ int start = pos;
+
+ //
+ // Reading the header name
+ // Header name is always US-ASCII
+ //
+
+ boolean colon = false;
+ MessageBytes headerValue = null;
+
+ while (!colon) {
+
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+
+ if (buf[pos] == Constants.COLON) {
+ colon = true;
+ headerValue = headers.addValue(buf, start, pos - start);
+ }
+ chr = buf[pos];
+ if ((chr >= Constants.A) && (chr <= Constants.Z)) {
+ buf[pos] = (byte) (chr - Constants.LC_OFFSET);
+ }
+
+ pos++;
+
+ }
+
+ // Mark the current buffer position
+ start = pos;
+ int realPos = pos;
+
+ //
+ // Reading the header value (which can be spanned over multiple lines)
+ //
+
+ boolean eol = false;
+ boolean validLine = true;
+
+ while (validLine) {
+
+ boolean space = true;
+
+ // Skipping spaces
+ while (space) {
+
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+
+ if ((buf[pos] == Constants.SP) || (buf[pos] == Constants.HT)) {
+ pos++;
+ } else {
+ space = false;
+ }
+
+ }
+
+ int lastSignificantChar = realPos;
+
+ // Reading bytes until the end of the line
+ while (!eol) {
+
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+
+ if (buf[pos] == Constants.CR) {
+ } else if (buf[pos] == Constants.LF) {
+ eol = true;
+ } else if (buf[pos] == Constants.SP) {
+ buf[realPos] = buf[pos];
+ realPos++;
+ } else {
+ buf[realPos] = buf[pos];
+ realPos++;
+ lastSignificantChar = realPos;
+ }
+
+ pos++;
+
+ }
+
+ realPos = lastSignificantChar;
+
+ // Checking the first character of the new line. If the character
+ // is a LWS, then it's a multiline header
+
+ // Read new bytes if needed
+ if (pos >= lastValid) {
+ if (!fill())
+ throw new EOFException(MESSAGES.eofError());
+ }
+
+ chr = buf[pos];
+ if ((chr != Constants.SP) && (chr != Constants.HT)) {
+ validLine = false;
+ } else {
+ eol = false;
+ // Copying one extra space in the buffer (since there must
+ // be at least one space inserted between the lines)
+ buf[realPos] = chr;
+ realPos++;
+ }
+
+ }
+
+ // Set the header value
+ headerValue.setBytes(buf, start, realPos - start);
+
+ return true;
+
+ }
+
+
+ // ---------------------------------------------------- InputBuffer Methods
+
+
+ /**
+ * Read some bytes.
+ */
+ public int doRead(ByteChunk chunk, Request req)
+ throws IOException {
+
+ if (lastActiveFilter == -1)
+ return inputStreamInputBuffer.doRead(chunk, req);
+ else
+ return activeFilters[lastActiveFilter].doRead(chunk,req);
+
+ }
+
+
+ // ------------------------------------------------------ Protected Methods
+
+
+ /**
+ * Fill the internal buffer using data from the undelying input stream.
+ *
+ * @return false if at end of stream
+ */
+ protected boolean fill()
+ throws IOException {
+
+ int nRead = 0;
+
+ if (parsingHeader) {
+
+ if (lastValid == buf.length) {
+ throw MESSAGES.requestHeaderTooLarge();
+ }
+
+ nRead = inputStream.read(buf, pos, buf.length - lastValid);
+ if (nRead > 0) {
+ lastValid = pos + nRead;
+ }
+
+ } else {
+
+ if (buf.length - end < 4500) {
+ // In this case, the request header was really large, so we allocate a
+ // brand new one; the old one will get GCed when subsequent requests
+ // clear all references
+ buf = new byte[buf.length];
+ end = 0;
+ }
+ pos = end;
+ lastValid = pos;
+ nRead = inputStream.read(buf, pos, buf.length - lastValid);
+ if (nRead > 0) {
+ lastValid = pos + nRead;
+ }
+
+ }
+
+ return (nRead > 0);
+
+ }
+
+
+ // ------------------------------------- InputStreamInputBuffer Inner Class
+
+
+ /**
+ * This class is an input buffer which will read its data from an input
+ * stream.
+ */
+ protected class InputStreamInputBuffer
+ implements InputBuffer {
+
+
+ /**
+ * Read bytes into the specified chunk.
+ */
+ public int doRead(ByteChunk chunk, Request req )
+ throws IOException {
+
+ if (pos >= lastValid) {
+ if (!fill())
+ return -1;
+ }
+
+ int length = lastValid - pos;
+ chunk.setBytes(buf, pos, length);
+ pos = lastValid;
+
+ return (length);
+
+ }
+
+
+ }
+
+
+}
Added: branches/7.2.x/src/main/java/org/apache/coyote/http11/InternalOutputBuffer.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/coyote/http11/InternalOutputBuffer.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/coyote/http11/InternalOutputBuffer.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,749 @@
+/*
+ * 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.io.IOException;
+import java.io.OutputStream;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+import org.apache.tomcat.util.buf.ByteChunk;
+import org.apache.tomcat.util.buf.CharChunk;
+import org.apache.tomcat.util.buf.MessageBytes;
+import org.apache.tomcat.util.http.HttpMessages;
+import org.apache.tomcat.util.http.MimeHeaders;
+
+import org.apache.coyote.ActionCode;
+import org.apache.coyote.OutputBuffer;
+import org.apache.coyote.Response;
+
+/**
+ * Output buffer.
+ *
+ * @author <a href="mailto:remm at apache.org">Remy Maucherat</a>
+ */
+public class InternalOutputBuffer
+ implements OutputBuffer, ByteChunk.ByteOutputChannel {
+
+ // -------------------------------------------------------------- Constants
+
+
+ // ----------------------------------------------------------- Constructors
+
+
+ /**
+ * Default constructor.
+ */
+ public InternalOutputBuffer(Response response) {
+ this(response, Constants.DEFAULT_HTTP_HEADER_BUFFER_SIZE);
+ }
+
+
+ /**
+ * Alternate constructor.
+ */
+ public InternalOutputBuffer(Response response, int headerBufferSize) {
+
+ this.response = response;
+
+ headers = response.getMimeHeaders();
+
+ buf = new byte[headerBufferSize];
+
+ outputStreamOutputBuffer = new OutputStreamOutputBuffer();
+
+ filterLibrary = new OutputFilter[0];
+ activeFilters = new OutputFilter[0];
+ lastActiveFilter = -1;
+
+ socketBuffer = new ByteChunk();
+ socketBuffer.setByteOutputChannel(this);
+
+ committed = false;
+ finished = false;
+
+ }
+
+
+ // ----------------------------------------------------- Instance Variables
+
+
+ /**
+ * Associated Coyote response.
+ */
+ protected Response response;
+
+
+ /**
+ * Headers of the associated request.
+ */
+ protected MimeHeaders headers;
+
+
+ /**
+ * Committed flag.
+ */
+ protected boolean committed;
+
+
+ /**
+ * Finished flag.
+ */
+ protected boolean finished;
+
+
+ /**
+ * The buffer used for header composition.
+ */
+ protected byte[] buf;
+
+
+ /**
+ * Position in the buffer.
+ */
+ protected int pos;
+
+
+ /**
+ * Underlying output stream.
+ */
+ protected OutputStream outputStream;
+
+
+ /**
+ * Underlying output buffer.
+ */
+ protected OutputBuffer outputStreamOutputBuffer;
+
+
+ /**
+ * Filter library.
+ * Note: Filter[0] is always the "chunked" filter.
+ */
+ protected OutputFilter[] filterLibrary;
+
+
+ /**
+ * Active filter (which is actually the top of the pipeline).
+ */
+ protected OutputFilter[] activeFilters;
+
+
+ /**
+ * Index of the last active filter.
+ */
+ protected int lastActiveFilter;
+
+
+ /**
+ * Socket buffer.
+ */
+ protected ByteChunk socketBuffer;
+
+
+ /**
+ * Socket buffer (extra buffering to reduce number of packets sent).
+ */
+ protected boolean useSocketBuffer = false;
+
+
+ // ------------------------------------------------------------- Properties
+
+
+ /**
+ * Set the underlying socket output stream.
+ */
+ public void setOutputStream(OutputStream outputStream) {
+
+ // FIXME: Check for null ?
+
+ this.outputStream = outputStream;
+
+ }
+
+
+ /**
+ * Get the underlying socket output stream.
+ */
+ public OutputStream getOutputStream() {
+
+ return outputStream;
+
+ }
+
+
+ /**
+ * Set the socket buffer size.
+ */
+ public void setSocketBuffer(int socketBufferSize) {
+
+ if (socketBufferSize > 500) {
+ useSocketBuffer = true;
+ socketBuffer.allocate(socketBufferSize, socketBufferSize);
+ } else {
+ useSocketBuffer = false;
+ }
+
+ }
+
+
+ /**
+ * Add an output filter to the filter library.
+ */
+ public void addFilter(OutputFilter filter) {
+
+ OutputFilter[] newFilterLibrary =
+ new OutputFilter[filterLibrary.length + 1];
+ for (int i = 0; i < filterLibrary.length; i++) {
+ newFilterLibrary[i] = filterLibrary[i];
+ }
+ newFilterLibrary[filterLibrary.length] = filter;
+ filterLibrary = newFilterLibrary;
+
+ activeFilters = new OutputFilter[filterLibrary.length];
+
+ }
+
+
+ /**
+ * Get filters.
+ */
+ public OutputFilter[] getFilters() {
+
+ return filterLibrary;
+
+ }
+
+
+ /**
+ * Clear filters.
+ */
+ public void clearFilters() {
+
+ filterLibrary = new OutputFilter[0];
+ lastActiveFilter = -1;
+
+ }
+
+
+ /**
+ * Add an output filter to the filter library.
+ */
+ public void addActiveFilter(OutputFilter filter) {
+
+ if (lastActiveFilter == -1) {
+ filter.setBuffer(outputStreamOutputBuffer);
+ } else {
+ for (int i = 0; i <= lastActiveFilter; i++) {
+ if (activeFilters[i] == filter)
+ return;
+ }
+ filter.setBuffer(activeFilters[lastActiveFilter]);
+ }
+
+ activeFilters[++lastActiveFilter] = filter;
+
+ filter.setResponse(response);
+
+ }
+
+
+ // --------------------------------------------------------- Public Methods
+
+
+ /**
+ * Flush the response.
+ *
+ * @throws IOException an undelying I/O error occured
+ */
+ public void flush()
+ throws IOException {
+
+ if (!committed) {
+
+ // Send the connector a request for commit. The connector should
+ // then validate the headers, send them (using sendHeader) and
+ // set the filters accordingly.
+ response.action(ActionCode.ACTION_COMMIT, null);
+
+ }
+
+ // Flush the current buffer
+ if (useSocketBuffer) {
+ socketBuffer.flushBuffer();
+ }
+
+ }
+
+
+ /**
+ * Recycle the output buffer. This should be called when closing the
+ * connection.
+ */
+ public void recycle() {
+
+ // Recycle Request object
+ response.recycle();
+ socketBuffer.recycle();
+
+ outputStream = null;
+ pos = 0;
+ lastActiveFilter = -1;
+ committed = false;
+ finished = false;
+
+ }
+
+
+ /**
+ * End processing of current HTTP request.
+ * Note: All bytes of the current request should have been already
+ * consumed. This method only resets all the pointers so that we are ready
+ * to parse the next HTTP request.
+ */
+ public void nextRequest() {
+
+ // Recycle Request object
+ response.recycle();
+ socketBuffer.recycle();
+
+ // Recycle filters
+ for (int i = 0; i <= lastActiveFilter; i++) {
+ activeFilters[i].recycle();
+ }
+
+ // Reset pointers
+ pos = 0;
+ lastActiveFilter = -1;
+ committed = false;
+ finished = false;
+
+ }
+
+
+ /**
+ * End request.
+ *
+ * @throws IOException an undelying I/O error occured
+ */
+ public void endRequest()
+ throws IOException {
+
+ if (!committed) {
+
+ // Send the connector a request for commit. The connector should
+ // then validate the headers, send them (using sendHeader) and
+ // set the filters accordingly.
+ response.action(ActionCode.ACTION_COMMIT, null);
+
+ }
+
+ if (finished)
+ return;
+
+ if (lastActiveFilter != -1)
+ activeFilters[lastActiveFilter].end();
+
+ if (useSocketBuffer) {
+ socketBuffer.flushBuffer();
+ }
+
+ finished = true;
+
+ }
+
+
+ // ------------------------------------------------ HTTP/1.1 Output Methods
+
+
+ /**
+ * Send an acknoledgement.
+ */
+ public void sendAck()
+ throws IOException {
+
+ if (!committed)
+ outputStream.write(Constants.ACK_BYTES);
+
+ }
+
+
+ /**
+ * Send the response status line.
+ */
+ public void sendStatus() {
+
+ // Write protocol name
+ write(Constants.HTTP_11_BYTES);
+ buf[pos++] = Constants.SP;
+
+ // Write status code
+ int status = response.getStatus();
+ switch (status) {
+ case 200:
+ write(Constants._200_BYTES);
+ break;
+ case 400:
+ write(Constants._400_BYTES);
+ break;
+ case 404:
+ write(Constants._404_BYTES);
+ break;
+ default:
+ write(status);
+ }
+
+ buf[pos++] = Constants.SP;
+
+ // Write message
+ String message = null;
+ if (org.apache.coyote.Constants.USE_CUSTOM_STATUS_MSG_IN_HEADER) {
+ message = response.getMessage();
+ }
+ if (message == null) {
+ write(getMessage(status));
+ } else {
+ write(message.replace('\n', ' ').replace('\r', ' '));
+ }
+
+ // End the response status line
+ if (org.apache.coyote.Constants.IS_SECURITY_ENABLED){
+ AccessController.doPrivileged(
+ new PrivilegedAction(){
+ public Object run(){
+ buf[pos++] = Constants.CR;
+ buf[pos++] = Constants.LF;
+ return null;
+ }
+ }
+ );
+ } else {
+ buf[pos++] = Constants.CR;
+ buf[pos++] = Constants.LF;
+ }
+
+ }
+
+ private String getMessage(final int message){
+ if (org.apache.coyote.Constants.IS_SECURITY_ENABLED){
+ return (String)AccessController.doPrivileged(
+ new PrivilegedAction(){
+ public Object run(){
+ return HttpMessages.getMessage(message);
+ }
+ }
+ );
+ } else {
+ return HttpMessages.getMessage(message);
+ }
+ }
+
+ /**
+ * Send a header.
+ *
+ * @param name Header name
+ * @param value Header value
+ */
+ public void sendHeader(MessageBytes name, MessageBytes value) {
+
+ if (name.getLength() > 0 && !value.isNull()) {
+ write(name);
+ buf[pos++] = Constants.COLON;
+ buf[pos++] = Constants.SP;
+ write(value);
+ buf[pos++] = Constants.CR;
+ buf[pos++] = Constants.LF;
+ }
+
+ }
+
+
+ /**
+ * Send a header.
+ *
+ * @param name Header name
+ * @param value Header value
+ */
+ public void sendHeader(ByteChunk name, ByteChunk value) {
+
+ write(name);
+ buf[pos++] = Constants.COLON;
+ buf[pos++] = Constants.SP;
+ write(value);
+ buf[pos++] = Constants.CR;
+ buf[pos++] = Constants.LF;
+
+ }
+
+
+ /**
+ * Send a header.
+ *
+ * @param name Header name
+ * @param value Header value
+ */
+ public void sendHeader(String name, String value) {
+
+ write(name);
+ buf[pos++] = Constants.COLON;
+ buf[pos++] = Constants.SP;
+ write(value);
+ buf[pos++] = Constants.CR;
+ buf[pos++] = Constants.LF;
+
+ }
+
+
+ /**
+ * End the header block.
+ */
+ public void endHeaders() {
+
+ buf[pos++] = Constants.CR;
+ buf[pos++] = Constants.LF;
+
+ }
+
+
+ // --------------------------------------------------- OutputBuffer Methods
+
+
+ /**
+ * Write the contents of a byte chunk.
+ *
+ * @param chunk byte chunk
+ * @return number of bytes written
+ * @throws IOException an undelying I/O error occured
+ */
+ public int doWrite(ByteChunk chunk, Response res)
+ throws IOException {
+
+ if (!committed) {
+
+ // Send the connector a request for commit. The connector should
+ // then validate the headers, send them (using sendHeaders) and
+ // set the filters accordingly.
+ response.action(ActionCode.ACTION_COMMIT, null);
+
+ }
+
+ if (lastActiveFilter == -1)
+ return outputStreamOutputBuffer.doWrite(chunk, res);
+ else
+ return activeFilters[lastActiveFilter].doWrite(chunk, res);
+
+ }
+
+
+ // ------------------------------------------------------ Protected Methods
+
+
+ /**
+ * Commit the response.
+ *
+ * @throws IOException an undelying I/O error occured
+ */
+ protected void commit()
+ throws IOException {
+
+ // The response is now committed
+ committed = true;
+ response.setCommitted(true);
+
+ if (pos > 0) {
+ // Sending the response header buffer
+ if (useSocketBuffer) {
+ socketBuffer.append(buf, 0, pos);
+ } else {
+ outputStream.write(buf, 0, pos);
+ }
+ }
+
+ }
+
+
+ /**
+ * This method will write the contents of the specyfied message bytes
+ * buffer to the output stream, without filtering. This method is meant to
+ * be used to write the response header.
+ *
+ * @param mb data to be written
+ */
+ protected void write(MessageBytes mb) {
+
+ if (mb.getType() == MessageBytes.T_BYTES) {
+ ByteChunk bc = mb.getByteChunk();
+ write(bc);
+ } else if (mb.getType() == MessageBytes.T_CHARS) {
+ CharChunk cc = mb.getCharChunk();
+ write(cc);
+ } else {
+ write(mb.toString());
+ }
+
+ }
+
+
+ /**
+ * This method will write the contents of the specyfied message bytes
+ * buffer to the output stream, without filtering. This method is meant to
+ * be used to write the response header.
+ *
+ * @param bc data to be written
+ */
+ protected void write(ByteChunk bc) {
+
+ // Writing the byte chunk to the output buffer
+ int length = bc.getLength();
+ System.arraycopy(bc.getBytes(), bc.getStart(), buf, pos, length);
+ pos = pos + length;
+
+ }
+
+
+ /**
+ * This method will write the contents of the specyfied char
+ * buffer to the output stream, without filtering. This method is meant to
+ * be used to write the response header.
+ *
+ * @param cc data to be written
+ */
+ protected void write(CharChunk cc) {
+
+ int start = cc.getStart();
+ int end = cc.getEnd();
+ char[] cbuf = cc.getBuffer();
+ for (int i = start; i < end; i++) {
+ char c = cbuf[i];
+ // Note: This is clearly incorrect for many strings,
+ // but is the only consistent approach within the current
+ // servlet framework. It must suffice until servlet output
+ // streams properly encode their output.
+ if (((c <= 31) && (c != 9)) || c == 127 || c > 255) {
+ c = ' ';
+ }
+ buf[pos++] = (byte) c;
+ }
+
+ }
+
+
+ /**
+ * This method will write the contents of the specyfied byte
+ * buffer to the output stream, without filtering. This method is meant to
+ * be used to write the response header.
+ *
+ * @param b data to be written
+ */
+ public void write(byte[] b) {
+
+ // Writing the byte chunk to the output buffer
+ System.arraycopy(b, 0, buf, pos, b.length);
+ pos = pos + b.length;
+
+ }
+
+
+ /**
+ * This method will write the contents of the specyfied String to the
+ * output stream, without filtering. This method is meant to be used to
+ * write the response header.
+ *
+ * @param s data to be written
+ */
+ protected void write(String s) {
+
+ if (s == null)
+ return;
+
+ // From the Tomcat 3.3 HTTP/1.0 connector
+ int len = s.length();
+ for (int i = 0; i < len; i++) {
+ char c = s.charAt (i);
+ // Note: This is clearly incorrect for many strings,
+ // but is the only consistent approach within the current
+ // servlet framework. It must suffice until servlet output
+ // streams properly encode their output.
+ if (((c <= 31) && (c != 9)) || c == 127 || c > 255) {
+ c = ' ';
+ }
+ buf[pos++] = (byte) c;
+ }
+
+ }
+
+
+ /**
+ * This method will print the specified integer to the output stream,
+ * without filtering. This method is meant to be used to write the
+ * response header.
+ *
+ * @param i data to be written
+ */
+ protected void write(int i) {
+
+ write(String.valueOf(i));
+
+ }
+
+
+ /**
+ * Callback to write data from the buffer.
+ */
+ public void realWriteBytes(byte cbuf[], int off, int len)
+ throws IOException {
+ if (len > 0) {
+ outputStream.write(cbuf, off, len);
+ }
+ }
+
+
+ // ----------------------------------- OutputStreamOutputBuffer Inner Class
+
+
+ /**
+ * This class is an output buffer which will write data to an output
+ * stream.
+ */
+ protected class OutputStreamOutputBuffer
+ implements OutputBuffer {
+
+
+ /**
+ * Write chunk.
+ */
+ public int doWrite(ByteChunk chunk, Response res)
+ throws IOException {
+
+ int length = chunk.getLength();
+ if (useSocketBuffer) {
+ socketBuffer.append(chunk.getBuffer(), chunk.getStart(),
+ length);
+ } else {
+ outputStream.write(chunk.getBuffer(), chunk.getStart(),
+ length);
+ }
+ return length;
+
+ }
+
+
+ }
+
+
+}
Added: branches/7.2.x/src/main/java/org/apache/tomcat/util/net/DefaultServerSocketFactory.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/tomcat/util/net/DefaultServerSocketFactory.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/tomcat/util/net/DefaultServerSocketFactory.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,70 @@
+/*
+ * 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.tomcat.util.net;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * Default server socket factory. Doesn't do much except give us
+ * plain ol' server sockets.
+ *
+ * @author db at eng.sun.com
+ * @author Harish Prabandham
+ */
+
+// Default implementation of server sockets.
+
+//
+// WARNING: Some of the APIs in this class are used by J2EE.
+// Please talk to harishp at eng.sun.com before making any changes.
+//
+class DefaultServerSocketFactory extends ServerSocketFactory {
+
+ DefaultServerSocketFactory () {
+ /* NOTHING */
+ }
+
+ public ServerSocket createSocket (int port)
+ throws IOException {
+ return new ServerSocket (port);
+ }
+
+ public ServerSocket createSocket (int port, int backlog)
+ throws IOException {
+ return new ServerSocket (port, backlog);
+ }
+
+ public ServerSocket createSocket (int port, int backlog,
+ InetAddress ifAddress)
+ throws IOException {
+ return new ServerSocket (port, backlog, ifAddress);
+ }
+
+ public Socket acceptSocket(ServerSocket socket)
+ throws IOException {
+ return socket.accept();
+ }
+
+ public void handshake(Socket sock)
+ throws IOException {
+ ; // NOOP
+ }
+
+
+ }
Added: branches/7.2.x/src/main/java/org/apache/tomcat/util/net/JIoEndpoint.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/tomcat/util/net/JIoEndpoint.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/tomcat/util/net/JIoEndpoint.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,1315 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2009, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.apache.tomcat.util.net;
+
+import java.io.IOException;
+import java.net.BindException;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.concurrent.Executor;
+
+import org.jboss.web.CoyoteLogger;
+
+/**
+ * Handle incoming TCP connections.
+ *
+ * This class implement a simple server model: one listener thread accepts on a socket and
+ * creates a new worker thread for each incoming connection.
+ *
+ * More advanced Endpoints will reuse the threads, use queues, etc.
+ *
+ * @author James Duncan Davidson
+ * @author Jason Hunter
+ * @author James Todd
+ * @author Costin Manolache
+ * @author Gal Shachor
+ * @author Yoav Shapira
+ * @author Remy Maucherat
+ */
+public class JIoEndpoint {
+
+
+ // ----------------------------------------------------------------- Fields
+
+
+ /**
+ * Available workers.
+ */
+ protected WorkerStack workers = null;
+
+
+ /**
+ * Running state of the endpoint.
+ */
+ protected volatile boolean running = false;
+
+
+ /**
+ * Will be set to true whenever the endpoint is paused.
+ */
+ protected volatile boolean paused = false;
+
+
+ /**
+ * Track the initialization state of the endpoint.
+ */
+ protected boolean initialized = false;
+
+
+ /**
+ * Current worker threads busy count.
+ */
+ protected int curThreadsBusy = 0;
+
+
+ /**
+ * Current worker threads count.
+ */
+ protected int curThreads = 0;
+
+
+ /**
+ * Sequence number used to generate thread names.
+ */
+ protected int sequence = 0;
+
+
+ /**
+ * Associated server socket.
+ */
+ protected ServerSocket serverSocket = null;
+
+
+ // ------------------------------------------------------------- Properties
+
+
+ /**
+ * Acceptor thread count.
+ */
+ protected int acceptorThreadCount = 0;
+ public void setAcceptorThreadCount(int acceptorThreadCount) { this.acceptorThreadCount = acceptorThreadCount; }
+ public int getAcceptorThreadCount() { return acceptorThreadCount; }
+
+
+ /**
+ * External Executor based thread pool.
+ */
+ protected Executor executor = null;
+ public void setExecutor(Executor executor) { this.executor = executor; }
+ public Executor getExecutor() { return executor; }
+
+
+ /**
+ * Maximum amount of worker threads.
+ */
+ protected int maxThreads = (org.apache.tomcat.util.Constants.LOW_MEMORY) ? 64 : ((Constants.MAX_THREADS == -1) ? 512 * Runtime.getRuntime().availableProcessors() : Constants.MAX_THREADS);
+ public void setMaxThreads(int maxThreads) { this.maxThreads = maxThreads; }
+ public int getMaxThreads() { return maxThreads; }
+
+
+ /**
+ * Priority of the acceptor and poller threads.
+ */
+ protected int threadPriority = Thread.NORM_PRIORITY;
+ public void setThreadPriority(int threadPriority) { this.threadPriority = threadPriority; }
+ public int getThreadPriority() { return threadPriority; }
+
+
+ /**
+ * Size of the socket poller.
+ */
+ protected int pollerSize = (org.apache.tomcat.util.Constants.LOW_MEMORY) ? 128 : (32 * 1024);
+ public void setPollerSize(int pollerSize) { this.pollerSize = pollerSize; }
+ public int getPollerSize() { return pollerSize; }
+
+
+ /**
+ * Keep-Alive timeout.
+ */
+ protected int keepAliveTimeout = -1;
+ public int getKeepAliveTimeout() { return keepAliveTimeout; }
+ public void setKeepAliveTimeout(int keepAliveTimeout) { this.keepAliveTimeout = keepAliveTimeout; }
+
+
+ /**
+ * Server socket port.
+ */
+ protected int port;
+ public int getPort() { return port; }
+ public void setPort(int port ) { this.port=port; }
+
+
+ /**
+ * Address for the server socket.
+ */
+ protected InetAddress address;
+ public InetAddress getAddress() { return address; }
+ public void setAddress(InetAddress address) { this.address = address; }
+
+
+ /**
+ * Handling of accepted sockets.
+ */
+ protected Handler handler = null;
+ public void setHandler(Handler handler ) { this.handler = handler; }
+ public Handler getHandler() { return handler; }
+
+
+ /**
+ * Allows the server developer to specify the backlog that
+ * should be used for server sockets. By default, this value
+ * is 100.
+ */
+ protected int backlog = 100;
+ public void setBacklog(int backlog) { if (backlog > 0) this.backlog = backlog; }
+ public int getBacklog() { return backlog; }
+
+
+ /**
+ * Socket TCP no delay.
+ */
+ protected boolean tcpNoDelay = false;
+ public boolean getTcpNoDelay() { return tcpNoDelay; }
+ public void setTcpNoDelay(boolean tcpNoDelay) { this.tcpNoDelay = tcpNoDelay; }
+
+
+ /**
+ * Socket linger.
+ */
+ protected int soLinger = 100;
+ public int getSoLinger() { return soLinger; }
+ public void setSoLinger(int soLinger) { this.soLinger = soLinger; }
+
+
+ /**
+ * Socket timeout.
+ */
+ protected int soTimeout = -1;
+ public int getSoTimeout() { return soTimeout; }
+ public void setSoTimeout(int soTimeout) { this.soTimeout = soTimeout; }
+
+
+ /**
+ * The default is true - the created threads will be
+ * in daemon mode. If set to false, the control thread
+ * will not be daemon - and will keep the process alive.
+ */
+ protected boolean daemon = true;
+ public void setDaemon(boolean b) { daemon = b; }
+ public boolean getDaemon() { return daemon; }
+
+
+ /**
+ * Name of the thread pool, which will be used for naming child threads.
+ */
+ protected String name = "TP";
+ public void setName(String name) { this.name = name; }
+ public String getName() { return name; }
+
+
+ /**
+ * Server socket factory.
+ */
+ protected ServerSocketFactory serverSocketFactory = null;
+ public void setServerSocketFactory(ServerSocketFactory factory) { this.serverSocketFactory = factory; }
+ public ServerSocketFactory getServerSocketFactory() { return serverSocketFactory; }
+
+
+ /**
+ * The socket poller used for event support.
+ */
+ protected Poller eventPoller = null;
+ public Poller getEventPoller() {
+ return eventPoller;
+ }
+
+
+ public boolean isRunning() {
+ return running;
+ }
+
+ public boolean isPaused() {
+ return paused;
+ }
+
+ public int getCurrentThreadCount() {
+ return curThreads;
+ }
+
+ public int getCurrentThreadsBusy() {
+ return workers!=null?curThreads - workers.size():0;
+ }
+
+
+ // ------------------------------------------------ Handler Inner Interface
+
+
+ /**
+ * Bare bones interface used for socket processing. Per thread data is to be
+ * stored in the ThreadWithAttributes extra folders, or alternately in
+ * thread local fields.
+ */
+ public interface Handler {
+ public enum SocketState {
+ OPEN, CLOSED, LONG
+ }
+ public SocketState process(Socket socket);
+ public SocketState event(Socket socket, SocketStatus status);
+ }
+
+
+ // --------------------------------------------------- Acceptor Inner Class
+
+
+ /**
+ * Server socket acceptor thread.
+ */
+ protected class Acceptor implements Runnable {
+
+
+ /**
+ * The background thread that listens for incoming TCP/IP connections and
+ * hands them off to an appropriate processor.
+ */
+ public void run() {
+
+ // Loop until we receive a shutdown command
+ while (running) {
+
+ // Loop if endpoint is paused
+ while (paused) {
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ // Ignore
+ }
+ }
+
+ // Accept the next incoming connection from the server socket
+ try {
+ Socket socket = serverSocketFactory.acceptSocket(serverSocket);
+ serverSocketFactory.initSocket(socket);
+ // Hand this socket off to an appropriate processor
+ if (!processSocket(socket)) {
+ // Close socket right away
+ try { socket.close(); } catch (IOException e) { }
+ }
+ } catch (IOException x) {
+ if (running) {
+ CoyoteLogger.UTIL_LOGGER.errorAcceptingSocket(x);
+ }
+ } catch (Throwable t) {
+ CoyoteLogger.UTIL_LOGGER.errorAcceptingSocket(t);
+ }
+
+ // The processor will recycle itself when it finishes
+
+ }
+
+ }
+
+ }
+
+
+ // ------------------------------------------------- SocketInfo Inner Class
+
+
+ /**
+ * Socket list class, used to avoid using a possibly large amount of objects
+ * with very little actual use.
+ */
+ public static class SocketInfo {
+ public static final int RESUME = 4;
+ public static final int WAKEUP = 8;
+ public Socket socket;
+ public int timeout;
+ public int flags;
+ public boolean resume() {
+ return (flags & RESUME) == RESUME;
+ }
+ public boolean wakeup() {
+ return (flags & WAKEUP) == WAKEUP;
+ }
+ public static int merge(int flag1, int flag2) {
+ return ((flag1 & RESUME) | (flag2 & RESUME))
+ | ((flag1 & WAKEUP) & (flag2 & WAKEUP));
+ }
+ }
+
+
+ // --------------------------------------------- SocketTimeouts Inner Class
+
+
+ /**
+ * Socket list class, used to avoid using a possibly large amount of objects
+ * with very little actual use.
+ */
+ public class SocketTimeouts {
+ protected int size;
+
+ protected Socket[] sockets;
+ protected long[] timeouts;
+ protected int pos = 0;
+
+ public SocketTimeouts(int size) {
+ this.size = 0;
+ sockets = new Socket[size];
+ timeouts = new long[size];
+ }
+
+ public void add(Socket socket, long timeout) {
+ sockets[size] = socket;
+ timeouts[size] = timeout;
+ size++;
+ }
+
+ public boolean remove(Socket socket) {
+ for (int i = 0; i < size; i++) {
+ if (sockets[i] == socket) {
+ sockets[i] = sockets[size - 1];
+ timeouts[i] = timeouts[size - 1];
+ size--;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public Socket check(long date) {
+ while (pos < size) {
+ if (date >= timeouts[pos]) {
+ Socket result = sockets[pos];
+ sockets[pos] = sockets[size - 1];
+ timeouts[pos] = timeouts[size - 1];
+ size--;
+ return result;
+ }
+ pos++;
+ }
+ pos = 0;
+ return null;
+ }
+
+ }
+
+
+ // ------------------------------------------------- SocketList Inner Class
+
+
+ /**
+ * Socket list class, used to avoid using a possibly large amount of objects
+ * with very little actual use.
+ */
+ public class SocketList {
+ protected int size;
+ protected int pos;
+
+ protected Socket[] sockets;
+ protected int[] timeouts;
+ protected int[] flags;
+
+ protected SocketInfo info = new SocketInfo();
+
+ public SocketList(int size) {
+ this.size = 0;
+ pos = 0;
+ sockets = new Socket[size];
+ timeouts = new int[size];
+ flags = new int[size];
+ }
+
+ public int size() {
+ return this.size;
+ }
+
+ public SocketInfo get() {
+ if (pos == size) {
+ return null;
+ } else {
+ info.socket = sockets[pos];
+ info.timeout = timeouts[pos];
+ info.flags = flags[pos];
+ pos++;
+ return info;
+ }
+ }
+
+ public void clear() {
+ size = 0;
+ pos = 0;
+ }
+
+ public boolean add(Socket socket, int timeout, int flag) {
+ if (size == sockets.length) {
+ return false;
+ } else {
+ for (int i = 0; i < size; i++) {
+ if (sockets[i] == socket) {
+ flags[i] = SocketInfo.merge(flags[i], flag);
+ return true;
+ }
+ }
+ sockets[size] = socket;
+ timeouts[size] = timeout;
+ flags[size] = flag;
+ size++;
+ return true;
+ }
+ }
+
+ public void duplicate(SocketList copy) {
+ copy.size = size;
+ copy.pos = pos;
+ System.arraycopy(sockets, 0, copy.sockets, 0, size);
+ System.arraycopy(timeouts, 0, copy.timeouts, 0, size);
+ System.arraycopy(flags, 0, copy.flags, 0, size);
+ }
+
+ }
+
+
+ // ------------------------------------------- SocketProcessor Inner Class
+
+
+ /**
+ * This class is the equivalent of the Worker, but will simply use in an
+ * external Executor thread pool.
+ */
+ protected class SocketProcessor implements Runnable {
+
+ protected Socket socket = null;
+
+ public SocketProcessor(Socket socket) {
+ this.socket = socket;
+ }
+
+ public void run() {
+
+ // Process the request from this socket
+ if (!setSocketOptions(socket) || (handler.process(socket) == Handler.SocketState.CLOSED)) {
+ // Close socket
+ try { socket.close(); } catch (IOException e) { }
+ }
+
+ // Finish up this request
+ socket = null;
+
+ }
+
+ }
+
+
+ // --------------------------------------- SocketEventProcessor Inner Class
+
+
+ /**
+ * This class is the equivalent of the Worker, but will simply use in an
+ * external Executor thread pool.
+ */
+ protected class SocketEventProcessor implements Runnable {
+
+ protected Socket socket = null;
+ protected SocketStatus status = null;
+
+ public SocketEventProcessor(Socket socket, SocketStatus status) {
+ this.socket = socket;
+ this.status = status;
+ }
+
+ public void run() {
+
+ Handler.SocketState socketState = handler.event(socket, status);
+ if (socketState == Handler.SocketState.CLOSED) {
+ // Close socket
+ try { socket.close(); } catch (IOException e) { }
+ } else if (socketState == Handler.SocketState.OPEN) {
+ // Process the keepalive after the event processing
+ // This is the main behavior difference with endpoint with pollers, which
+ // will add the socket to the poller
+ if (handler.process(socket) == Handler.SocketState.CLOSED) {
+ // Close socket
+ try { socket.close(); } catch (IOException e) { }
+ }
+ }
+ socket = null;
+
+ }
+
+ }
+
+
+ // ----------------------------------------------------- Poller Inner Class
+
+
+ /**
+ * Poller class.
+ */
+ public class Poller implements Runnable {
+
+ /**
+ * List of sockets to be added to the poller.
+ */
+ protected SocketList addList = null;
+
+ /**
+ * List of sockets to be added to the poller.
+ */
+ protected SocketList localAddList = null;
+
+ /**
+ * Structure used for storing timeouts.
+ */
+ protected SocketTimeouts timeouts = null;
+
+
+ /**
+ * Last run of maintain. Maintain will run usually every 5s.
+ */
+ protected long lastMaintain = System.currentTimeMillis();
+
+
+ /**
+ * Amount of connections inside this poller.
+ */
+ protected int connectionCount = 0;
+ public int getConnectionCount() { return connectionCount; }
+
+ public Poller() {
+ }
+
+ /**
+ * Create the poller. The java.io poller only deals with timeouts.
+ */
+ protected void init() {
+
+ timeouts = new SocketTimeouts(pollerSize);
+
+ connectionCount = 0;
+ addList = new SocketList(pollerSize);
+ localAddList = new SocketList(pollerSize);
+
+ }
+
+ /**
+ * Destroy the poller.
+ */
+ protected void destroy() {
+ // Wait for pollerTime before doing anything, so that the poller threads
+ // exit, otherwise parallel destruction of sockets which are still
+ // in the poller can cause problems
+ try {
+ synchronized (this) {
+ this.wait(2);
+ }
+ } catch (InterruptedException e) {
+ // Ignore
+ }
+ // Close all sockets in the add queue
+ SocketInfo info = addList.get();
+ while (info != null) {
+ if (!processSocket(info.socket, SocketStatus.STOP)) {
+ try { info.socket.close(); } catch (IOException e) { }
+ }
+ info = addList.get();
+ }
+ addList.clear();
+ // Close all sockets still in the poller
+ long future = System.currentTimeMillis() + Integer.MAX_VALUE;
+ Socket socket = timeouts.check(future);
+ while (socket != null) {
+ if (!processSocket(socket, SocketStatus.TIMEOUT)) {
+ try { socket.close(); } catch (IOException e) { }
+ }
+ socket = timeouts.check(future);
+ }
+ connectionCount = 0;
+ }
+
+ /**
+ * Add specified socket and associated pool to the poller. The socket will
+ * be added to a temporary array, and polled first after a maximum amount
+ * of time equal to pollTime (in most cases, latency will be much lower,
+ * however).
+ *
+ * @param socket to add to the poller
+ */
+ public void add(Socket socket, int timeout, boolean resume, boolean wakeup) {
+ if (timeout < 0) {
+ timeout = keepAliveTimeout;
+ }
+ if (timeout < 0) {
+ timeout = soTimeout;
+ }
+ if (timeout <= 0) {
+ // Always put a timeout in
+ timeout = Integer.MAX_VALUE;
+ }
+ boolean ok = false;
+ synchronized (this) {
+ // Add socket to the list. Newly added sockets will wait
+ // at most for pollTime before being polled
+ if (addList.add(socket, timeout, (resume ? SocketInfo.RESUME : 0)
+ | (wakeup ? SocketInfo.WAKEUP : 0))) {
+ ok = true;
+ this.notify();
+ }
+ }
+ if (!ok) {
+ // Can't do anything: close the socket right away
+ if (!processSocket(socket, SocketStatus.ERROR)) {
+ try { socket.close(); } catch (IOException e) { }
+ }
+ }
+ }
+
+ /**
+ * Timeout checks.
+ */
+ protected void maintain() {
+
+ long date = System.currentTimeMillis();
+ // Maintain runs at most once every 5s, although it will likely get called more
+ if ((date - lastMaintain) < 5000L) {
+ return;
+ } else {
+ lastMaintain = date;
+ }
+ Socket socket = timeouts.check(date);
+ while (socket != null) {
+ if (!processSocket(socket, SocketStatus.TIMEOUT)) {
+ try { socket.close(); } catch (IOException e) { }
+ }
+ socket = timeouts.check(date);
+ }
+
+ }
+
+ /**
+ * The background thread that listens for incoming TCP/IP connections and
+ * hands them off to an appropriate processor.
+ */
+ public void run() {
+
+ int maintain = 0;
+ // Loop until we receive a shutdown command
+ while (running) {
+
+ // Loop if endpoint is paused
+ while (paused) {
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ // Ignore
+ }
+ }
+ // Check timeouts for suspended connections if the poller is empty
+ while (connectionCount < 1 && addList.size() < 1) {
+ // Reset maintain time.
+ try {
+ if (soTimeout > 0 && running) {
+ maintain();
+ }
+ synchronized (this) {
+ this.wait(10000);
+ }
+ } catch (InterruptedException e) {
+ // Ignore
+ } catch (Throwable t) {
+ CoyoteLogger.UTIL_LOGGER.errorProcessingSocketTimeout(t);
+ }
+ }
+
+ try {
+
+ // Add sockets which are waiting to the poller
+ if (addList.size() > 0) {
+ synchronized (this) {
+ // Duplicate to another list, so that the syncing is minimal
+ addList.duplicate(localAddList);
+ addList.clear();
+ }
+ SocketInfo info = localAddList.get();
+ while (info != null) {
+ if (info.wakeup()) {
+ // Resume event if socket is present in the poller
+ if (timeouts.remove(info.socket)) {
+ if (info.resume()) {
+ if (!processSocket(info.socket, SocketStatus.OPEN_CALLBACK)) {
+ try { info.socket.close(); } catch (IOException e) { }
+ }
+ } else {
+ timeouts.add(info.socket, System.currentTimeMillis() + info.timeout);
+ }
+ }
+ } else {
+ if (info.resume()) {
+ timeouts.remove(info.socket);
+ if (!processSocket(info.socket, SocketStatus.OPEN_CALLBACK)) {
+ try { info.socket.close(); } catch (IOException e) { }
+ }
+ } else {
+ timeouts.add(info.socket, System.currentTimeMillis() + info.timeout);
+ }
+ }
+ info = localAddList.get();
+ }
+ }
+
+ try {
+ Thread.sleep(2);
+ } catch (InterruptedException e) {
+ // Ignore
+ }
+
+ // Process socket timeouts
+ if (soTimeout > 0 && maintain++ > 1000 && running) {
+ maintain = 0;
+ maintain();
+ }
+
+ } catch (Throwable t) {
+ if (maintain == 0) {
+ CoyoteLogger.UTIL_LOGGER.errorProcessingSocketTimeout(t);
+ } else {
+ CoyoteLogger.UTIL_LOGGER.errorPollingSocketWithException(t);
+ }
+ }
+
+ }
+
+ synchronized (this) {
+ this.notifyAll();
+ }
+
+ }
+
+ }
+
+
+ // ----------------------------------------------------- Worker Inner Class
+
+
+ protected class Worker implements Runnable {
+
+ protected Thread thread = null;
+ protected boolean available = false;
+ protected Socket socket = null;
+ protected SocketStatus status = null;
+
+
+ /**
+ * Process an incoming TCP/IP connection on the specified socket. Any
+ * exception that occurs during processing must be logged and swallowed.
+ * <b>NOTE</b>: This method is called from our Connector's thread. We
+ * must assign it to our own thread so that multiple simultaneous
+ * requests can be handled.
+ *
+ * @param socket TCP socket to process
+ */
+ protected synchronized void assign(Socket socket) {
+
+ // Wait for the Processor to get the previous Socket
+ while (available) {
+ try {
+ wait();
+ } catch (InterruptedException e) {
+ }
+ }
+
+ // Store the newly available Socket and notify our thread
+ this.socket = socket;
+ this.status = null;
+ available = true;
+ notifyAll();
+
+ }
+
+
+ protected synchronized void assign(Socket socket, SocketStatus status) {
+
+ // Wait for the Processor to get the previous Socket
+ while (available) {
+ try {
+ wait();
+ } catch (InterruptedException e) {
+ }
+ }
+
+ // Store the newly available Socket and notify our thread
+ this.socket = socket;
+ this.status = status;
+ available = true;
+ notifyAll();
+
+ }
+
+
+ /**
+ * Await a newly assigned Socket from our Connector, or <code>null</code>
+ * if we are supposed to shut down.
+ */
+ private synchronized Socket await() {
+
+ // Wait for the Connector to provide a new Socket
+ while (!available) {
+ try {
+ wait();
+ } catch (InterruptedException e) {
+ }
+ }
+
+ // Notify the Connector that we have received this Socket
+ Socket socket = this.socket;
+ available = false;
+ notifyAll();
+
+ return (socket);
+
+ }
+
+
+
+ /**
+ * The background thread that listens for incoming TCP/IP connections and
+ * hands them off to an appropriate processor.
+ */
+ public void run() {
+
+ // Process requests until we receive a shutdown signal
+ while (running) {
+
+ // Wait for the next socket to be assigned
+ Socket socket = await();
+ if (socket == null)
+ continue;
+
+ // Process the request from this socket
+ if (status != null){
+ Handler.SocketState socketState = handler.event(socket, status);
+ if (socketState == Handler.SocketState.CLOSED) {
+ // Close socket
+ try { socket.close(); } catch (IOException e) { }
+ } else if (socketState == Handler.SocketState.OPEN) {
+ // Process the keepalive after the event processing
+ // This is the main behavior difference with endpoint with pollers, which
+ // will add the socket to the poller
+ if (handler.process(socket) == Handler.SocketState.CLOSED) {
+ // Close socket
+ try { socket.close(); } catch (IOException e) { }
+ }
+ }
+ } else if ((status == null) && (!setSocketOptions(socket) || (handler.process(socket) == Handler.SocketState.CLOSED))) {
+ // Close socket
+ try { socket.close(); } catch (IOException e) { }
+ }
+
+ // Finish up this request
+ recycleWorkerThread(this);
+
+ }
+
+ }
+
+
+ /**
+ * Start the background processing thread.
+ */
+ public void start() {
+ thread = new Thread(this);
+ thread.setName(getName() + "-" + (++curThreads));
+ thread.setDaemon(true);
+ thread.start();
+ }
+
+
+ }
+
+
+ // -------------------- Public methods --------------------
+
+ public void init()
+ throws Exception {
+
+ if (initialized)
+ return;
+
+ // Initialize thread count defaults for acceptor
+ if (acceptorThreadCount == 0) {
+ acceptorThreadCount = 1;
+ }
+ if (serverSocketFactory == null) {
+ serverSocketFactory = ServerSocketFactory.getDefault();
+ }
+ if (serverSocket == null) {
+ try {
+ if (address == null) {
+ serverSocket = serverSocketFactory.createSocket(port, backlog);
+ } else {
+ serverSocket = serverSocketFactory.createSocket(port, backlog, address);
+ }
+ } catch (BindException be) {
+ if (address == null) {
+ throw new BindException(be.getMessage() + "<null>:" + port);
+ } else {
+ throw new BindException(be.getMessage() + " " +
+ address.toString() + ":" + port);
+ }
+ }
+ }
+ //if( serverTimeout >= 0 )
+ // serverSocket.setSoTimeout( serverTimeout );
+
+ initialized = true;
+
+ }
+
+ public void start()
+ throws Exception {
+ // Initialize socket if not done before
+ if (!initialized) {
+ init();
+ }
+ if (!running) {
+ running = true;
+ paused = false;
+
+ // Create worker collection
+ if (executor == null) {
+ workers = new WorkerStack(maxThreads);
+ }
+
+ // Start event poller thread
+ eventPoller = new Poller();
+ eventPoller.init();
+ Thread pollerThread = new Thread(eventPoller, getName() + "-Poller");
+ pollerThread.setPriority(threadPriority);
+ pollerThread.setDaemon(true);
+ pollerThread.start();
+
+ // Start acceptor threads
+ for (int i = 0; i < acceptorThreadCount; i++) {
+ Thread acceptorThread = new Thread(new Acceptor(), getName() + "-Acceptor-" + i);
+ acceptorThread.setPriority(threadPriority);
+ acceptorThread.setDaemon(daemon);
+ acceptorThread.start();
+ }
+ }
+ }
+
+ public void pause() {
+ if (running && !paused) {
+ paused = true;
+ unlockAccept();
+ }
+ }
+
+ public void resume() {
+ if (running) {
+ paused = false;
+ }
+ }
+
+ public void stop() {
+ if (running) {
+ running = false;
+ unlockAccept();
+ eventPoller.destroy();
+ eventPoller = null;
+ }
+ }
+
+ /**
+ * Deallocate APR memory pools, and close server socket.
+ */
+ public void destroy() throws Exception {
+ if (running) {
+ stop();
+ }
+ if (serverSocket != null) {
+ try {
+ if (serverSocket != null)
+ serverSocket.close();
+ } catch (Exception e) {
+ CoyoteLogger.UTIL_LOGGER.errorClosingSocket(e);
+ }
+ serverSocket = null;
+ }
+ initialized = false ;
+ }
+
+
+ /**
+ * Unlock the accept by using a local connection.
+ */
+ protected void unlockAccept() {
+ Socket s = null;
+ try {
+ // Need to create a connection to unlock the accept();
+ if (address == null) {
+ s = new Socket("localhost", port);
+ } else {
+ s = new Socket(address, port);
+ // setting soLinger to a small value will help shutdown the
+ // connection quicker
+ s.setSoLinger(true, 0);
+ }
+ } catch (Exception e) {
+ // Ignore
+ } finally {
+ if (s != null) {
+ try {
+ s.close();
+ } catch (Exception e) {
+ // Ignore
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Set the options for the current socket.
+ */
+ protected boolean setSocketOptions(Socket socket) {
+ // Process the connection
+ int step = 1;
+ try {
+
+ // 1: Set socket options: timeout, linger, etc
+ if (soLinger >= 0) {
+ socket.setSoLinger(true, soLinger);
+ }
+ if (tcpNoDelay) {
+ socket.setTcpNoDelay(tcpNoDelay);
+ }
+ if (soTimeout > 0) {
+ socket.setSoTimeout(soTimeout);
+ }
+
+ // 2: SSL handshake
+ step = 2;
+ serverSocketFactory.handshake(socket);
+
+ } catch (Throwable t) {
+ if (step == 2) {
+ CoyoteLogger.UTIL_LOGGER.handshakeFailed(t);
+ } else {
+ CoyoteLogger.UTIL_LOGGER.unexpectedError(t);
+ }
+ // Tell to close the socket
+ return false;
+ }
+ return true;
+ }
+
+
+ /**
+ * Create (or allocate) and return an available processor for use in
+ * processing a specific HTTP request, if possible. If the maximum
+ * allowed processors have already been created and are in use, return
+ * <code>null</code> instead.
+ */
+ protected Worker createWorkerThread() {
+
+ synchronized (workers) {
+ if (workers.size() > 0) {
+ curThreadsBusy++;
+ return workers.pop();
+ }
+ if ((maxThreads > 0) && (curThreads < maxThreads)) {
+ curThreadsBusy++;
+ if (curThreadsBusy == maxThreads) {
+ CoyoteLogger.UTIL_LOGGER.maxThreadsReached(maxThreads, address, port);
+ }
+ return (newWorkerThread());
+ } else {
+ if (maxThreads < 0) {
+ curThreadsBusy++;
+ return (newWorkerThread());
+ } else {
+ return (null);
+ }
+ }
+ }
+
+ }
+
+
+ /**
+ * Create and return a new processor suitable for processing HTTP
+ * requests and returning the corresponding responses.
+ */
+ protected Worker newWorkerThread() {
+
+ Worker workerThread = new Worker();
+ workerThread.start();
+ return (workerThread);
+
+ }
+
+
+ /**
+ * Return a new worker thread, and block while to worker is available.
+ */
+ protected Worker getWorkerThread() {
+ // Allocate a new worker thread
+ Worker workerThread = createWorkerThread();
+ if (org.apache.tomcat.util.net.Constants.WAIT_FOR_THREAD
+ || org.apache.tomcat.util.Constants.LOW_MEMORY) {
+ while (workerThread == null) {
+ try {
+ synchronized (workers) {
+ workers.wait();
+ }
+ } catch (InterruptedException e) {
+ // Ignore
+ }
+ workerThread = createWorkerThread();
+ }
+ }
+ return workerThread;
+ }
+
+
+ /**
+ * Recycle the specified Processor so that it can be used again.
+ *
+ * @param workerThread The processor to be recycled
+ */
+ protected void recycleWorkerThread(Worker workerThread) {
+ synchronized (workers) {
+ workers.push(workerThread);
+ curThreadsBusy--;
+ workers.notify();
+ }
+ }
+
+
+ /**
+ * Process given socket.
+ */
+ protected boolean processSocket(Socket socket) {
+ try {
+ if (executor == null) {
+ Worker worker = getWorkerThread();
+ if (worker != null) {
+ worker.assign(socket);
+ } else {
+ return false;
+ }
+ } else {
+ executor.execute(new SocketProcessor(socket));
+ }
+ } catch (Throwable t) {
+ // This means we got an OOM or similar creating a thread, or that
+ // the pool and its queue are full
+ CoyoteLogger.UTIL_LOGGER.errorProcessingSocket(t);
+ return false;
+ }
+ return true;
+ }
+
+
+ /**
+ * Process given socket for an event.
+ */
+ protected boolean processSocket(Socket socket, SocketStatus status) {
+ try {
+ if (executor == null) {
+ Worker worker = getWorkerThread();
+ if (worker != null) {
+ worker.assign(socket, status);
+ } else {
+ return false;
+ }
+ } else {
+ executor.execute(new SocketEventProcessor(socket, status));
+ }
+ } catch (Throwable t) {
+ // This means we got an OOM or similar creating a thread, or that
+ // the pool and its queue are full
+ CoyoteLogger.UTIL_LOGGER.errorProcessingSocket(t);
+ return false;
+ }
+ return true;
+ }
+
+
+ // ------------------------------------------------- WorkerStack Inner Class
+
+
+ public class WorkerStack {
+
+ protected Worker[] workers = null;
+ protected int end = 0;
+
+ public WorkerStack(int size) {
+ workers = new Worker[size];
+ }
+
+ /**
+ * Put the object into the queue.
+ *
+ * @param object the object to be appended to the queue (first element).
+ */
+ public void push(Worker worker) {
+ workers[end++] = worker;
+ }
+
+ /**
+ * Get the first object out of the queue. Return null if the queue
+ * is empty.
+ */
+ public Worker pop() {
+ if (end > 0) {
+ return workers[--end];
+ }
+ return null;
+ }
+
+ /**
+ * Get the first object out of the queue, Return null if the queue
+ * is empty.
+ */
+ public Worker peek() {
+ return workers[end];
+ }
+
+ /**
+ * Is the queue empty?
+ */
+ public boolean isEmpty() {
+ return (end == 0);
+ }
+
+ /**
+ * How many elements are there in this queue?
+ */
+ public int size() {
+ return (end);
+ }
+ }
+
+}
Modified: branches/7.2.x/src/main/java/org/apache/tomcat/util/net/NioEndpoint.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/tomcat/util/net/NioEndpoint.java 2012-09-25 12:49:25 UTC (rev 2086)
+++ branches/7.2.x/src/main/java/org/apache/tomcat/util/net/NioEndpoint.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -187,15 +187,15 @@
}
if (this.connections == null) {
- this.connections = new ConcurrentHashMap<>();
+ this.connections = new ConcurrentHashMap<Long, NioChannel>();
}
if (this.recycledChannelProcessors == null) {
- this.recycledChannelProcessors = new ConcurrentLinkedQueue<>();
+ this.recycledChannelProcessors = new ConcurrentLinkedQueue<ChannelProcessor>();
}
if (this.recycledHandshakeProcessors == null) {
- this.recycledHandshakeProcessors = new ConcurrentLinkedQueue<>();
+ this.recycledHandshakeProcessors = new ConcurrentLinkedQueue<HandshakeHandler>();
}
// If the executor is not set, create it with a fixed thread pool
@@ -1199,9 +1199,9 @@
*/
public void init() {
this.mutex = new Object();
- this.channelList = new ConcurrentHashMap<>(this.size);
- this.recycledChannelList = new ConcurrentLinkedQueue<>();
- this.recycledCompletionHandlers = new ConcurrentLinkedQueue<>();
+ this.channelList = new ConcurrentHashMap<Long, ChannelInfo>(this.size);
+ this.recycledChannelList = new ConcurrentLinkedQueue<ChannelInfo>();
+ this.recycledCompletionHandlers = new ConcurrentLinkedQueue<CompletionHandler<Integer, NioChannel>>();
}
/**
@@ -1646,8 +1646,8 @@
this.size = maxThreads;
this.mutex = new Object();
this.counter = new AtomicInteger(0);
- this.fileDatas = new ConcurrentLinkedQueue<>();
- this.recycledFileDatas = new ConcurrentLinkedQueue<>();
+ this.fileDatas = new ConcurrentLinkedQueue<SendfileData>();
+ this.recycledFileDatas = new ConcurrentLinkedQueue<SendfileData>();
}
/**
Modified: branches/7.2.x/src/main/java/org/apache/tomcat/util/net/SSLImplementation.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/tomcat/util/net/SSLImplementation.java 2012-09-25 12:49:25 UTC (rev 2086)
+++ branches/7.2.x/src/main/java/org/apache/tomcat/util/net/SSLImplementation.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -80,26 +80,6 @@
}
}
- /**
- * @return the implementation name
- */
abstract public String getImplementationName();
-
- /**
- *
- * @return a new instance of {@link NioJSSESocketChannelFactory}
- */
- public abstract NioJSSESocketChannelFactory getServerSocketChannelFactory();
-
- /**
- * @param channel
- * @return the {@link SSLSupport} attached to this channel
- */
- public abstract SSLSupport getSSLSupport(NioChannel channel);
-
- /**
- * @param session
- * @return the {@link SSLSupport} attached to this session
- */
abstract public SSLSupport getSSLSupport(SSLSession session);
}
\ No newline at end of file
Added: branches/7.2.x/src/main/java/org/apache/tomcat/util/net/ServerSocketFactory.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/tomcat/util/net/ServerSocketFactory.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/tomcat/util/net/ServerSocketFactory.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,173 @@
+/*
+ * 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.tomcat.util.net;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.Hashtable;
+
+/**
+ * This class creates server sockets. It may be subclassed by other
+ * factories, which create particular types of server sockets. This
+ * provides a general framework for the addition of public socket-level
+ * functionality. It it is the server side analogue of a socket factory,
+ * and similarly provides a way to capture a variety of policies related
+ * to the sockets being constructed.
+ *
+ * <P> Like socket factories, Server Socket factory instances have two
+ * categories of methods. First are methods used to create sockets.
+ * Second are methods which set properties used in the production of
+ * sockets, such as networking options. There is also an environment
+ * specific default server socket factory; frameworks will often use
+ * their own customized factory.
+ *
+ * <P><hr><em> It may be desirable to move this interface into the
+ * <b>java.net</b> package, so that is not an extension but the preferred
+ * interface. Should this be serializable, making it a JavaBean which can
+ * be saved along with its networking configuration?
+ * </em>
+ *
+ * @author db at eng.sun.com
+ * @author Harish Prabandham
+ */
+public abstract class ServerSocketFactory implements Cloneable {
+
+ //
+ // NOTE: JDK 1.1 bug in class GC, this can get collected
+ // even though it's always accessible via getDefault().
+ //
+
+ private static ServerSocketFactory theFactory;
+ protected Hashtable attributes=new Hashtable();
+
+ /**
+ * Constructor is used only by subclasses.
+ */
+
+ protected ServerSocketFactory () {
+ /* NOTHING */
+ }
+
+ /** General mechanism to pass attributes from the
+ * ServerConnector to the socket factory.
+ *
+ * Note that the "prefered" mechanism is to
+ * use bean setters and explicit methods, but
+ * this allows easy configuration via server.xml
+ * or simple Properties
+ */
+ public void setAttribute( String name, Object value ) {
+ if( name!=null && value !=null)
+ attributes.put( name, value );
+ }
+
+ /**
+ * Returns a copy of the environment's default socket factory.
+ */
+ public static synchronized ServerSocketFactory getDefault () {
+ //
+ // optimize typical case: no synch needed
+ //
+
+ if (theFactory == null) {
+ //
+ // Different implementations of this method could
+ // work rather differently. For example, driving
+ // this from a system property, or using a different
+ // implementation than JavaSoft's.
+ //
+
+ theFactory = new DefaultServerSocketFactory ();
+ }
+
+ try {
+ return (ServerSocketFactory) theFactory.clone ();
+ } catch (CloneNotSupportedException e) {
+ throw new RuntimeException (e.getMessage ());
+ }
+ }
+
+ /**
+ * Returns a server socket which uses all network interfaces on
+ * the host, and is bound to a the specified port. The socket is
+ * configured with the socket options (such as accept timeout)
+ * given to this factory.
+ *
+ * @param port the port to listen to
+ * @exception IOException for networking errors
+ * @exception InstantiationException for construction errors
+ */
+ public abstract ServerSocket createSocket (int port)
+ throws IOException, InstantiationException;
+
+ /**
+ * Returns a server socket which uses all network interfaces on
+ * the host, is bound to a the specified port, and uses the
+ * specified connection backlog. The socket is configured with
+ * the socket options (such as accept timeout) given to this factory.
+ *
+ * @param port the port to listen to
+ * @param backlog how many connections are queued
+ * @exception IOException for networking errors
+ * @exception InstantiationException for construction errors
+ */
+
+ public abstract ServerSocket createSocket (int port, int backlog)
+ throws IOException, InstantiationException;
+
+ /**
+ * Returns a server socket which uses only the specified network
+ * interface on the local host, is bound to a the specified port,
+ * and uses the specified connection backlog. The socket is configured
+ * with the socket options (such as accept timeout) given to this factory.
+ *
+ * @param port the port to listen to
+ * @param backlog how many connections are queued
+ * @param ifAddress the network interface address to use
+ * @exception IOException for networking errors
+ * @exception InstantiationException for construction errors
+ */
+
+ public abstract ServerSocket createSocket (int port,
+ int backlog, InetAddress ifAddress)
+ throws IOException, InstantiationException;
+
+ public void initSocket( Socket s ) {
+ }
+
+ /**
+ Wrapper function for accept(). This allows us to trap and
+ translate exceptions if necessary
+
+ @exception IOException;
+ */
+ public abstract Socket acceptSocket(ServerSocket socket)
+ throws IOException;
+
+ /**
+ Extra function to initiate the handshake. Sometimes necessary
+ for SSL
+
+ @exception IOException;
+ */
+ public abstract void handshake(Socket sock)
+ throws IOException;
+}
+
Added: branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSEFactory.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSEFactory.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSEFactory.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,56 @@
+/*
+ * 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.tomcat.util.net.jsse;
+
+import java.net.Socket;
+
+import javax.net.ssl.SSLSocket;
+
+import org.apache.tomcat.util.net.SSLSupport;
+import org.apache.tomcat.util.net.ServerSocketFactory;
+import javax.net.ssl.SSLSession;
+
+/**
+ * Factory interface to construct components based on the JSSE version
+ * in use.
+ *
+ * @author Bill Barker
+ * @author Filip Hanik
+ */
+
+public class JSSEFactory {
+
+ /**
+ * Returns the ServerSocketFactory to use.
+ */
+ public ServerSocketFactory getSocketFactory() {
+ return new JSSESocketFactory();
+ }
+
+ /**
+ * returns the SSLSupport attached to this socket.
+ */
+ public SSLSupport getSSLSupport(Socket socket) {
+ return new JSSESupport((SSLSocket)socket);
+ }
+
+ public SSLSupport getSSLSupport(SSLSession session) {
+ return new JSSESupport(session);
+ }
+
+};
Added: branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSEImplementation.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSEImplementation.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSEImplementation.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,71 @@
+/*
+ * 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.tomcat.util.net.jsse;
+
+import java.net.Socket;
+
+import org.apache.tomcat.util.net.NioChannel;
+import org.apache.tomcat.util.net.SSLImplementation;
+import org.apache.tomcat.util.net.SSLSupport;
+import org.apache.tomcat.util.net.ServerSocketFactory;
+import javax.net.ssl.SSLSession;
+
+/* JSSEImplementation:
+
+ Concrete implementation class for JSSE
+
+ @author EKR
+*/
+
+public class JSSEImplementation extends SSLImplementation
+{
+ static final String SSLSocketClass = "javax.net.ssl.SSLSocket";
+
+ static org.jboss.logging.Logger logger =
+ org.jboss.logging.Logger.getLogger(JSSEImplementation.class);
+
+ private JSSEFactory factory = null;
+
+ public JSSEImplementation() throws ClassNotFoundException {
+ // Check to see if JSSE is floating around somewhere
+ Class.forName(SSLSocketClass);
+ factory = new JSSEFactory();
+ }
+
+
+ public String getImplementationName(){
+ return "JSSE";
+ }
+
+ public ServerSocketFactory getServerSocketFactory() {
+ ServerSocketFactory ssf = factory.getSocketFactory();
+ return ssf;
+ }
+
+ public SSLSupport getSSLSupport(Socket s) {
+ SSLSupport ssls = factory.getSSLSupport(s);
+ return ssls;
+ }
+
+ public SSLSupport getSSLSupport(SSLSession session) {
+ SSLSupport ssls = factory.getSSLSupport(session);
+ return ssls;
+ }
+
+
+}
Added: branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSESocketFactory.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSESocketFactory.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSESocketFactory.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,805 @@
+/*
+ * 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.tomcat.util.net.jsse;
+
+import static org.jboss.web.CoyoteMessages.MESSAGES;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.cert.CRL;
+import java.security.cert.CRLException;
+import java.security.cert.CertPathParameters;
+import java.security.cert.CertStore;
+import java.security.cert.CertStoreParameters;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.cert.CollectionCertStoreParameters;
+import java.security.cert.PKIXBuilderParameters;
+import java.security.cert.X509CertSelector;
+import java.util.Collection;
+import java.util.Locale;
+import java.util.Vector;
+
+import javax.net.ssl.CertPathTrustManagerParameters;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.ManagerFactoryParameters;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLServerSocketFactory;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSessionContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509KeyManager;
+
+import org.jboss.web.CoyoteLogger;
+
+/*
+ 1. Make the JSSE's jars available, either as an installed
+ extension (copy them into jre/lib/ext) or by adding
+ them to the Tomcat classpath.
+ 2. keytool -genkey -alias tomcat -keyalg RSA
+ Use "changeit" as password ( this is the default we use )
+ */
+
+/**
+ * SSL server socket factory. It _requires_ a valid RSA key and
+ * JSSE.
+ *
+ * @author Harish Prabandham
+ * @author Costin Manolache
+ * @author Stefan Freyr Stefansson
+ * @author EKR -- renamed to JSSESocketFactory
+ * @author Jan Luehe
+ * @author Bill Barker
+ */
+public class JSSESocketFactory
+ extends org.apache.tomcat.util.net.ServerSocketFactory {
+
+ private static final boolean RFC_5746_SUPPORTED;
+ // defaults
+ static String defaultProtocol = "TLS";
+ static boolean defaultClientAuth = false;
+ static String defaultKeystoreType = "JKS";
+ private static final String defaultKeystoreFile
+ = System.getProperty("user.home") + "/.keystore";
+ private static final String defaultKeyPass = "changeit";
+ private static final int defaultSessionCacheSize = 0;
+ private static final int defaultSessionTimeout = 86400;
+
+ static org.jboss.logging.Logger log =
+ org.jboss.logging.Logger.getLogger(JSSESocketFactory.class);
+
+ static {
+ boolean result = false;
+ SSLContext context;
+ try {
+ context = SSLContext.getInstance("TLS");
+ context.init(null, null, new SecureRandom());
+ SSLServerSocketFactory ssf = context.getServerSocketFactory();
+ String ciphers[] = ssf.getSupportedCipherSuites();
+ for (String cipher : ciphers) {
+ if ("TLS_EMPTY_RENEGOTIATION_INFO_SCSV".equals(cipher)) {
+ result = true;
+ break;
+ }
+ }
+ } catch (NoSuchAlgorithmException e) {
+ // Assume no RFC 5746 support
+ } catch (KeyManagementException e) {
+ // Assume no RFC 5746 support
+ }
+ RFC_5746_SUPPORTED = result;
+ }
+
+ protected boolean initialized;
+ protected String clientAuth = "false";
+ protected SSLServerSocketFactory sslProxy = null;
+ protected String[] enabledCiphers;
+ protected boolean allowUnsafeLegacyRenegotiation = false;
+
+ /**
+ * Flag to state that we require client authentication.
+ */
+ protected boolean requireClientAuth = false;
+
+ /**
+ * Flag to state that we would like client authentication.
+ */
+ protected boolean wantClientAuth = false;
+
+
+ public JSSESocketFactory () {
+ }
+
+ public ServerSocket createSocket (int port)
+ throws IOException
+ {
+ if (!initialized) init();
+ ServerSocket socket = sslProxy.createServerSocket(port);
+ initServerSocket(socket);
+ return socket;
+ }
+
+ public ServerSocket createSocket (int port, int backlog)
+ throws IOException
+ {
+ if (!initialized) init();
+ ServerSocket socket = sslProxy.createServerSocket(port, backlog);
+ initServerSocket(socket);
+ return socket;
+ }
+
+ public ServerSocket createSocket (int port, int backlog,
+ InetAddress ifAddress)
+ throws IOException
+ {
+ if (!initialized) init();
+ ServerSocket socket = sslProxy.createServerSocket(port, backlog,
+ ifAddress);
+ initServerSocket(socket);
+ return socket;
+ }
+
+ public Socket acceptSocket(ServerSocket socket)
+ throws IOException
+ {
+ SSLSocket asock = null;
+ try {
+ asock = (SSLSocket)socket.accept();
+ } catch (SSLException e){
+ throw new SocketException("SSL handshake error" + e.toString());
+ }
+ return asock;
+ }
+
+ public void handshake(Socket sock) throws IOException {
+ // We do getSession instead of startHandshake() so we can call this multiple times
+ SSLSession session = ((SSLSocket)sock).getSession();
+ if (session.getCipherSuite().equals("SSL_NULL_WITH_NULL_NULL"))
+ throw new IOException("SSL handshake failed. Ciper suite in SSL Session is SSL_NULL_WITH_NULL_NULL");
+
+ if (!allowUnsafeLegacyRenegotiation && !RFC_5746_SUPPORTED) {
+ // Prevent further handshakes by removing all cipher suites
+ ((SSLSocket) sock).setEnabledCipherSuites(new String[0]);
+ }
+ }
+
+ /*
+ * Determines the SSL cipher suites to be enabled.
+ *
+ * @param requestedCiphers Comma-separated list of requested ciphers
+ * @param supportedCiphers Array of supported ciphers
+ *
+ * @return Array of SSL cipher suites to be enabled, or null if none of the
+ * requested ciphers are supported
+ */
+ protected String[] getEnabledCiphers(String requestedCiphers,
+ String[] supportedCiphers) {
+
+ String[] enabledCiphers = null;
+
+ if (requestedCiphers != null) {
+ Vector vec = null;
+ String cipher = requestedCiphers;
+ int index = requestedCiphers.indexOf(',');
+ if (index != -1) {
+ int fromIndex = 0;
+ while (index != -1) {
+ cipher = requestedCiphers.substring(fromIndex, index).trim();
+ if (cipher.length() > 0) {
+ /*
+ * Check to see if the requested cipher is among the
+ * supported ciphers, i.e., may be enabled
+ */
+ for (int i=0; supportedCiphers != null
+ && i<supportedCiphers.length; i++) {
+ if (supportedCiphers[i].equals(cipher)) {
+ if (vec == null) {
+ vec = new Vector();
+ }
+ vec.addElement(cipher);
+ break;
+ }
+ }
+ }
+ fromIndex = index+1;
+ index = requestedCiphers.indexOf(',', fromIndex);
+ } // while
+ cipher = requestedCiphers.substring(fromIndex);
+ }
+
+ if (cipher != null) {
+ cipher = cipher.trim();
+ if (cipher.length() > 0) {
+ /*
+ * Check to see if the requested cipher is among the
+ * supported ciphers, i.e., may be enabled
+ */
+ for (int i=0; supportedCiphers != null
+ && i<supportedCiphers.length; i++) {
+ if (supportedCiphers[i].equals(cipher)) {
+ if (vec == null) {
+ vec = new Vector();
+ }
+ vec.addElement(cipher);
+ break;
+ }
+ }
+ }
+ }
+
+ if (vec != null) {
+ enabledCiphers = new String[vec.size()];
+ vec.copyInto(enabledCiphers);
+ }
+ } else {
+ enabledCiphers = sslProxy.getDefaultCipherSuites();
+ }
+
+ return enabledCiphers;
+ }
+
+ /*
+ * Gets the SSL server's keystore password.
+ */
+ protected String getKeystorePassword() {
+ String keyPass = (String)attributes.get("keypass");
+ if (keyPass == null) {
+ keyPass = defaultKeyPass;
+ }
+ String keystorePass = (String)attributes.get("keystorePass");
+ if (keystorePass == null) {
+ keystorePass = keyPass;
+ }
+ return keystorePass;
+ }
+
+ /*
+ * Gets the SSL server's keystore.
+ */
+ protected KeyStore getKeystore(String type, String provider, String pass)
+ throws IOException {
+
+ String keystoreFile = (String)attributes.get("keystore");
+ if (keystoreFile == null)
+ keystoreFile = defaultKeystoreFile;
+
+ return getStore(type, provider, keystoreFile, pass);
+ }
+
+ /*
+ * Gets the SSL server's truststore.
+ */
+ protected KeyStore getTrustStore(String keystoreType,
+ String keystoreProvider) throws IOException {
+ KeyStore trustStore = null;
+
+ String truststoreFile = (String)attributes.get("truststoreFile");
+ if(truststoreFile == null) {
+ truststoreFile = System.getProperty("javax.net.ssl.trustStore");
+ }
+ if(log.isDebugEnabled()) {
+ log.debug("Truststore = " + truststoreFile);
+ }
+ String truststorePassword = (String)attributes.get("truststorePass");
+ if( truststorePassword == null) {
+ truststorePassword = System.getProperty("javax.net.ssl.trustStorePassword");
+ }
+ if(log.isDebugEnabled()) {
+ log.debug("TrustPass = " + truststorePassword);
+ }
+ String truststoreType = (String)attributes.get("truststoreType");
+ if( truststoreType == null) {
+ truststoreType = System.getProperty("javax.net.ssl.trustStoreType");
+ }
+ if(truststoreType == null) {
+ truststoreType = keystoreType;
+ }
+ if(log.isDebugEnabled()) {
+ log.debug("trustType = " + truststoreType);
+ }
+ String truststoreProvider =
+ (String)attributes.get("truststoreProvider");
+ if( truststoreProvider == null) {
+ truststoreProvider =
+ System.getProperty("javax.net.ssl.trustStoreProvider");
+ }
+ if (truststoreProvider == null) {
+ truststoreProvider = keystoreProvider;
+ }
+ if(log.isDebugEnabled()) {
+ log.debug("trustProvider = " + truststoreProvider);
+ }
+
+ if (truststoreFile != null){
+ trustStore = getStore(truststoreType, truststoreProvider,
+ truststoreFile, truststorePassword);
+ }
+
+ return trustStore;
+ }
+
+ /*
+ * Gets the key- or truststore with the specified type, path, and password.
+ */
+ private KeyStore getStore(String type, String provider, String path,
+ String pass) throws IOException {
+
+ KeyStore ks = null;
+ InputStream istream = null;
+ try {
+ if (provider == null) {
+ ks = KeyStore.getInstance(type);
+ } else {
+ ks = KeyStore.getInstance(type, provider);
+ }
+ if(!("PKCS11".equalsIgnoreCase(type) || "".equalsIgnoreCase(path))) {
+ File keyStoreFile = new File(path);
+ if (!keyStoreFile.isAbsolute()) {
+ keyStoreFile = new File(System.getProperty("catalina.base"),
+ path);
+ }
+ istream = new FileInputStream(keyStoreFile);
+ }
+
+ char[] storePass = null;
+ if (pass != null) {
+ storePass = pass.toCharArray();
+ }
+ ks.load(istream, storePass);
+ } catch (FileNotFoundException fnfe) {
+ CoyoteLogger.UTIL_LOGGER.errorLoadingKeystore(type, path, fnfe.getMessage());
+ throw fnfe;
+ } catch (IOException ioe) {
+ CoyoteLogger.UTIL_LOGGER.errorLoadingKeystoreWithException(type, path, ioe.getMessage(), ioe);
+ throw ioe;
+ } catch(Exception ex) {
+ CoyoteLogger.UTIL_LOGGER.errorLoadingKeystoreWithException(type, path, ex.getMessage(), ex);
+ throw new IOException(ex);
+ } finally {
+ if (istream != null) {
+ try {
+ istream.close();
+ } catch (IOException ioe) {
+ // Do nothing
+ }
+ }
+ }
+
+ return ks;
+ }
+
+ /**
+ * Reads the keystore and initializes the SSL socket factory.
+ */
+ void init() throws IOException {
+ try {
+
+ String clientAuthStr = (String) attributes.get("clientauth");
+ if("true".equalsIgnoreCase(clientAuthStr) ||
+ "yes".equalsIgnoreCase(clientAuthStr)) {
+ requireClientAuth = true;
+ } else if("want".equalsIgnoreCase(clientAuthStr)) {
+ wantClientAuth = true;
+ }
+
+ // SSL protocol variant (e.g., TLS, SSL v3, etc.)
+ String protocol = (String) attributes.get("protocol");
+ if (protocol == null) {
+ protocol = defaultProtocol;
+ }
+
+ // Certificate encoding algorithm (e.g., SunX509)
+ String algorithm = (String) attributes.get("algorithm");
+ if (algorithm == null) {
+ algorithm = KeyManagerFactory.getDefaultAlgorithm();;
+ }
+
+ String keystoreType = (String) attributes.get("keystoreType");
+ if (keystoreType == null) {
+ keystoreType = defaultKeystoreType;
+ }
+
+ String keystoreProvider =
+ (String) attributes.get("keystoreProvider");
+
+ String trustAlgorithm =
+ (String)attributes.get("truststoreAlgorithm");
+ if( trustAlgorithm == null ) {
+ trustAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
+ }
+
+ // Create and init SSLContext
+ SSLContext context = (SSLContext) attributes.get("SSLContext");
+ if (context == null) {
+ context = SSLContext.getInstance(protocol);
+ context.init(
+ getKeyManagers(keystoreType, keystoreProvider,
+ algorithm, (String) attributes.get("keyAlias")),
+ getTrustManagers(keystoreType, keystoreProvider,
+ trustAlgorithm), new SecureRandom());
+ }
+
+ // Configure SSL session cache
+ int sessionCacheSize;
+ if (attributes.get("sessionCacheSize") != null) {
+ sessionCacheSize = Integer.parseInt(
+ (String)attributes.get("sessionCacheSize"));
+ } else {
+ sessionCacheSize = defaultSessionCacheSize;
+ }
+ int sessionCacheTimeout;
+ if (attributes.get("sessionCacheTimeout") != null) {
+ sessionCacheTimeout = Integer.parseInt(
+ (String)attributes.get("sessionCacheTimeout"));
+ } else {
+ sessionCacheTimeout = defaultSessionTimeout;
+ }
+ SSLSessionContext sessionContext =
+ context.getServerSessionContext();
+ if (sessionContext != null) {
+ sessionContext.setSessionCacheSize(sessionCacheSize);
+ sessionContext.setSessionTimeout(sessionCacheTimeout);
+ }
+
+ // create proxy
+ sslProxy = context.getServerSocketFactory();
+
+ // Determine which cipher suites to enable
+ String requestedCiphers = (String)attributes.get("ciphers");
+ enabledCiphers = getEnabledCiphers(requestedCiphers,
+ sslProxy.getSupportedCipherSuites());
+
+ allowUnsafeLegacyRenegotiation =
+ "true".equals(attributes.get("allowUnsafeLegacyRenegotiation"));
+
+ // Check the SSL config is OK
+ checkConfig();
+
+ } catch(Exception e) {
+ if( e instanceof IOException )
+ throw (IOException)e;
+ throw new IOException(e.getMessage());
+ }
+ }
+
+ /**
+ * Gets the initialized key managers.
+ */
+ protected KeyManager[] getKeyManagers(String keystoreType,
+ String keystoreProvider,
+ String algorithm,
+ String keyAlias)
+ throws Exception {
+
+ KeyManager[] kms = null;
+
+ String keystorePass = getKeystorePassword();
+
+ KeyStore ks = getKeystore(keystoreType, keystoreProvider, keystorePass);
+ if (keyAlias != null && !ks.isKeyEntry(keyAlias)) {
+ throw new IOException(MESSAGES.noKeyAlias(keyAlias));
+ }
+
+ KeyManagerFactory kmf = KeyManagerFactory.getInstance(algorithm);
+ kmf.init(ks, keystorePass.toCharArray());
+
+ kms = kmf.getKeyManagers();
+ if (keyAlias != null) {
+ if (JSSESocketFactory.defaultKeystoreType.equals(keystoreType)) {
+ keyAlias = keyAlias.toLowerCase(Locale.ENGLISH);
+ }
+ for(int i=0; i<kms.length; i++) {
+ kms[i] = new JSSEKeyManager((X509KeyManager)kms[i], keyAlias);
+ }
+ }
+
+ return kms;
+ }
+
+ /**
+ * Gets the intialized trust managers.
+ */
+ protected TrustManager[] getTrustManagers(String keystoreType,
+ String keystoreProvider, String algorithm)
+ throws Exception {
+ String crlf = (String) attributes.get("crlFile");
+
+ TrustManager[] tms = null;
+
+ KeyStore trustStore = getTrustStore(keystoreType, keystoreProvider);
+ if (trustStore != null) {
+ if (crlf == null) {
+ TrustManagerFactory tmf = TrustManagerFactory.getInstance(algorithm);
+ tmf.init(trustStore);
+ tms = tmf.getTrustManagers();
+ } else {
+ TrustManagerFactory tmf = TrustManagerFactory.getInstance(algorithm);
+ CertPathParameters params = getParameters(algorithm, crlf, trustStore);
+ ManagerFactoryParameters mfp = new CertPathTrustManagerParameters(params);
+ tmf.init(mfp);
+ tms = tmf.getTrustManagers();
+ }
+ }
+
+ return tms;
+ }
+
+ /**
+ * Return the initialization parameters for the TrustManager.
+ * Currently, only the default <code>PKIX</code> is supported.
+ *
+ * @param algorithm The algorithm to get parameters for.
+ * @param crlf The path to the CRL file.
+ * @param trustStore The configured TrustStore.
+ * @return The parameters including the CRLs and TrustStore.
+ */
+ protected CertPathParameters getParameters(String algorithm,
+ String crlf,
+ KeyStore trustStore)
+ throws Exception {
+ CertPathParameters params = null;
+ if("PKIX".equalsIgnoreCase(algorithm)) {
+ PKIXBuilderParameters xparams = new PKIXBuilderParameters(trustStore,
+ new X509CertSelector());
+ Collection crls = getCRLs(crlf);
+ CertStoreParameters csp = new CollectionCertStoreParameters(crls);
+ CertStore store = CertStore.getInstance("Collection", csp);
+ xparams.addCertStore(store);
+ xparams.setRevocationEnabled(true);
+ String trustLength = (String)attributes.get("trustMaxCertLength");
+ if(trustLength != null) {
+ try {
+ xparams.setMaxPathLength(Integer.parseInt(trustLength));
+ } catch(Exception ex) {
+ log.warn("Bad maxCertLength: "+trustLength);
+ }
+ }
+
+ params = xparams;
+ } else {
+ throw new CRLException("CRLs not supported for type: "+algorithm);
+ }
+ return params;
+ }
+
+
+ /**
+ * Load the collection of CRLs.
+ *
+ */
+ protected Collection<? extends CRL> getCRLs(String crlf)
+ throws IOException, CRLException, CertificateException {
+
+ File crlFile = new File(crlf);
+ if( !crlFile.isAbsolute() ) {
+ crlFile = new File(System.getProperty("catalina.base"), crlf);
+ }
+ Collection<? extends CRL> crls = null;
+ InputStream is = null;
+ try {
+ CertificateFactory cf = CertificateFactory.getInstance("X.509");
+ is = new FileInputStream(crlFile);
+ crls = cf.generateCRLs(is);
+ } catch(IOException iex) {
+ throw iex;
+ } catch(CRLException crle) {
+ throw crle;
+ } catch(CertificateException ce) {
+ throw ce;
+ } finally {
+ if(is != null) {
+ try{
+ is.close();
+ } catch(Exception ex) {
+ }
+ }
+ }
+ return crls;
+ }
+
+ /**
+ * Set the SSL protocol variants to be enabled.
+ * @param socket the SSLServerSocket.
+ * @param protocols the protocols to use.
+ */
+ protected void setEnabledProtocols(SSLServerSocket socket, String []protocols){
+ if (protocols != null) {
+ socket.setEnabledProtocols(protocols);
+ }
+ }
+
+ /**
+ * Determines the SSL protocol variants to be enabled.
+ *
+ * @param socket The socket to get supported list from.
+ * @param requestedProtocols Comma-separated list of requested SSL
+ * protocol variants
+ *
+ * @return Array of SSL protocol variants to be enabled, or null if none of
+ * the requested protocol variants are supported
+ */
+ protected String[] getEnabledProtocols(SSLServerSocket socket,
+ String requestedProtocols){
+ String[] supportedProtocols = socket.getSupportedProtocols();
+
+ String[] enabledProtocols = null;
+
+ if (requestedProtocols != null) {
+ Vector vec = null;
+ String protocol = requestedProtocols;
+ int index = requestedProtocols.indexOf(',');
+ if (index != -1) {
+ int fromIndex = 0;
+ while (index != -1) {
+ protocol = requestedProtocols.substring(fromIndex, index).trim();
+ if (protocol.length() > 0) {
+ /*
+ * Check to see if the requested protocol is among the
+ * supported protocols, i.e., may be enabled
+ */
+ for (int i=0; supportedProtocols != null
+ && i<supportedProtocols.length; i++) {
+ if (supportedProtocols[i].equals(protocol)) {
+ if (vec == null) {
+ vec = new Vector();
+ }
+ vec.addElement(protocol);
+ break;
+ }
+ }
+ }
+ fromIndex = index+1;
+ index = requestedProtocols.indexOf(',', fromIndex);
+ } // while
+ protocol = requestedProtocols.substring(fromIndex);
+ }
+
+ if (protocol != null) {
+ protocol = protocol.trim();
+ if (protocol.length() > 0) {
+ /*
+ * Check to see if the requested protocol is among the
+ * supported protocols, i.e., may be enabled
+ */
+ for (int i=0; supportedProtocols != null
+ && i<supportedProtocols.length; i++) {
+ if (supportedProtocols[i].equals(protocol)) {
+ if (vec == null) {
+ vec = new Vector();
+ }
+ vec.addElement(protocol);
+ break;
+ }
+ }
+ }
+ }
+
+ if (vec != null) {
+ enabledProtocols = new String[vec.size()];
+ vec.copyInto(enabledProtocols);
+ }
+ }
+
+ return enabledProtocols;
+ }
+
+ /**
+ * Configure Client authentication for this version of JSSE. The
+ * JSSE included in Java 1.4 supports the 'want' value. Prior
+ * versions of JSSE will treat 'want' as 'false'.
+ * @param socket the SSLServerSocket
+ */
+ protected void configureClientAuth(SSLServerSocket socket){
+ if (wantClientAuth){
+ socket.setWantClientAuth(wantClientAuth);
+ } else {
+ socket.setNeedClientAuth(requireClientAuth);
+ }
+ }
+
+ /**
+ * Configure Client authentication for this version of JSSE. The
+ * JSSE included in Java 1.4 supports the 'want' value. Prior
+ * versions of JSSE will treat 'want' as 'false'.
+ * @param socket the SSLSocket
+ */
+ protected void configureClientAuth(SSLSocket socket){
+ // Per JavaDocs: SSLSockets returned from
+ // SSLServerSocket.accept() inherit this setting.
+ }
+
+ /**
+ * Configures the given SSL server socket with the requested cipher suites,
+ * protocol versions, and need for client authentication
+ */
+ private void initServerSocket(ServerSocket ssocket) {
+
+ SSLServerSocket socket = (SSLServerSocket) ssocket;
+
+ if (enabledCiphers != null) {
+ socket.setEnabledCipherSuites(enabledCiphers);
+ }
+
+ String requestedProtocols = (String) attributes.get("protocols");
+ setEnabledProtocols(socket, getEnabledProtocols(socket,
+ requestedProtocols));
+
+ // we don't know if client auth is needed -
+ // after parsing the request we may re-handshake
+ configureClientAuth(socket);
+ }
+
+ /**
+ * Checks that the certificate is compatible with the enabled cipher suites.
+ * If we don't check now, the JIoEndpoint can enter a nasty logging loop.
+ * See bug 45528.
+ */
+ private void checkConfig() throws IOException {
+ // Create an unbound server socket
+ ServerSocket socket = sslProxy.createServerSocket();
+ initServerSocket(socket);
+
+ try {
+ // Set the timeout to 1ms as all we care about is if it throws an
+ // SSLException on accept.
+ socket.setSoTimeout(1);
+
+ socket.accept();
+ // Will never get here - no client can connect to an unbound port
+ } catch (SSLException ssle) {
+ // SSL configuration is invalid. Possibly cert doesn't match ciphers
+ IOException ioe = new IOException(MESSAGES.invalidSSLConfiguration(ssle.getMessage()));
+ ioe.initCause(ssle);
+ throw ioe;
+ } catch (Exception e) {
+ /*
+ * Possible ways of getting here
+ * socket.accept() throws a SecurityException
+ * socket.setSoTimeout() throws a SocketException
+ * socket.accept() throws some other exception (after a JDK change)
+ * In these cases the test won't work so carry on - essentially
+ * the behaviour before this patch
+ * socket.accept() throws a SocketTimeoutException
+ * In this case all is well so carry on
+ */
+ } finally {
+ // Should be open here but just in case
+ if (!socket.isClosed()) {
+ socket.close();
+ }
+ }
+
+ }
+
+}
Added: branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSESupport.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSESupport.java (rev 0)
+++ branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/JSSESupport.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -0,0 +1,246 @@
+/*
+ * 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.tomcat.util.net.jsse;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.SocketException;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateFactory;
+
+import javax.net.ssl.HandshakeCompletedEvent;
+import javax.net.ssl.HandshakeCompletedListener;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocket;
+import javax.security.cert.X509Certificate;
+
+import org.apache.tomcat.util.net.Constants;
+import org.apache.tomcat.util.net.SSLSupport;
+
+/** JSSESupport
+
+ Concrete implementation class for JSSE
+ Support classes.
+
+ This will only work with JDK 1.2 and up since it
+ depends on JDK 1.2's certificate support
+
+ @author EKR
+ @author Craig R. McClanahan
+ @author Filip Hanik
+ Parts cribbed from JSSECertCompat
+ Parts cribbed from CertificatesValve
+*/
+
+class JSSESupport implements SSLSupport {
+
+ private static org.jboss.logging.Logger log =
+ org.jboss.logging.Logger.getLogger(JSSESupport.class);
+
+ protected SSLSocket ssl;
+ protected SSLSession session;
+
+ Listener listener = new Listener();
+
+ JSSESupport(SSLSocket sock){
+ ssl=sock;
+ session = sock.getSession();
+ sock.addHandshakeCompletedListener(listener);
+ }
+
+ JSSESupport(SSLSession session) {
+ this.session = session;
+ }
+
+ public String getCipherSuite() throws IOException {
+ // Look up the current SSLSession
+ if (session == null)
+ return null;
+ return session.getCipherSuite();
+ }
+
+ public Object[] getPeerCertificateChain()
+ throws IOException {
+ return getPeerCertificateChain(false);
+ }
+
+ protected java.security.cert.X509Certificate [] getX509Certificates(SSLSession session)
+ throws IOException {
+ Certificate [] certs=null;
+ try {
+ certs = session.getPeerCertificates();
+ } catch( Throwable t ) {
+ log.debug("Error getting client certs",t);
+ return null;
+ }
+ if( certs==null ) return null;
+
+ java.security.cert.X509Certificate [] x509Certs =
+ new java.security.cert.X509Certificate[certs.length];
+ for(int i=0; i < certs.length; i++) {
+ if (certs[i] instanceof java.security.cert.X509Certificate ) {
+ // always currently true with the JSSE 1.1.x
+ x509Certs[i] = (java.security.cert.X509Certificate) certs[i];
+ } else {
+ try {
+ byte [] buffer = certs[i].getEncoded();
+ CertificateFactory cf =
+ CertificateFactory.getInstance("X.509");
+ ByteArrayInputStream stream =
+ new ByteArrayInputStream(buffer);
+ x509Certs[i] = (java.security.cert.X509Certificate) cf.generateCertificate(stream);
+ } catch(Exception ex) {
+ log.info("Error translating cert " + certs[i], ex);
+ return null;
+ }
+ }
+ if(log.isTraceEnabled())
+ log.trace("Cert #" + i + " = " + x509Certs[i]);
+ }
+ if(x509Certs.length < 1)
+ return null;
+ return x509Certs;
+ }
+
+ public Object[] getPeerCertificateChain(boolean force)
+ throws IOException {
+ // Look up the current SSLSession
+ if (session == null)
+ return null;
+
+ // Convert JSSE's certificate format to the ones we need
+ X509Certificate [] jsseCerts = null;
+ try {
+ jsseCerts = session.getPeerCertificateChain();
+ } catch(Exception bex) {
+ // ignore.
+ }
+ if (jsseCerts == null)
+ jsseCerts = new X509Certificate[0];
+ if(jsseCerts.length <= 0 && force) {
+ session.invalidate();
+ handShake();
+ session = ssl.getSession();
+ }
+ return getX509Certificates(session);
+ }
+
+ protected void handShake() throws IOException {
+ if( ssl.getWantClientAuth() ) {
+ log.debug("No client cert sent for want");
+ } else {
+ ssl.setNeedClientAuth(true);
+ }
+
+ if (ssl.getEnabledCipherSuites().length == 0) {
+ // Handshake is never going to be successful.
+ // Assume this is because handshakes are disabled
+ log.warn("SSL server initiated renegotiation is disabled, closing connection");
+ session.invalidate();
+ ssl.close();
+ return;
+ }
+
+ InputStream in = ssl.getInputStream();
+ int oldTimeout = ssl.getSoTimeout();
+ ssl.setSoTimeout(1000);
+ byte[] b = new byte[0];
+ listener.reset();
+ ssl.startHandshake();
+ int maxTries = 60; // 60 * 1000 = example 1 minute time out
+ for (int i = 0; i < maxTries; i++) {
+ if(log.isTraceEnabled())
+ log.trace("Reading for try #" +i);
+ try {
+ int x = in.read(b);
+ } catch(SSLException sslex) {
+ log.info("SSL Error getting client Certs",sslex);
+ throw sslex;
+ } catch (IOException e) {
+ // ignore - presumably the timeout
+ }
+ if (listener.completed) {
+ break;
+ }
+ }
+ ssl.setSoTimeout(oldTimeout);
+ if (listener.completed == false) {
+ throw new SocketException("SSL Cert handshake timeout");
+ }
+
+ }
+
+ /**
+ * Copied from <code>org.apache.catalina.valves.CertificateValve</code>
+ */
+ public Integer getKeySize()
+ throws IOException {
+ // Look up the current SSLSession
+ SSLSupport.CipherData c_aux[]=ciphers;
+ if (session == null)
+ return null;
+ Integer keySize = (Integer) session.getValue(Constants.KEY_SIZE_KEY);
+ if (keySize == null) {
+ int size = 0;
+ String cipherSuite = session.getCipherSuite();
+ for (int i = 0; i < c_aux.length; i++) {
+ if (cipherSuite.indexOf(c_aux[i].phrase) >= 0) {
+ size = c_aux[i].keySize;
+ break;
+ }
+ }
+ keySize = new Integer(size);
+ session.putValue(Constants.KEY_SIZE_KEY, keySize);
+ }
+ return keySize;
+ }
+
+ public String getSessionId()
+ throws IOException {
+ // Look up the current SSLSession
+ if (session == null)
+ return null;
+ // Expose ssl_session (getId)
+ byte [] ssl_session = session.getId();
+ if ( ssl_session == null)
+ return null;
+ StringBuilder buf=new StringBuilder("");
+ for(int x=0; x<ssl_session.length; x++) {
+ String digit=Integer.toHexString((int)ssl_session[x]);
+ if (digit.length()<2) buf.append('0');
+ if (digit.length()>2) digit=digit.substring(digit.length()-2);
+ buf.append(digit);
+ }
+ return buf.toString();
+ }
+
+
+ private static class Listener implements HandshakeCompletedListener {
+ volatile boolean completed = false;
+ public void handshakeCompleted(HandshakeCompletedEvent event) {
+ completed = true;
+ }
+ void reset() {
+ completed = false;
+ }
+ }
+
+}
+
Modified: branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/NioJSSESocketChannelFactory.java
===================================================================
--- branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/NioJSSESocketChannelFactory.java 2012-09-25 12:49:25 UTC (rev 2086)
+++ branches/7.2.x/src/main/java/org/apache/tomcat/util/net/jsse/NioJSSESocketChannelFactory.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -112,7 +112,9 @@
break;
}
}
- } catch (NoSuchAlgorithmException | KeyManagementException e) {
+ } catch (NoSuchAlgorithmException e) {
+ // Assume no RFC 5746 support
+ } catch (KeyManagementException e) {
// Assume no RFC 5746 support
}
RFC_5746_SUPPORTED = result;
@@ -362,7 +364,7 @@
for (int i = 0; supportedCiphers != null && i < supportedCiphers.length; i++) {
if (supportedCiphers[i].equals(cipher)) {
if (vec == null) {
- vec = new Vector<>();
+ vec = new Vector<Object>();
}
vec.addElement(cipher);
break;
@@ -385,7 +387,7 @@
for (int i = 0; supportedCiphers != null && i < supportedCiphers.length; i++) {
if (supportedCiphers[i].equals(cipher)) {
if (vec == null) {
- vec = new Vector<>();
+ vec = new Vector<Object>();
}
vec.addElement(cipher);
break;
Modified: branches/7.2.x/src/main/java/org/jboss/web/CatalinaLogger.java
===================================================================
--- branches/7.2.x/src/main/java/org/jboss/web/CatalinaLogger.java 2012-09-25 12:49:25 UTC (rev 2086)
+++ branches/7.2.x/src/main/java/org/jboss/web/CatalinaLogger.java 2012-09-26 13:54:12 UTC (rev 2087)
@@ -653,4 +653,8 @@
@Message(id = 1140, value = "Failed protocol handler [%s] JMX registration.")
void failedProtocolJmxRegistration(Object objectName, @Cause Throwable t);
+ @LogMessage(level = INFO)
+ @Message(id = 1141, value = "NIO 2 is not available, the java.io connector will be used insteaf")
+ void usingJavaIoConnector();
+
}
Modified: branches/7.2.x/webapps/docs/changelog.xml
===================================================================
--- branches/7.2.x/webapps/docs/changelog.xml 2012-09-25 12:49:25 UTC (rev 2086)
+++ branches/7.2.x/webapps/docs/changelog.xml 2012-09-26 13:54:12 UTC (rev 2087)
@@ -16,7 +16,14 @@
<body>
-<section name="JBoss Web 7.7.0.Alpha1 (remm)">
+<section name="JBoss Web 7.2.0.Alpha1 (remm)">
+ <subsection name="General">
+ <changelog>
+ <add>
+ Switch to JBoss Logging for i18n. (remm)
+ </add>
+ </changelog>
+ </subsection>
<subsection name="Catalina">
<changelog>
<fix>
@@ -65,9 +72,6 @@
<add>
NIO 2 HTTP connector. (benothman)
</add>
- <add>
- Drop java.io connectors (AJP and HTTP). AJP now requires native. (remm)
- </add>
</changelog>
</subsection>
<subsection name="Jasper">
More information about the jbossweb-commits
mailing list