All Classes and Interfaces
Class
Description
A thing which can have named attachments.
Handler responsible for checking of confidentiality is required for the requested resource and if so rejecting the request
and redirecting to a secure address.
A channel which writes a fixed amount of data.
AbstractFramedChannel<C extends AbstractFramedChannel<C,R,S>,R extends AbstractFramedStreamSourceChannel<C,R,S>,S extends AbstractFramedStreamSinkChannel<C,R,S>>
A
ConnectedChannel which can be used to send and receive Frames.AbstractFramedStreamSinkChannel<C extends AbstractFramedChannel<C,R,S>,R extends AbstractFramedStreamSourceChannel<C,R,S>,S extends AbstractFramedStreamSinkChannel<C,R,S>>
Framed Stream Sink Channel.
Utility class to ease the implementation of framed protocols.
Interface that is called when a frame event takes place.
AbstractFramedStreamSourceChannel<C extends AbstractFramedChannel<C,R,S>,R extends AbstractFramedStreamSourceChannel<C,R,S>,S extends AbstractFramedStreamSinkChannel<C,R,S>>
Source channel, used to receive framed messages.
HTTP2 stream source channel
A receive listener that performs a callback when it receives a message
A base class for
SecurityContext implementations predominantly focusing on the notification handling allowing the
specific implementation for focus on authentication.To reduce allocations we use a custom linked list data structure
Base class responsible for associating the
SecurityContext instance with the current request.Handler that can accept or reject a request based on an attribute of the remote peer
todo: should we support non-regex values for performance reasons?
Access log handler.
Interface that is used by the access log handler to send data to the log file manager.
Representation of an account, most likely a user account.
AJP client side channel.
AJP stream sink channel that corresponds to a request send from the load balancer to the backend
A server-side AJP connection.
Underlying AJP request channel.
An attachment that provides information about the current content encoding that will be chosen for the response
Handler that whitelists certain HTTP methods.
ALPN provides an API to applications that want to make use of the
Application Layer Protocol Negotiation.The client-side provider interface that applications must
implement to interact with the negotiation of the protocol.
Base, empty, interface for providers.
The server-side provider interface that applications must
implement to interact with the negotiation of the protocol.
SSLEngine wrapper that provides some super hacky ALPN support on JDK8.
SSLEngine that will limit the cipher selection to HTTP/2 suitable protocols if the client is offering h2 as an option.
Open listener adaptor for ALPN connections
Interface that allows for ALPN providers to be dynamically selected.
A thing which can have named attachments.
Handler that adds an attachment to the request
An immutable, type-safe object attachment key.
Interface that represents a persistent authenticated session.
This is the final
HttpHandler in the security chain, it's purpose is to act as a barrier at the end of the chain to
ensure authenticate is called after the mechanisms have been associated with the context and the constraint checked.Handler responsible for checking the constraints for the current request and marking authentication as required if
applicable.
Enumeration of tokens expected in a HTTP Digest 'Authentication-Info' header.
The interface to be implemented by a single authentication mechanism.
The AuthenticationOutcome is used by an AuthenticationMechanism to indicate the outcome of the call to authenticate, the
overall authentication process will then used this along with the current AuthenticationState to decide how to proceed
with the current request.
Simple class to wrap the result of requesting a mechanism sends it's challenge.
An Undertow
SecurityContext that uses Undertow AuthenticationMechanism
instances for authentication.Factory for authentication mechanisms.
Authentication handler that adds one or more authentication
mechanisms to the security context
Enumeration to indicate the authentication mode in use.
Predicate that returns true if authentication is required.
Exception that is thrown when bad request is detected
The mod_cluster balancer config.
The authentication handler responsible for BASIC authentication as described by RFC2617
Basic SSL session information.
OutputStream implementation which buffers all the data until BinaryOutputStream.close() is called and then will
try to send it in a blocking fashion with the provided StreamSinkFrameChannel.A
HttpHandler that initiates a blocking request.An interface that provides the input and output streams for blocking HTTP requests.
BlockingReadTimeoutHandler allows configurable blocking I/O timeouts
for read operations within an exchange.A sender that uses an output stream.
BlockingTimeoutHandler allows configurable blocking I/O timeouts for write
operations within an exchange.
A buffered binary message.
A buffered text message.
Represents an output stream that can write byte buffers
directly.
Callback that allows the bytes read from or written to a stream to be tracked
A pool of byte buffers
Represents a byte range for a range request
Handler for Range requests.
The bytes sent
HttpHandler responsible for setting up the AuthenticatedSessionManager for cached authentications and
registering a NotificationReceiver to receive the security notifications.An
AuthenticationMechanism which uses any cached AuthenticatedSessionManager.AuthenticatedSessions.Handler that attaches a cache to the exchange, a handler can query this cache to see if the
cache has a cached copy of the content, and if so have the cache serve this content automatically.
Utility class for dealing with certificates
Handler wrapper that chains several handler wrappers together.
An HTTP request handler which upgrades the HTTP request and hands it off as a socket to any XNIO consumer.
Channel that implements HTTP chunked transfer coding.
Channel to de-chunkify data
The Client Cert based authentication mechanism.
A client connection.
A client connection provider.
A client request.
A client response.
Returns statistics about the Undertow client connection
A close message
Channel exception handler that closes the channel, logs a debug level
message and closes arbitrary other resources.
Exchange attribute that represents a combination of attributes that should be merged into a single string.
A concurrent deque that allows direct item removal without traversal.
ConduitFactory<C extends org.xnio.conduits.Conduit>
ConduitListener<T extends org.xnio.conduits.Conduit>
ConduitWrapper<T extends org.xnio.conduits.Conduit>
Interface that provides a means of wrapping a
Conduit.Handler that pushes resources based on a provided URL
Handlers HTTP CONNECT requests, allowing the server to act as a forward proxy.
Exception that represents a connection error
The connection pool error handler is intended to be used per node and will therefore be shared across I/O threads.
Counting error handler, this only propagates the state to the delegate handler after reaching a given limit.
Manager that controls the behaviour of a
ProxyConnectionPoolSSL session information that is read directly from the SSL session of the
XNIO connection
This class provides the connector part of the
HttpServerExchange API.Connector level statistics
Exchange attribute that represents a fixed value
Returns true if the request header is present and contains one of the strings to match.
A resource that has been pre-compressed
Class that provides a way of serving pre-encoded resources.
Callback class that provides a notification of a HTTP 100 Continue response in the client.
A HTTP cookie.
A cookie
Class that contains utility methods for dealing with cookies.
A basic copy on write map.
Representation of a users Credential.
Deprecated.
The current time
Utility for parsing and generating dates
Conduit that saves all the data that is written through it and can dump it to the console
Conduit that saves all the data that is written through it and can dump it to the console
Log Receiver that stores logs in a directory under the specified file name, and rotates them after
midnight.
A byte buffer pool that supports reference counted pools.
A default callback implementation that simply ends the exchange
A resource supplier that just delegates directly to a resource manager
Listener interface for default response handlers.
Content coding for 'deflate'
Channel that handles deflate compression
An open listener that handles being delegated to, e.g.
Stream sink channel.
A stream source channel that can be marked as detached.
Enumeration of the supported digest algorithms.
HttpHandler to handle HTTP Digest authentication, both according to RFC-2617 and draft update to allow additional
algorithms to be used.Enumeration of tokens expected in a HTTP Digest 'Authorization' header.
An extension of
Credential to provide some additional methods needed to enable verification of a request where
DigestAuthenticationMechanism is in use.Enumeration to represent the Digest quality of protection options.
Enumeration of tokens expected in a HTTP Digest 'WWW_Authenticate' header.
A non-blocking buffer cache where entries are indexed by a path and are made up of a
subsequence of blocks in a fixed large direct buffer.
DirectByteBufferDeallocator Utility class used to free direct buffer memory.Constant Content
Handler that disables response caching by browsers and proxies.
Handler that blacklists certain HTTP methods.
Handler that eagerly parses form data.
A stream source conduit which is always empty.
Handler that serves as the basis for content encoding implementations.
Returns true if all the provided arguments are equal to each other
Handler that dispatches to a given handler and allows mapping exceptions
to be handled by additional handlers.
Representation of a string attribute from a HTTP server exchange.
An interface that knows how to build an exchange attribute from a textual representation.
Attribute parser for exchange attributes.
Utility class for retrieving exchange attributes
Interface that can be used to wrap an exchange attribute.
Listener interface for events that are run at the completion of a request/response
cycle (i.e.
Interface that is used to determine if a connection should be exclusive.
Returns true if the given attribute is not null and not an empty string
Parser that transforms an extended access log format string into a
Undertow access log format string.
Base interface for WebSocket Extensions implementation.
Base interface for WebSocket Extension handshake.
Authentication mechanism that uses an externally provided principal.
Representation of an external credential.
A modified version of ConcurrentLinkedDeque which includes direct
removal.
Handler that serves up a file from disk to serve as an error page.
A file resource
Serves files from the file system.
A conduit that calls a finish listener when there is no data left in the underlying conduit.
A channel which reads data of a fixed length and calls a finish listener.
An efficient and flexible Base64 implementation.
Controls the decoding process.
An input stream which decodes bytes as they are read from a stream with Base64 encoded data.
An output stream which decodes base64 data written to it, and writes the decoded output to the
wrapped inner stream.
Controls the encoding process.
An input stream which encodes bytes as they are read from a stream.
An output stream which base64 encodes all passed data and writes it to the wrapped target output stream.
Representation of form data.
Parser for form data.
Parser definition for form encoded data.
Factory class that can create a form data parser for a given request.
Handler that implements rfc7239 Forwarded header
Frame header data for frames that are received
FramePriority<C extends AbstractFramedChannel<C,R,S>,R extends AbstractFramedStreamSourceChannel<C,R,S>,S extends AbstractFramedStreamSinkChannel<C,R,S>>
Interface that can be used to determine where to insert a given frame into the pending frame queue.
A authentication mechanism that requires the presence of two headers in the request.
Handler that allows for graceful server shutdown.
A listener which can be registered with the handler to be notified when all pending requests have finished.
AuthenticationMechanism for GSSAPI / SPNEGO based authentication.The GSSAPIServerSubjectFactory is a factory responsible for returning the
Subject that should be used for handing the
GSSAPI based authentication for a specific request.A
Credential to wrap an established GSSContext.Content coding for 'deflate'
Interface that provides a way of providing a textual representation of a handler.
Parser that can build a handler from a string representation.
Utility class with convenience methods for dealing with handlers
Interface that can be used to wrap the handler chains, adding additional handlers.
Abstract base class for doing a WebSocket Handshake.
An optimized array-backed header map.
NOTE: if you add a new header here you must also add it to
HttpRequestParserRepresentation of a token allowed within a header.
Utility to parse the tokens contained within a HTTP header.
An array-backed list/deque for header string values.
A conduit that discards all data written to it.
A utility class for mapping between byte arrays and their hex representation and back again.
The request scheme
Class that maintains a table of remote hosts that this proxy knows about.
A decoder for HPACK.
Encoder for HPACK frames.
Exception that is thrown when the HPACK compress context is broken.
HTTP2 channel.
HTTP2 client provider that uses HTTP upgrade rather than ALPN.
Plaintext HTTP2 client provider that works using HTTP upgrade
Headers channel
Parser for HTTP2 GO_AWAY frames
A HTTP2 go away frame
Headers channel
Open listener for HTTP2 server
A HTTP2 Ping frame
A structure that represents HTTP2 priority information.
HTTP2 client provider that connects to endpoints that are known to support HTTP2
Parser that supports push back when not all data can be read.
Push promise channel
A HTTP2 push promise frame
The recieve listener for a Http2 connection.
A HTTP2 RST Stream channel
A server connection.
A Http2 Setting
//TODO: ack
A HTTP2 Settings frame
Stream sink channel used for HTTP2 communication.
Upgrade listener for HTTP2, this allows connections to be established using the upgrade
mechanism as detailed in Section 3.2.
Exchange attachments that have specific meaning when using the HTTP protocol
Class that provides support for dealing with HTTP 100 (Continue) responses.
A continue response that is in the process of being sent.
Handler that provides support for HTTP/1.1 continue responses.
Handler for requests that require 100-continue responses.
A handler for an HTTP request.
Open listener for HTTP server.
The basic HTTP parser.
A server-side HTTP connection.
An HTTP server request/response exchange.
HttpServerExchange.WrapperConduitFactory<T extends org.xnio.conduits.Conduit>
An HTTP case-insensitive Latin-1 string.
A handler that handles HTTP trace requests
Server side upgrade handler.
Listener that is used to perform a HTTP upgrade.
The handshaking protocol implementation for Hybi-07.
The handshaking protocol implementation for Hybi-07, which is identical to Hybi-08, and thus is just a thin
subclass of
Hybi07Handshake that sets a different version number.The handshaking protocol implementation for Hybi-13.
A predicate that returns true if the request is idempotent
according to the HTTP RFC.
The IdentityManager interface to be implemented by an identity manager implementation providing user verification and
identity loading to Undertow.
The ident username, not used, included for apache access log compatibility
Conduit that adds support to close a channel once for a specified time no
reads and no writes were performed.
AuthenticationMechanismFactory that simply returns a pre configured AuthenticationMechanismImmediateConduitFactory<T extends org.xnio.conduits.Conduit>
Wrapper that allows you to use a non-pooed item as a pooled value
The default in memory session manager.
Handler that can accept or reject a request based on the IP address of the remote peer.
Access log receiver that logs messages at INFO level.
Open listener adaptor for ALPN connections that uses the SSLExplorer based approach and hack into the JDK8
SSLEngine via reflection.
Open listener adaptor for ALPN connections that use the JDK9 API
Jetty ALPN implementation.
Handler that appends the JVM route to the session id.
Handler that builds up a cache of resources that a browsers requests, and uses
server push to push them when supported.
Class that contains static constants and utility methods for legacy Set-Cookie format.
A limited buffer pooled allocator.
A registry of listeners, and the services that are exposed via these listeners.
Initial implementation of a load balancing proxy client.
Utility methods for getting the locale from a request.
The local IP address
A handler that performs DNS lookup to resolve a local address.
The local port
The local server name
Interface that generates the header for an access log.
A non-blocking cache where entries are indexed by a key.
Exception that is thrown when multipart parsing cannot parse a request
Deprecated.
NOTE: If you add a new method here you must also add it to
HttpRequestParserHandler that records some metrics
Deprecated.
An interface that allows the current status of the mod_cluster container to be queried and modified
A
HttpHandler that implements virtual hosts based on the Host: http header
header.The node configuration.
A NonceManager is used by the HTTP Digest authentication mechanism to request nonces and to validate the nonces sent from the
client.
The interface to be interested by classes interested in processing security related notifications.
A
HttpHandler to register a list of NotificationReceiver instances with the current SecurityContext.A cookie
A pool of objects.
Interface that represents an open listener, aka a connector.
Open listener adaptor for ALPN connections that use the Wildfly OpenSSL implementation
A handler for the HTTP Origin (RFC 6454) header.
Exception that is thrown if the max query or path parameter limit is exceeded
Wrapper for parse timeout.
A Credential representing the password of an Account.
Handler that dispatches to a given handler based of a prefix match of the path.
Handler that dispatches to a given handler based of a prefix match of the path.
Path parameter
Session config that is based on a path parameter and URL rewriting
A path resource
Serves files from the file system.
A handler that translates non slash separator characters in the URL into a slash.
Represents a parsed web socket path template.
A handler that matches URI templates
Deprecated.
The result of a path template match.
Utility class that provides fast path matching of path templates.
A handler that performs reverse DNS lookup to resolve a peer address
Implementation of
permessage-deflate WebSocket Extension.Implementation of
permessage-deflate WebSocket Extension handshake.A buffer that is used when processing pipelined requests, that allows the server to
buffer multiple responses into a single write() call.
Deprecated.
Represents a generic pooled object
A modified version of ConcurrentLinkedDequeue which includes direct
removal and is portable accorss all JVMs.
Channel that implements HTTP chunked transfer coding for data streams that already have chunk markers.
A resource supplier that allows pre-compressed resources to be served if the client accepts the request.
A predicate.
An interface that knows how to build a predicate from a textual representation.
Handler that sets up the predicate context
Parser for the undertow-handlers.conf file.
Parser that can build a predicate from a string representation.
Utility class used for creating predicates
Handler that can deal with a large number of predicates.
Protocol version strings.
Additional attachments that are specific to requests that are being proxied from one server to another
Yet another callback class, this one used by the proxy handler
A client that provides connections for the proxy handler.
An opaque interface that may contain information about the proxy target
A connection to a backend proxy.
A pool of connections to a target host.
An HTTP handler which proxies content to a remote server.
Handler that sets the peer address to the value of the X-Forwarded-For header.
Open listener for proxied connections
Query parameter
Methods for dealing with the query string
The query string
Exchange attribute that wraps string attributes in quotes.
Utility class for parsing headers that accept q values
A resource implementation that
Class that implements the token bucket algorithm.
An exception that is thrown when an attribute is read only
Wrapper for read timeout.
Interface that provides an easy way to read data from the request.
Utility class for building redirects.
A redirect handler that redirects to the specified location via a 302 redirect.
A reference counted pooled implementation, that basically consists of a main buffer, that can be sliced off into smaller buffers,
and the underlying buffer will not be freed until all the slices and the main buffer itself have also been freed.
A predicate that does a regex match against an exchange.
The relative path
The remote Host address (if resolved)
The remote IP address
The remote IP address
The remote user
Exception that is thrown that indicates that SSL renegotiation is required
in order to get a client cert.
Handler that will buffer all request data
A request cookie
Handler that dumps a exchange to a log.
Handler that serves as the basis for request content encoding.
A request header
Predicate that returns true if the Content-Size of a request is larger than a
given size.
Represents a limit on a number of running requests.
A handler which limits the maximum number of concurrent requests.
The request line
The request method
The request protocol
The request scheme
Predicate that returns true if the Content-Size of a request is smaller than a
given size.
The request URL
Representation of a static resource.
An event that is fired when a resource is modified
Watched file event types.
Listener that is invoked when a resource changes.
Representation of a resource manager.
Interface that allows for more flexibility when resolving a resource than is currently provided
by
ResourceManager.Facade for an underlying buffer cache that contains response information.
The request status code
A handler which simply sets a response code.
Callback that is invoked just before the response is commit
A response cookie
A response header
Handler that limits the download rate
The request status code
The response time
This will only work if
UndertowOptions.RECORD_REQUEST_START_TIME has been setClass that contains utility methods for dealing with RFC6265 Cookies.
Factory for route/affinity iterator parser.
Enumeration of supported route parsing strategies.
A Handler that handles the common case of routing via path template and method name.
Handler that will set the SameSite flag to response cookies
A utility class that can check known user agents which are known to be incompatible with SameSite=None attribute.
Sets the
Handler that will set the secure flag on all cookies that are received over a secure connection
A
SessionIdGenerator that uses a secure random to generate a
session ID.The security context.
Deprecated.
Instead extend AbstractSecurityContextAssociationHandler to provide alternative contexts.
Default
SecurityContextFactory implementation.The internal SecurityContext used to hold the state of security for the current exchange.
The security handler responsible for attaching the SecurityContext to the current
HttpServerExchange.Notification representing a security event such as a successful or failed authentication.
Sender interface that allows for callback based async IO.
A server connection.
Represents the server side of a Server Sent Events connection.
Callback handler that is invoked when a client connects to a SSE endpoint
Represents a HTTP session.
Handler that attaches the session to the request.
Interface that abstracts the process of attaching a session to an exchange.
Encapsulation of session cookie configuration.
Strategy for generating session ID's.
A listener for session events.
Utility class that maintains the session listeners.
Interface that manages sessions.
Optional interface that can be implemented by
SessionManager
implementations that provides session manager statistics.An extension to the
NonceManager interface for Nonce managers that also support the association of a pre-prepared
hash against a currently valid nonce.Utility class for working with sessions.
Handler that can set an arbitrary attribute on the exchange.
A handler that sets response code but continues the exchange so the servlet's
error page can be returned.
Set a fixed response header.
Handler that generates an extremely simple no frills error page
A default
NonceManager implementation to provide reasonable single host management of nonces.Simple pool that attempts to maintain a specified number of objects in the pool.
Deprecated.
An extension to
AbstractConfidentialityHandler that uses the Host header from the incoming message and specifies the
confidential address by just switching the port.Authenticator that can be used to configure single sign on.
Conduit for SSL connections.
Handler that sets SSL information on the connection based on the following headers:
Session config that stores the session ID in the current SSL session.
SSL session information.
A handler that buffers the full response and attaches it to the exchange.
Base class for processes Frame bases StreamSourceChannels.
Simple utility class for reading a string
A simple write listener that can be used to write out the contents of a String.
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.
A string keyed map that can be accessed as a substring, eliminating the need to allocate a new string
to do a key comparison against.
The thread name
The request method
An exception indicating that the response channel was prematurely closed.
Convenience class used to build an Undertow server.
Undertow client class.
starting from 1000
Warning this class consists of generated code.
Input stream that reads from the underlying channel.
log messages start at 5000
Warning this class consists of generated code.
Warning this class consists of generated code.
Buffering output stream that wraps a channel.
Created by Marek Marusic <mmarusic@redhat.com> on 7/25/19.
A handler that will decode the URL and query parameters to the specified charset.
Utilities for dealing with URLs
An utility class which can be used to check if a sequence of bytes or ByteBuffers contain non UTF-8 data.
Utility class which allows to extract a UTF8 String from bytes respecting valid code-points
The virtual host handler.
WebSocketChannel which is used for WebSocketVersion.V08StreamSinkFrameChannel implementation for writing WebSocket Frames on WebSocketVersion.V08 connectionsWebSocketChannel which is used for WebSocketVersion.V08A WebSocketChannel that handles version 13
A
ConnectedChannel which can be used to send and receive WebSocket Frames.Interface that represents a frame channel that is in the process of being created
The Web socket client.
Interface that is used on the client side to accept web socket connections
Base class for all WebSocket Exceptions
WebSocketException which will be thrown if a corrupted frame was detected
Web socket frame priority
The different WebSocketFrame types which are out there.
WebSocketException which should be used during the WebSocket-Handshake processing.An abstraction for a Http exchange.
WebSocketException which will be thrown if a corrupted frame was detected
log messages start at 25000
Warning this class consists of generated code.
start at 20000
Warning this class consists of generated code.
HttpHandler which will process the HttpServerExchange and do the actual handshake/upgrade
to WebSocket.Utility class which holds general useful utility methods which
can be used within WebSocket implementations.
Enum which list all the different versions of the WebSocket specification (to the current date).
Wrapper for write timeout.
A
Credential implementation which wraps an X.509 certificate.Adaptor between a ByteBufferPool and an XNIO Pool