# All Classes and Interfaces

Class
Description
AbandonedConfig
Configuration settings for abandoned object removal.
AbandonedTrace
Tracks connection usage for recovering and reporting abandoned connections.
AbsoluteOrder
Title: Membership - Absolute Order
AbsoluteOrder.AbsoluteComparator
A comparator for absolute ordering of members.
AbstractAccessLogValve
Abstract implementation of the Valve interface that generates a web server access log with the detailed line contents matching a configurable pattern.
AbstractAccessLogValve.AccessLogElement
AccessLogElement writes the partial message into the buffer.
AbstractAccessLogValve.ByteSentElement
Write bytes sent, excluding HTTP headers - %b, %B.
AbstractAccessLogValve.CachedElement
Marks an AccessLogElement as needing to have the value cached at the start of the request rather than just recorded at the end as the source data for the element may not be available at the end of the request.
AbstractAccessLogValve.ConnectionStatusElement
Write connection status when response is completed - %X.
AbstractAccessLogValve.CookieElement
Write a specific cookie - %{xxx}c.
AbstractAccessLogValve.DateFormatCache
Cache structure for formatted timestamps based on seconds.
AbstractAccessLogValve.ElapsedTimeElement
Write time taken to process the request - %D, %T.
AbstractAccessLogValve.ElapsedTimeElement.Style
Style for formatting elapsed time.
AbstractAccessLogValve.FirstByteTimeElement
Write time until first byte is written (commit time) in millis - %F.
AbstractAccessLogValve.HeaderElement
Write incoming headers - %{xxx}i.
AbstractAccessLogValve.HttpStatusCodeElement
Write HTTP status code of the response - %s.
AbstractAccessLogValve.IdentifierElement
Write identifier element %{xxx}L.
AbstractAccessLogValve.LocalAddrElement
Write local IP address - %A.
AbstractAccessLogValve.LogicalUserNameElement
Write remote logical username from identd (always returns '-') - %l.
AbstractAccessLogValve.MethodElement
Write request method (GET, POST, etc.) - %m.
AbstractAccessLogValve.QueryElement
Write query string (prepended with a '?'
AbstractAccessLogValve.RequestAttributeElement
Write an attribute in the ServletRequest - %{xxx}r.
AbstractAccessLogValve.RequestElement
Write first line of the request (method and request URI) - %r.
AbstractAccessLogValve.RequestURIElement
Write requested URL path - %U.
AbstractAccessLogValve.ResponseHeaderElement
Write a specific response header - %{xxx}o.
AbstractAccessLogValve.SessionAttributeElement
Write an attribute in the HttpSession - %{xxx}s.
AbstractAccessLogValve.SessionIdElement
Write user session ID - %S.
AbstractAccessLogValve.StringElement
Write any constant string.
AbstractAccessLogValve.ThreadNameElement
Write thread name - %I.
AbstractAccessLogValve.UserElement
Write remote user that was authenticated (if any), else '-' - %u.
AbstractAjpProtocol<S>
This the base implementation for the AJP protocol handlers.
AbstractArchiveResource
Abstract resource implementation for archive-based resources.
AbstractArchiveResourceSet
Abstract resource set implementation for archive-based resources.
AbstractCatalinaCommandTask
Abstract task for Catalina commands.
AbstractCatalinaTask
Abstract base class for Ant tasks that interact with the Manager web application for dynamically deploying and undeploying applications.
AbstractChunk
Base class for the *Chunk implementation to reduce duplication.
AbstractCreateStatementInterceptor
Abstraction interceptor.
AbstractEndpoint<S,U>
Abstract endpoint implementation.
AbstractEndpoint.BindState
Enum representing the possible states of the bind operation.
AbstractEndpoint.Handler<S>
Interface for handlers used by an endpoint.
AbstractEndpoint.Handler.SocketState
Different types of socket states to react upon.
AbstractFileResourceSet
Abstract implementation of `WebResourceSet` that is based on a directory on a file system.
AbstractGroup
Convenience base class for `Group` implementations.
AbstractHttp11Protocol<S>
Base implementation of the HTTP/1.1 and HTTP/1.0 protocols.
AbstractInputStreamJar
Base implementation of Jar for implementations that use a JarInputStream to access the JAR file.
AbstractNetworkChannelEndpoint<S,U>
Provides a base implementation for endpoints that use a `NetworkChannel`.
AbstractObjectCreationFactory
Abstract base class for `ObjectCreationFactory` implementations.
AbstractProcessor
Provides functionality and attributes common to all supported protocols (currently HTTP and AJP) for processing a single request/response.
AbstractProcessorLight
This is a light-weight abstract processor implementation that is intended as a basis for all Processor implementations from the light-weight upgrade processors to the HTTP/AJP processors.
AbstractProtocol<S>
Abstract base class for protocol handlers.
AbstractProtocol.ConnectionHandler<S>
Connection handler base class.
AbstractProtocol.RecycledProcessors
Pool of recycled processors.
AbstractQueryReport
Abstract class that wraps statements and intercepts query executions.
AbstractRef
Abstract base class for `Reference` implementations used by the naming context.
AbstractReplicatedMap<K,V>
An abstract replicated map implementation.
AbstractReplicatedMap.MapEntry<K,V>
Represents an entry in the replicated map, including metadata about its role (primary, backup, proxy).
AbstractReplicatedMap.MapMessage
Represents a message sent between replicated map instances.
AbstractReplicatedMap.MapOwner
Interface for the owner of this replicated map.
AbstractResource
Abstract `WebResource` implementation that provides common functionality for all web resource implementations.
AbstractResourceSet
Abstract `WebResourceSet` implementation that provides common functionality for all web resource set implementations.
AbstractRole
Convenience base class for `Role` implementations.
AbstractRxTask
Abstract base class for receive tasks in the Catalina Tribes framework.
AbstractSender
Abstract base implementation of a data sender.
AbstractSingleArchiveResource
Abstract `WebResource` implementation for resources within a single archive (e.g., a JAR file).
AbstractSingleArchiveResourceSet
Base class for a `WebResourceSet` based on a single, rather than nested, archive.
AbstractStreamProvider
Abstract base class for `StreamProvider` implementations that provide common functionality for opening connections and streams.
AbstractUser
Convenience base class for `User` implementations.
AcceptEncoding
Represents a single Accept-Encoding value with its quality factor.
AcceptLanguage
Represents a single language entry from an Accept-Language header.
Acceptor<U>
Acceptor thread that accepts incoming connections.
Acceptor.AcceptorState
States of the acceptor lifecycle.
AccessLog
Intended for use by a `Valve` to indicate that the `Valve` provides access logging.
AccessLogAdapter
A helper class that wraps several AccessLog instances.
AccessLogValve
This is a concrete implementation of `AbstractAccessLogValve` that outputs the access log to a file.
ActionCode
ActionCodes represent callbacks from the servlet container to the coyote connector.
ActionHook
Action hook.
Adapter
Adapter.
AddDefaultCharsetFilter
Filter that explicitly sets the default character set for media subtypes of the "text" type to ISO-8859-1, or another user defined character set.
AddDefaultCharsetFilter.ResponseWrapper
Wrapper that adds a character set for text media types if no character set is specified.
AddPortOffsetRule
Rule that applies port offset to connectors during server configuration parsing.
AjpMessage
A single packet for communication between the web server and the container.
AjpNio2Protocol
This the NIO2 based protocol handler implementation for AJP.
AjpNioProtocol
This the NIO based protocol handler implementation for AJP.
AjpProcessor
AJP Processor implementation.
AnnotationElementValue
Element value that represents an annotation.
AnnotationEntry
Represents one annotation in the annotation table
Annotations
base class for annotations
AntCompiler
Main JSP compiler class.
AntCompiler.JasperAntLogger
Ant logger that captures compilation output for reporting.
AntCompiler.SystemLogHandler
Handler that captures System.err output for compilation error reporting.
ApplicationBufferHandler
Callback interface to be able to expand buffers when buffer overflow exceptions happen or to replace buffers
ApplicationContext
Standard implementation of `ServletContext` that represents a web application's execution environment.
ApplicationContextFacade
Facade object which masks the internal `ApplicationContext` object from the web application.
ApplicationFilterChain
Implementation of `jakarta.servlet.FilterChain` used to manage the execution of a set of filters for a particular request.
ApplicationFilterConfig
Implementation of a `jakarta.servlet.FilterConfig` useful in managing the filter instances instantiated when a web application is first started.
ApplicationFilterFactory
Factory for the creation and caching of Filters and creation of Filter Chains.
ApplicationFilterRegistration
Dynamic filter registration implementation.
ApplicationMapping
Holds servlet mapping data for a single request.
ApplicationParameter
Representation of a context initialization parameter that is configured in the server configuration file, rather than the application deployment descriptor.
ApplicationPart
Adaptor to allow `FileItem` objects generated by the package renamed commons-upload to be used by the Servlet 3.0 upload API that expects `Part`s.
ApplicationServletRegistration
Dynamic servlet registration implementation.
ApplicationSessionCookieConfig
Implementation of session cookie configuration.
AprLifecycleListener
Implementation of `LifecycleListener` that will init and destroy APR.
AprStatus
Deprecated.
Unused.
AprStatus
Holds APR status without the need to load other classes.
Arg
Represents a single argument for JMX operations.
ArrayElementValue
Element value that represents an array of element values.
Arrays
Utility class for array operations in the Tribes clustering framework.
ArrayStack<E>
Imported copy of the `ArrayStack` class from Commons Collections, which was the only direct dependency from Digester.
Ascii
This class implements some basic ASCII character handling functions.
Asn1Parser
This is a very basic ASN.1 parser that provides the limited functionality required by Tomcat.
Asn1Writer
Utility class for writing ASN.1 DER-encoded data structures.
AsyncChannelGroupUtil
This is a utility class that enables multiple `WsWebSocketContainer` instances to share a single `AsynchronousChannelGroup` while ensuring that the group is destroyed when no longer required.
AsyncChannelWrapper
This is a wrapper for a `AsynchronousSocketChannel` that limits the methods available thereby simplifying the process of implementing SSL/TLS support since there are fewer methods to intercept.
AsyncChannelWrapperNonSecure
Generally, just passes calls straight to the wrapped `AsynchronousSocketChannel`.
AsyncChannelWrapperSecure
Wraps the `AsynchronousSocketChannel` with SSL/TLS.
AsyncContextCallback
Provides a mechanism for the Coyote connectors to communicate with the `AsyncContext`.
AsyncContextImpl
Implementation of `AsyncContext` that manages the lifecycle of an asynchronous request processing operation.
AsyncDispatcher
Interface for performing asynchronous dispatch operations within the container.
AsyncFileHandler
A `FileHandler` implementation that uses a queue of log entries.
AsyncListenerWrapper
Wrapper for an `AsyncListener` that supports custom request and response objects for event customization.
AttributeInfo
Internal configuration information for an `Attribute` descriptor.
AttributeParser
Converts a JSP attribute value into the unquoted equivalent.
AuthConfigFactoryImpl
Implementation of `AuthConfigFactory` for the JASPIC authentication framework.
AuthenticatedUserRealm
This Realm is intended for use with Authenticator implementations (`SSLAuthenticator`, `SpnegoAuthenticator`) that authenticate the user as well as obtain the user credentials.
Authentication
Enumeration of authentication types used in OpenSSL cipher specifications.
AuthenticationException
Exception thrown on authentication error connecting to a remote websocket endpoint.
AuthenticationType
Defines the authentication types supported by the WebSocket client.
Authenticator
An Authenticator is a component (usually a Valve or Container) that provides some sort of authentication service.
Authenticator
Base class for the authentication methods used by the WebSocket client.
AuthenticatorBase
Basic implementation of the Valve interface that enforces the `<security-constraint>` elements in the web application deployment descriptor.
AuthenticatorBase.AllowCorsPreflight
Defines the modes for handling CORS preflight requests in the authenticator.
AuthenticatorBase.SsoReauthenticationMode
Defines the modes for SSO re-authentication behavior.
AuthenticatorFactory
Utility method to return the appropriate authenticator according to the scheme that the server uses.
Authorization
Parser for an "Authorization" header.
B2CConverter
NIO based character decoder.
BackgroundProcess
Interface for objects that need periodic background processing.
BackgroundProcessManager
Provides a background processing mechanism that triggers roughly once a second.
BackportBase
Base class providing common implementation for back-port utilities.
BackportEnglish
Generates a set of English property files to back-port updates to a previous version.
BackportTranslations
Generates a set of translated property files to back-port updates to a previous version.
BackupManager
Cluster session manager that provides backup session replication.
BadRequestException
Extend IOException to identify it as being caused by a bad request from a remote client.
BaseAttributeFilter
Implementation of `NotificationFilter` for attribute change notifications.
BaseCatalinaMBean<T>
Abstract base class for Catalina MBeans that provides typed access to the managed resource.
BaseGenericObjectPool<T>
Base class that provides common functionality for `GenericObjectPool` and `GenericKeyedObjectPool`.
BaseModelMBean
Basic implementation of the `DynamicMBean` interface, which supports the minimal requirements of the interface contract.
BaseNotificationBroadcaster
Implementation of `NotificationBroadcaster` for attribute change notifications.
BaseObject
A base class for common functionality.
BaseObjectPool<T>
A simple base implementation of `ObjectPool`.
BaseObjectPoolConfig<T>
Provides the implementation for the common attributes shared by the sub-classes.
BaseRedirectorHelperTask
Abstract base class to add output redirection support for Catalina Ant tasks.
BasicAuthenticator
An Authenticator and Valve implementation of HTTP BASIC Authentication, as outlined in RFC 7617: "The 'Basic' HTTP Authentication Scheme"
BasicAuthenticator
Authenticator supporting the BASIC authentication method.
BasicAuthenticator.BasicCredentials
Parser for an HTTP Authorization header for BASIC authentication as per RFC 2617 section 2, and the Base64 encoded credentials as per RFC 2045 section 6.8.
BasicDataSource
Basic implementation of `javax.sql.DataSource` that is configured via JavaBeans properties.
BasicDataSourceFactory
JNDI object factory that creates an instance of `BasicDataSource` that has been configured based on the `RefAddr` values of the specified `Reference`, which must match the names and data types of the `BasicDataSource` bean properties with the following exceptions: `connectionInitSqls` must be passed to this factory as a single String using semicolon to delimit the statements whereas `BasicDataSource` requires a collection of Strings.
BasicDataSourceMXBean
Interface to keep API compatibility.
BasicManagedDataSource
BasicManagedDataSource is an extension of BasicDataSource which creates ManagedConnections.
BeanFactory
Object factory for any Resource conforming to the JavaBean spec.
BeanRepository
Repository of {page, request, session, application}-scoped beans
BodyContentImpl
Write text to a character-output stream, buffering characters to provide efficient writing of single characters, arrays, and strings.
Bootstrap
Bootstrap loader for Catalina.
Buffer
Provides utilities related to the use of directly allocated `ByteBuffer` instances with native code.
BufferedInputFilter
Input filter responsible for reading and buffering the request body, so that it does not interfere with client SSL handshake messages.
BufferPool
Pool for reusing byte buffers in Tribes messaging.
ByteArrayOutputStream
This class implements an output stream in which the data is written into a byte array.
ByteArrayServletOutputStream
Class that extends ServletOutputStream, used as a wrapper from within `SsiInclude`
ByteBufferHolder
Simple wrapper for a `ByteBuffer` that remembers if the buffer has been flipped or not.
ByteBufferUtils
Utility methods for working with `ByteBuffer` instances.
ByteChunk
This class is used to represent a chunk of bytes, and utilities to manipulate byte[].
ByteChunk.BufferOverflowException
Exception thrown when a byte chunk buffer overflows.
ByteChunk.ByteInputChannel
Input interface, used when the buffer is empty.
ByteChunk.ByteOutputChannel
When we need more space we'll either grow the buffer ( up to the limit ) or send it to a channel.
ByteMessage
A byte message is not serialized and deserialized by the channel instead it is sent as a byte array.
C2BConverter
NIO based character encoder.
Cache
Cache for web resources managed by a StandardRoot.
CachedResource
This class is designed to wrap a 'raw' WebResource and providing caching for expensive operations.
CallbackHandlerImpl
Default implementation of a JASPIC CallbackHandler.
CallMethodRule
Rule implementation that calls a method on an object on the stack (normally the top/parent object), passing arguments collected from subsequent `CallParamRule` rules or from the body of this element.
CallParamRule
Rule implementation that saves a parameter for use by a surrounding `CallMethodRule`.
CallStack
Strategy for obtaining and printing the current call stack.
CaseInsensitiveKeyMap<V>
A Map implementation that uses case-insensitive (using `Locale.ENGLISH`) strings as keys.
Catalina
Startup/Shutdown shell program for Catalina.
Catalina.ServerXml
Interface for generated server XML loading classes.
CatalinaBaseConfigurationSource
Configuration source that loads resources from the Catalina base directory.
CatalinaCluster
A CatalinaCluster interface allows to plug in and out the different cluster implementations
CatalinaClusterSF
Generate Cluster Element with Membership,Sender,Receiver,Deployer and ReplicationValve
CatalinaProperties
Utility class to read the bootstrap Catalina configuration.
Catch
Tag plugin implementation for the JSTL catch tag.
CertificateCreateRule
Rule implementation that creates an SSLHostConfigCertificate.
CertificateStoreAppender
Store the Certificate attributes.
CertificateStreamProvider
Provider for SSL socket factory using certificate streams.
CertificateVerifier
Is called during handshake and hooked into openssl via `SSL_CTX_set_cert_verify_callback`.
CGIServlet
CGI-invoking servlet for web applications, used to execute scripts which comply to the Common Gateway Interface (CGI) specification and are named in the path-info used to invoke this servlet.
CGIServlet.HTTPHeaderInputStream
This is an input stream specifically for reading HTTP headers.
Channel
A channel is a representation of a group of nodes all participating in some sort of communication with each other.
ChannelCoordinator
The channel coordinator object coordinates the membership service, the sender and the receiver.
ChannelData
The `ChannelData` object is used to transfer a message through the channel interceptor stack and eventually out on a transport to be sent to another node.
ChannelException
A channel exception is thrown when an internal error happens somewhere in the channel.
ChannelException.FaultyMember
Represent a failure to a specific member when a message was sent to more than one member
ChannelInterceptor
A ChannelInterceptor is an interceptor that intercepts messages and membership messages in the channel stack.
ChannelInterceptor.InterceptorEvent
Event fired by an interceptor.
ChannelInterceptorBase
Abstract class for the interceptor base class.
ChannelListener
An interface to listens to incoming messages from a channel.
ChannelMessage
Message that is passed through the interceptor stack after the data serialized in the Channel object and then passed down to the interceptor and eventually down to the ChannelSender component.
ChannelReceiver
The `ChannelReceiver` interface is the data receiver component at the bottom layer, the IO layer (for layers see the `Channel` interface).
ChannelSender
The `ChannelSender` interface is the data sender component at the bottom layer, the IO layer (for layers see the `Channel` interface).
ChannelSF
Generate Channel Element
CharChunk
Utilities to manipulate char chunks.
CharChunk.CharInputChannel
Input interface, used when the buffer is empty.
CharChunk.CharOutputChannel
When we need more space we'll either grow the buffer ( up to the limit ) or send it to a channel.
CharsetCache
Cache for Charset instances.
CharsetHolder
Represents a character encoding to be used for a request or response.
CharsetMapper
Utility class that attempts to map from a Locale to the corresponding character set to be used for interpreting input text (or generating output text) when the Content-Type header does not include one.
CharsetUtil
Utility methods for charset operations.
CheckEol
Ant task that checks that all the files in the given fileset have end-of-line delimiters that are appropriate.
Choose
Tag plugin for the JSTL <c:choose> tag.
ChunkedInputFilter
Chunked input filter.
ChunkedOutputFilter
Chunked output filter.
ChunkExtension
Unlike other HTTP parsers, this is a stateless (state is held by the calling code), streaming parser as chunk headers are read as part of the request body and it is not always possible to buffer then entire chunk header in memory.
ChunkExtension.State
Parsing states for chunk extension.
Cipher
All the standard cipher suites for SSL/TSL.
ClassElementValue
Represents a class element value in the constant pool.
ClassFormatException
Thrown when the BCEL attempts to read a class file and determines that a class is malformed or otherwise cannot be interpreted as a class file.
ClassLoaderFactory
Utility class for building class loaders for Catalina.
ClassLoaderFactory.Repository
Represents a repository location and its type.
ClassLoaderFactory.RepositoryType
Defines the types of repositories that can be used with a class loader.
ClassLoaderLogManager
Per classloader LogManager implementation.
ClassLoaderLogManager.ClassLoaderLogInfo
Holds the logging configuration information for a specific class loader.
ClassLoaderLogManager.LogNode
Represents a node in the logger hierarchy tree.
ClassLoaderLogManager.RootLogger
This class is needed to instantiate the root of each per classloader hierarchy.
ClassLoaderUtil
Utility class for loading classes using multiple class loaders.
ClassNameMBean<T>
A convenience base class for ModelMBean implementations where the underlying base class (and therefore the set of supported properties) is different for varying implementations of a standard interface.
ClassParser
Wrapper class that parses a given Java .class file.
ClasspathURLStreamHandler
URL stream handler that resolves resources from the classpath.
ClientAbortException
Extend IOException to identify it as being caused by an abort of a request by a remote client.
ClientEndpointHolder
Holds a client endpoint and provides access to its class name and instance.
Closeable
Interface of an object, which may be closed.
CloseNowException
This exception is thrown to signal to the Tomcat internals that an error has occurred that requires the connection to be closed.
CloudMembershipProvider
Abstract base class for cloud-based membership providers.
CloudMembershipService
A `MembershipService` that uses Kubernetes API(default) or DNS to retrieve the members of a cluster.
CloudMembershipServiceMBean
MBean interface for the CloudMembershipService.
Cluster
A Cluster works as a Cluster client/server for the local host Different Cluster implementations can be used to support different ways to communicate within the Cluster.
ClusterDeployer
A ClusterDeployer interface allows to plug in and out the different deployment implementations
ClusterListener
Receive SessionID cluster change from other backup node after primary session node is failed.
ClusterManager
The common interface used by all cluster manager.
ClusterManagerBase
Base class for cluster session managers.
ClusterMessage
Interface for messages exchanged between cluster nodes.
ClusterMessageBase
Base implementation of `ClusterMessage` providing common fields and methods for cluster messages.
ClusterRuleSet
RuleSet for processing the contents of a Cluster definition element.
ClusterSession
Interface for a cluster-aware session that extends both `Session` and `HttpSession`.
ClusterSessionListener
Receive replicated SessionMessage form other cluster node.
ClusterSingleSignOn
A Valve that supports a "single sign on" user experience on each node of a cluster, where the security identity of a user who successfully authenticates to one web application is propagated to other web applications and to other nodes cluster in the same security domain.
ClusterSingleSignOnListener
Cluster extension of `SingleSignOnListener` that simply adds the marker interface `ReplicatedSessionListener` which allows the listener to be replicated across the cluster along with the session.
ClusterValve
Cluster valves are a simple extension to the Tomcat valve architecture with a small addition of being able to reference the cluster component in the container it sits in.
CollectedInfo
Listener to provide information to mod_heartbeat.c.
CombinedRealm
Realm implementation that contains one or more realms.
Compiler
Main JSP compiler class.
CompressionConfig
Configuration for HTTP response compression settings.
ConcurrentCache<K,V>
A thread-safe cache that uses an eden space backed by a `ConcurrentHashMap` and a long-term space backed by a `WeakHashMap`.
ConcurrentCache<K,V>
A thread-safe cache that uses an eden space backed by a `ConcurrentHashMap` and a long-term space backed by a `WeakHashMap`.
ConcurrentDateFormat
A thread safe wrapper around `SimpleDateFormat` that does not make use of ThreadLocal and - broadly - only creates enough SimpleDateFormat objects to satisfy the concurrency requirements.
ConcurrentLruCache<T>
A thread-safe LRU (Least Recently Used) cache with a configurable size limit.
ConcurrentMessageDigest
A thread safe wrapper around `MessageDigest` that does not make use of ThreadLocal and - broadly - only creates enough MessageDigest objects to satisfy the concurrency requirements.
ConfigFileLoader
This class is used to obtain `InputStream`s for configuration files from a given location String.
ConfigurationSource
Abstracts configuration file storage.
ConfigurationSource.Resource
Represents a resource: a stream to the resource associated with its URI.
ConnectionFactory
Abstract factory interface for creating `Connection`s.
ConnectionPool
Implementation of simple connection pool.
ConnectionPool
JMX MBean wrapper for a `ConnectionPool`.
ConnectionPool.PoolCleaner
A scheduled task that periodically checks for abandoned connections, validates idle connections, and resizes the idle pool according to the pool's configuration.
ConnectionPoolMBean
JMX MBean interface for monitoring and managing a JDBC connection pool.
ConnectionState
Interceptor that keep track of connection state to avoid roundtrips to the database.
Connector
Implementation of a Coyote connector.
ConnectorCreateRule
Rule implementation that creates a connector.
ConnectorMBean
A ModelMBean implementation for the `org.apache.coyote.tomcat5.CoyoteConnector` component.
ConnectorSF
Store Connector and Listeners
ConnectorStoreAppender
Store the Connector attributes.
Const
Constants for the project, mostly defined in the JVM specification.
Constant
Abstract superclass for classes to represent the different constant types in the constant pool of a class file.
ConstantClass
This class is derived from the abstract `Constant` and represents a reference to a (external) class.
ConstantDouble
This class is derived from the abstract `Constant` and represents a reference to a Double object.
ConstantFloat
This class is derived from the abstract `Constant` and represents a reference to a float object.
ConstantInteger
This class is derived from the abstract `Constant` and represents a reference to an int object.
ConstantLong
This class is derived from the abstract `Constant` and represents a reference to a long object.
ConstantPool
This class represents the constant pool, that is, a table of constants, of a parsed classfile.
Constants
Constants used by the authentication framework.
Constants
Constants used by the core Catalina package.
Constants
Manifest constants for this Java package.
Constants
Manifest constants for the `org.apache.catalina.ha.tcp` package.
Constants
Constants used by the manager web application.
Constants
Constants used by the host manager web application.
Constants
Static constants for this package.
Constants
Constants used by the security package.
Constants
Manifest constants for the `org.apache.catalina.session` package.
Constants
String constants for the startup package.
Constants
Constants used by the storeconfig package.
Constants
Manifest constants for the `org.apache.catalina.tribes.membership` package.
Constants
Manifest constants for the `org.apache.catalina.tribes.transport` package.
Constants
Manifest constants for this Java package.
Constants
Manifest constants for the `org.apache.catalina.valves` package.
Constants
Constants.
Constants
Constants.
Constants
Constants.
Constants
HTTP/2 protocol constants.
Constants
Some constants and other global data that are used by the compiler and the runtime.
Constants
Static constants for this package.
Constants
Constants for the translation build utility.
Constants
Constants.
Constants
Constants for descriptor utilities.
Constants
Constants for web descriptor utilities.
Constants
Constants for network utilities.
Constants
String constants for the scan package.
Constants
Static constants for this package.
Constants
Internal implementation constants.
Constants
Internal implementation constants.
Constants
Internal implementation constants.
Constants.AccessLog
Constants specific to the AccessLogValve class.
ConstantTime
Utility class for methods that, for security reasons, need to run in - as far as practical - constant time.
ConstantUtf8
Extends the abstract `Constant` to represent a reference to a UTF-8 encoded string.
Contained
Decoupling interface which specifies that an implementing class is associated with at most one Container instance.
Container
A Container is an object that can execute requests received from a client, and return responses based on those requests.
ContainerBase
Abstract implementation of the Container interface, providing common functionality required by nearly every implementation.
ContainerEvent
General event for notifying listeners of significant changes on a Container.
ContainerListener
Interface defining a listener for significant Container generated events.
ContainerMBean
MBean wrapper for ContainerBase instances, providing JMX management operations for child containers, valves, and lifecycle listeners.
ContainerServlet
A ContainerServlet is a servlet that has access to Catalina internal functionality, and is loaded from the Catalina class loader instead of the web application class loader.
ContentRange
Represents a parsed Content-Range HTTP header value as defined by RFC 9110.
Context
A Context is a Container that represents a servlet context, and therefore an individual web application, in the Catalina servlet engine.
ContextAccessController
Handles the access control on the JNDI contexts.
ContextBind
Defines methods for binding and unbinding the current thread's context class loader to a web application class loader.
ContextBindings
Handles the associations : Object with a NamingContext Calling thread with a NamingContext Calling thread with object bound to the same naming context Thread context class loader with a NamingContext Thread context class loader with object bound to the same NamingContext The objects are typically Catalina Server or Context objects.
ContextConfig
Startup event listener for a Context that configures the properties of that Context, and the associated defined servlets.
ContextConfig.ContextXml
Interface for loading context XML configuration into a Context.
ContextConfig.DefaultWebXmlCacheEntry
Cache entry for the default web.xml fragment associated with a Host.
ContextConfig.JavaClassCacheEntry
Cache entry for a Java class used during annotation scanning.
ContextEjb
Representation of an EJB resource reference for a web application, as represented in a `<ejb-ref>` element in the deployment descriptor.
ContextEnvironment
Representation of an application environment entry, as represented in an `<env-entry>` element in the deployment descriptor.
ContextEnvironmentMBean
A ModelMBean implementation for the `org.apache.tomcat.util.descriptor.web.ContextEnvironment` component.
ContextHandler
Representation of a handler reference for a web service, as represented in a `<handler>` element in the deployment descriptor.
ContextLocalEjb
Representation of a local EJB resource reference for a web application, as represented in a `<ejb-local-ref>` element in the deployment descriptor.
ContextMBean
A ModelMBean implementation for the `org.apache.catalina.Context` component.
ContextName
Utility class to manage context names so there is one place where the conversions between baseName, path and version take place.
ContextNamingInfoListener
Implementation of `LifecycleListener` that will create context naming information environment entries.
ContextResource
Representation of a resource reference for a web application, as represented in a `<resource-ref>` element in the deployment descriptor.
ContextResourceEnvRef
Representation of an application resource reference, as represented in an `<res-env-ref>` element in the deployment descriptor.
ContextResourceLink
Representation of a resource link for a web application, as represented in a `<ResourceLink>` element in the server configuration file.
ContextResourceLinkMBean
A ModelMBean implementation for the `org.apache.tomcat.util.descriptor.web.ContextResourceLink` component.
ContextResourceMBean
A ModelMBean implementation for the `org.apache.tomcat.util.descriptor.web.ContextResource` component.
ContextRuleSet
RuleSet for processing the contents of a Context definition element.
ContextService
Representation of a web service reference for a web application, as represented in a `<service-ref>` element in the deployment descriptor.
ContextTransaction
Representation of an application resource reference, as represented in an `<res-env-ref>` element in the deployment descriptor.
ContinueResponseTiming
Defines timing options for responding to requests that contain a '100-continue' expectations.
Cookie
Cookie header parser based on RFC6265
CookieProcessor
Interface for processing HTTP cookies.
CookieProcessorBase
Base implementation of `CookieProcessor`.
CookiesWithoutEquals
Enum for handling cookies that do not contain an equals sign.
CopyParentClassLoaderRule
Rule that copies the `parentClassLoader` property from the next-to-top item on the stack (which must be a `Container`) to the top item on the stack (which must also be a `Container`).
CorsFilter
A `Filter` that enable client-side cross-origin requests by implementing W3C's CORS (Cross-Origin Resource Sharing) specification for resources.
CorsFilter.CORSRequestType
Enumerates varies types of CORS requests.
CoyoteAdapter
Implementation of a request processor which delegates the processing to a Coyote processor.
CoyoteInputStream
This class handles reading bytes.
CoyoteOutputStream
Coyote implementation of the servlet output stream.
CoyotePrincipal
Generic implementation of java.security.Principal that is used to represent principals authenticated at the protocol handler level.
CoyoteReader
Coyote implementation of the buffered reader.
CoyoteWriter
Coyote implementation of the servlet writer.
CrawlerSessionManagerValve
Web crawlers can trigger the creation of many thousands of sessions as they crawl a site which may result in significant memory consumption.
CredentialHandler
This interface is used by the `Realm` to compare the user provided credentials with the credentials stored in the `Realm` for that user.
CredentialHandlerRuleSet
RuleSet for processing the contents of a CredentialHandler definition element.
CredentialHandlerSF
Store server.xml Element CredentialHandler
CsrfPreventionFilter
Provides basic CSRF protection for a web application.
CsrfPreventionFilter.CsrfResponseWrapper
Wrapper for `HttpServletResponse` that adds CSRF nonces to encoded URLs.
CsrfPreventionFilter.LruCache<T>
Despite its name, this is a FIFO cache not an LRU cache.
CsrfPreventionFilter.MimePredicate
A no-nonce Predicate that evaluates a MIME type instead of a URL.
CsrfPreventionFilter.NonceCache<T>
Interface for a cache of nonces used for CSRF protection.
CsrfPreventionFilter.PatternPredicate
A no-nonce Predicate that matches a regular expression.
CsrfPreventionFilter.PrefixPredicate
A no-nonce Predicate that matches a prefix.
CsrfPreventionFilter.SuffixPredicate
A no-nonce Predicate that matches a suffix.
CsrfPreventionFilterBase
Base class for CSRF prevention filters.
CustomObjectInputStream
Custom subclass of `ObjectInputStream` that loads from the class loader for this web application.
DataSender
Interface for data senders used in the Catalina Tribes framework.
DataSource
A DataSource that can be instantiated through IoC and implements the DataSource interface since the DataSourceProxy is used as a generic proxy.
DataSourceConnectionFactory
A `DataSource`-based implementation of `ConnectionFactory`.
DataSourceFactory
JNDI object factory that creates an instance of `BasicDataSource` that has been configured based on the `RefAddr` values of the specified `Reference`, which must match the names and data types of the `BasicDataSource` bean properties.
DataSourceLinkFactory
Object factory for resource links for shared data sources.
DataSourceLinkFactory.DataSourceHandler
Simple wrapper class that will allow a user to configure a ResourceLink for a data source so that when `DataSource.getConnection()` is called, it will invoke `DataSource.getConnection(String, String)` with the preconfigured username and password.
DataSourceMXBean
Defines the methods that will be made available via JMX.
DataSourcePropertyStore
WebDAV dead properties storage using a DataSource.
DataSourceProxy
The DataSource proxy lets us implements methods that don't exist in the current compiler JDK but might be methods that are part of a future JDK DataSource interface.
DataSourceRealm
Implementation of Realm that works with any JDBC JNDI DataSource.
DataSourceStore
Implementation of the `Store` interface that stores serialized session objects in a database.
DataSourceUserDatabase
UserDatabase backed by a data source.
DataSourceUserDatabaseFactory
JNDI object creation factory for `DataSourceUserDatabase` instances.
DataSourceUserDatabaseMBean
A ModelMBean implementation for the `org.apache.catalina.users.DataSourceUserDatabase` component.
DataSourceXAConnectionFactory
An implementation of XAConnectionFactory which uses a real XADataSource to obtain connections and XAResources.
DateFormatCache
Cache structure for SimpleDateFormat formatted timestamps based on seconds.
DecoderEntry
Entry that maps a class to its corresponding WebSocket decoder class.
DefaultEvictionPolicy<T>
Provides the default implementation of `EvictionPolicy` used by the pools.
DefaultInstanceManager
Default implementation of `InstanceManager` that handles annotation-based dependency injection for EJB, JPA, and web service references.
DefaultPooledObject<T>
This wrapper is used to track the additional information, such as state, for the pooled objects.
DefaultPooledObjectInfo
Implements providing information on pooled objects via JMX.
DefaultPooledObjectInfoMBean
The interface that defines the information about pooled objects that will be exposed via JMX.
DefaultServerEndpointConfigurator
Default implementation of `ServerEndpointConfig.Configurator` for WebSocket server endpoints.
DefaultServlet
The default resource-serving servlet for most web applications, used to serve static resources such as HTML pages and images.
DefaultServlet.CompressionFormat
Represents a compression format with an associated file extension and encoding.
DefaultServlet.SortManager
A class encapsulating the sorting of resources.
DefaultServlet.SortManager.Order
Order specification for directory listing sorting.
DeferredFileOutputStream
An output stream which will retain data in memory until a specified threshold is reached, and only then commit it to disk.
DelegatingCallableStatement
A base delegating implementation of `CallableStatement`.
DelegatingConnection<C>
A base delegating implementation of `Connection`.
DelegatingDatabaseMetaData
A base delegating implementation of `DatabaseMetaData`.
DelegatingPreparedStatement
A base delegating implementation of `PreparedStatement`.
DelegatingResultSet
A base delegating implementation of `ResultSet`.
DelegatingStatement
A base delegating implementation of `Statement`.
DeltaManager
The DeltaManager manages replicated sessions by only replicating the deltas in data.
DeltaRequest
This class is used to track the series of actions that happens when a request is executed.
DeltaSession
Similar to the StandardSession except that this session will keep track of deltas during a request.
DeployTask
Ant task that implements the `/deploy` command, supported by the Tomcat manager application.
DestroyMode
Destroy context provided to object factories via `destroyObject` and `invalidateObject` methods.
Diagnostics
Utility class for JVM diagnostics, including thread dumps and VM information retrieval.
DigestAuthenticator
An Authenticator and Valve implementation of HTTP DIGEST Authentication, as outlined in RFC 7616: "HTTP Digest Authentication"
DigestAuthenticator
Authenticator supporting the DIGEST authentication method.
DigestAuthenticator.AuthDigest
This enum exists because RFC 7616 and Java use different names for some digests.
DigestAuthenticator.DigestInfo
Holds the parsed and validated information from a Digest authentication request.
DigestAuthenticator.NonceInfo
Tracks information about a server nonce, including timestamp and seen nonce counts.
DigestCredentialHandlerBase
Base implementation for the Tomcat provided `CredentialHandler`s.
Digester
A Digester processes an XML input stream by matching a series of element nesting patterns to execute Rules that have been added prior to the start of parsing.
Digester.GeneratedCodeLoader
Interface for loading generated code by class name.
DigesterFactory
Wrapper class around the Digester that hide Digester's initialization details.
DirectByteArrayOutputStream
Byte array output stream that exposes the byte array directly
DirResourceSet
Represents a `WebResourceSet` based on a directory.
DiskFileItem
The default implementation of the `FileItem` interface.
DiskFileItemFactory
The default `FileItemFactory` implementation.
DispatchType
This enumeration lists the different types of dispatches that request processing can trigger.
DisposableConnectionFacade
A DisposableConnectionFacade object is the top most interceptor that wraps an object of type `PooledConnection`.
DistributedManager
Interface implemented by session managers that do not keep a complete copy of all sessions in memory but do know where every session is.
DNSMembershipProvider
A `MembershipProvider` that uses DNS to retrieve the members of a cluster.
DocumentProperties
A collection of interfaces, one per property, that enables the object being populated by the digester to signal to the digester that it supports the given property and that the digester should populate that property if available.
DocumentProperties.Charset
Interface for objects that can receive the character encoding used by the source XML document.
DomainFilterInterceptor
Filters membership based on domain.
DomainFilterInterceptorMBean
MBean interface for the DomainFilterInterceptor.
DOMWriter
A DOM writer optimised for use by WebDAV.
DriverAdapterCPDS
An adapter for JDBC drivers that do not include an implementation of `ConnectionPoolDataSource`, but still include a `DriverManager` implementation.
DriverConnectionFactory
A `Driver`-based implementation of `ConnectionFactory`.
DriverManagerConnectionFactory
A `DriverManager`-based implementation of `ConnectionFactory`.
DummyProxySession
A dummy proxy session used for testing purposes.
EjbFactory
Object factory for EJBs.
EjbRef
Represents a reference address to an EJB.
ELArithmetic
A helper class of Arithmetic defined by the EL Specification.
ELArithmetic.BigDecimalDelegate
Arithmetic delegate for BigDecimal operations.
ELArithmetic.BigIntegerDelegate
Arithmetic delegate for BigInteger operations.
ELArithmetic.DoubleDelegate
Arithmetic delegate for double/float operations.
ELArithmetic.LongDelegate
Arithmetic delegate for long/integer operations.
ELContextImpl
Implementation of ELContext.
ELContextWrapper
Simple ELContextWrapper for runtime evaluation of EL w/ dynamic FunctionMappers
ElementValue
The element_value structure is documented at https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.7.16.1
ElementValuePair
An annotation's element value pair.
ELFunctionMapper
This class generates functions mappers for the EL expressions in the page.
ELInterpreter
Defines the interface for the expression language interpreter.
ELInterpreterFactory
Provides `ELInterpreter` instances for JSP compilation.
ELInterpreterFactory.DefaultELInterpreter
Default implementation of `ELInterpreter` that delegates to `JspUtil.interpreterCall(boolean, String, Class, String)`.
ELInterpreterTagSetters
A non-specification compliant `ELInterpreter` that optimizes a subset of setters for tag attributes.
ELNode
This class defines internal representation for an EL Expression.
ELNode.ELText
Represents anything in EL expression, other than functions, including function arguments etc.
ELNode.Function
Represents a function.
ELNode.Nodes
An ordered list of ELNode.
ELNode.Root
Represents an EL expression: anything in ${ and }.
ELNode.Text
Represents text outside of EL expression.
ELNode.Visitor
A visitor class for traversing ELNodes.
ELParser
This class implements a parser for EL expressions.
ELSupport
A helper class that implements the EL Specification.
EmbeddedServletOptions
A class to hold all init parameters specific to the JSP engine.
EmptyResource
A `WebResource` implementation that represents a non-existent resource.
EmptyResourceSet
A `WebResourceSet` implementation that is not backed by a file system and behaves as if it has no resources available.
EncodedSolidusHandling
Enumerates the possible handling strategies for encoded solidus characters (%2F) in URI paths.
EncryptInterceptor
Adds encryption using a pre-shared key.
EncryptInterceptorMBean
MBean interface for managing the `EncryptInterceptor` configuration and status.
Encryption
Enumerates the encryption algorithms supported by OpenSSL cipher suites.
EncryptionLevel
Enumerates the encryption strength levels used in OpenSSL cipher suite configuration.
EndpointClassHolder
Holds a reference to a WebSocket endpoint class for later instantiation.
EndpointHolder
Holds a reference to a WebSocket endpoint instance.
Engine
An Engine is a Container that represents the entire Catalina servlet engine.
EngineConfig
Startup event listener for an Engine that configures the properties of that Engine, and the associated defined contexts.
EngineRuleSet
RuleSet for processing the contents of an Engine definition element.
EntityTag
Utility class for parsing and comparing HTTP entity tags (ETags) as defined in RFC 7232.
EnumElementValue
Represents an enum constant element value in a Java annotation.
EnvironmentPropertySource
A `IntrospectionUtils.PropertySource` that uses environment variables to resolve expressions.
ErrorDispatcher
Class responsible for dispatching JSP parse and javac compilation errors to the configured error handler.
ErrorHandler
The `ErrorHandler` class is used when sending messages that are sent asynchronously and the application still needs to get confirmation when the message was sent successfully or when a message errored out.
ErrorHandler
Interface for handling JSP parse and javac compilation errors.
ErrorPage
Representation of an error page element for a web application, as represented in a `<error-page>` element in the deployment descriptor.
ErrorPageSupport
Provides support for tracking per exception type and per HTTP status code error pages.
ErrorReportValve
Implementation of a Valve that outputs HTML error pages.
ErrorState
Enumeration of possible error states for a Coyote connection or request/response.
Escape
Provides utility methods to escape content for different contexts.
EvaluationContext
Extended EL context that wraps an existing ELContext and provides additional functionality for lambda expression evaluation.
EvictionConfig
This class is used by pool implementations to pass configuration information to `EvictionPolicy` instances.
EvictionPolicy<T>
To provide a custom eviction policy (i.e. something other than `DefaultEvictionPolicy` for a pool, users must provide an implementation of this interface that provides the required eviction policy.
ExactRateLimiter
A RateLimiter that compromises efficiency for accuracy in order to provide exact rate limiting.
ExceptionUtils
Utilities for handling Throwables and Exceptions.
ExceptionUtils
Utilities for handling Throwable and Exceptions.
ExceptionUtils
Utilities for handling Throwables and Exceptions.
ExceptionUtils
Utilities for handling Throwables and Exceptions.
Executor
Interface for a lifecycle-managed executor service within the Catalina container.
ExecutorFactory
Factory for creating thread pool executors for Tribes clustering.
ExpandWar
Expand out a WAR in a Host's appBase.
ExpiresFilter
ExpiresFilter is a Java Servlet API port of Apache mod_expires to add '`Expires`' and '`Cache-Control: max-age=`' headers to HTTP response according to its '`Content-Type`'.
ExpiresFilter.Duration
Duration composed of an `ExpiresFilter.Duration.amount` and a `ExpiresFilter.Duration.unit`
ExpiresFilter.DurationUnit
Duration unit
ExpiresFilter.ExpiresConfiguration
Main piece of configuration of the filter.
ExpiresFilter.StartingPoint
Expiration configuration starting point.
ExpressionBuilder
Builds compiled EL expressions from parsed AST nodes.
ExpressionFactoryImpl
Implementation of `ExpressionFactory`.
ExpressionParseTree
Represents a parsed expression.
ExpressionTokenizer
Parses an expression string to return the individual tokens.
ExtendedAccessLogValve
An implementation of the W3c Extended Log File Format.
ExtendedAccessLogValve.CookieElement
Log element that outputs the value(s) of a named cookie.
ExtendedAccessLogValve.DateElement
Log element that outputs the date in yyyy-MM-dd format for GMT.
ExtendedAccessLogValve.PatternTokenizer
Tokenizer for parsing the log pattern string.
ExtendedAccessLogValve.RequestAttributeElement
Log element that outputs a servlet request attribute value.
ExtendedAccessLogValve.RequestHeaderElement
Log element that outputs a specific request header value.
ExtendedAccessLogValve.RequestParameterElement
Log element that outputs a URL-encoded request parameter value.
ExtendedAccessLogValve.ResponseAllHeaderElement
write a specific response header - x-O(xxx)
ExtendedAccessLogValve.ResponseHeaderElement
Log element that outputs a specific response header value.
ExtendedAccessLogValve.ServletContextElement
Log element that outputs a servlet context attribute value.
ExtendedAccessLogValve.SessionAttributeElement
Log element that outputs a session attribute value.
ExtendedAccessLogValve.TimeElement
Log element that outputs the time in HH:mm:ss format.
ExtendedRpcCallback
Extension to the `RpcCallback` interface.
ExtractingRoot
If the main resources are packaged as a WAR file then any JARs will be extracted to the work directory and used from there.
FactoryBase
Abstract base class that provides common functionality required by subclasses.
FactoryCreateRule
Rule implementation that uses an `ObjectCreationFactory` to create a new object which it pushes onto the object stack.
FailedContext
An implementation of `Context` that is used as a place-holder for deployed applications when their deployment fails and a Context instance (usually `StandardContext` but may be any Context implementation) cannot be created.
FairBlockingQueue<E>
A simple implementation of a blocking queue with fairness waiting. invocations to method poll(...) will get handed out in the order they were received.
FarmWarDeployer
A farm war deployer is a class that is able to deploy/undeploy web applications in WAR from within the cluster.
FastHttpDateFormat
Utility class to generate HTTP dates.
FastRateLimiter
A RateLimiter that compromises accuracy for speed in order to provide maximum throughput.
FastRemovalDequeue<T>
The FastRemovalDequeue is a Dequeue that supports constant time removal of entries.
FeatureInfo
Convenience base class for `AttributeInfo` and `OperationInfo` classes that will be used to collect configuration information for the `ModelMBean` beans exposed for management.
FileChangeListener
Interface for listening to file changes in a deployment directory.
FileCountLimitExceededException
This exception is thrown if a request contains more files than the specified limit.
FileHandler
Implementation of Handler that appends log messages to a file named {prefix}{date}{suffix} in a configured directory.
FileHandler.ThreadFactory
Thread factory for creating log file cleanup threads.
FileInfo
Tomcat Native 1.2.33 and earlier won't initialise unless this class is present.
FileItem
This class represents a file or form item that was received within a `multipart/form-data` POST request.
FileItemFactory
A factory interface for creating `FileItem` instances.
FileItemHeaders
This class provides support for accessing the headers for a file or form item that was received within a `multipart/form-data` POST request.
FileItemHeadersImpl
Default implementation of the `FileItemHeaders` interface.
FileItemHeadersSupport
Interface that will indicate that `FileItem` or `FileItemStream` implementations will accept the headers read for the item.
FileItemIterator
An iterator, as returned by `FileUploadBase.getItemIterator(RequestContext)`.
FileItemIteratorImpl
The iterator, which is returned by `FileUploadBase.getItemIterator(RequestContext)`.
FileItemStream
This interface provides access to a file or form item that was received within a `multipart/form-data` POST request.
FileItemStream.ItemSkippedException
This exception is thrown, if an attempt is made to read data from the `InputStream`, which has been returned by `FileItemStream.openStream()`, after `Iterator.hasNext()` has been invoked on the iterator, which created the `FileItemStream`.
FileItemStreamImpl
Default implementation of `FileItemStream`.
FileMessage
Contains the data for a file being transferred over TCP, this is essentially a fragment of a file, read and written by the FileMessageFactory.
FileMessageFactory
This factory is used to read files and write files by splitting them up into smaller messages.
FileResource
Represents a single resource (file or directory) that is located on a file system.
FileResourceSet
Represents a `WebResourceSet` based on a single file.
FileSizeLimitExceededException
Thrown to indicate that A files size exceeds the configured maximum.
FileStore
Concrete implementation of the Store interface that utilizes a file per saved Session in a configured directory.
FileUpload
High level API for processing file uploads.
FileUploadBase
High level API for processing file uploads.
FileUploadException
Exception for errors encountered while processing the request.
FileUploadIOException
This exception is thrown for hiding an inner `FileUploadException` in an `IOException`.
FileUtils
General file manipulation utilities.
FilterBase
Base class for filters that provides generic initialisation and a simple no-op destruction.
FilterDef
Representation of a filter definition for a web application, as represented in a `<filter>` element in the deployment descriptor.
FilterMap
Representation of a filter mapping for a web application, as represented in a `<filter-mapping>` element in the deployment descriptor.
FilterUtil
General purpose utility methods related to filters and filter processing.
FilterValve
A Valve to wrap a Filter, allowing a user to run Servlet Filters as a part of the Valve chain.
FindLeaksTask
Ant task that implements the `/findleaks` command, supported by the Tomcat manager application.
ForceUtcTimeZone
Ant task that forces the default time zone to UTC.
ForEach
Tag plugin implementation for the JSTL <c:forEach> tag.
FormAuthenticator
An Authenticator and Valve implementation of FORM BASED Authentication, as described in the Servlet API Specification.
ForTokens
Tag plugin implementation for the JSTL <c:forTokens> tag.
FragmentationInterceptor
The fragmentation interceptor splits up large messages into smaller messages and assembles them on the other end.
FragmentationInterceptor.FragCollection
Collection that holds the fragments of a message for reassembly.
FragmentationInterceptor.FragKey
Key used to identify a set of fragments belonging to the same original message.
FragmentationInterceptorMBean
MBean interface for managing the fragmentation interceptor.
FragmentJarScannerCallback
Callback handling a web-fragment.xml descriptor.
FrameworkListener
This listener must be declared in server.xml as a Server listener, possibly optional.
FunctionMapperFactory
Factory that wraps a target FunctionMapper, capturing all function mappings so that an immutable snapshot can be created.
FunctionMapperImpl
Thread-safe implementation of FunctionMapper that supports externalization.
FunctionMapperImpl.Function
Represents a mapped EL function with serialization support.
GenericGroup<UD>
Concrete implementation of `Group` for a `UserDatabase`.
GenericKeyedObjectPool<K,T>
A configurable `KeyedObjectPool` implementation.
GenericKeyedObjectPoolConfig<T>
A simple structure encapsulating the configuration for a `GenericKeyedObjectPool`.
GenericKeyedObjectPoolMXBean<K>
Defines the methods that will be made available via JMX.
GenericNamingResourcesFactory
Simple way of configuring generic resources by using reflection.
GenericObjectPool<T>
A configurable `ObjectPool` implementation.
GenericObjectPoolConfig<T>
A simple structure encapsulating the configuration for a `GenericObjectPool`.
GenericObjectPoolMXBean
Defines the methods that will be made available via JMX.
GenericPrincipal
Generic implementation of java.security.Principal that is available for use by `Realm` implementations.
GenericRole<UD>
Concrete implementation of `Role` for a `UserDatabase`.
GenericUser<UD>
Concrete implementation of `User` for a `UserDatabase`.
GlobalNamingResourcesSF
store server.xml GlobalNamingResource.
GlobalResourcesLifecycleListener
Implementation of `LifecycleListener` that instantiates the set of MBeans associated with global JNDI resources that are subject to management.
Globals
Global constants that are applicable to multiple packages within Catalina.
Group
Abstract representation of a group of `User`s in a `UserDatabase`.
Group
All the supported named groups.
GroupChannel
The default implementation of a Channel.
The GroupChannel manages the replication channel.
GroupChannel.InterceptorIterator
An iterator to loop through the interceptors in a channel.
GroupChannelMBean
MBean interface for managing a GroupChannel.
GroupMBean
A ModelMBean implementation for the `org.apache.catalina.Group` component.
GzipInterceptor
Channel interceptor that compresses messages using GZIP before transmission and decompresses received messages.
GzipInterceptorMBean
MBean interface for managing a GzipInterceptor.
GzipOutputFilter
Gzip output filter that compresses response data using the GZIP algorithm.
Handler
URL stream handler for WAR file URLs.
HandlerRef
Represents a reference handler for a web service.
HeadersTooLargeException
Exception used to mark the specific error condition of the HTTP headers exceeding the maximum permitted size.
HeaderUtil
Utility methods for HTTP header processing.
HealthCheckValve
Simple Valve that responds to cloud orchestrators health checks.
Heartbeat
Can be implemented by the ChannelListener and Membership listeners to receive heartbeat notifications from the Channel
HeartbeatListener
Lifecycle listener that provides heartbeat information to mod_heartbeat for Apache HTTP Server.
HexUtils
Tables useful when converting byte arrays to and from strings of hexadecimal digits.
HomesUserDatabase
Concrete implementation of the `UserDatabase` interface that considers all directories in a specified base directory to be "home" directories for those users.
Host
A Host is a Container that represents a virtual host in the Catalina servlet engine.
Host
Utility class for parsing HTTP Host header values.
HostConfig
Startup event listener for a `Host` that configures the properties of that Host, and the associated defined contexts.
HostConfig.DeployedApplication
This class represents the state of a deployed application, as well as the monitored resources.
HostManagerServlet
Servlet that enables remote management of the virtual hosts installed on the server.
HostRuleSet
RuleSet for processing the contents of a Host definition element.
HpackDecoder
A decoder for HPACK.
HPackHuffman
Utility class for Huffman encoding and decoding used in HPACK compression for HTTP/2 headers.
HPackHuffman.HuffmanCode
Represents a Huffman code with a value and bit length.
HTMLHostManagerServlet
Servlet that enables remote management of the virtual hosts deployed on the server.
HTMLManagerServlet
Servlet that enables remote management of the web applications deployed within the same virtual host as this web application is.
Http11InputBuffer
InputBuffer for HTTP that provides request header parsing as well as transfer encoding.
Http11Nio2Protocol
HTTP/1.1 protocol implementation using NIO2.
Http11NioProtocol
HTTP/1.1 protocol implementation using NIO.
Http11OutputBuffer
Provides buffering for the HTTP headers (allowing responses to be reset before they have been committed) and the link to the Socket for writing the headers (once committed) and the response body.
Http11Processor
Processor for HTTP/1.1 requests and responses.
Http2AsyncUpgradeHandler
Asynchronous HTTP/2 upgrade handler that uses non-blocking I/O for all operations.
Http2OutputBuffer
HTTP/2 output buffer that wraps a chain of `OutputFilter` instances and delegates to a `Stream.StreamOutputBuffer`.
Http2Protocol
HTTP/2 protocol handler.
HttpHeaderParser
Parses HTTP request and response headers from a byte buffer.
HttpHeaderParser.HeaderDataSource
Provides access to the header data buffer for the parser.
HttpHeaderParser.HeaderParsePosition
Possible parser positions during header parsing.
HttpHeaderParser.HeaderParseStatus
Possible return values from `HttpHeaderParser.parseHeader()`.
HttpHeaderSecurityFilter
Provides a single configuration point for security measures that required the addition of one or more HTTP headers to the response.
HttpJspBase
This is the super class of all JSP-generated servlets.
HttpOutputBuffer
HTTP/1.1 output buffer interface.
HttpParser
HTTP header value parser implementation.
IdentityInputFilter
Identity input filter.
IdentityOutputFilter
Identity output filter.
If
Tag plugin for the JSTL `<c:if>` tag.
ImplicitTldRuleSet
RulesSet for digesting implicit.tld files.
Import
Tag plugin for the JSTL `<c:import>` tag.
Import
Utility class for importing translated properties files.
Injectable
Interface for objects that can be injected with dependencies.
InjectionTarget
Represents a target for dependency injection.
InlineExecutorService
An executor service that runs tasks inline on the calling thread.
InputBuffer
The buffer used by Tomcat request.
InputBuffer
This class is only for internal use in the protocol implementation.
InputFilter
Input filter interface.
InputSourceUtil
Utility methods for working with `InputSource` instances.
InsecureStreamProvider
Stream provider that uses an insecure SSL context for testing purposes.
InstanceKeyDataSource
The base class for `SharedPoolDataSource` and `PerUserPoolDataSource`.
InstanceManager
Interface for creating and managing instances of objects.
InstanceManagerBindings
Utility class for binding `InstanceManager` instances to class loaders.
InstanceManagerFactory
Factory for obtaining `InstanceManager` instances from a JSP `ServletConfig`.
InstrumentableClassLoader
Specifies a class loader capable of being decorated with `ClassFileTransformer`s.
InterceptorPayload
Payload object used to pass an `ErrorHandler` to interceptors.
InterceptorSF
Generate Interceptor Element
InternalHttpUpgradeHandler
This Tomcat specific interface is implemented by handlers that require direct access to Tomcat's I/O layer rather than going through the Servlet API.
InternalRewriteMap
Utility class providing built-in rewrite map implementations.
InternalRewriteMap.Escape
RewriteMap that URL-encodes strings.
InternalRewriteMap.LowerCase
RewriteMap that converts strings to lower case.
InternalRewriteMap.Unescape
RewriteMap that URL-decodes strings.
InternalRewriteMap.UpperCase
RewriteMap that converts strings to upper case.
Introspection
Provides introspection utilities that either require knowledge of Tomcat internals or are solely used by Tomcat internals.
IntrospectionUtils
Utils for introspection and reflection
IntrospectionUtils.PropertySource
Interface for a source of named properties used during introspection.
InvalidContentTypeException
Thrown to indicate that the request is not a multipart request.
InvalidFileNameException
This exception is thrown in case of an invalid file name.
InvalidParameterException
Extend `IllegalStateException` to identify the cause as an invalid parameter.
IOFileUploadException
Thrown to indicate an IOException.
IOTools
Contains commonly needed I/O-related methods.
IOUtils
General IO stream manipulation utilities.
IPv6Utils
IPv6 utilities.
IStoreConfig
Interface for storing Catalina configuration to XML.
IStoreFactory
Interface for storing XML elements to a configuration file.
JAASCallbackHandler
Implementation of the JAAS `CallbackHandler` interface, used to negotiate delivery of the username and credentials that were specified to our constructor.
JAASMemoryLoginModule
Implementation of the JAAS LoginModule interface, primarily for use in testing `JAASRealm`.
JAASRealm
Implementation of Realm that authenticates users via the Java Authentication and Authorization Service (JAAS).
Jar
Provides an abstraction for use by the various classes that need to scan JARs.
JarContents
This class represents the contents of a jar by determining whether a given resource might be in the cache, based on a bloom filter.
JarFactory
Provide a mechanism to obtain objects that implement `Jar`.
JarFileUrlJar
Implementation of `Jar` that is optimised for file based JAR URLs that refer directly to a JAR file (e.g.
JarFileUrlNestedJar
Implementation of `Jar` that is optimised for file based JAR URLs that refer to a JAR file nested inside a WAR (e.g.
JarResource
Represents a single resource (file or directory) that is located within a JAR.
JarResourceRoot
Represents a JAR file as a resource root within a web application.
JarResourceSet
Represents a `WebResourceSet` based on a JAR file.
JarScanFilter
Filter used to determine which JAR files should be included in a scan.
JarScanner
Scans a web application and classloader hierarchy for JAR files.
JarScannerCallback
This interface is implemented by clients of the `JarScanner` to enable them to receive notification of a discovered JAR.
JarScannerFactory
Provide a mechanism for Jasper to obtain a reference to the JarScanner implementation.
JarScannerSF
Store server.xml Element JarScanner
JarScanType
Defines the types of JAR scans that can be performed.
JarWarResource
Represents a single resource (file or directory) that is located within a JAR that in turn is located in a WAR file.
JarWarResourceSet
Represents a `WebResourceSet` based on a JAR file that is nested inside a packed WAR file.
JasperELResolver
Jasper-specific CompositeELResolver that optimizes certain functions to avoid unnecessary resolver calls.
JasperELResolver.GraalBeanELResolver
Extend ELResolver for Graal to avoid bean info use if possible, as BeanELResolver needs manual reflection configuration.
JasperException
Base class for all exceptions generated by the JSP engine.
JasperInitializer
Initializer for the Jasper JSP Engine.
JasperLoader
Class loader for loading servlet class files (corresponding to JSP files) and tag handler class files (corresponding to tag files).
JavacErrorDetail
Class providing details about a javac compilation error.
JavaClass
Represents a Java class, that is, the data structures, constant pool, fields, methods and commands contained in a Java .class file.
JavaCompiler
Main JSP compiler class.
javaURLContextFactory
Context factory for the "java:" namespace.
Jdbc41Bridge
Defines bridge methods to JDBC 4.1 (Java 7 or above) methods to allow call sites to operate safely (without `AbstractMethodError`) when using a JDBC driver written for JDBC 4.0 (Java 6 or above).
JDBCAccessLogValve
Deprecated.
Non scalable design, and not documented.
JdbcInterceptor
Abstract class that is to be extended for implementations of interceptors.
JdbcLeakPrevention
This class is loaded by `WebappClassLoaderBase` to enable it to deregister JDBC drivers forgotten by the web application.
JdkLoggerFormatter
A more compact formatter.
JDTCompiler
JDT class compiler.
JKStatusUpdateTask
Ant task that implements the `/status` command, supported by the mod_jk status (1.2.9) application.
JMXAccessorCondition
Definition:
JMXAccessorConditionBase
Base class for JMX accessor conditions.
JMXAccessorCreateTask
Create new MBean at JMX JSR 160 MBeans Server.
JMXAccessorEqualsCondition
Definition
JMXAccessorGetTask
Access JMX JSR 160 MBeans Server.
JMXAccessorInvokeTask
Access JMX JSR 160 MBeans Server.
JMXAccessorQueryTask
Query for Mbeans.
JMXAccessorSetTask
Access JMX JSR 160 MBeans Server.
JMXAccessorTask
Access JMX JSR 160 MBeans Server.
JMXAccessorUnregisterTask
unregister an MBean at JMX JSR 160 MBeans Server.
JmxChannel
JMX channel interface for managing JMX registration of a channel.
JmxEnabled
This interface is implemented by components that will be registered with an MBean server when they are created and unregistered when they are destroyed.
JMXGetTask
Ant task that implements the JMX Get command (`/jmxproxy/?`
JMXProxyServlet
This servlet will dump JMX attributes in a simple format and implement proxy services for modeler.
JMXQueryTask
Ant task that implements the JMX Query command (`/jmxproxy/?`
JmxRegistry
JMX registry for managing MBean registration for a channel.
JMXSetTask
Ant task that implements the JMX Set command (`/jmxproxy/?`
JmxUtil
Utility class for JMX registration of JDBC pool components.
JNDIRealm
Implementation of Realm that works with a directory server accessed via the Java Naming and Directory Interface (JNDI) APIs.
JNDIRealm.JNDIConnection
Class holding the connection to the directory plus the associated non thread safe message formats.
JNDIRealm.User
A protected class representing a User
JniLifecycleListener
An implementation of LifeCycleListener that loads a native library into the JVM.
Jre19Compat
Jre20Compat
Jre21Compat
Jre22Compat
JRE 22 compatibility implementation.
JreCompat
This is the base implementation class for JRE compatibility and provides an implementation based on Java 17.
JreMemoryLeakPreventionListener
Provide a workaround for known places where the Java Runtime environment can cause a memory leak or lock files.
JrePlatform
Provides flags for detecting the operating system platform.
JreVendor
Provides flags for detecting the JVM vendor.
JsonAccessLogValve
Access log valve derivative that rewrites entries as JSON.
JsonAccessLogValve.CharElement
write any char
JsonErrorReportValve
Implementation of a Valve that outputs error JSON.
JsonFormatter
Provides the same information as the one line format but using JSON formatting.
JsonFormatter.JSONFilter
Provides escaping of values so they can be included in a JSON document.
JspApplicationContextImpl
Implementation of JspApplicationContext.
JspC
Shell for the jspc compiler.
JspCompilationContext
A placeholder for various things that are used throughout the JSP engine.
JspConfig
Handles the jsp-config element in WEB_INF/web.xml.
JspConfig.JspProperty
Represents the JSP property configuration values for a JSP page or group of pages.
JspConfig.JspPropertyGroup
Represents a JSP property group with a path, extension, and associated JSP property.
JspConfigDescriptorImpl
Implementation of JspConfigDescriptor that provides access to JSP property groups and tag library descriptors.
JspContextWrapper
Implementation of a JSP Context Wrapper.
JspCServletContext
Simple `ServletContext` implementation without HTTP-specific methods.
JspELException
Exception wrapper that adds a JSP-specific mark to an ELException for better error tracking.
JspFactoryImpl
Implementation of JspFactory.
JspFragmentHelper
Helper class from which all Jsp Fragment helper classes extend.
JspHelper
Helper JavaBean for JSPs, because JSTL 1.1/EL 2.0 is too dumb to do what I need (call methods with parameters), or I am too dumb to use it correctly. :)
JspMethodExpression
Wrapper around a MethodExpression that adds JSP-specific error tracking with marks.
JspMethodNotFoundException
Exception wrapper that adds a JSP-specific mark to a MethodNotFoundException for better error tracking.
JspPropertyGroup
Representation of a jsp-property-group element in web.xml.
JspPropertyGroupDescriptorImpl
Implementation of JspPropertyGroupDescriptor that wraps a JspPropertyGroup.
JspPropertyNotFoundException
Exception thrown when a JSP property is not found.
JspPropertyNotWritableException
Exception thrown when a JSP property is not writable.
JspRuntimeContext
Class for tracking JSP compile time file dependencies when the >%@include file="
JspRuntimeLibrary
Bunch of util methods that are used by code generated for useBean, getProperty and setProperty.
JspServlet
The Jasper JSP engine.
JspServletWrapper
The Jasper JSP engine.
JspSourceDependent
Interface for tracking the source files dependencies, for the purpose of compiling out of date pages.
JspSourceDirectives
Provides runtime access to selected compile time directives.
JspSourceImports
The EL engine needs access to the imports used in the JSP page to configure the ELContext.
JspUtil
This class has all the utility method(s).
JspUtil.ValidAttribute
Represents a valid attribute for a tag.
JspValueExpression
Wrapper for providing context to ValueExpressions.
JspWriterImpl
Write text to a character-output stream, buffering characters to provide efficient writing of single characters, arrays, and strings.
JSSEImplementation
JSSE-based SSL implementation.
JSSEKeyManager
X509KeyManager which allows selection of a specific key pair and certificate chain (identified by their keystore alias name) to be used by the server to authenticate itself to SSL clients.
JSSESupport
JSSESupport.
JSSEUtil
SSLUtil implementation for JSSE.
JvmRouteBinderValve
Valve to handle Tomcat jvmRoute takeover using mod_jk module after node failure.
KeyedObjectPool<K,V>
A "keyed" pooling interface.
KeyedPooledObjectFactory<K,V>
An interface defining life-cycle methods for instances to be served by a `KeyedObjectPool`.
KeyedReentrantReadWriteLock
Provides a reentrant read/write lock for a given key.
KeyExchange
Key exchange algorithms supported by OpenSSL.
KubernetesMembershipProvider
A `MembershipProvider` that uses Kubernetes API to retrieve the members of a cluster.
LambdaExpressionNestedState
Stores the state required for correct evaluation of lambda expressions.
LazyReplicatedMap<K,V>
A smart implementation of a stateful replicated map. uses primary/secondary backup strategy.
Library
Manages loading of the Tomcat Native (tcnative) library.
LibraryNotFoundError
Exception thrown when a required native library cannot be found.
Lifecycle
Common interface for component life cycle methods.
Lifecycle.SingleUse
Marker interface used to indicate that the instance should only be used once.
LifecycleBase
Base implementation of the `Lifecycle` interface that implements the state transition rules for `Lifecycle.start()` and `Lifecycle.stop()`
LifecycleEvent
General event for notifying listeners of significant changes on a component that implements the Lifecycle interface.
LifecycleException
General purpose exception that is thrown to indicate a lifecycle related problem.
LifecycleListener
Interface defining a listener for significant events (including "component start" and "component stop") generated by a component that implements the Lifecycle interface.
LifecycleListenerRule
Rule that creates a new `LifecycleListener` and associates it with the top object on the stack which must implement `Container`.
LifecycleMBeanBase
Base implementation of MBean registration for lifecycle components.
LifecycleState
The list of valid states for components that implement `Lifecycle`.
LimitedInputStream
An input stream, which limits its data size.
LimitLatch
Shared latch that allows the latch to be acquired a limited number of times after which all subsequent requests to acquire the latch will be placed in a FIFO queue until one of the shares is returned.
ListenCallback
Internal interface, similar to the MessageListener but used at the IO base The listen callback interface is used by the replication system when data has been received.
ListenerCreateRule
Rule implementation that creates a server listener.
ListenerCreateRule.OptionalListener
A listener that is optional and may not be available at runtime.
ListException
An exception wrapping a list of exceptions.
ListTask
Ant task that implements the `/list` command, supported by the Tomcat manager application.
LoadBalancerDrainingValve
A Valve to detect situations where a load-balanced node receiving a request has been deactivated by the load balancer (JK_LB_ACTIVATION=DIS) and the incoming request has no valid session.
Loader
A Loader represents a Java ClassLoader implementation that can be used by a Container to load class files (within a repository associated with the Loader) that are designed to be reloaded upon request, as well as a mechanism to detect whether changes have occurred in the underlying repository.
LoaderSF
Store Loader Element.
Localizer
Class responsible for converting error codes to corresponding localized error messages.
LocalResolver
A resolver for locally cached XML resources.
LocalXAConnectionFactory
An implementation of XAConnectionFactory which manages non-XA connections in XA transactions.
LocalXAConnectionFactory.LocalXAResource
LocalXAResource is a fake XAResource for non-XA connections.
LockOutRealm
This class extends the CombinedRealm (hence it can wrap other Realms) to provide a user lock out mechanism if there are too many failed authentication attempts in a given period of time.
LockOutRealm.LockRecord
Internal record to track lock state for a user.
Log
A simple logging interface abstracting logging APIs.
LogConfigurationException
An exception that is thrown only if a suitable `LogFactory` or `Log` instance cannot be created by the corresponding factory methods.
LogFactory
This is a modified LogFactory that uses a simple `ServiceLoader` based discovery mechanism with a default of using JDK based logging.
LoginConfig
Representation of a login configuration element for a web application, as represented in a `<login-config>` element in the deployment descriptor.
Logs
Simple class that holds references to global loggers.
LogUtil
Utility class for log-related operations.
LookupFactory
Object factory for lookups.
LookupRef
Represents a reference to lookup.
MailSessionFactory
Factory class that creates a JNDI named JavaMail Session factory, which can be used for managing inbound and outbound electronic mail messages via JavaMail APIs.
ManagedBean
Internal configuration information for a managed bean (MBean) descriptor.
ManagedChannel
A managed channel interface gives you access to the components of the channels such as senders, receivers, interceptors etc for configurations purposes
ManagedConcurrentWeakHashMap<K,V>
Concurrent hash map that holds its keys via weak references.
ManagedConnection<C>
ManagedConnection is responsible for managing a database connection in a transactional environment (typically called "Container Managed").
ManagedDataSource<C>
The ManagedDataSource is a PoolingDataSource that creates ManagedConnections.
Manager
A Manager manages the pool of Sessions that are associated with a particular Context.
ManagerBase
Minimal implementation of the Manager interface that supports no session persistence or distributable capabilities.
ManagerBase.SessionTiming
Record for session timing information.
ManagerServlet
Servlet that enables remote management of the web applications installed within the same virtual host as this web application is.
ManagerSF
Store server.xml Manager element
Mapper
Mapper, which implements the servlet API mapping rules (which are derived from the HTTP rules).
Mapper.ContextList
List of mapped contexts.
Mapper.ContextVersion
Represents a versioned context.
Mapper.MapElement<T>
Base class for mapped elements.
Mapper.MappedContext
Represents a mapped context.
Mapper.MappedHost
Represents a mapped host.
Mapper.MappedWrapper
Represents a mapped wrapper.
MapperListener
Mapper listener.
MappingData
Mapping data.
Mark
Mark represents a point in the JSP input.
Matcher
This is a utility class to match file globs.
MBeanDumper
General helper to dump MBean contents to the log.
MBeanFactory
Factory for creating MBeans.
MbeansDescriptorsDigesterSource
Source for loading MBean descriptors from XML using a Digester.
MbeansDescriptorsIntrospectionSource
Source for creating MBean descriptors through introspection.
MBeanUtils
Public utility methods in support of the server side MBeans implementation.
McastService
A membership implementation using simple multicast.
McastServiceImpl
A membership implementation using simple multicast.
McastServiceImpl.RecoveryThread
Thread that handles recovery.
McastServiceMBean
MBean interface for McastService.
MediaType
Represents a parsed media type.
MediaTypeCache
Caches the results of parsing content-type headers.
Member
The Member interface, defines a member in the group.
MemberImpl
A membership implementation using simple multicast.
Membership
A membership implementation using simple multicast.
Membership.MbrEntry
Entry for a member in the membership.
MembershipListener
The MembershipListener interface is used as a callback to the membership service.
MembershipProvider
Interface for membership providers.
MembershipProviderBase
Base implementation for membership providers.
MembershipService
The `MembershipService` interface is the membership component at the bottom layer, the IO layer (for layers see the javadoc for the `Channel` interface).
MembershipServiceBase
Base implementation for membership services.
MemoryRealm
Simple implementation of Realm that reads an XML file to configure the valid users, passwords, and roles.
MemoryRuleSet
RuleSet for recognizing the users defined in the XML file processed by `MemoryRealm`.
MemoryUserDatabase
Concrete implementation of `UserDatabase` that loads all defined users, groups, and roles into an in-memory data structure, and uses a specified XML file for its persistent storage.
MemoryUserDatabaseFactory
JNDI object creation factory for `MemoryUserDatabase` instances.
MemoryUserDatabaseMBean
A ModelMBean implementation for the `org.apache.catalina.users.MemoryUserDatabase` component.
MessageBytes
This class is used to represent a sub array of bytes in an HTTP message.
MessageDestination
Representation of a message destination for a web application, as represented in a `<message-destination>` element in the deployment descriptor.
MessageDestinationRef
Representation of a message destination reference for a web application, as represented in a `<message-destination-ref>` element in the deployment descriptor.
MessageDigest
Supported message digest algorithms.
MessageDigestCredentialHandler
This credential handler supports the following forms of stored passwords: encodedCredential - a hex encoded digest of the password digested using the configured digest {MD5}encodedCredential - a Base64 encoded MD5 digest of the password {SHA}encodedCredential - a Base64 encoded SHA1 digest of the password {SSHA}encodedCredential - 20 byte Base64 encoded SHA1 digest followed by variable length salt.
MessageDispatchInterceptor
The message dispatcher is a way to enable asynchronous communication through a channel.
MessageDispatchInterceptorMBean
MBean interface for MessageDispatchInterceptor.
MessageFactory
Factory for creating localized EL messages.
MessageHandlerResult
Result of a message handler operation.
MessageHandlerResultType
Types of message handler results.
MessageInfoImpl
Implementation of MessageInfo for JASPIC authentication.
MessageListener
The listener to be registered with the ChannelReceiver, internal Tribes component.
MessagePart
Represents a part of a WebSocket message.
Method
HTTP method constants and utilities.
MethodExpressionImpl
An `Expression` that refers to a method on an object.
MethodExpressionLiteral
Literal method expression.
MimeHeaders
Memory-efficient repository for Mime Headers.
MimeTypeMappings
Build utility for MIME type mappings.
MimeUtility
Utility class to decode MIME texts.
ModelerSource
Source for descriptor data.
MultiCastSender
Sender to proxies using multicast socket.
MultiLockFairBlockingQueue<E>
EXPERIMENTAL AND NOT YET COMPLETE!
MultipartDef
Representation of the multipart configuration for a servlet.
MultipartStream
Low level API for processing file uploads.
MultipartStream.IllegalBoundaryException
Thrown upon attempt of setting an invalid boundary token.
MultipartStream.MalformedStreamException
Thrown to indicate that the input stream fails to follow the required syntax.
MultipartStream.ProgressNotifier
Internal class, which is used to invoke the `ProgressListener`.
MultiPointSender
Multi-point sender interface.
MultiThrowable
Wraps a list of throwables as a single throwable.
NameParserImpl
Parses names.
NamingContext
Catalina JNDI Context implementation.
NamingContextBindingsEnumeration
Naming enumeration implementation.
NamingContextEnumeration
Naming enumeration implementation.
NamingContextListener
Helper class used to initialize and populate the JNDI context associated with each context and server.
NamingEntry
Represents a binding in a NamingContext.
NamingResources
Defines an interface for the object that is added to the representation of a JNDI resource in web.xml to enable it to also be the implementation of that JNDI resource.
NamingResourcesImpl
Holds and manages the naming resources defined in the Jakarta EE Naming Context and their associated JNDI context.
NamingResourcesMBean
A ModelMBean implementation for the `org.apache.catalina.deploy.NamingResourcesImpl` component.
NamingResourcesSF
Store server.xml elements Resources at context and GlobalNamingResources
NamingRuleSet
RuleSet for processing the JNDI Enterprise Naming Context resource declaration elements.
NestedCredentialHandler
Nested credential handler that delegates to multiple handlers.
NetMask
A class representing a CIDR netmask.
NetMaskSet
This class maintains a Set of NetMask objects and allows to check if a given IP address is matched by any of the NetMasks, making it easy to create Allow and Deny lists of CIDR networks and hosts.
NewlineReductionServletWriter
This class filters duplicate newlines instructions from the compiler output, and therefore from the runtime JSP.
Nio2Channel
Base class for a SocketChannel wrapper used by the endpoint.
Nio2Endpoint
NIO2 endpoint.
Nio2Endpoint.Nio2SocketWrapper
Nio2Endpoint.SendfileData
SendfileData class.
NioChannel
Base class for a SocketChannel wrapper used by the endpoint.
NioEndpoint
NIO endpoint.
NioEndpoint.NioSocketWrapper
NIO socket wrapper that wraps an NioChannel.
NioEndpoint.PollerEvent
PollerEvent, cacheable object for poller events to avoid GC
NioEndpoint.SendfileData
SendfileData class.
NioReceiver
NIO-based receiver for cluster communication.
NioReceiverMBean
MBean interface for NIO receiver management.
NioReplicationTask
A worker thread class which can drain channels and echo-back the input.
NioSender
This class is NOT thread safe and should never be used with more than one thread at a time.
Node
An internal data representation of a JSP page or a JSP document (XML).
Node.AttributeDirective
Represents an attribute directive
Node.AttributeGenerator
Used as a placeholder for the evaluation code of a custom action attribute (used by the tag plugin machinery only).
Node.ChildInfo
Collected information about child elements.
Node.ChildInfoBase
Base class for nodes that collect child element information.
Node.Comment
Represents a Jsp comment Comments are kept for completeness.
Node.CustomTag
Represents a custom tag
Node.Declaration
Represents a declaration
Node.DoBodyAction
Represents a <jsp:doBody> tag file action
Node.ELExpression
Represents an EL expression.
Node.Expression
Represents an expression.
Node.ForwardAction
Represents a forward action
Node.GetProperty
Represents a getProperty action
Node.IncludeAction
Represents an include action
Node.IncludeDirective
Represents an include directive
Node.InvokeAction
Represents a <jsp:invoke> tag file action
Node.JspAttribute
Represents attributes that can be request time expressions.
Node.JspBody
Represents a JspBody node (<jsp:body>)
Node.JspElement
Represents a <jsp:element>.
Node.JspOutput
Represents a <jsp:output>.
Node.JspRoot
Represents the root of a Jsp document (XML syntax)
Node.JspText
Represents the body of a <jsp:text> element
Node.NamedAttribute
Represents a Named Attribute (<jsp:attribute>)
Node.Nodes
An ordered list of Node, used to represent the body of an element, or a jsp page of jsp document.
Node.PageDirective
Represents a page directive
Node.ParamAction
Represents a param action
Node.Root
Represents the root of a Jsp page or Jsp document
Node.ScriptingElement
Represents an expression, declaration, or scriptlet
Node.Scriptlet
Represents a scriptlet
Node.SetProperty
Represents a setProperty action
Node.TagDirective
Represents a tag directive
Node.TaglibDirective
Represents a custom taglib directive
Node.TemplateText
Represents a template text string
Node.UninterpretedTag
Represents an uninterpreted tag, from a Jsp document
Node.UseBean
Represents a useBean action
Node.VariableDirective
Represents a variable directive
Node.Visitor
A visitor class for visiting the node.
NoDescriptorRegistry
An implementation of the MBean registry that effectively disables MBean registration.
NonBlockingCoordinator
Title: Auto merging leader election algorithm
NonBlockingCoordinator.CoordinationEvent
Represents a coordination event in the election protocol.
NonBlockingCoordinator.CoordinationMessage
Represents a coordination message used in the election protocol.
NonClosingJarInputStream
When using a `JarInputStream` with an XML parser, the stream will be closed by the parser.
NonLoginAuthenticator
An Authenticator and Valve implementation that checks only security constraints not involving user authentication.
NonPipeliningProcessor
Marker interface used to indicate that the `Processor` does not implement pipe-lining of requests (e.g.
NoOpCallStack
CallStack strategy using no-op implementations of all functionality.
NotificationInfo
Internal configuration information for a `Notification` descriptor.
NullRealm
Minimal Realm implementation that always returns null when an attempt is made to validate a username and password.
ObjectCreateRule
Rule implementation that creates a new object and pushes it onto the object stack.
ObjectCreationFactory
Interface for use with `FactoryCreateRule`.
ObjectPool<T>
A pooling simple interface.
ObjectReader
The object reader object is an object used in conjunction with java.nio TCP messages.
ObjectReflectionPropertyInspector
Tool for inspecting and generating reflection-less property setter code.
OneLineFormatter
Provides same information as default log format but on a single line to make it easier to grep the logs.
OpenEjbFactory
Object factory for EJBs.
OpenSSLCertificateVerifier
Certificate verifier that wraps an X509TrustManager for OpenSSL.
OpenSSLCipherConfigurationParser
Class in charge with parsing openSSL expressions to define a list of ciphers.
OpenSSLConf
Represents an OpenSSL configuration containing a list of commands.
OpenSSLConfCmd
Represents an OpenSSL configuration command with a name-value pair.
OpenSSLConfSF
Store OpenSSLConf
OpenSSLContext
OpenSSL implementation of the SSL context.
OpenSSLEngine
Implements a `SSLEngine` using OpenSSL BIO abstractions.
OpenSSLImplementation
OpenSSL implementation of SSLImplementation.
OpenSSLLifecycleListener
Implementation of `LifecycleListener` that will do the global initialization of OpenSSL according to specified configuration parameters.
OpenSSLSessionContext
OpenSSL specific `SSLSessionContext` implementation.
OpenSSLSessionStats
Stats exposed by an OpenSSL session context.
OpenSSLStatus
Holds OpenSSL status without the need to load other classes.
OpenSSLStatus.Name
OpenSSL library variant that has been identified.
OpenSSLUtil
OpenSSL implementation of SSL utility operations.
OperationInfo
Internal configuration information for an `Operation` descriptor.
Optional
Represents an optional value that may or may not be present.
Options
A class to hold all init parameters specific to the JSP engine.
OrderInterceptor
The order interceptor guarantees that messages are received in the same order they were sent.
OrderInterceptor.Counter
Counter for tracking message sequence numbers.
OrderInterceptor.MessageOrder
Represents a message in the ordering queue.
Otherwise
Tag plugin for the JSTL otherwise tag.
Out
Tag plugin for the JSTL out tag.
OutputBuffer
The buffer used by Tomcat response.
OutputBuffer
Output buffer.
OutputFilter
Output filter.
PageContextImpl
Implementation of the PageContext class from the JSP spec.
PageInfo
A repository for various info about the translation unit under compilation.
ParallelNioSender
A sender that sends messages to multiple members in parallel using NIO.
ParallelWebappClassLoader
A class loader that is parallel capable.
Param
Tag plugin for the JSTL `<c:param>` tag.
ParameterInfo
Internal configuration information for a `Parameter` descriptor.
ParameterLimitValve
This is a concrete implementation of `ValveBase` that allows alternative values for the Connector attributes `maxParameterCount`, `maxPartCount` and `maxPartHeaderSize` to be applied to a request.
ParameterMap<K,V>
Implementation of java.util.Map that includes a `locked` property.
ParameterParser
A simple parser intended to parse sequences of name/value pairs.
Parameters
Utility class for parsing and managing HTTP parameters.
ParserController
Controller for the parsing of a JSP page.
PasswdUserDatabase
Concrete implementation of the `UserDatabase` interface that processes the `/etc/passwd` file on a Unix system.
PEMFile
RFC 1421 PEM file containing X509 certificates or private keys.
PeriodicEventListener
Interface for components that want to be notified of periodic events.
PerMessageDeflate
Implementation of the permessage-deflate WebSocket extension as defined in RFC 7692.
PersistentManager
Implementation of the Manager interface that makes use of a Store to swap active Sessions to disk.
PersistentManagerBase
Extends the `ManagerBase` class to implement most of the functionality required by a Manager which supports any kind of persistence, even if only for restarts.
PersistentManagerSF
Stores the server.xml PersistentManager element with nested "Store".
PersistentProviderRegistrations
Utility class for the loading and saving of JASPIC persistent provider registrations.
PersistentProviderRegistrations.Property
Represents a name-value property within a JASPIC provider registration.
PersistentProviderRegistrations.Provider
Represents a single JASPIC provider registration.
PersistentProviderRegistrations.Providers
Container for JASPIC provider registrations loaded from the configuration file.
PersistentValve
Valve that implements per-request session persistence.
PerUserPoolDataSource
A pooling `DataSource` appropriate for deployment within J2EE environment.
PerUserPoolDataSourceFactory
A JNDI ObjectFactory which creates `PerUserPoolDataSource`s.
Pipeline
Interface describing a collection of Valves that should be executed in sequence when the `invoke()` method is invoked.
PojoClassHolder
Holds a POJO class for use as a WebSocket client endpoint.
PojoEndpointBase
Base implementation (client and server have different concrete implementations) of the wrapper that converts a POJO instance into a WebSocket endpoint instance.
PojoEndpointClient
Wrapper class for instances of POJOs annotated with `ClientEndpoint` so they appear as standard `Endpoint` instances.
PojoEndpointServer
Wrapper class for instances of POJOs annotated with `ServerEndpoint` so they appear as standard `Endpoint` instances.
PojoHolder
Holds a POJO instance for use as a WebSocket client endpoint.
PojoMessageHandlerBase<T>
Common implementation code for the POJO message handlers.
PojoMessageHandlerPartialBase<T>
Common implementation code for the POJO partial message handlers.
PojoMessageHandlerPartialBinary
ByteBuffer specific concrete implementation for handling partial messages.
PojoMessageHandlerPartialText
Text specific concrete implementation for handling partial messages.
PojoMessageHandlerWholeBase<T>
Common implementation code for the POJO whole message handlers.
PojoMessageHandlerWholeBinary
ByteBuffer specific concrete implementation for handling whole messages.
PojoMessageHandlerWholePong
PongMessage specific concrete implementation for handling whole messages.
PojoMessageHandlerWholeText
Text specific concrete implementation for handling whole messages.
PojoMethodMapping
For a POJO class annotated with `ServerEndpoint`, an instance of this class creates and caches the method handler, method information and parameter information for the onXXX calls.
PojoPathParam
Stores the parameter type and name for a parameter that needs to be passed to an onXxx method of `Endpoint`.
Pool
Provides access to APR memory pools which are used to manage memory allocations for natively created instances.
PoolableCallableStatement
A `DelegatingCallableStatement` that cooperates with `PoolingConnection` to implement a pool of `CallableStatement`s.
PoolableConnection
A delegating connection that, rather than closing the underlying connection, returns itself to an `ObjectPool` when closed.
PoolableConnectionFactory
A `PooledObjectFactory` that creates `PoolableConnection`s.
PoolableConnectionMXBean
Defines the attributes and methods that will be exposed via JMX for `PoolableConnection` instances.
PoolableManagedConnection
PoolableConnection that unregisters from TransactionRegistry on Connection real destroy.
PoolableManagedConnectionFactory
A `PoolableConnectionFactory` that creates `PoolableManagedConnection`s.
PoolablePreparedStatement<K>
A `DelegatingPreparedStatement` that cooperates with `PoolingConnection` to implement a pool of `PreparedStatement`s.
PoolConfiguration
A list of properties that are configurable for a connection pool.
PooledConnection
Represents a pooled connection and holds a reference to the `Connection` object
PooledConnectionMBean
JMX MBean interface for monitoring pooled connections.
PooledObject<T>
Defines the wrapper that is used to track the additional information, such as state, for the pooled objects.
PooledObjectFactory<T>
An interface defining life-cycle methods for instances to be served by an `ObjectPool`.
PooledObjectState
Provides all possible states of a `PooledObject`.
PooledParallelSender
A pooled sender that uses `ParallelNioSender` instances for parallel message delivery.
PooledParallelSenderMBean
MBean interface for monitoring a PooledParallelSender.
PooledSender
An abstract pooled sender that manages a pool of `DataSender` instances.
PooledSoftReference<T>
Extension of `DefaultPooledObject` to wrap pooled soft references.
PoolExhaustedException
Exception thrown when the connection pool is exhausted and no connections are available.
PoolingConnection
A `DelegatingConnection` that pools `PreparedStatement`s.
PoolingConnection.StatementType
Statement types.
PoolingDataSource<C>
A simple `DataSource` implementation that obtains `Connection`s from the specified `ObjectPool`.
PoolingDriver
A `Driver` implementation that obtains `Connection`s from a registered `ObjectPool`.
PoolProperties
Implementation of `PoolConfiguration` that holds the configuration properties for a connection pool.
PoolProperties.InterceptorDefinition
Definition of a JDBC interceptor with its configuration properties.
PoolProperties.InterceptorProperty
Represents a property for a JDBC interceptor.
PoolUtilities
Utility methods for managing JDBC pool properties.
PoolUtils
This class consists exclusively of static methods that operate on or return ObjectPool or KeyedObjectPool related interfaces.
Priority
HTTP priority header parser as per RFC 9218.
Processor
Common interface for processors of all protocols.
ProgressListener
The `ProgressListener` may be used to display a progress bar or do stuff like that.
PropertiesRoleMappingListener
Implementation of `LifecycleListener` that will populate the context's role mapping from a properties file.
ProtectedFunctionMapper
Maps EL functions to their Java method counterparts.
Protocol
Represents the SSL/TLS protocol versions supported by OpenSSL.
ProtocolException
Used when we need to indicate failure but the (Servlet) API doesn't declare any appropriate exceptions.
ProtocolHandler
Abstract the protocol implementation, including threading, etc.
Proxy
This class represents a front-end httpd server.
ProxyConnection
A ProxyConnection object is the bottom most interceptor that wraps an object of type `PooledConnection`.
ProxyErrorReportValve
Implementation of a Valve that proxies or redirects error reporting to other urls.
PStmtKey
A key uniquely identifying `PreparedStatement`s.
PStmtKeyCPDS
Deprecated.
Use `PStmtKey`.
QueryTimeoutInterceptor
Interceptor that sets a query timeout on every created `Statement`.
QuotedStringTokenizer
Tokenizer that splits input text into tokens, respecting quoted strings (enclosed in double quotes), escape sequences, and comment lines (starting with `#`).
RandomizedTextRewriteMap
Implement a map for the txt: and rnd: mod_rewrite capabilities.
Ranges
Represents the value of an HTTP Range header.
Ranges.Entry
Represents a single range entry with a start and end position.
RateLimiter
Defines the contract for a rate limiter that tracks and limits the number of requests per time window for a given identifier.
RateLimiterBase
Base implementation of `RateLimiter`, provides runtime data maintenance mechanism monitor.
RateLimitFilter
Servlet filter that can help mitigate Denial of Service (DoS) and Brute Force attacks by limiting the number of a requests that are allowed from a single IP address within a time window (also referred to as a time bucket), e.g. 300 Requests per 60 seconds.
ReadBufferOverflowException
Exception thrown when the WebSocket buffer size is insufficient.
Realm
A Realm is a read-only facade for an underlying security realm used to authenticate individual users, and identify the security roles associated with those users.
RealmBase
Simple implementation of Realm that reads an XML file to configure the valid users, passwords, and roles.
RealmBase.AllRolesMode
Defines the mode for handling the `*.roles` special role.
RealmRuleSet
RuleSet for processing the contents of a Realm definition element.
RealmSF
Store server.xml Element Realm
ReceiverBase
Base implementation of a channel receiver that handles TCP connections and provides configuration for socket options, thread pools, and message handling.
Redirect
Tag plugin for the JSTL <c:redirect> tag.
ReferenceCountedJar
This class provides a wrapper around `Jar` that uses reference counting to close and re-create the wrapped `Jar` instance as required.
ReflectionUtil
Utilities for Managing Serialization and Reflection.
Registry
Registry for modeler MBeans.
RegistryMBean
Interface for modeler MBeans.
ReloadTask
Ant task that implements the `/reload` command, supported by the Tomcat manager application.
RemoteAddrFilter
Deprecated.
This Filter will be removed in Tomcat 12 onwards.
RemoteAddrValve
Deprecated.
This Valve will be removed in Tomcat 12 onwards.
RemoteCIDRFilter
A servlet filter that restricts access to resources based on the remote client's IP address or CIDR block.
RemoteCIDRValve
A valve that restricts access based on the remote client's IP address or CIDR block.
RemoteHostFilter
Concrete implementation of `RequestFilter` that filters based on the remote client's host name.
RemoteHostValve
Concrete implementation of `RequestFilterValve` that filters based on the remote client's host name optionally combined with the server connector port number.
RemoteIpFilter
Servlet filter to integrate "X-Forwarded-For" and "X-Forwarded-Proto" HTTP headers.
RemoteIpFilter.XForwardedRequest
Wrapper for `HttpServletRequest` that allows modification of headers, remote address, scheme, and other properties used by the RemoteIpFilter.
RemoteIpValve
Tomcat port of mod_remoteip, this valve replaces the apparent client remote IP address and hostname for the request with the IP address list presented by a proxy or a load balancer via a request headers (e.g.
RemoteProcessException
Message thrown by a sender when USE_SYNC_ACK receives a FAIL_ACK_COMMAND.
Remove
Tag plugin for the JSTL <c:remove> tag.
RepeatableArchive
Ant task to assist with repeatable builds.
ReplicatedContext
Replicated context that supports session replication across cluster nodes.
ReplicatedContext.MultiEnumeration<T>
Enumeration that combines multiple enumerations into one.
ReplicatedContext.ReplApplContext
Application context implementation for replicated contexts.
ReplicatedMap<K,V>
All-to-all replication for a hash map implementation.
ReplicatedMapEntry
For smarter replication, an object can implement this interface to replicate diffs
The replication logic will call the methods in the following order:
`1. if ( entry.isDirty() )
try { 2.`
ReplicatedSessionListener
This is a marker interface used to indicate an implementation of `SessionListener` that should be replicated with the session across the cluster.
ReplicationStream
Custom subclass of `ObjectInputStream` that loads from the class loader for this web application.
ReplicationTransmitter
Transmit message to other cluster members Actual senders are created based on the replicationMode type
ReplicationValve
Valve that triggers session replication across the cluster.
Request
Wrapper object for the Coyote request.
Request
This is a low-level, efficient representation of a server request.
RequestContext
Abstracts access to the request information needed for file uploads.
RequestDumperFilter
Implementation of a Filter that logs interesting contents from the specified Request (before processing) and the corresponding Response (after processing).
RequestFacade
Facade class that wraps a Coyote request object.
RequestFilter
Implementation of a Filter that performs filtering based on comparing the appropriate request property (selected based on which subclass you choose to configure into your Container's pipeline) against the regular expressions configured for this Filter.
RequestFilterValve
Implementation of a Valve that performs filtering based on comparing the appropriate request property (selected based on which subclass you choose to configure into your Container's pipeline) against the regular expressions configured for this Valve.
RequestGroupInfo
JMX artifact to aggregate data from each request processor thread.
RequestInfo
Structure holding the Request and Response objects.
RequestUtil
General purpose request parsing and encoding utility methods.
RequestUtil
Utility methods for HTTP request processing.
ResetAbandonedTimer
Class that resets the abandoned timer on any activity on the Connection or any successful query executions.
ResetAbandonedTimerMBean
MBean interface for the ResetAbandonedTimer connection pool interceptor.
ResizableExecutor
Executor that supports dynamic resizing of the thread pool and queue.
Resolver
Resolver abstract class.
ResolverImpl
Implementation of the Resolver interface for the rewrite valve.
ResourceBase
Representation of a Context element.
ResourceEntry
Resource entry.
ResourceEnvFactory
Object factory for Resources env.
ResourceEnvRef
Represents a reference address to a resource environment.
ResourceFactory
Object factory for Resources.
ResourceLinkFactory
Object factory for resource links.
ResourceLinkRef
Represents a reference address to a resource.
ResourceRef
Represents a reference address to a resource.
ResourceSet<T>
Extended implementation of HashSet that includes a `locked` property.
ResourcesTask
Ant task that implements the `/resources` command, supported by the Tomcat manager application.
Response
Wrapper object for the Coyote response.
Response
A response object holds a message from a responding partner.
Response
Response object.
ResponseFacade
Facade class that wraps a Coyote response object.
ResponseIncludeWrapper
An HttpServletResponseWrapper, used from `SSIServletExternalResolver`.
ResponseUtil
Utility methods for HTTP response handling.
RestCsrfPreventionFilter
Provides basic CSRF protection for REST APIs.
RetryableQueue<T>
A retryable queue interface that extends `BlockingQueue`.
RewriteCond
Rewrite condition.
RewriteCond.Condition
Abstract condition interface.
RewriteCond.LexicalCondition
Lexical comparison condition.
RewriteCond.PatternCondition
Pattern-based condition.
RewriteCond.ResourceCondition
Resource existence condition.
RewriteMap
Interface for user defined lookup/replacement logic that can be defined in a `rewrite.config` file by a `RewriteMap` directive.
RewriteRule
Represents a rewrite rule for URL rewriting.
RewriteValve
Note: Extra caution should be used when adding a Rewrite Rule.
Rfc6265CookieProcessor
A `CookieProcessor` implementation that follows RFC 6265 for cookie parsing and generation.
Role
Abstract representation of a security role, suitable for use in environments like JAAS that want to deal with `Principals`.
RoleMBean
A ModelMBean implementation for the `org.apache.catalina.Role` component.
RpcCallback
The RpcCallback interface is an interface for the Tribes channel to request a response object to a request that came in.
RpcChannel
A channel to handle RPC messaging
RpcChannel.RpcCollector
Class that holds all response.
RpcChannel.RpcCollectorKey
Key used to identify an RPC collector.
RpcMessage
A message used for RPC communication between group members.
RpcMessage.NoRpcChannelReply
A reply message sent when no RPC channel is found for a given RPC ID.
Rule
Concrete implementations of this class implement actions to be taken when a corresponding nested pattern of XML elements has been matched.
Rules
Public interface defining a collection of Rule instances (and corresponding matching patterns) plus an implementation of a matching policy that selects the rules that match a particular pattern of nested elements discovered during parsing.
RulesBase
Default implementation of the `Rules` interface that supports the standard rule matching behavior.
RuleSet
Public interface defining a shorthand means of configuring a complete set of related `Rule` definitions, possibly associated with a particular namespace URI, in one operation.
RxTaskPool
A very simple thread pool class.
RxTaskPool.TaskCreator
Factory interface for creating receive tasks.
SafeForkJoinWorkerThreadFactory
Provides a `ForkJoinPool.ForkJoinWorkerThreadFactory` that provides `ForkJoinWorkerThread`s that won't trigger memory leaks due to retained references to web application class loaders.
SameSiteCookies
Defines the possible values for the SameSite cookie attribute.
SavedRequest
Object that saves the critical information from a request so that form-based authentication can reproduce it once the user has been authenticated.
SavedRequestInputFilter
Input filter responsible for replaying the request body when restoring the saved request after FORM authentication.
ScheduledThreadPoolExecutor
Class which wraps a ScheduledExecutorService, while preventing lifecycle and configuration operations.
SecretKeyCredentialHandler
A credential handler that uses a `SecretKeyFactory` (PBE) to hash credentials.
SecureNio2Channel
Implementation of a secure socket channel for NIO2.
SecureNioChannel
Implementation of a secure socket channel
SecurityCollection
Representation of a web resource collection for a web application's security constraint, as represented in a `<web-resource-collection>` element in the deployment descriptor.
SecurityConstraint
Representation of a security constraint element for a web application, as represented in a `<security-constraint>` element in the deployment descriptor.
SecurityListener
This listener must only be nested within `Server` elements.
SecurityRoleRef
Representation of a security role reference for a web application, as represented in a `<security-role-ref>` element in the deployment descriptor.
SelectorContext
Catalina JNDI Context implementation.
SemaphoreValve
Implementation of a Valve that limits concurrency.
Sender
Interface to send data to proxies.
SenderSF
Factory that generates the configuration store output for a Sender element.
SenderState
Tracks the delivery state of a sender associated with a cluster member.
SendfileDataBase
Base class for sendfile operations.
SendfileKeepAliveState
Defines the keep-alive state of a connection during sendfile processing.
SendfileState
Defines the progress state of a sendfile operation.
SendMailFactory
Factory class that creates a JNDI named javamail MimePartDataSource object which can be used for sending email using SMTP.
SendMessageData
Data about a message send operation.
Server
A `Server` element represents the entire Catalina servlet container.
ServerCookie
Server-side cookie representation.
ServerCookies
This class is not thread-safe.
ServerInfo
Simple utility module to make it easy to plug in the server identifier when integrating Tomcat.
ServerinfoTask
Ant task that implements the `/serverinfo` command supported by the Tomcat manager application.
Service
A Service is a group of one or more Connectors that share a single Container to process their incoming requests.
ServiceBindingPropertySource
A `IntrospectionUtils.PropertySource` that uses Kubernetes service bindings to resolve expressions.
ServiceMBean
JMX MBean wrapper for a `Service` instance.
ServiceRef
Represents a reference web service.
ServletConnectionImpl
Implementation of `ServletConnection` that provides connection metadata such as connection ID, protocol, and security status.
ServletDef
Representation of a servlet definition for a web application, as represented in a `<servlet>` element in the deployment descriptor.
ServletRequestContext
Provides access to the request information needed for a request made to an HTTP servlet.
ServletResponseWrapperInclude
ServletResponseWrapper used by the JSP 'include' action.
ServletWriter
This is what is used to generate servlets.
Session
A Session is the Catalina-internal facade for an `HttpSession` that is used to maintain state information between requests for a particular user of a web application.
SessionConfig
Utility class for managing session configuration.
SessionConfig
Representation of a session configuration element for a web application, as represented in a `<session-config>` element in the deployment descriptor.
SessionEvent
General event for notifying listeners of significant changes on a Session.
SessionIdGenerator
Interface for generating session identifiers.
SessionIdGeneratorBase
Base implementation of `SessionIdGenerator` that manages a pool of `SecureRandom` instances for generating session identifiers.
SessionInitializerFilter
A `Filter` that initializes the `HttpSession` for the `HttpServletRequest` by calling its getSession() method.
SessionListener
Interface defining a listener for significant Session generated events.
SessionMessage
The SessionMessage interface is used when a session has been created, modified, expired in a Tomcat cluster node.
SessionMessageImpl
Session cluster message.
SessionsTask
Ant task that implements the `/sessions` command supported by the Tomcat manager application.
SessionUtils
Utility methods on HttpSessions.
Set
Tag plugin for the JSTL `<c:set>` tag.
SetCharacterEncodingFilter
Example filter that sets the character encoding to be used in parsing the incoming request, either unconditionally or only if the client did not specify a character encoding.
SetNextNamingRule
Rule implementation that calls a method on the (top-1) (parent) object, passing the top object (child) as an argument.
SetNextRule
Rule implementation that calls a method on the (top-1) (parent) object, passing the top object (child) as an argument.
SetPropertiesRule
Rule implementation that sets properties on the object at the top of the stack, based on attributes with corresponding names.
SetPropertiesRule.Listener
Callback interface for objects that need to be notified when all XML attributes have been processed by this rule.
SetPropertyClass
Represents a class in the reflection-based property setter/getter code generation system.
SharedPoolDataSource
A pooling `DataSource` appropriate for deployment within J2EE environment.
SharedPoolDataSourceFactory
A JNDI ObjectFactory which creates `SharedPoolDataSource`s
SignatureScheme
All the signature schemes for TLS 1.3.
SimpleAuthConfigProvider
Basic implementation primarily intended for use when using third-party `ServerAuthModule` implementations that only provide the module.
SimpleCoordinator
A dinky coordinator, just uses a sorted version of the member array.
SimpleElementValue
Represents a simple element value in an annotation, where the value is a primitive type or String referenced by an index in the constant pool.
SimpleInstanceManager
SimpleInstanceManager implements the org.apache.tomcat.InstanceManager interface.
SimpleServerAuthConfig
Basic implementation primarily intended for use when using third-party `ServerAuthModule` implementations that only provide the module.
SimpleServerAuthContext
Basic implementation primarily intended for use when using third-party `ServerAuthModule` implementations that only provide the module.
SimpleTcpCluster
A Cluster implementation using simple multicast.
SingleSignOn
A Valve that supports a "single sign on" user experience, where the security identity of a user who successfully authenticates to one web application is propagated to other web applications in the same security domain.
SingleSignOnEntry
A class that represents entries in the cache of authenticated users.
SingleSignOnListener
Listener that notifies the `SingleSignOn` valve when a session is destroyed or its ID changes.
SingleSignOnSessionKey
Key used by SSO to identify a session.
SizeException
This exception is thrown, if a requests permitted size is exceeded.
SizeLimitExceededException
Thrown to indicate that the request size exceeds the configured maximum.
SlowQueryReport
Slow query report interceptor.
SlowQueryReport.QueryStats
Holds timing and invocation statistics for a single SQL query.
SlowQueryReport.QueryStatsComparator
Compares QueryStats by their lastInvocation value.
SlowQueryReportJmx
JMX-enabled slow query report interceptor.
SlowQueryReportJmxMBean
JMX MBean interface for exposing slow query statistics via JMX.
SmapInput
Represents a mapping entry from a generated Java file line number back to the original JSP source file and line number.
SmapStratum
Represents the line and file mappings associated with a JSR-045 "stratum".
SmapStratum.LineInfo
Represents a single LineSection in an SMAP, associated with a particular stratum.
SmapUtil
Contains static utilities for generating SMAP data based on the current version of Jasper.
Sockaddr
Tomcat Native 1.2.33 and earlier won't initialise unless this class is present.
SocketBufferHandler
Manages read and write `ByteBuffer` instances for a socket connection, handling buffer state transitions between read and write modes.
SocketEvent
Defines events that occur per socket that require further processing by the container.
SocketProcessorBase<S>
Base class for socket processors that handle I/O events on a wrapped socket.
SocketProperties
Properties that can be set in the <Connector> element in server.xml.
SocketWrapperBase<E>
Base class for wrapping a socket connection.
SocketWrapperBase.BlockingMode
Defines the blocking behavior for I/O operations.
SocketWrapperBase.CompletionCheck
Interface for determining whether a completion handler should be invoked.
SocketWrapperBase.CompletionHandlerCall
Defines the possible outcomes for completion handler invocation.
SocketWrapperBase.CompletionState
Represents the completion state of an asynchronous I/O operation.
SoftReferenceObjectPool<T>
A `SoftReference` based `ObjectPool`.
SparseUserDatabase
Abstract base class for a sparse user database implementation.
SparseUserDatabaseMBean
A ModelMBean implementation for the `org.apache.catalina.users.SparseUserDatabase` component.
SpnegoAuthenticator
A SPNEGO authenticator that uses the SPNEGO/Kerberos support built in to Java 6.
SQLExceptionList
An SQLException based on a list of Throwable causes.
SSICommand
The interface that all SSI commands ( SSIEcho, SSIInclude, ...) must implement.
SSIConditional
SSI command that handles all conditional directives.
SSIConditionalState
This class is used by SSIMediator and SSIConditional to keep track of state information necessary to process the nested conditional commands ( if, elif, else, endif ).
SSIConfig
Implements the Server-side #config command.
SSIEcho
Return the result associated with the supplied Server Variable.
SSIExec
Implements the Server-side #exec command.
SSIExternalResolver
Interface used by SSIMediator to talk to the 'outside world' ( usually a servlet ).
SSIFilter
Filter to process SSI requests within a webpage.
SSIFlastmod
Implements the Server-side #flastmod command.
SSIFsize
Implements the Server-side #fsize command.
SSIInclude
Implements the Server-side #include command.
SSIMediator
Allows the different SSICommand implementations to share data/talk to each other.
SSIPrintenv
Implements the Server-side #printenv command.
SSIProcessor
The entry point to SSI processing.
SSIServlet
Servlet to process SSI requests within a webpage.
SSIServletExternalResolver
An implementation of SSIExternalResolver that is used with servlets.
SSIServletExternalResolver.ServletContextAndPath
Holds a servlet context and an associated path.
SSIServletRequestUtil
Utility methods for SSI servlet request handling.
SSISet
Implements the Server-side #set command.
SSIStopProcessingException
Exception used to tell SSIProcessor that it should stop processing SSI commands.
SSL
JNI bindings for OpenSSL SSL functionality.
SSLAuthenticator
An Authenticator and Valve implementation of authentication that utilizes SSL certificates to identify client users.
SSLConf
JNI bindings for OpenSSL SSL_CONF operations.
SslConnectorCiphersTask
Ant task that implements the `/sslConnectorCiphers` command supported by the Tomcat manager application.
SSLContext
JNI bindings for OpenSSL SSL_CTX operations.
SSLContext
This interface is needed to override the default SSLContext class to allow SSL implementation pluggability without having to use JCE.
SSLContext.SNICallBack
Deprecated.
Unused.
SSLHostConfig
Represents the TLS configuration for a virtual host.
SSLHostConfig.CertificateVerification
Certificate verification levels.
SSLHostConfig.Type
SSL configuration type.
SSLHostConfigCertificate
Represents the SSL certificate configuration for a virtual host.
SSLHostConfigCertificate.Type
Defines the types of SSL certificates supported.
SSLHostConfigSF
Store SSLHostConfig
SSLImplementation
Provides a factory and base implementation for the Tomcat specific mechanism that allows alternative SSL/TLS implementations to be used without requiring the implementation of a full JSSE provider.
SSLSessionManager
Defines an interface used to manage SSL sessions.
SSLSupport
Defines an interface to interact with SSL sessions.
SSLUtil
Provides a common interface for `SSLImplementation`s to create the necessary JSSE implementation objects for TLS connections created via the JSSE API.
SSLUtil.ProtocolInfo
Optional interface that can be implemented by `SSLEngine`s to indicate that they support ALPN and can provide the protocol agreed with the client.
SSLUtilBase
Common base class for `SSLUtil` implementations.
SSLValve
When using mod_proxy_http, the client SSL information is not included in the protocol (unlike mod_jk and mod_proxy_ajp).
StandardContext
Standard implementation of the Context interface.
StandardContextSF
Store server.xml Context element with all children Store all context at server.xml Store existing app.xml context a conf/enginename/hostname/app.xml Store with backup
StandardEngine
Standard implementation of the Engine interface.
StandardEngine.AccessLogListener
Listener that manages access log configuration for engine, host, and context lifecycle events.
StandardEngine.NoopAccessLog
No-op implementation of AccessLog used as a placeholder when access logging is not configured.
StandardEngineSF
Store server.xml Element Engine
StandardHost
Standard implementation of the Host interface.
StandardHostSF
Store server.xml Element Host
StandardJarScanFilter
Standard implementation of JarScanFilter that provides configuration for JAR scanning filters.
StandardJarScanner
The default `JarScanner` implementation scans the WEB-INF/lib directory followed by the provided classloader and then works up the classloader hierarchy.
StandardManager
Standard implementation of the Manager interface that provides simple session persistence across restarts of this component (such as when the entire server is shut down and restarted, or when a particular web application is reloaded).
StandardPipeline
Standard implementation of a processing Pipeline that will invoke a series of Valves that have been configured to be called in order.
StandardRoot
Provides the resources implementation for a web application.
StandardServer
Standard implementation of the Server interface, available for use (but not required) when deploying and starting Catalina.
StandardServerSF
Store server.xml Server element and children ( Listener,GlobalNamingResource,Service)
StandardService
Standard implementation of the `Service` interface.
StandardServiceSF
Store server.xml Element Service and all children
StandardSession
Standard implementation of the Session interface.
StandardSessionAccessor
Accessor for a StandardSession object.
StandardSessionFacade
Facade for the StandardSession object.
StandardSessionIdGenerator
Standard implementation of `SessionIdGenerator` that generates session identifiers using a pool of `SecureRandom` instances.
StandardThreadExecutor
Standard implementation of an `Executor` based on a Java thread pool.
StandardVirtualThreadExecutor
An executor that uses a new virtual thread for each task.
StandardWrapper
Standard implementation of the Wrapper interface that represents an individual servlet definition.
StandardWrapperFacade
Facade for the StandardWrapper object.
StartTask
Ant task that implements the `/start` command, supported by the Tomcat manager application.
StatementCache
Interceptor that caches `PreparedStatement` and/or `CallableStatement` instances on a connection.
StatementCacheMBean
MBean interface for monitoring the statement cache.
StatementDecoratorInterceptor
Implementation of JdbcInterceptor that proxies resultSets and statements.
StatementDecoratorInterceptor.ResultSetProxy
Invocation handler that proxies ResultSet instances.
StatementFacade
Facade that creates statement and result set proxies.
StatementFinalizer
Keeps track of statements associated with a connection and invokes close upon `Connection.close()` Useful for applications that don't close the associated statements after being done with a connection.
StaticMember
Static member representation for cluster membership.
StaticMembershipInterceptor
Channel interceptor that manages static membership for a cluster.
StaticMembershipInterceptorMBean
MBean interface for the static membership interceptor.
StaticMembershipProvider
Provider that manages static membership for a cluster.
StaticMembershipProvider.MemberMessage
Message sent between membership providers to coordinate membership state.
StaticMembershipService
Service that manages static membership for a cluster channel.
StaticMembershipServiceMBean
MBean interface for the static membership service.
StatusManagerServlet
This servlet will display a complete status of the HTTP/1.1 connector.
StatusTransformer
This is a refactoring of the servlet to externalize the output into a simple class.
StopPooledThreadException
A custom `RuntimeException` thrown by the `ThreadPoolExecutor` to signal that the thread should be disposed of.
StopTask
Ant task that implements the `/stop` command, supported by the Tomcat manager application.
Store
A Store is the abstraction of a Catalina component that provides persistent storage and loading of Sessions and their associated user data.
StoreAppender
StoreAppends generate really the xml tag elements
StoreBase
Abstract implementation of the `Store` interface to support most of the functionality required by a `Store`.
StoreConfig
Store Server/Service/Host/Context at file or PrintWriter.
StoreConfigLifecycleListener
Loads and registers a StoreConfig MBean with the name Catalina:type=StoreConfig.
StoreContextAppender
store StandardContext Attributes ...
StoreDescription
Bean of a StoreDescription
StoreFactoryBase
StoreFactory saves special elements.
StoreFactoryRule
Rule that creates a new `IStoreFactory` instance, and associates it with the top object on the stack (which must implement `IStoreFactory`).
StoreFileMover
Move server.xml or context.xml as backup
StoreLoader
XML Format
StoreManager
PersistentManager would have been a better name but that would have clashed with the implementation name.
StoreRegistry
Central StoreRegistry for all server.xml elements
Stream
A stream of elements supporting sequential operations such as filter, map, reduce, and various terminal operations.
StreamELResolverImpl
EL resolver that provides stream operations on arrays and collections through the `.stream` method.
StreamProvider
Provides the ability to open input streams to remote URLs.
Streams
Utility class for working with streams.
Strftime
Converts dates to strings using the same format specifiers as strftime Notes: This does not mimic strftime perfectly.
StringCache
This class implements a String cache for ByteChunk and CharChunk.
StringCache.ByteEntry
Cache entry for byte chunk to String mapping.
StringCache.CharEntry
Cache entry for char chunk to String mapping.
StringInterpreter
Defines the interface for the String interpreter.
StringInterpreterEnum
Provides an optimised conversion of string values to Enums.
StringInterpreterFactory
Provides `StringInterpreter` instances for JSP compilation.
StringInterpreterFactory.DefaultStringInterpreter
Default implementation of StringInterpreter that handles standard type conversions.
StringManager
An internationalization / localization helper class which reduces the bother of handling ResourceBundles and takes care of the common cases of message formatting which otherwise require the creation of Object arrays and such.
StringManager
An internationalization / localization helper class which reduces the bother of handling ResourceBundles and takes care of the common cases of message formatting which otherwise require the creation of Object arrays and such.
StringManager
An internationalization / localization helper class which reduces the bother of handling ResourceBundles and takes care of the common cases of message formatting which otherwise require the creation of Object arrays and such.
StringUtil
Utility methods for string manipulation in Catalina.
StringUtils
Utility methods to build a separated list from a given set (not java.util.Set) of inputs and return that list as a string or append it to an existing StringBuilder.
StructuredField
Parsing of structured fields as per RFC 8941.
StuckThreadDetectionValve
This valve allows to detect requests that take a long time to process, which might indicate that the thread that is processing it is stuck.
Substitution
Represents a URL substitution pattern for rewrite rules.
Substitution.RewriteCondBackReferenceElement
Substitution element that produces a back-reference to a rewrite condition group.
Substitution.ServerVariableElement
Substitution element that resolves a server variable.
Substitution.ServerVariableEnvElement
Substitution element that resolves an environment variable.
Substitution.ServerVariableHttpElement
Substitution element that resolves an HTTP header variable.
Substitution.ServerVariableSslElement
Substitution element that resolves an SSL variable.
Substitution.StaticElement
Substitution element that produces a static string value.
Substitution.SubstitutionElement
Abstract base class for individual substitution elements.
SwallowedExceptionListener
Pools that unavoidably swallow exceptions may be configured with an instance of this listener so the user may receive notification of when this happens.
SwallowedExceptionLogger
Class for logging swallowed exceptions.
SynchronizedQueue<T>
This is intended as a (mostly) GC-free alternative to `ConcurrentLinkedQueue` when the requirement is to create an unbounded queue with no requirement to shrink the queue.
SynchronizedStack<T>
This is intended as a (mostly) GC-free alternative to `Stack` when the requirement is to create a pool of re-usable objects with no requirement to shrink the pool.
SystemLogHandler
This helper class may be used to do sophisticated redirection of System.out and System.err on a per Thread basis.
SystemPropertySource
A `IntrospectionUtils.PropertySource` that uses system properties to resolve expressions.
TagConstants
Constants for JSP tag action names and URIs used during compilation.
TagFileProcessor
1.
TagFileXml
Bare-bone model of a tag file loaded from a TLD.
TagHandlerPool
Pool of tag handlers that can be reused.
TaglibDescriptorImpl
Implementation of TaglibDescriptor that holds the location and URI of a tag library.
TaglibXml
Common representation of a Tag Library Descriptor (TLD) XML file.
TagPlugin
This interface is to be implemented by the plugin author, to supply an alternate implementation of the tag handlers.
TagPluginContext
This interface allows the plugin author to make inquiries about the properties of the current tag, and to use Jasper resources to generate direct Java codes in place of tag handler invocations.
TagPluginManager
Manages tag plugin optimizations.
TagPluginParser
Parser for Tag Plugin descriptors.
TagXml
Model of a tag define in a tag library descriptor.
TaskQueue
As task queue specifically designed to run with a thread pool executor.
TaskThread
A Thread implementation that records the time at which it was created.
TaskThreadFactory
Simple task thread factory to use to create threads for an executor implementation.
TcclThreadFactory
ThreadFactory implementation that creates threads with the thread context class loader set to the class loader that loaded this factory.
TcpFailureDetector
The TcpFailureDetector is a useful interceptor that adds reliability to the membership layer.
TcpFailureDetectorMBean
MBean interface for managing the TcpFailureDetector interceptor.
TcpPingInterceptor
Sends periodic TCP pings to cluster members for health monitoring.
TcpPingInterceptorMBean
MBean interface for managing the TcpPingInterceptor.
TcpSender
TCP-based sender for sending heartbeat messages to proxy servers.
TE
Represents a Transfer-Encoding value with optional parameters and quality factor.
TextOptimizer
Provides optimizations for text nodes in JSP pages.
ThreadBindingListener
Callback for establishing naming association when entering the application scope.
ThreaddumpTask
Ant task that implements the `/threaddump` command supported by the Tomcat manager application.
ThreadLocalLeakPreventionListener
A `LifecycleListener` that triggers the renewal of threads in Executor pools when a `Context` is being stopped to avoid thread-local related memory leaks.
ThreadPoolExecutor
An `ExecutorService` that executes each submitted task using one of possibly several pooled threads, normally configured using `Executors` factory methods.
ThreadPoolExecutor.AbortPolicy
A handler for rejected tasks that throws a `RejectedExecutionException`.
ThreadPoolExecutor.CallerRunsPolicy
A handler for rejected tasks that runs the rejected task directly in the calling thread of the `execute` method, unless the executor has been shut down, in which case the task is discarded.
ThreadPoolExecutor.DiscardOldestPolicy
A handler for rejected tasks that discards the oldest unhandled request and then retries `execute`, unless the executor is shut down, in which case the task is discarded.
ThreadPoolExecutor.DiscardPolicy
A handler for rejected tasks that silently discards the rejected task.
ThreadPoolExecutor.RejectedExecutionHandler
Handler for tasks that cannot be executed by the thread pool.
ThresholdingOutputStream
An output stream which triggers an event when a specified number of bytes of data have been written to it.
ThroughputInterceptor
Interceptor that measures and reports message throughput statistics.
ThroughputInterceptorMBean
MBean interface for managing the ThroughputInterceptor.
ThrowableCallStack
CallStack strategy that uses the stack trace from a `Throwable`.
TimeBucketCounter
A fast counter that optimizes efficiency at the expense of approximate bucket indexing.
TimeBucketCounterBase
This class maintains a thread safe hash map that has timestamp-based buckets followed by a string for a key, and a counter for an integer value.
TldCache
This class caches parsed instances of TLD files to remove the need for the same TLD to be parsed for each JSP that references it.
TldParser
Parses a Tag Library Descriptor.
TldPreScanned
TLD scanner that processes only pre-scanned TLD URLs, skipping JAR scanning.
TldResourcePath
A TLD Resource Path as defined in JSP 7.3.2.
TldRuleSet
Digester rule set for parsing Tag Library Descriptor files.
TldRuleSet.Attribute
Intermediate representation of a tag attribute during TLD parsing.
TldRuleSet.Variable
Intermediate representation of a tag variable during TLD parsing.
TldScanner
Scans for and loads Tag Library Descriptors contained in a web application.
TLSCertificateReloadListener
A `LifecycleListener` that may be used to monitor the expiration dates of TLS certificates and trigger automatic reloading of the TLS configuration a set number of days before the TLS certificate expires.
TLSClientHelloExtractor
This class extracts the SNI host name and ALPN protocols from a TLS client-hello message.
TLSClientHelloExtractor.ExtractorResult
Possible results of TLS ClientHello extraction.
TLSUtil
Utility methods for TLS-related operations.
TokenList
Utility class for parsing and manipulating HTTP token lists.
TokenStreamProvider
Stream provider that authenticates using a bearer token.
Tomcat
Minimal tomcat starter for embedding/unit tests.
Tomcat.DefaultWebXmlListener
Fix reload - required if reloading and using programmatic configuration.
Tomcat.ExistingStandardWrapper
Helper class for wrapping existing servlets.
Tomcat.FixContextListener
Fix startup sequence - required if you don't use web.xml.
TomcatCSS
Provides the default Tomcat CSS styles.
TomcatJarInputStream
The purpose of this subclass is to obtain references to the JarEntry objects for META-INF/ and META-INF/MANIFEST.MF that are otherwise swallowed by the JarInputStream implementation.
TomcatPrincipal
Defines additional methods implemented by `Principal`s created by Tomcat's standard `Realm` implementations.
TomcatURLStreamHandlerFactory
Factory for URL stream handlers that supports the war and classpath protocols.
Tool
General purpose wrapper for command line tools that should execute in an environment with the common class loader environment set up by Catalina.
TooManyActiveSessionsException
An exception that indicates the maximum number of active sessions has been reached and the server is refusing to create any new sessions.
ToStringUtil
Utility class used to help generate return values for calls to `Object.toString()`.
ToStringUtil
Utility class used to provide String representations of objects.
TrackedUse
Allows pooled objects to make information available about when and how they were used available to the object pool.
TrackedWebResource
Represents a web resource that tracks its creation source for leak detection.
TransactionContext
TransactionContext represents the association between a single XAConnectionFactory and a Transaction.
TransactionContextListener
A listener for transaction completion events.
TransactionFactory
Object factory for User transactions.
TransactionRef
Represents a reference address to a transaction.
TransactionRegistry
TransactionRegistry tracks Connections and XAResources in a transacted environment for a single XAConnectionFactory.
Transformation
The internal representation of the transformation that a WebSocket extension performs on a message.
TransformationBuilder
Builder for creating WebSocket transformations.
TransformationFactory
Factory for managing WebSocket transformation builders.
TransformationResult
Possible results of a WebSocket frame transformation operation.
TrapException
Interceptor that traps any unhandled exception types and throws an exception that has been declared by the method called, or throw an SQLException if it is declared.
TrimSpacesOption
Options for the trimDirectiveWhitespaces JSP attribute.
TwoPhaseCommitInterceptor
Two-phase commit interceptor that ensures reliable message delivery.
TwoPhaseCommitInterceptor.MapEntry
Entry that holds a message, its ID, and the timestamp of arrival.
Txt2Html
Ant task to convert a given set of files from Text to HTML.
UDecoder
All URL decoding happens here.
UEncoder
Efficient implementation of a UTF-8 encoder.
UEncoder.SafeCharsSet
Pre-defined sets of safe characters for URL encoding.
UndeployMessage
Cluster message that indicates an application has been undeployed.
UndeployTask
Ant task that implements the `/undeploy` command, supported by the Tomcat manager application.
UniqueAttributesImpl
Wraps the default attributes implementation and ensures that each attribute has a unique qname as required by the JSP specification.
UniqueId
Represents a globally unique Id.
Upgrade
Represents an HTTP Upgrade protocol value with optional version.
UpgradeApplicationBufferHandler
Trivial implementation of `ApplicationBufferHandler` to support saving of HTTP request bodies during an HTTP/1.1 upgrade.
UpgradeGroupInfo
This aggregates the data collected from each UpgradeInfo instance.
UpgradeInfo
Structure to hold statistical information about connections that have been established using the HTTP/1.1 upgrade mechanism.
UpgradeProcessorBase
Base class for HTTP upgrade processors.
UpgradeProcessorExternal
Upgrade processor for external (Servlet-based) upgrade handlers.
UpgradeProcessorInternal
Upgrade processor for internal (Coyote-based) upgrade handlers.
UpgradeProtocol
Protocol handler for HTTP upgrade connections.
UpgradeServletInputStream
Input stream for an HTTP upgraded connection.
UpgradeServletOutputStream
Output stream for an HTTP upgraded connection.
UpgradeToken
Token used during the upgrade process.
UpgradeUtil
Utility methods for handling WebSocket upgrade requests.
UploadContext
Enhanced access to the request information needed for file uploads, which fixes the Content Length data access in `RequestContext`.
UriTemplate
Extracts path parameters from URIs used to create web socket connections using the URI template defined for the associated Endpoint.
UriUtil
Utility class for working with URIs and URLs.
Url
Tag plugin that optimizes JSTL <c:url> tag handling.
URLEncoder
This class is very similar to the java.net.URLEncoder class.
UrlJar
Implementation of `Jar` that is optimised for non-file based JAR URLs.
UsageTracking<T>
This interface may be implemented by an object pool to enable clients (primarily those clients that wrap pools to provide pools with extended features) to provide additional information to the pool relating to object using allowing more informed decisions and reporting to be made regarding abandoned objects.
User
Abstract representation of a user in a `UserDatabase`.
UserConfig
Startup event listener for a Host that configures Contexts (web applications) for all defined "users" who have a web application in a directory with the specified name in their home directories.
UserDatabase
Abstraction of the set of users defined by the operating system on the current server platform.
UserDatabase
Abstract representation of a database of `User`s and `Group`s that can be maintained by an application, along with definitions of corresponding `Role`s, and referenced by a `Realm` for authentication and access control.
UserDatabaseRealm
Implementation of `Realm` that is based on an implementation of `UserDatabase` made available through the JNDI resources configured for this instance of Catalina.
UserDatabaseRealm.UserDatabasePrincipal
Principal implementation backed by a live `UserDatabase`.
UserDataHelper
This helper class assists with the logging associated with invalid input data.
UserDataHelper.Mode
Log mode for the next log message.
UserMBean
A ModelMBean implementation for the `org.apache.catalina.User` component.
Utf8Encoder
Encodes characters as bytes using UTF-8.
Util
Util contains some often used consts, static methods and embedded class to support the JSTL tag plugin.
Util
Utility class for modeler operations.
Util
Utility class for internal use only within the `org.apache.tomcat.websocket` package.
Util.DecoderMatch
Holds the result of matching decoders against a target type.
Util.ImportResponseWrapper
Wraps responses to allow us to retrieve results as Strings.
Utils
Utility class for translation operations.
Utils
Utility class for build operations.
Utils
Utility methods.
UUIDGenerator
Simple generation of a UUID.
Validation
Utility class for validation operations related to EL identifiers.
Validator
Interface to be implemented by custom validator classes.
ValidatorTask
Task for validating a web application deployment descriptor, using XML schema validation.
ValidatorXml
Model of a Tag Library Validator from the XML descriptor.
ValueExpressionImpl
An `Expression` that can get or set a value.
ValueExpressionLiteral
A literal value expression that represents a constant value.
Valve
A Valve is a request processing component associated with a particular Container.
ValveBase
Convenience base class for implementations of the Valve interface.
VariableMapperFactory
Factory for creating variable mappers that track variable resolutions.
VariableMapperImpl
Implementation of VariableMapper that stores variables in a map.
VerbatimFormatter
Outputs just the log message with no additional elements and no escaping.
VersionLoggerListener
Logs version information on startup.
VirtualResource
A virtual resource that represents a directory entry created on-the-fly.
VirtualThreadExecutor
An executor that uses a new virtual thread for each task.
VminfoTask
Ant task that implements the `/vminfo` command supported by the Tomcat manager application.
VoidInputFilter
Void input filter, which returns -1 when attempting a read.
VoidOutputFilter
Void output filter, which silently swallows bytes written.
WarResource
Represents a single resource (file or directory) that is located within a WAR.
WarResourceSet
Represents a `WebResourceSet` based on a WAR file.
WarURLConnection
URL connection for WAR resources that wraps a JAR URL connection.
WarWatcher
The WarWatcher watches the deployDir for changes made to the directory (adding new WAR files->deploy or remove WAR files->undeploy) and notifies a listener of the changes made.
WarWatcher.WarFilter
File name filter for war files
WarWatcher.WarInfo
File information on existing WAR files
WatchedResourceSF
Store factory for watched resources in a StandardContext.
WebAnnotationSet
AnnotationSet for processing the annotations of the web application classes (`/WEB-INF/classes` and `/WEB-INF/lib`).
WebappClassLoader
Standard web application class loader.
WebappClassLoaderBase
Specialized web application class loader.
WebappClassLoaderBase.PrivilegedGetClassLoader
WebappLoader
Classloader implementation which is specialized for handling web applications in the most efficient way, while being Catalina aware (all accesses to resources are made through `WebResourceRoot`).
WebappProperties
An interface intended for use by class loaders associated with a web application that enables them to provide additional information to JULI about the web application with which they are associated.
WebappServiceLoader<T>
A variation of Java's JAR ServiceLoader that respects exclusion rules for web applications.
WebdavIfHeader
The `IfHeader` class represents the state lists defined through the HTTP If header, which is specified in RFC 2518 as follows :
WebdavServlet
This servlet adds support for WebDAV level 3.
WebdavServlet.MemoryPropertyStore
Default property store, which provides memory storage without persistence.
WebdavServlet.PropertyStore
Handling of dead properties on resources.
WebdavServlet.PropertyUpdateType
Type of property update in a PROPPATCH.
WebdavServlet.PropfindType
Type of PROPFIND request.
WebdavServlet.ProppatchOperation
Represents a PROPPATCH sub operation to be performed.
WebResource
Represents a file or directory within a web application.
WebResourceLockSet
Interface implemented by `WebResourceSet` implementations that wish to provide locking functionality.
WebResourceLockSet.ResourceLock
Deprecated.
Unused.
WebResourceRoot
Represents the complete set of resources for a web application.
WebResourceRoot.ArchiveIndexStrategy
Strategies for archive indexing.
WebResourceRoot.CacheStrategy
Provides a mechanism to modify the caching behaviour.
WebResourceRoot.ResourceSetType
Types of resource sets in a WebResourceRoot.
WebResourceRootSF
Generate Resources element
WebResourceSet
Represents a set of resources that are part of a web application.
WebRuleSet
RuleSet for processing the contents of a web application deployment descriptor (`/WEB-INF/web.xml`) resource.
WebXml
Representation of common elements of web.xml and web-fragment.xml.
WebXmlParser
Parser for web.xml and web-fragment.xml deployment descriptors.
When
Tag plugin for the `<c:when>` JSTL tag.
WrappedMessageHandler
Interface for message handlers that wrap another message handler.
Wrapper
A Wrapper is a Container that represents an individual servlet definition from the deployment descriptor of the web application.
WrapperLifecycleSF
Store factory for wrapper lifecycle listeners.
WrapperListenerSF
Store factory for wrapper listeners.
WrapperMappingInfo
Encapsulates information used to register a Wrapper mapping.
WriteBuffer
Provides an expandable set of buffers for writes.
WriteBuffer.Sink
Interface implemented by clients of the WriteBuffer to enable data to be written back out from the buffer.
WsContainerProvider
WebSocket container provider for Tomcat.
WsContextListener
In normal usage, this `ServletContextListener` does not need to be explicitly configured as the `WsSci` performs all the necessary bootstrap and installs this listener in the `ServletContext`.
WsExtension
Implementation of WebSocket extension.
WsExtensionParameter
Implementation of WebSocket extension parameter.
WsFilter
Handles the initial HTTP connection for WebSocket connections.
WsFrameBase
Takes the ServletInputStream, processes the WebSocket frames it contains and extracts the messages.
WsFrameBase.ReadState
WAITING - not suspended Server case: waiting for a notification that data is ready to be read from the socket, the socket is registered to the poller Client case: data has been read from the socket and is waiting for data to be processed PROCESSING - not suspended Server case: reading from the socket and processing the data Client case: processing the data if such has already been read and more data will be read from the socket SUSPENDING_WAIT - suspended, a call to suspend() was made while in WAITING state.
WsFrameClient
WebSocket frame handler for client connections.
WsFrameServer
WebSocket frame handler for server connections.
WsHandshakeRequest
Represents the request that this session was opened under.
WsHandshakeResponse
Represents the response to a WebSocket handshake.
WsHttpUpgradeHandler
Servlet 3.1 HTTP upgrade handler for WebSocket connections.
WsIOException
Allows the WebSocket implementation to throw an `IOException` that includes a `CloseReason` specific to the error that can be passed back to the client.
WsMappingResult
Result of WebSocket endpoint mapping, containing the configured endpoint and path parameters.
WsPongMessage
WebSocket pong message containing application data.
WsRemoteEndpointAsync
Asynchronous remote endpoint for sending WebSocket messages.
WsRemoteEndpointBase
Base class for WebSocket remote endpoints.
WsRemoteEndpointBasic
Synchronous (basic) remote endpoint for sending WebSocket messages.
WsRemoteEndpointImplBase
Base implementation of a WebSocket remote endpoint.
WsRemoteEndpointImplClient
Client-side implementation of a WebSocket remote endpoint.
WsRemoteEndpointImplServer
This is the server side `RemoteEndpoint` implementation - i.e. what the server uses to send data to the client.
WsSci
Registers an interest in any class that is annotated with `ServerEndpoint` so that Endpoint can be published via the WebSocket server.
WsServerContainer
Provides a per class loader (i.e. per web application) instance of a ServerContainer.
WsSession
Implementation of a WebSocket session.
WsSessionListener
Listener for HTTP session events to manage authenticated WebSocket sessions.
WsWebSocketContainer
Client-side WebSocket container implementation.
WsWriteTimeout
Provides timeouts for asynchronous web socket writes.
X509SubjectDnRetriever
An X509UsernameRetriever that returns a certificate's entire SubjectDN as the username.
X509UsernameRetriever
Provides an interface for retrieving a username from an X509Certificate.
XAConnectionFactory
XAConnectionFactory is an extension of ConnectionFactory used to create connections in a transaction managed environment.
XADataSource
XA-enabled data source for distributed transaction support.
XByteBuffer
The XByteBuffer provides a dual functionality.
XmlEncodingBase
Base class for those elements that need to track the encoding used in the source XML.
XmlErrorHandler
SAX error handler that collects warnings and errors for later processing.
XmlIdentifiers
Defines constants for well-known Public and System identifiers documented by the Servlet and JSP specifications.
XMLWriter
XMLWriter helper class. writeText is the only method in the class doing XML escaping.