Class CoyoteAdapter

  • All Implemented Interfaces:
    Adapter

    public class CoyoteAdapter
    extends Object
    implements Adapter
    Implementation of a request processor which delegates the processing to a Coyote processor.
    Author:
    Craig R. McClanahan, Remy Maucherat
    • Field Detail

      • ALLOW_BACKSLASH

        protected static final boolean ALLOW_BACKSLASH
      • sm

        protected static final StringManager sm
        The string manager for this package.
    • Constructor Detail

      • CoyoteAdapter

        public CoyoteAdapter​(Connector connector)
        Construct a new CoyoteProcessor associated with the specified connector.
        Parameters:
        connector - CoyoteConnector that owns this processor
    • Method Detail

      • service

        public void service​(Request req,
                            Response res)
                     throws Exception
        Description copied from interface: Adapter
        Call the service method, and notify all listeners
        Specified by:
        service in interface Adapter
        Parameters:
        req - The request object
        res - The response object
        Throws:
        Exception - if an error happens during handling of the request. Common errors are:
        • IOException if an input/output error occurs and we are processing an included servlet (otherwise it is swallowed and handled by the top level error handler mechanism)
        • ServletException if a servlet throws an exception and we are processing an included servlet (otherwise it is swallowed and handled by the top level error handler mechanism)
        Tomcat should be able to handle and log any other exception ( including runtime exceptions )
      • prepare

        public boolean prepare​(Request req,
                               Response res)
                        throws IOException,
                               ServletException
        Description copied from interface: Adapter
        Prepare the given request/response for processing. This method requires that the request object has been populated with the information available from the HTTP headers.
        Specified by:
        prepare in interface Adapter
        Parameters:
        req - The request object
        res - The response object
        Returns:
        true if processing can continue, otherwise false in which case an appropriate error will have been set on the response
        Throws:
        IOException
        ServletException
      • checkRecycled

        public void checkRecycled​(Request req,
                                  Response res)
        Description copied from interface: Adapter
        Assert that request and response have been recycled. If they have not then log a warning and force a recycle. This method is called as a safety check when a processor is being recycled and may be returned to a pool for reuse.
        Specified by:
        checkRecycled in interface Adapter
        Parameters:
        req - Request
        res - Response
      • getDomain

        public String getDomain()
        Description copied from interface: Adapter
        Provide the name of the domain to use to register MBeans for components associated with the connector.
        Specified by:
        getDomain in interface Adapter
        Returns:
        The MBean domain name
      • postParseRequest

        protected boolean postParseRequest​(Request req,
                                           Request request,
                                           Response res,
                                           Response response)
                                    throws IOException,
                                           ServletException
        Perform the necessary processing after the HTTP headers have been parsed to enable the request/response pair to be passed to the start of the container pipeline for processing.
        Parameters:
        req - The coyote request object
        request - The catalina request object
        res - The coyote response object
        response - The catalina response object
        Returns:
        true if the request should be passed on to the start of the container pipeline, otherwise false
        Throws:
        IOException - If there is insufficient space in a buffer while processing headers
        ServletException - If the supported methods of the target servlet cannot be determined
      • parsePathParameters

        protected void parsePathParameters​(Request req,
                                           Request request)
        Extract the path parameters from the request. This assumes parameters are of the form /path;name=value;name2=value2/ etc. Currently only really interested in the session ID that will be in this form. Other parameters can safely be ignored.
        Parameters:
        req - The Coyote request object
        request - The Servlet request object
      • parseSessionSslId

        protected void parseSessionSslId​(Request request)
        Look for SSL session ID if required. Only look for SSL Session ID if it is the only tracking method enabled.
        Parameters:
        request - The Servlet request object
      • parseSessionCookiesId

        protected void parseSessionCookiesId​(Request request)
        Parse session id in Cookie.
        Parameters:
        request - The Servlet request object
      • convertURI

        protected void convertURI​(MessageBytes uri,
                                  Request request)
                           throws IOException
        Character conversion of the URI.
        Parameters:
        uri - MessageBytes object containing the URI
        request - The Servlet request object
        Throws:
        IOException - if a IO exception occurs sending an error to the client
      • convertMB

        protected void convertMB​(MessageBytes mb)
        Character conversion of the a US-ASCII MessageBytes.
        Parameters:
        mb - The MessageBytes instance containing the bytes that should be converted to chars
      • normalize

        public static boolean normalize​(MessageBytes uriMB)
        This method normalizes "\", "//", "/./" and "/../".
        Parameters:
        uriMB - URI to be normalized
        Returns:
        false if normalizing this URI would require going above the root, or if the URI contains a null byte, otherwise true
      • checkNormalize

        public static boolean checkNormalize​(MessageBytes uriMB)
        Check that the URI is normalized following character decoding. This method checks for "\", 0, "//", "/./" and "/../".
        Parameters:
        uriMB - URI to be checked (should be chars)
        Returns:
        false if sequences that are supposed to be normalized are still present in the URI, otherwise true
      • copyBytes

        protected static void copyBytes​(byte[] b,
                                        int dest,
                                        int src,
                                        int len)
        Copy an array of bytes to a different position. Used during normalization.
        Parameters:
        b - The bytes that should be copied
        dest - Destination offset
        src - Source offset
        len - Length