Package org.apache.coyote.http11

Class Http11Processor

    • Field Detail

      • keepAlive

        protected volatile boolean keepAlive
        Keep-alive.

      • openSocket

        protected volatile boolean openSocket
        Flag used to indicate that the socket should be kept open (e.g. for keep alive or send file).

      • readComplete

        protected volatile boolean readComplete
        Flag that indicates if the request headers have been completely read.

      • http11

        protected boolean http11
        HTTP/1.1 flag.

      • http09

        protected boolean http09
        HTTP/0.9 flag.

      • contentDelimitation

        protected boolean contentDelimitation
        Content delimiter for the request (if false, the connection will be closed at the end of the request).

      • restrictedUserAgents

        protected java.util.regex.Pattern restrictedUserAgents
        Regular expression that defines the restricted user agents.

      • maxKeepAliveRequests

        protected int maxKeepAliveRequests
        Maximum number of Keep-Alive requests to honor.

      • connectionUploadTimeout

        protected int connectionUploadTimeout
        Maximum timeout on uploads. 5 minutes as in Apache HTTPD server.

      • disableUploadTimeout

        protected boolean disableUploadTimeout
        Flag to disable setting a different time-out on uploads.

      • maxSavePostSize

        protected int maxSavePostSize
        Max saved post size.

      • upgradeToken

        protected UpgradeToken upgradeToken
        Instance of the new protocol to use after the HTTP connection has been upgraded.

    • Method Detail

      • setCompression

        @Deprecated
public void setCompression​(java.lang.String compression)
        Deprecated.
        Use AbstractHttp11Protocol.setCompression(String)
        Set compression level.
        Parameters:
        compression - One of on, force, off or the minimum compression size in bytes which implies on

      • setCompressionMinSize

        @Deprecated
public void setCompressionMinSize​(int compressionMinSize)
        Deprecated.
        Use AbstractHttp11Protocol.setCompressionMinSize(int)
        Set Minimum size to trigger compression.
        Parameters:
        compressionMinSize - The minimum content length required for compression in bytes

      • setNoCompressionUserAgents

        @Deprecated
public void setNoCompressionUserAgents​(java.lang.String noCompressionUserAgents)
        Deprecated.
        Use AbstractHttp11Protocol.setNoCompressionUserAgents(String)
        Set no compression user agent pattern. Regular expression as supported by Pattern. e.g.: gorilla|desesplorer|tigrus.
        Parameters:
        noCompressionUserAgents - The regular expression for user agent strings for which compression should not be applied

      • setCompressibleMimeTypes

        @Deprecated
public void setCompressibleMimeTypes​(java.lang.String[] compressibleMimeTypes)
        Deprecated.
        Use AbstractHttp11Protocol.setCompressibleMimeType(String)
        Set compressible mime-type list.
        Parameters:
        compressibleMimeTypes - MIME types for which compression should be enabled

      • getCompression

        @Deprecated
public java.lang.String getCompression()
        Deprecated.
        Use AbstractHttp11Protocol.getCompression()
        Return compression level.
        Returns:
        The current compression level in string form (off/on/force)

      • setRestrictedUserAgents

        public void setRestrictedUserAgents​(java.lang.String restrictedUserAgents)
        Set restricted user agent list (which will downgrade the connector to HTTP/1.0 mode). Regular expression as supported by Pattern.
        Parameters:
        restrictedUserAgents - The regular expression as supported by Pattern for the user agents e.g. "gorilla|desesplorer|tigrus"

      • setMaxKeepAliveRequests

        public void setMaxKeepAliveRequests​(int mkar)
        Set the maximum number of Keep-Alive requests to allow. This is to safeguard from DoS attacks. Setting to a negative value disables the limit.
        Parameters:
        mkar - The new maximum number of Keep-Alive requests allowed

      • getMaxKeepAliveRequests

        public int getMaxKeepAliveRequests()
        Get the maximum number of Keep-Alive requests allowed. A negative value means there is no limit.
        Returns:
        the number of Keep-Alive requests that we will allow.

      • setMaxSavePostSize

        public void setMaxSavePostSize​(int msps)
        Set the maximum size of a POST which will be buffered in SSL mode. When a POST is received where the security constraints require a client certificate, the POST body needs to be buffered while an SSL handshake takes place to obtain the certificate.
        Parameters:
        msps - The maximum size POST body to buffer in bytes

      • getMaxSavePostSize

        public int getMaxSavePostSize()
        Return the maximum size of a POST which will be buffered in SSL mode.
        Returns:
        The size in bytes

      • setDisableUploadTimeout

        public void setDisableUploadTimeout​(boolean isDisabled)
        Set the flag to control whether a separate connection timeout is used during upload of a request body.
        Parameters:
        isDisabled - true if the separate upload timeout should be disabled

      • getDisableUploadTimeout

        public boolean getDisableUploadTimeout()
        Get the flag that controls upload time-outs.
        Returns:
        true if the separate upload timeout is disabled

      • setConnectionUploadTimeout

        public void setConnectionUploadTimeout​(int timeout)
        Set the upload timeout.
        Parameters:
        timeout - Upload timeout in milliseconds

      • getConnectionUploadTimeout

        public int getConnectionUploadTimeout()
        Get the upload timeout.
        Returns:
        Upload timeout in milliseconds

      • setServer

        @Deprecated
public void setServer​(java.lang.String server)
        Deprecated.
        Use AbstractHttp11Protocol.setServer(String)
        Set the server header name.
        Parameters:
        server - The new value to use for the server header

      • setServerRemoveAppProvidedValues

        @Deprecated
public void setServerRemoveAppProvidedValues​(boolean serverRemoveAppProvidedValues)
        Deprecated.

      • service

        public AbstractEndpoint.Handler.SocketState service​(SocketWrapperBase<?> socketWrapper)
                                             throws java.io.IOException
        Description copied from class: AbstractProcessorLight
        Service a 'standard' HTTP request. This method is called for both new requests and for requests that have partially read the HTTP request line or HTTP headers. Once the headers have been fully read this method is not called again until there is a new HTTP request to process. Note that the request type may change during processing which may result in one or more calls to AbstractProcessorLight.dispatch(SocketEvent). Requests may be pipe-lined.
        Specified by:
        service in class AbstractProcessorLight
        Parameters:
        socketWrapper - The connection to process
        Returns:
        The state the caller should put the socket in when this method returns
        Throws:
        java.io.IOException - If an I/O error occurs during the processing of the request

      • prepareResponse

        protected final void prepareResponse()
                              throws java.io.IOException
        When committing the response, we have to validate the set of headers, as well as setup the response filters.
        Specified by:
        prepareResponse in class AbstractProcessor
        Throws:
        java.io.IOException

      • populatePort

        protected void populatePort()
        Called when a host header is not present or is empty in the request (e.g. HTTP/1.0). It populates the server port with appropriate information. The source is expected to vary by protocol.

        The default implementation is a NO-OP.

        This implementation provides the server port from the local port.

        Overrides:
        populatePort in class AbstractProcessor

      • flushBufferedWrite

        protected boolean flushBufferedWrite()
                              throws java.io.IOException
        Description copied from class: AbstractProcessor
        Flush any pending writes. Used during non-blocking writes to flush any remaining data from a previous incomplete write.
        Specified by:
        flushBufferedWrite in class AbstractProcessor
        Returns:
        true if data remains to be flushed at the end of method
        Throws:
        java.io.IOException - If an I/O error occurs while attempting to flush the data

      • finishResponse

        protected final void finishResponse()
                             throws java.io.IOException
        Specified by:
        finishResponse in class AbstractProcessor
        Throws:
        java.io.IOException

      • flush

        protected final void flush()
                    throws java.io.IOException
        Specified by:
        flush in class AbstractProcessor
        Throws:
        java.io.IOException

      • sslReHandShake

        protected final void sslReHandShake()
                             throws java.io.IOException
        Description copied from class: AbstractProcessor
        Processors that can perform a TLS re-handshake (e.g. HTTP/1.1) should override this method and implement the re-handshake.
        Overrides:
        sslReHandShake in class AbstractProcessor
        Throws:
        java.io.IOException - If authentication is required then there will be I/O with the client and this exception will be thrown if that goes wrong

      • getUpgradeToken

        public UpgradeToken getUpgradeToken()
        Description copied from class: AbstractProcessor
        Generate an upgrade token. Processors that implement HTTP upgrade must override this method and provide the necessary token.
        Specified by:
        getUpgradeToken in interface Processor
        Overrides:
        getUpgradeToken in class AbstractProcessor
        Returns:
        An upgrade token encapsulating the information required to process the upgrade request

      • doHttpUpgrade

        protected final void doHttpUpgrade​(UpgradeToken upgradeToken)
        Description copied from class: AbstractProcessor
        Process an HTTP upgrade. Processors that support HTTP upgrade should override this method and process the provided token.
        Overrides:
        doHttpUpgrade in class AbstractProcessor
        Parameters:
        upgradeToken - Contains all the information necessary for the Processor to process the upgrade

      • getLeftoverInput

        public java.nio.ByteBuffer getLeftoverInput()
        Description copied from class: AbstractProcessor
        Allows retrieving additional input during the upgrade process. Processors that implement HTTP upgrade must override this method.
        Specified by:
        getLeftoverInput in interface Processor
        Overrides:
        getLeftoverInput in class AbstractProcessor
        Returns:
        leftover bytes

      • isUpgrade

        public boolean isUpgrade()
        Description copied from class: AbstractProcessor
        Processors that implement HTTP upgrade must override this method.
        Specified by:
        isUpgrade in interface Processor
        Overrides:
        isUpgrade in class AbstractProcessor
        Returns:
        true if the Processor is currently processing an upgrade request, otherwise false

      • recycle

        public final void recycle()
        Description copied from interface: Processor
        Recycle the processor, ready for the next request which may be on the same connection or a different connection.
        Specified by:
        recycle in interface Processor
        Overrides:
        recycle in class AbstractProcessor

      • pause

        public void pause()
        Description copied from interface: Processor
        Informs the processor that the underlying I/O layer has stopped accepting new connections. This is primarily intended to enable processors that use multiplexed connections to prevent further 'streams' being added to an existing multiplexed connection.