All Classes and Interfaces
Class
Description
A skeletal
AddressResolver implementation.Decoder for both
BinaryMemcacheRequest and BinaryMemcacheResponse.A
MessageToByteEncoder that encodes binary memcache messages into bytes.Default implementation of a
BinaryMemcacheMessage.AbstractBootstrap is a helper class that makes it easy to bootstrap a Channel.Exposes the configuration of an
AbstractBootstrap.A skeletal implementation of a buffer.
Skeletal
ByteBufAllocator implementation to extend.A skeletal
Channel implementation.A skeletal
ChannelPoolHandler implementation.A skeletal
ChannelPoolMap implementation.Base implementation of
Constant.Deprecated.
Do not use.
Abstract Disk HttpData implementation
A skeletal implementation of
DnsMessage.An OPT RR record.
A skeletal implementation of
DnsRecord.Abstract base class for
EventExecutor implementations.Deprecated.
override
SingleThreadEventExecutor.wakesUpForTask(Runnable) to re-create this behaviourAbstract base class for
EventExecutorGroup implementations.Skeletal implementation of
EventLoop.Skeletal implementation of
EventLoopGroup.Abstract
Future implementation which does not allow for cancellation.Abstract base class which defines commonly used features required to build
Http2ConnectionHandler instances.Abstract implementation of
Http2StreamFrame.Abstract HttpData implementation
A skeletal builder implementation of
InboundHttp2ToHttpAdapter and its subtypes.A skeletal implementation of
InternalLogger.Base class for
IoUringBufferRingAllocator implementations which support large allocations.The default
MemcacheObject implementation.A
ChannelHandler that aggregates an MemcacheMessage
and its following MemcacheContents into a single MemcacheMessage with
no following MemcacheContents.Abstract super class for both ascii and binary decoders.
A general purpose
AbstractMemcacheObjectEncoder that encodes MemcacheMessages.Abstract Memory HttpData implementation
Base class for precomputed factories that create
MultiSearchProcessors.AbstractNioChannel base class for Channels that operate on bytes.Abstract base class for
Channel implementations which use a Selector based approach.Special
Channel.Unsafe sub-type which allows to access the underlying SelectableChannelAbstractNioChannel base class for Channels that operate on messages.Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Abstract base class for classes wants to implement
ReferenceCounted.Abstract base class for
ByteBuf implementations that count references.This class provides the functionality to either accept or reject new
Channels
based on their IP address.Abstract base class for
EventExecutors that want to support scheduling.Base class for precomputed factories that create
SearchProcessors.A skeletal server-side
Channel implementation.Enables SNI
(Server Name Indication) extension for server side SSL.
An abstract
Socks4Message.An abstract
Socks5Message.An abstract
SocksMessage.Abstract class for Simple Strings or Errors.
AbstractTrafficShapingHandler allows to limit the global bandwidth
(see
GlobalTrafficShapingHandler) or per session
bandwidth (see ChannelTrafficShapingHandler), as traffic shaping.An auto-tuning pooling
ByteBufAllocator, that follows an anti-generational hypothesis.Calculate sizes in a adaptive way.
The
RecvByteBufAllocator that automatically increases and
decreases the predicted buffer size on feed back.A message that wraps another message with a sender address and a recipient address.
Resolves a possibility unresolved
SocketAddress.Creates and manages
NameResolvers so that each EventExecutor has its own resolver instance.Implements Aho–Corasick
string search algorithm.
Provides an
SSLEngine agnostic way to configure a ApplicationProtocolNegotiator.Defines which application level protocol negotiation to use.
Defines the most common behaviors for the peer which is notified of the selected protocol.
Defines the most common behaviors for the peer that selects the application protocol.
Provides a set of protocol names used in ALPN and NPN.
Configures a
ChannelPipeline depending on the application-level protocol negotiation result of
SslHandler.Deprecated.
Header of Redis Array Message.
Arrays of RESP.
The newline characters to insert between header entries.
The separator characters to insert between a header name and a header value.
A string which has been encoded into a character encoding whose character always takes a single byte, similarly to
ASCII.
Attribute interface
An attribute which allows to store a value reference.
Key which can be used to access
Attribute out of the AttributeMap.Holds
Attributes which can be accessed via AttributeKey.Cache which stores the nameservers that should be used to resolve a specific hostname.
A factory that creates auto-scaling
EventExecutorChooserFactory.EventExecutorChooser instances.A container for the utilization metric of a single EventExecutor.
Enumeration of supported Base64 dialects.
Combines two
DnsQueryLifecycleObserver into a single DnsQueryLifecycleObserver.Combines two
DnsQueryLifecycleObserverFactory into a single DnsQueryLifecycleObserverFactory.The client codec that combines the proper encoder and decoder.
An interface that defines a binary Memcache message, providing common properties for
BinaryMemcacheRequest and BinaryMemcacheResponse.An object aggregator for the memcache binary protocol.
Represents all Opcodes that can occur in a
BinaryMemcacheMessage.Represents a full
BinaryMemcacheRequest, which contains the header and optional key and extras.The decoder part which takes care of decoding the request-specific headers.
The encoder part which takes care of encoding the request headers.
Represents a full
BinaryMemcacheResponse, which contains the header and optional key and extras.The decoder which takes care of decoding the response headers.
The encoder which takes care of encoding the response headers.
Contains all possible status values a
BinaryMemcacheResponse can return.The full server codec that combines the correct encoder and decoder.
Web Socket frame containing binary data.
Implements Bitap string search algorithm.
An
IllegalStateException which is raised when a user performed a blocking operation
when the user is in an event loop thread.Represents a supplier of
boolean-valued results.Exposes the configuration of a
Bootstrap.SslContextOptions that are specific to BoringSSL.KeyManagerFactory that can be used to support custom key signing via BoringSSLAsyncPrivateKeyMethod.Allow to log keys, logging keys are following
NSS Key Log Format.
Contains methods that can be used to detect if BouncyCastle is available.
Decompresses a
ByteBuf encoded with the brotli format.Compress a
ByteBuf with the Brotli compression.Provides a way to specify the Brotli compression mode.
BrotliOptions holds Encoder.Parameters for
Brotli compression.The header of Bulk Strings in RESP.
A chunk of bulk strings which is used for Redis chunked transfer-encoding.
Decodes a received
ByteBuf into an array of bytes.Encodes the requested array of bytes into a
ByteBuf.A random and sequential accessible sequence of zero or more bytes (octets).
Implementations are responsible to allocate buffers.
An interface that can be implemented by any object that know how to turn itself into a
ByteBuf.Used to control the format and verbosity of logging for
ByteBufs and ByteBufHolders.A packet which is send or receive.
An
InputStream which reads data from a ByteBuf.An
OutputStream which writes data to a ByteBuf.Deprecated.
Use
ByteProcessor.A collection of utility methods that is related with handling
ByteBuf,
such as the generation of hex dump and swapping an integer's byte order.Utilities for byte-based primitive collections.
A hash map implementation of
ByteObjectMap that uses open addressing for keys.Interface for a primitive map that uses
bytes as keys.A primitive entry in the map, provided by the iterator from
ByteObjectMap.entries()Provides a mechanism to iterate over a collection of bytes.
A
ByteProcessor which finds the first appearance which is not of a specific byte.A
ByteProcessor which finds the first appearance of a specific byte.A Codec for on-the-fly encoding/decoding of bytes to messages and vise-versa.
ChannelInboundHandlerAdapter which decodes bytes in a stream-like fashion from one ByteBuf to
another Message type.Cumulate
ByteBufs.Uncompresses a
ByteBuf encoded with the Bzip2 format.Compresses a
ByteBuf using the Bzip2 algorithm.The
CertificateBuilder produce X509Bundle instances, where the keys use the specified
algorithm, and the certificate have the specified data.The
CertificateBuilder.Algorithm enum encapsulates both the key type, key generation parameters, and the signature
algorithm to use.The extended key usage field specify what the certificate and key is allowed to be used for.
The key usage field specify what the certificate and key is allowed to be used for.
A nexus to a network socket or a component which is capable of I/O
operations such as read, write, connect, and bind.
Unsafe operations that should never be called from user-code.
A set of configuration properties of a
Channel.ChannelHandler implementation which represents a combination out of a ChannelInboundHandler and
the ChannelOutboundHandler.A
RuntimeException which is thrown when an I/O operation fails.Deprecated.
Use
ChannelFactory instead.Creates a new
Channel.This implementation allows to register
ChannelFuture instances which will get notified once some amount of
data was written and so a checkpoint was reached.The result of an asynchronous
Channel I/O operation.Listens to the result of a
ChannelFuture.ChannelException which holds ChannelFutures that failed because of an error.The result of an asynchronous
ChannelGroup operation.Listens to the result of a
ChannelGroupFuture.Handles an I/O event or intercepts an I/O operation, and forwards it to its next handler in
its
ChannelPipeline.Indicates that the same instance of the annotated
ChannelHandler
can be added to one or more ChannelPipelines multiple times
without a race condition.Skeleton implementation of a
ChannelHandler.Enables a
ChannelHandler to interact with its ChannelPipeline
and other handlers.Represents the globally unique identifier of a
Channel.ChannelHandler which adds callbacks for state changes.Abstract base class for
ChannelInboundHandler implementations which provide
implementations of all of their methods.A special
ChannelInboundHandler which offers an easy way to initialize a Channel once it was
registered to its EventLoop.A channel initializer extension make it possible to enforce rules and apply modifications across multiple,
disconnected uses of Netty within the same JVM process.
Special event which will be fired and passed to the
ChannelInboundHandler.userEventTriggered(ChannelHandlerContext, Object) methods once the input of
a SocketChannel was shutdown and the DuplexChannelConfig.isAllowHalfClosure() method returns
true.User event that signifies the channel's input side is shutdown, and we tried to shut it down again.
Allows to only match some
Channel's for operations in ChannelGroup.Helper class which provides often used
ChannelMatcher implementations.Represents the properties of a
Channel implementation.A
ChannelOption allows to configure a ChannelConfig in a type-safe
way.(Transport implementors only) an internal data structure used by
AbstractChannel to store its pending
outbound write requests.ChannelHandler which will get notified for IO-outbound-operations.Skeleton implementation of a
ChannelOutboundHandler.Special event which will be fired and passed to the
ChannelInboundHandler.userEventTriggered(ChannelHandlerContext, Object) methods once the output of
a SocketChannel was shutdown.Used to fail pending writes when a channel's output has been shutdown.
A list of
ChannelHandlers which handles or intercepts inbound events and outbound operations of a
Channel.A
ChannelException which is thrown when a ChannelPipeline
failed to execute an operation.Allows to acquire and release
Channel and so act as a pool of these.Handler which is called for various actions done by the
ChannelPool.Allows to map
ChannelPool implementations to a specific key.An special
ChannelFuture which is used to indicate the FileRegion transfer progressAn
EventListener listener which will be called once the sending task associated with future is
being transferred.Special
ChannelPromise which will be notified once the associated bytes is transferring.Special
ChannelFuture which is writable.Deprecated.
Use
PromiseCombiner
Class which is used to consolidate multiple channel futures into one, by
listening to the individual futures and producing an aggregated result
(success/failure) when all futures have completed.Deprecated.
use
PromiseNotifier.This implementation of the
AbstractTrafficShapingHandler is for channel
traffic shaping, that is to say a per channel limitation of the bandwidth.Utilities for char-based primitive collections.
A hash map implementation of
CharObjectMap that uses open addressing for keys.Interface for a primitive map that uses
chars as keys.A primitive entry in the map, provided by the iterator from
CharObjectMap.entries()Internal use only!
Converts to/from native types, general
Object, and CharSequences.A utility class that provides various common operations and constants
related with
Charset and its relevant classes.A
ChunkedInput that fetches data from a file chunk by chunk.A data stream of indefinite length which is consumed by
ChunkedWriteHandler.A
ChunkedInput that fetches data from a file chunk by chunk using
NIO FileChannel.A
ChunkedInput that fetches data from a ReadableByteChannel
chunk by chunk.A
ChunkedInput that fetches data from an InputStream chunk by
chunk.A
ChannelHandler that adds support for writing a large data stream
asynchronously neither spending a lot of memory nor getting
OutOfMemoryError.Cipher suites
Converts a Java cipher suite string to an OpenSSL cipher suite string and vice versa.
Provides a means to filter the supplied cipher suite based upon the supported and default cipher suites.
Utility which ensures that classes are loaded by the
ClassLoader.Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Encapsulates a direct
ByteBuffer and its mechanism for immediate deallocation, if any.Performing cleartext upgrade, by h2c HTTP upgrade or Prior Knowledge.
User event that is fired to notify about HTTP/2 protocol is started.
Indicates the state of the
SSLEngine with respect to client authentication.A RFC6265 compliant cookie decoder to be used client side.
Deprecated.
A RFC6265 compliant cookie encoder to be used client side, so
only name=value pairs are sent.
Web Socket Frame for closing the connection.
A FIFO queue of bytes where producers add bytes by repeatedly adding
ByteBuf and consumers take bytes in
arbitrary lengths.An
Exception which is thrown by a codec.Will add multiple values for the same header as single header with a comma separated list of values.
Deprecated.
MessageToByteEncoder implementation which uses JBoss Marshalling to marshal
an Object.Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
A virtual buffer which shows multiple buffers as a single merged buffer.
A composite
SimpleNameResolver that resolves a host name against a sequence of NameResolvers.An
EncoderException that is raised when compression failed.CompressionOptions provides compression options for
various types of compressor types, like Brotli.A decorating HTTP2 encoder that will compress data frames according to the
content-encoding header for each
stream.Deprecated.
For removal in Netty 4.2.
A scalable concurrent multimap implementation.
The multimap entry type with primitive
int keys.ConnectException which will be thrown if a connection could
not be established because of a connection timeout.A singleton which is safe to compare via the
== operator.A pool of
Constants.UnmarshallerProvider which store a reference to the Unmarshaller in the
ChannelHandlerContext via the ChannelHandlerContext.attr(AttributeKey)
method.Web Socket continuation frame containing continuation text or binary data.
Deprecated.
Use
Cookie instead.An interface defining an
HTTP cookie.
Parent of Client and Server side cookie decoders
Deprecated.
Use
ClientCookieDecoder
or ServerCookieDecoder instead.Parent of Client and Server side cookie encoders
Possible values for the SameSite attribute.
An
DecoderException which is thrown when the received frame data could not be decoded by
an inbound handler.An
DecoderException which is thrown when the received WebSocketFrame data could not be decoded by
an inbound handler.Configuration for Cross-Origin Resource Sharing (CORS).
Deprecated.
Use
CorsConfigBuilder instead.Deprecated.
Removed without alternatives.
Builder used to configure and build a
CorsConfig instance.Handles Cross Origin Resource Sharing (CORS) requests.
A UDP/IP
Channel.A
ChannelConfig for a DatagramChannel.A
DnsQuery implementation for UDP/IP.Decodes a
DatagramPacket into a DatagramDnsQuery.A
DnsResponse implementation for UDP/IP.Decodes a
DatagramPacket into a DatagramDnsResponse.The message container that is used for
DatagramChannel to communicate with the remote peer.A decoder that decodes the content of the received
DatagramPacket using
the specified ByteBuf decoder.An encoder that encodes the content in
AddressedEnvelope to DatagramPacket using
the specified message encoder.Act as special
InetSocketAddress to be able to easily pass all needed data from JNI without the need
to create more objects then needed.A formatter for HTTP header dates, such as "Expires" and "Date" headers, or "expires" field in "Set-Cookie".
An
CodecException which is thrown by a decoder.Provides the accessor methods for the
DecoderResult property of a decoded message.A
DecoderException that is raised when decompression failed.Decorator around another
Http2ConnectionDecoder instance.A decorator around another
Http2ConnectionEncoder instance.Decorator around another
Http2FrameWriter instance.The default
AddressedEnvelope implementation.Default
Attributes lookup and remove exibit
AttributeMap implementation which not exibit any blocking behaviour on attribute lookup while using a
copy-on-write approach on the modify path.Attributes lookup and remove exibit
O(logn) time worst-case
complexity, hence attribute::set(null) is to be preferred to remove.Default implementation of
AuthoritativeDnsServerCache, backed by a ConcurrentMap.The default implementation of the
BinaryMemcacheRequest.The default implementation of the
BinaryMemcacheResponse.A default implementation of
BulkStringRedisContent.Default implementation of a
ByteBufHolder that holds it's data in a ByteBuf.The default
ChannelConfig implementation.The default
ChannelGroup implementation.The default
ChannelId implementation.The default
ChannelPipeline implementation.The default
ChannelProgressivePromise implementation.The default
ChannelPromise implementation.The default
Cookie implementation.Deprecated.
Use
DefaultCookie instead.The default
DatagramChannelConfig implementation.Default implementation of
DnsCache, backed by a ConcurrentMap.Default implementation of a
DnsCnameCache.Default
DnsOptEcsRecord implementation.The default
DnsQuery implementation.The default
DnsQuestion implementation.The default
DnsRawRecord implementation.The default
DnsRecordDecoder implementation.The default
DnsRecordEncoder implementation.The default
DnsResponse implementation.A
DnsServerAddressStreamProvider which will use predefined default DNS servers to use for DNS resolution.Default
SingleThreadEventExecutor implementation which just execute all submitted task in a
serial fashion.Default implementation which uses simple round-robin to choose next
EventExecutor.Default implementation of
MultithreadEventExecutorGroup which will use DefaultEventExecutor instances
to handle the tasks.Deprecated.
The default implementation of a
FullBinaryMemcacheRequest.The default implementation of a
FullBinaryMemcacheResponse.Default implementation of
FullHttpRequest.Default implementation of a
FullHttpResponse.Default implementation of
Headers;A concrete implementation of
DefaultHeaders that allows for direct instantiation.Default
HostsFileEntriesResolver that resolves hosts file entries only once.Simple implementation of
Http2Connection.Provides the default implementation for processing inbound frame events and delegates to a
Http2FrameListenerDefault implementation of
Http2ConnectionEncoder.The default
Http2DataFrame implementation.A
Http2FrameReader that supports all frame types defined by the HTTP/2 specification.A
Http2FrameWriter that supports all frame types defined by the HTTP/2 specification.The default
Http2GoAwayFrame implementation.The default
Http2HeadersFrame implementation.Basic implementation of
Http2LocalFlowController.The default
Http2PingFrame implementation.Default implementation of Http2PriorityFrame
Default implementation of
Http2PushPromiseFrameBasic implementation of
Http2RemoteFlowController.The default
Http2ResetFrame implementation.The default
Http2SettingsFrame implementation.The default
Http2WindowUpdateFrame implementation.Default implementation of
Http3SettingsFrame.The default
HttpContent implementation.Default factory giving
Attribute and FileUpload according to constructor.Default implementation of
HttpHeaders.A builder of
HttpHeadersFactory instances, that itself implements HttpHeadersFactory.The default
HttpMessage implementation.The default
HttpRequest implementation.The default
HttpResponse implementation.A default implementation for
LastBulkStringRedisContent.The default
LastHttpContent implementation.The default implementation for the
LastMemcacheContent.Default implementation of
LastSmtpContent that does no validation of the raw data passed in.The default implementation for the
LastStompContentSubframe.Default implementation of
MarshallerProvider which just create a new Marshaller
on ever DefaultMarshallerProvider.getMarshaller(ChannelHandlerContext) call.The
RecvByteBufAllocator that yields a buffer size prediction based upon decrementing the value from
the max bytes per read.Default implementation of
MaxMessagesRecvByteBufAllocator which respects ChannelConfig.isAutoRead()
and also prevents overflow.The default
MemcacheContent implementation.Default
MessageSizeEstimator implementation which supports the estimation of the size of
ByteBuf, ByteBufHolder and FileRegion.A
InetNameResolver that resolves using JDK's built-in domain name lookup mechanism.Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
A priority queue which uses natural ordering of elements.
The default
SctpChannelConfig implementation for SCTP.The default
SctpServerChannelConfig implementation for SCTP.Factory which uses the default select strategy.
The default
ServerSocketChannelConfig implementation.Default implementation of
SmtpContent that does no validation of the raw data passed in.Default
SmtpRequest implementation.Default
SmtpResponse implementation.The default
SocketChannelConfig implementation.The default
Socks4CommandRequest.The default
Socks4CommandResponse.The default
Socks5CommandRequest.The default
Socks5CommandResponse.The default
Socks5InitialRequest.The default
Socks5InitialResponse.The default
Socks5PasswordAuthRequest.The default
Socks5PasswordAuthResponse.The default
Socks5PrivateAuthRequest implementation.The default
Socks5PrivateAuthResponse implementation.The default
SpdyDataFrame implementation.The default
SpdyGoAwayFrame implementation.The default
SpdyHeadersFrame implementation.The default
SpdyPingFrame implementation.The default
SpdyRstStreamFrame implementation.The default
SpdySettingsFrame implementation.The default
SpdyStreamFrame implementation.The default
SpdySynReplyFrame implementation.The default
SpdySynStreamFrame implementation.The default
SpdyWindowUpdateFrame implementation.The default
StompContentSubframe implementation.Default implementation of
StompFrame.Default implementation of
StompHeadersSubframe.A
ThreadFactory implementation with a simple naming rule.Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Default implementation of
UnmarshallerProvider which will just create a new Unmarshaller
on every call to DefaultUnmarshallerProvider.getUnmarshaller(ChannelHandlerContext)perframe-deflate
handshake implementation.
perframe-deflate
handshake implementation.
DeflateOptions holds DeflateOptions.compressionLevel(),
DeflateOptions.memLevel() and DeflateOptions.windowBits() for Deflate compression.An HTTP2 frame listener that will decompress data frames according to the
content-encoding header for each
stream.Adapter class which allows to wrap another
SslContext and init SSLEngine instances.A decoder that splits the received
ByteBufs by one or more
delimiters.A set of commonly used delimiters for
DelimiterBasedFrameDecoder.Disable a test when slow leak detection is enabled.
Disk implementation of Attributes
Disk FileUpload implementation that stores file into real files
A cache for DNS resolution entries.
Represents the results from a previous DNS query which can be cached.
A cache for
CNAMEs.A metadata carrier exception, to propagate
DnsResponseCode information as an enrichment
within the UnknownHostException cause.The superclass which contains core information concerning a
DnsQuery and a DnsResponse.A DNS-based
InetNameResolver.A
DnsNameResolver builder.Strategy that influence how
Channels are used during queries.A
RuntimeException raised when DnsNameResolver failed to perform a successful query.A
DnsNameResolverException raised when DnsNameResolver failed to perform a successful query because
of an timeout.The DNS
OpCode as defined in RFC2929.An ECS record as defined in Client Subnet in DNS Queries.
An OPT RR record.
A DNS query message.
This interface provides visibility into individual DNS queries.
Used to generate new instances of
DnsQueryLifecycleObserver.A DNS question.
A generic
DnsRecord that contains an undecoded RDATA.A DNS resource record.
Decodes a DNS record into its object representation.
Encodes a
DnsRecord into binary representation.Represents a DNS record type.
A DNS response message.
The DNS
RCODE, as defined in RFC2929.Represents a section of a
DnsMessage.Provides an infinite sequence of DNS server addresses to
DnsNameResolver.An infinite stream of DNS server addresses.
Provides an opportunity to override which
DnsServerAddressStream is used to resolve a specific hostname.Utility methods related to
DnsServerAddressStreamProvider.An infinite stream of DNS server addresses, that requests feedback to be returned to it.
A
UnixChannel that supports communication via
UNIX domain datagram sockets.A
ChannelConfig for a DomainDatagramChannel.The message container that is used for
DomainDatagramChannel to communicate with the remote peer.Act as special
DomainSocketAddress to be able to easily pass all needed data from JNI without the need
to create more objects then needed.Deprecated.
Use
DomainWildcardMappingBuilder instead.Deprecated.
Deprecated.
A address for a
Unix Domain Socket.
A
UnixChannel that supports communication via
Unix Domain Socket.Special
ChannelConfig for DomainSocketChannels.Different modes of reading from a
DomainSocketChannel.Builder that allows to build
Mappings that support
DNS wildcard matching.A duplex
Channel that has two sides that can be shutdown independently.A
ChannelConfig for a DuplexChannel.Deprecated.
Do not use.
ChannelOutboundHandler implementation which allows to dynamically replace the used
remoteAddress and / or localAddress when making a connection attempt.Base class for
Channel implementations that are used in an embedded fashion.An empty
ByteBuf whose capacity and maximum capacity are all 0.An
CodecException which is thrown by an encoder.Tells if
netty-transport-native-epoll is
supported.DatagramChannel implementation that uses linux EPOLL Edge-Triggered Mode for
maximal performance.This is an internal datastructure which can be directly passed to epoll_wait to reduce the overhead.
Deprecated.
Use
SingleThreadIoEventLoop with EpollIoHandlerDeprecated.
IoEvent that must be handled by the EpollIoHandle.IoHandle implementation which is using epoll.IoHandler which uses epoll under the covers.Implementation of
IoOps that is used by EpollIoHandler and so for epoll based transports.Deprecated.
Netty always uses level-triggered mode.
Class that provides utility methods to setup
QUIC when using the EPOLL transport.ServerSocketChannel implementation that uses linux EPOLL Edge-Triggered Mode for
maximal performance.SocketChannel implementation that uses linux EPOLL Edge-Triggered Mode for
maximal performance.
struct tcp_info
{
__u8 tcpi_state;
__u8 tcpi_ca_state;
__u8 tcpi_retransmits;
__u8 tcpi_probes;
__u8 tcpi_backoff;
__u8 tcpi_options;
__u8 tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
__u32 tcpi_rto;
__u32 tcpi_ato;
__u32 tcpi_snd_mss;
__u32 tcpi_rcv_mss;
__u32 tcpi_unacked;
__u32 tcpi_sacked;
__u32 tcpi_lost;
__u32 tcpi_retrans;
__u32 tcpi_fackets;
__u32 tcpi_last_data_sent;
__u32 tcpi_last_ack_sent;
__u32 tcpi_last_data_recv;
__u32 tcpi_last_ack_recv;
__u32 tcpi_pmtu;
__u32 tcpi_rcv_ssthresh;
__u32 tcpi_rtt;
__u32 tcpi_rttvar;
__u32 tcpi_snd_ssthresh;
__u32 tcpi_snd_cwnd;
__u32 tcpi_advmss;
__u32 tcpi_reordering;
__u32 tcpi_rcv_rtt;
__u32 tcpi_rcv_space;
__u32 tcpi_total_retrans;
};
Errors of RESP.
Internal usage only!
Internal usage only!
The
EventExecutor is a special EventExecutorGroup which comes
with some handy methods to see if a Thread is executed in a event loop.Factory that creates new
EventExecutorChooserFactory.EventExecutorChoosers.Chooses the next
EventExecutor to use.An
EventExecutorChooserFactory.EventExecutorChooser that exposes metrics for observation.The
EventExecutorGroup is responsible for providing the EventExecutor's to use
via its EventExecutorGroup.next() method.Will handle all the I/O operations for a
Channel once registered.Special
ChannelException which will be thrown by EventLoop and EventLoopGroup
implementations when an error occurs.Special
EventExecutorGroup which allows registering Channels that get
processed for later selection during the event loop.Deprecated.
Not used anymore by new
IoEventLoopGroup and IoEventLoop implementationsThe
CompleteFuture which is failed already.Uncompresses a
ByteBuf encoded by FastLzFrameEncoder using the FastLZ algorithm.Compresses a
ByteBuf using the FastLZ algorithm.A special variant of
ThreadLocal that yields higher access performance when accessed from a
FastThreadLocalThread.A special
Thread that provides fast access to FastThreadLocal variables.Native
FileDescriptor implementation which allows to wrap an int and provide a
FileDescriptor for it.A region of a file that is sent via a
Channel which supports
zero-copy file transfer.FileUpload interface that could be in memory, on temporary file or any other implementations.
An
TrustManagerFactory that trusts an X.509 certificate whose hash matches.A builder for creating
FingerprintTrustManagerFactory.ChannelPool implementation that takes another ChannelPool implementation and enforce a maximum
number of concurrent connections.A decoder that splits the received
ByteBufs by the fixed number
of bytes.The
RecvByteBufAllocator that always yields the same buffer
size prediction.A default fixed redis message pool.
The
FlowControlHandler ensures that only one message per read() is sent downstream.ChannelDuplexHandler which consolidates Channel.flush() / ChannelHandlerContext.flush()
operations (which also includes
Channel.writeAndFlush(Object) / Channel.writeAndFlush(Object, ChannelPromise) and
ChannelOutboundInvoker.writeAndFlush(Object) /
ChannelOutboundInvoker.writeAndFlush(Object, ChannelPromise)).Allows to configure a strategy for when flushes should be happening.
Holds the results of formatting done by
MessageFormatter.A
BinaryMemcacheRequest that also includes the content.A
BinaryMemcacheResponse that also includes the content.An aggregated bulk string of RESP.
Combines
HttpMessage and LastHttpContent into one
message.Combine the
HttpRequest and FullHttpMessage, so the request is a complete HTTP
request.Combination of a
HttpResponse and FullHttpMessage.Combines
MemcacheMessage and LastMemcacheContent into one
message.The result of an asynchronous operation.
A subtype of
GenericFutureListener that hides type parameter for convenience.Listens to the result of a
Future.A generic socket option.
Version for
GlobalChannelTrafficShapingHandler.This implementation of the
This version shall not be in the same pipeline than other TrafficShapingHandler.
The general use should be as follow:
Create your unique GlobalChannelTrafficShapingHandler like:
GlobalChannelTrafficShapingHandler myHandler = new GlobalChannelTrafficShapingHandler(executor);
The executor could be the underlying IO worker pool
pipeline.addLast(myHandler);
Note that this handler has a Pipeline Coverage of "all" which means only one such handler must be created and shared among all channels as the counter must be shared among all channels.
Other arguments can be passed like write or read limitation (in bytes/s where 0 means no limitation) or the check interval (in millisecond) that represents the delay between two computations of the bandwidth and so the call back of the doAccounting method (0 means no accounting at all).
Note that as this is a fusion of both Global and Channel Traffic Shaping, limits are in 2 sets, respectively Global and Channel.
A value of 0 means no accounting for checkInterval.
AbstractTrafficShapingHandler is for global
and per channel traffic shaping, that is to say a global limitation of the bandwidth, whatever
the number of opened channels and a per channel limitation of the bandwidth.This version shall not be in the same pipeline than other TrafficShapingHandler.
The general use should be as follow:
Create your unique GlobalChannelTrafficShapingHandler like:
GlobalChannelTrafficShapingHandler myHandler = new GlobalChannelTrafficShapingHandler(executor);
The executor could be the underlying IO worker pool
pipeline.addLast(myHandler);
Note that this handler has a Pipeline Coverage of "all" which means only one such handler must be created and shared among all channels as the counter must be shared among all channels.
Other arguments can be passed like write or read limitation (in bytes/s where 0 means no limitation) or the check interval (in millisecond) that represents the delay between two computations of the bandwidth and so the call back of the doAccounting method (0 means no accounting at all).
Note that as this is a fusion of both Global and Channel Traffic Shaping, limits are in 2 sets, respectively Global and Channel.
A value of 0 means no accounting for checkInterval.
Single-thread singleton
EventExecutor.This implementation of the
AbstractTrafficShapingHandler is for global
traffic shaping, that is to say a global limitation of the bandwidth, whatever
the number of opened channels.GzipOptions holds DeflateOptions.compressionLevel(),
DeflateOptions.memLevel() and DeflateOptions.windowBits() for Gzip compression.The command of an HAProxy proxy protocol header
Message container for decoded HAProxy proxy protocol parameters
Decodes an HAProxy proxy protocol header
Encodes an HAProxy proxy protocol message
A
DecoderException which is thrown when an invalid HAProxy proxy protocol header is encounteredThe HAProxy proxy protocol specification version.
A protocol proxied by HAProxy which is represented by its transport protocol and address family.
The address family of an HAProxy proxy protocol header.
The transport protocol of an HAProxy proxy protocol header
Represents a
HAProxyTLV of the type HAProxyTLV.Type.PP2_TYPE_SSL.A Type-Length Value (TLV vector) that can be added to the PROXY protocol
to include additional information like SSL information.
The registered types a TLV can have regarding the PROXY protocol 1.5 spec
A
Timer optimized for approximated I/O timeout scheduling.Abstraction for hash code generation and equality comparison.
Common interface for
Headers which represents a mapping of key to value.Provides utility methods related to
Headers.A container of hosts file entries.
A container of hosts file entries
Resolves a hostname against the hosts file entries.
A parser for hosts files.
A
ChannelDuplexHandler providing additional functionality for HTTP/2.Client-side cleartext upgrade codec from HTTP to HTTP/2.
Constants and utility method used for encoding/decoding HTTP2 frames.
Manager for the state of an HTTP/2 connection with the remote end-point.
A view of the connection from one endpoint (local or remote).
Listener for life-cycle events for streams in this connection.
A key to be used for associating application-defined properties with streams within this connection.
Provides empty implementations of all
Http2Connection.Listener methods.Handler for inbound traffic on behalf of
Http2ConnectionHandler.Handler for outbound HTTP/2 traffic.
Provides the default implementation for processing inbound frame events and delegates to a
Http2FrameListenerBuilder which builds
Http2ConnectionHandler objects.Signifies that the connection preface and
the initial SETTINGS frame have been sent.
A
ChunkedInput that fetches data chunk by chunk for use with HTTP/2 Data Frames.HTTP/2 DATA frame.
Interface that defines an object capable of producing HTTP/2 data frames.
All error codes identified by the HTTP/2 spec.
This class brings
Http2Connection.Listener and Http2FrameListener together to provide
NOOP implementation so inheriting classes can selectively choose which methods to override.Exception thrown when an HTTP/2 error was encountered.
Used when a stream creation attempt fails but may be because the stream was previously closed.
Provides the ability to handle multiple stream exceptions with one throw statement.
Provides a hint as to if shutdown is justified, what type of shutdown should be executed.
Represents an exception that can be isolated to a single stream (as opposed to the entire connection).
Provides utility methods for accessing specific flags as defined by the HTTP/2 spec.
Base interface for all HTTP/2 flow controllers.
An HTTP/2 frame.
Convenience class that provides no-op implementations for all methods of
Http2FrameListener.An HTTP/2 handler that maps HTTP/2 frames to
Http2Frame objects and vice versa.Builder for the
Http2FrameCodec.An listener of HTTP/2 frames.
Provides a decorator around a
Http2FrameListener and delegates all method callsLogs HTTP2 frames for debugging purposes.
Reads HTTP/2 frames from an input
ByteBuf and notifies the specified
Http2FrameListener when frames are complete.Configuration specific to
Http2FrameReaderA single stream within an HTTP/2 connection.
An HTTP/2 exception for a specific
Http2FrameStream.A visitor that allows to iterate over a collection of
Http2FrameStreams.Registry of all standard frame types defined by the HTTP/2 specification.
A writer responsible for marshaling HTTP/2 frames to the channel.
Configuration specific to
Http2FrameWriterHTTP/2 GOAWAY frame.
A collection of headers sent or received via HTTP/2.
HTTP/2 pseudo-headers names.
Decodes HPACK-encoded headers blocks into
Http2Headers.Configuration related elements for the
Http2HeadersDecoder interfaceEncodes
Http2Headers into HPACK-encoded headers blocks.Configuration related elements for the
Http2HeadersEncoder interfaceDetermine if a header name/value pair is treated as
sensitive.
HTTP/2 HEADERS frame.
Decorator around a
Http2FrameReader that logs all inbound frames before calling
back the listener.Manager for the life cycle of the HTTP/2 connection.
A
Http2FlowController for controlling the inbound flow of DATA frames from the remote endpoint.Deprecated.
use
Http2FrameCodecBuilder together with Http2MultiplexHandler.Deprecated.
use
Http2FrameCodecBuilder together with Http2MultiplexHandler.An HTTP/2 handler that creates child channels for each stream.
This exception is thrown when there are no more stream IDs available for the current connection
Decorator around a
Http2FrameWriter that logs all outbound frames before calling the
writer.HTTP/2 PING Frame.
HTTP/2 Priority Frame
Provides an extensibility point for users to define the validity of push requests.
HTTP/2 Push Promise Frame
A
Http2FlowController for controlling the flow of outbound DATA frames to the remote
endpoint.Implementations of this interface are used to progressively write chunks of the underlying
payload to the stream.
Listener to the number of flow-controlled bytes written per stream.
HTTP/2 RST_STREAM frame.
Provides utilities related to security requirements specific to HTTP/2.
Server-side codec for performing a cleartext upgrade from HTTP/1.x to HTTP/2.
Settings for one endpoint in an HTTP/2 connection.
An ack for a previously received
Http2SettingsFrame.HTTP/2 SETTINGS frame.
Provides a Consumer like interface to consume remote settings received but not yet ACKed.
A single stream within an HTTP2 connection.
The allowed states of an HTTP2 stream.
ChannelOptions that are specific to Http2StreamChannels.A frame whose meaning may apply to a particular stream, instead of the entire connection.
This handler converts from
Http2StreamFrame to HttpObject,
and back.A visitor that allows iteration over a collection of streams.
HTTP/2 WINDOW_UPDATE frame.
Contains utility methods that help to bootstrap server / clients with HTTP3 support.
See CANCEL_PUSH.
Handler that handles HTTP3 connections.
Marker interface for frames that can be sent and received on a
HTTP3 control stream.
See DATA.
Different HTTP3 error codes.
An exception related to violate the HTTP3 spec.
Marker interface that is implemented by all HTTP3 frames.
This handler converts from
Http3RequestStreamFrame to HttpObject,
and back.See GOAWAY.
HTTP/2 (and HTTP/3) pseudo-headers names.
See HEADERS.
Thrown if
Http3Headers validation fails for some reason.See MAX_PUSH_ID.
See PUSH_PROMISE.
Abstract base class that users can extend to init HTTP/3 push-streams for clients.
Marker interface for frames that can be sent and received on a
HTTP3 push stream.
Abstract base class that users can extend to init HTTP/3 push-streams for servers.
Marker interface for frames that can be sent and received on a
HTTP3 request stream.
ChannelInboundHandlerAdapter which makes it easy to handle
HTTP3 request streams.Abstract base class that users can extend to init HTTP/3 request-streams.
Handler that handles HTTP3 for the server-side.
A manager for push streams
for a server.
Represents a collection of HTTP/3 settings as defined by the
HTTP/3 specification.
See SETTINGS.
A
ChunkedInput that fetches data chunk by chunk for use with HTTP chunked transfers.A combination of
HttpRequestEncoder and HttpResponseDecoder
which enables easier client side HTTP implementation.Client-side handler for handling an HTTP upgrade handshake to another protocol.
The source codec that is used in the pipeline initially.
A codec that the source can be upgraded to.
User events that are fired to notify about upgrade status.
An HTTP chunk which is used for HTTP chunked transfer-encoding.
Compresses an
HttpMessage and an HttpContent in gzip or
deflate encoding while respecting the "Accept-Encoding" header.Decodes the content of the received
HttpRequest and HttpContent.Encodes the content of the outbound
HttpResponse and HttpContent.Provides utility methods and constants for the HTTP/2 to HTTP conversion
Provides utility methods and constants for the HTTP/3 to HTTP conversion
Provides the HTTP header extensions used to carry HTTP/2 information in HTTP objects
Provides the HTTP header extensions used to carry HTTP/3 information in HTTP objects
Extended interface for InterfaceHttpData
Interface to enable creation of InterfaceHttpData objects
A configuration object for specifying the behaviour of
HttpObjectDecoder and its subclasses.A user event designed to communicate that a expectation has failed and there should be no expectation that a
body will follow.
Deprecated.
Use
DateFormatter insteadStandard HTTP header names.
Provides the constants for the standard HTTP header names and values and
commonly used utility methods that accesses an
HttpMessage.Deprecated.
Use
HttpHeaderNames instead.Deprecated.
Use
HttpHeaderValues instead.An interface for creating
HttpHeaders instances.Functions used to perform various validations of HTTP header names and values.
Standard HTTP header values.
An interface that defines an HTTP message, providing common properties for
HttpRequest and HttpResponse.A
ChannelHandler that aggregates an HttpMessage
and its following HttpContents into a single FullHttpRequest
or FullHttpResponse (depending on if it used to handle requests or responses)
with no following HttpContents.This decoder will decode Body and can handle POST BODY.
This decoder will decode Body and can handle POST BODY.
Exception when the body is fully decoded, even if there is still data
Exception when an error occurs while decoding
states follow NOTSTARTED PREAMBLE ( (HEADERDELIMITER DISPOSITION (FIELD |
FILEUPLOAD))* (HEADERDELIMITER DISPOSITION MIXEDPREAMBLE (MIXEDDELIMITER
MIXEDDISPOSITION MIXEDFILEUPLOAD)+ MIXEDCLOSEDELIMITER)* CLOSEDELIMITER)+
EPILOGUE
First getStatus is: NOSTARTED
Content-type: multipart/form-data, boundary=AaB03x => PREAMBLE in Header
--AaB03x => HEADERDELIMITER content-disposition: form-data; name="field1"
=> DISPOSITION
Joe Blow => FIELD --AaB03x => HEADERDELIMITER content-disposition:
form-data; name="pics" => DISPOSITION Content-type: multipart/mixed,
boundary=BbC04y
--BbC04y => MIXEDDELIMITER Content-disposition: attachment;
filename="file1.txt" => MIXEDDISPOSITION Content-Type: text/plain
... contents of file1.txt ... => MIXEDFILEUPLOAD --BbC04y =>
MIXEDDELIMITER Content-disposition: file; filename="file2.gif" =>
MIXEDDISPOSITION Content-type: image/gif Content-Transfer-Encoding:
binary
...contents of file2.gif... => MIXEDFILEUPLOAD --BbC04y-- =>
MIXEDCLOSEDELIMITER --AaB03x-- => CLOSEDELIMITER
Once CLOSEDELIMITER is found, last getStatus is EPILOGUE
Exception when try reading data from request in chunked format, and not
enough data are available (need more chunks)
Exception when a field content is too long
Exception when the maximum number of fields for a given form is reached
This encoder will help to encode Request for a FORM as POST.
Different modes to use to encode form data.
Exception when an error occurs while encoding
This decoder will decode Body and can handle POST BODY.
Handler that establishes a blind forwarding proxy tunnel using
HTTP/1.1 CONNECT request.
Specific case of a connection failure, which may include headers from the proxy.
An HTTP request.
An HTTP response.
Defines the common schemes used for the HTTP protocol as defined by
rfc7230.
A combination of
HttpRequestDecoder and HttpResponseEncoder
which enables easier server side HTTP implementation.HttpServerKeepAliveHandler helps close persistent connections when appropriate.
A server-side handler that receives HTTP requests and optionally performs a protocol switch if
the requested protocol is supported.
The source codec that is used in the pipeline initially.
A codec that the source can be upgraded to.
Creates a new
HttpServerUpgradeHandler.UpgradeCodec for the requested protocol name.User event that is fired to notify about the completion of an HTTP upgrade
to another protocol.
The class of HTTP status.
Translates HTTP/1.x object writes into HTTP/2 frames.
Builder which builds
HttpToHttp2ConnectionHandler objects.Utility methods useful in the HTTP context.
This class will not do any filtering of ciphers suites.
A user event triggered by
IdleStateHandler when a Channel is idle.Triggers an
IdleStateEvent when a Channel has not performed
read, write, or both operation for a while.An
IllegalStateException which is raised when a user attempts to access a ReferenceCounted whose
reference count has been decreased to 0 (and consequently freed).Executes
Runnable objects in the caller's thread.Executor which execute tasks in the callers thread.This adapter provides just header/data events from the HTTP message flow defined
in [RFC 7540], Section 8.1.
Builds an
InboundHttp2ToHttpAdapter.Translates HTTP/1.x object reads into HTTP/2 frames.
A skeletal
NameResolver implementation that resolves InetAddress.A
AbstractAddressResolver that resolves InetSocketAddress.Inline commands of RESP.
Insecure
QuicTokenHandler which only does basic token generation / validation without any
crypto.An insecure
TrustManagerFactory that trusts all X.509 certificates without any verification.Utilities for int-based primitive collections.
Deprecated.
For removal in netty 4.2
Integers of RESP.
Interface for all Objects that could be encoded/decoded using HttpPostRequestEncoder/Decoder
This decoder will decode Body and can handle POST BODY.
Internal-use-only logger used by Netty.
Creates an
InternalLogger or changes the default factory
implementation.The log level that
InternalLogger can log at.The internal data structure that stores the thread-local variables for Netty and all
FastThreadLocals.Deprecated.
use
SocketProtocolFamily.A hash map implementation of
IntObjectMap that uses open addressing for keys.Interface for a primitive map that uses
ints as keys.A primitive entry in the map, provided by the iterator from
IntObjectMap.entries()Represents a supplier of
int-valued results.Thrown when HTTP chunk extensions could not be parsed, typically due to incorrect use of CR LF delimiters.
Thrown when HTTP chunks could not be parsed, typically due to incorrect use of CR LF delimiters.
Thrown when strict line parsing is enabled,
and HTTP start- and header field-lines are not separated by CR LF octet pairs.
EventLoopGroup for IoEventLoops.A handle that can be registered to an
IoHandler.Handles IO dispatching for an
ThreadAwareExecutor.The context for an
IoHandler that is run by an ThreadAwareExecutor.Factory for
IoHandler instances.An IO op that can be submitted to an
IoRegistration via IoRegistration.submit(IoOps).
// * These submitted IoOps will result in IoEvents on the related IoHandle.A registration for IO.
IoUringBufferRingAllocator implementation which uses an adaptive strategy to allocate buffers, which
will decrease / increase the buffer size depending on if the allocated buffers were completely used or not before.Allocator that is responsible to allocate buffers for a buffer ring.
Configuration class for an
IoUringBufferRing.Event that is fired when a read failed because the buffer ring was exhausted for now.
DomainSocketChannel implementation that uses linux io_uringIoUringBufferRingAllocator implementation which uses a fixed size for the buffers that are returned by
AbstractIoUringBufferRingAllocator.allocate().IoEvent that will be produced as an result of a IoUringIoOps.IoHandle implementation for io_uring.IoHandler which is implemented in terms of the Linux-specific io_uring API.Configuration class for an
IoUringIoHandler,
managing the settings for a RingBuffer and its io_uring file descriptor.struct tcp_info
{
__u8 tcpi_state;
__u8 tcpi_ca_state;
__u8 tcpi_retransmits;
__u8 tcpi_probes;
__u8 tcpi_backoff;
__u8 tcpi_options;
__u8 tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
__u32 tcpi_rto;
__u32 tcpi_ato;
__u32 tcpi_snd_mss;
__u32 tcpi_rcv_mss;
__u32 tcpi_unacked;
__u32 tcpi_sacked;
__u32 tcpi_lost;
__u32 tcpi_retrans;
__u32 tcpi_fackets;
__u32 tcpi_last_data_sent;
__u32 tcpi_last_ack_sent;
__u32 tcpi_last_data_recv;
__u32 tcpi_last_ack_recv;
__u32 tcpi_pmtu;
__u32 tcpi_rcv_ssthresh;
__u32 tcpi_rtt;
__u32 tcpi_rttvar;
__u32 tcpi_snd_ssthresh;
__u32 tcpi_snd_cwnd;
__u32 tcpi_advmss;
__u32 tcpi_reordering;
__u32 tcpi_rcv_rtt;
__u32 tcpi_rcv_space;
__u32 tcpi_total_retrans;
};
Represent an array of struct array and so can be passed directly over via JNI without the need to do any more
array copies.
Implement this interface to create new rules.
Used in
IpFilterRule to decide if a matching IP Address should be allowed or denied to connect.
This class allows one to filter new
Channels based on the
IpSubnetFilters passed to its constructor.Use this class to create rules for
RuleBasedIpFilter that group IP addresses into subnets.Deprecated.
Deprecated.
A listener to be notified by which protocol was select by its peer.
Factory interface for
JdkApplicationProtocolNegotiator.ProtocolSelectionListener objects.Interface to define the role of an application protocol selector in the SSL handshake process.
Factory interface for
JdkApplicationProtocolNegotiator.ProtocolSelector objects.Abstract factory pattern for wrapping an
SSLEngine object.Logger factory which creates a
java.util.logging
logger.
Deprecated.
An
SslContext which uses JDK's SSL/TLS implementation.Deprecated.
Decompress a
ByteBuf using the inflate algorithm.Compresses a
ByteBuf using the deflate algorithm.Splits a byte stream of JSON objects and arrays into individual objects/arrays and passes them up the
ChannelPipeline.Compresses a
ByteBuf using the deflate algorithm.Implements
Knuth-Morris-Pratt
string search algorithm.
If KQueue is available the JNI resources will be loaded when this class loads.
Deprecated.
IoEvent to use with KQueueIoHandler.IoHandle implementation that can be used with the KQueueIoHandler.IoHandler which uses kqueue under the covers.Implementation of
IoOps for
that is used by KQueueIoHandler and so for kqueue based transports.A last chunk of Bulk Strings.
The last
HttpContent which has trailing headers.The
MemcacheContent which signals the end of the content batch.The last part of a sequence of
SmtpContents that are sent after a DATA request.The last
StompContentSubframe which signals the end of the content batchAlternative leak detector implementation for reliable and performant detection in tests.
Special exception type to show that an allocation is prohibited at the moment, for example because the
LeakPresenceDetector.ResourceScope is closed, or because the current thread cannot be associated with a particular scope.A resource scope keeps track of the resources for a particular set of threads.
Junit 5 extension for leak detection using
LeakPresenceDetector.A decoder that splits the received
ByteBufs dynamically by the
value of the length field in the message.An encoder that prepends the length of the message.
A decoder that splits the received
ByteBufs on line endings.A class to represent line separators in different environments.
A socket which provides access Linux native methods.
An endpoint in the local transport.
A
Channel for the local transport.Deprecated.
IoOps implementation that can be used with LocalIoHandler.A
ServerChannel for the local transport which allows in VM communication.Logger factory which creates an
Apache Log4J
logger.
A
DnsQueryLifecycleObserverFactory that enables detailed logging in the DnsNameResolver.A
ChannelHandler that logs all events using a logging framework.Maps the regular
LogLevels with the InternalLogLevel ones.Utilities for long-based primitive collections.
Counter for long.
A hash map implementation of
LongObjectMap that uses open addressing for keys.Interface for a primitive map that uses
longs as keys.A primitive entry in the map, provided by the iterator from
LongObjectMap.entries()Uncompresses a
ByteBuf encoded with the LZ4 format.Compresses a
ByteBuf using the LZ4 format.Uncompresses a
ByteBuf encoded with the LZF format.Compresses a
ByteBuf using the LZF format.Compresses a
ByteBuf using the LZMA algorithm.DnsServerAddressStreamProvider implementation which makes use of the same mechanism as
Apple's open source mDNSResponder to retrieve the
current nameserver configuration of the system.IoEventLoop implementation that is owned by the user and so needs to be driven by the user manually with the
given Thread.Maintains the mapping from the objects of one type to the objects of the other type.
This provider is responsible to get a
Marshaller for the given ChannelHandlerContext.Decoder which MUST be used with
MarshallingEncoder.MessageToByteEncoder implementation which uses JBoss Marshalling to marshal
an Object.Math utility methods.
RecvByteBufAllocator that limits a read operation based upon a maximum value per individual read
and a maximum amount when a read operation is attempted by the event loop.RecvByteBufAllocator that limits the number of read operations that will be attempted when a read operation
is attempted by the event loop.An Memcache content chunk.
Marker interface for both ascii and binary messages.
Defines a common interface for all
MemcacheObject implementations.Memory implementation of Attributes
Default FileUpload implementation that stores file into memory.
Warning: be aware of the memory limitation.
Warning: be aware of the memory limitation.
Raised by
MessageAggregator when aggregation fails due to an unexpected message sequence.An abstract
ChannelHandler that aggregates a series of message objects into a single aggregated message.Formats messages according to very simple substitution rules.
Responsible to estimate the size of a message.
ChannelOutboundHandlerAdapter which encodes message in a stream-like fashion from one message to an
ByteBuf.A Codec for on-the-fly encoding/decoding of message.
ChannelInboundHandlerAdapter which decodes from one message to an other message.ChannelOutboundHandlerAdapter which encodes from one message to an other message
For example here is an implementation which decodes an Integer to an String.Mixed implementation using both in Memory and in File with a limit of size
Mixed implementation using both in Memory and in File with a limit of size
A fake
Ticker that allows the caller control the flow of time.A multi-producer (concurrent and thread-safe
offer and fill),
single-consumer (single-threaded poll and drain) queue of primitive integers.This implementation is based on MpscAtomicUnpaddedArrayQueue from JCTools.
See MQTTV3.1/connack
Variable header of
MqttConnectMessageSee MQTTV3.1/connect
Payload of
MqttConnectMessageReturn Code of
MqttConnAckMessageVariable Header for the
MqttConnectMessageA
MqttIdentifierRejectedException which is thrown when a CONNECT request contains invalid client identifier.Base class for all MQTT message types.
Utility class with factory methods to create different types of MQTT messages.
Variable Header containing, Packet Id and Properties as in MQTT v5 spec.
Variable Header containing only Message Id
See MQTTV3.1/msg-id
MQTT Message Types.
MQTT Properties container
MQTT property base class
Deprecated.
See MQTTV3.1/puback
See MQTTV3.1/publish
Variable Header of the
MqttPublishMessageVariable Header containing Packet Id, reason code and Properties as in MQTT v5 spec.
Variable Header for AUTH and DISCONNECT messages represented by
MqttMessageProvides a set of enumeration that exposes standard MQTT 5 reason codes used by various messages.
Reason codes for MQTT Auth message.
Reason codes for MQTT Disconnect message.
Reason codes for MQTT PubAck message.
Reason codes for MQTT PubComp message.
Reason codes for MQTT PubRec message.
Reason codes for MQTT PubRel message.
Reason codes for MQTT SubAck message.
Reason codes for MQTT UnsubAck message.
See MQTTV3.1/suback
Payload of the
MqttSubAckMessagePayload of the
MqttSubscribeMessageModel the SubscriptionOption used in Subscribe MQTT v5 packet
Contains a topic name and Qos Level.
A
MqttUnacceptableProtocolVersionException which is thrown when
a CONNECT request contains unacceptable protocol version.Payload for MQTT unsuback message as in V5.
Payload of the
MqttUnsubscribeMessageMqtt version specific constant values used by multiple classes in mqtt-codec.
A
DnsServerAddressStreamProvider which iterates through a collection of
DnsServerAddressStreamProvider until the first non-null result is found.Interface for
SearchProcessor that implements simultaneous search for multiple strings.Abstract base class for
EventExecutorGroup implementations that handles their tasks with multiple threads at
the same time.Abstract base class for
EventLoopGroup implementations that handles their tasks with multiple threads at
the same time.IoEventLoopGroup implementation that will handle its tasks with multiple threads.Resolves an arbitrary string that represents the name of an endpoint into an address.
Special
Comparator implementation to sort the nameservers to use when follow redirects.Native helper methods
Internal usage only!
Helper class to load JNI resources.
A utility class for wrapping calls to
Runtime.A class that holds a number of network-related constants.
Provides
ChannelOption over a given SocketOption which is then passed through the underlying
NetworkChannel.An NIO datagram
Channel that sends and receives an
AddressedEnvelopeinvalid input: '<'ByteBuf, SocketAddress>.DuplexChannel which uses NIO selector based implementation to support
UNIX Domain Sockets.Deprecated.
Use
SingleThreadIoEventLoop with NioIoHandlerDeprecated.
IoEvent that must be handled by the NioIoHandle.IoHandle subtype for NIO based implementations that will work with NioIoHandler.Implementation of
IoOps for
that is used by NioIoHandler and so for NIO based transports.SctpChannel implementation which use non-blocking mode and allows to read /
write SctpMessages to the underlying SctpChannel.SctpServerChannel implementation which use non-blocking mode to accept new
connections and create the NioSctpChannel for them.Allows to create an
IoHandle for a SelectableChannel, not necessarily created by Netty.A
ServerChannel implementation which uses
NIO selector based implementation to support UNIX Domain Sockets.A
ServerSocketChannel implementation which uses
NIO selector based implementation to accept new connections.SocketChannel which uses NIO selector based implementation.An arbitrary task that can be executed by
NioEventLoop when a SelectableChannel becomes ready.Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
EventExecutorGroup which will preserve Runnable execution order but makes no guarantees about what
EventExecutor (and therefore Thread) will be used to execute the Runnables.A
AddressResolver that does not perform any resolution but always reports successful resolution.A noop
AuthoritativeDnsServerCache that actually never caches anything.A noop DNS cache that actually never caches anything.
Special
SSLException which will get thrown if a packet is
received that not looks like a TLS/SSL record.Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Light-weight object pool.
Handle for an pooled
Object that will be used to notify the ObjectPool once it can
reuse the pooled Object again.Deprecated.
For removal.
A grab-bag of useful utility methods.
A handler for SSL clients to handle and act upon stapled OCSP responses.
OcspServerCertificateValidator validates incoming server's certificate
using OCSP.Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use
NioSctpChannel.Deprecated.
use
NioSctpServerChannel.Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Tells if
netty-tcnative and its OpenSSL support
are available.Deprecated.
Wraps another
KeyManagerFactory and caches its chains / certs for an alias for better performance when using
SslProvider.OPENSSL or SslProvider.OPENSSL_REFCNT.Provides compression and decompression implementations for TLS Certificate Compression
(RFC 8879).
Configuration for TLS1.3 certificate compression extension.
The configuration for algorithm.
The usage mode of the
OpenSslCertificateCompressionAlgorithm.Builder for an
OpenSslCertificateCompressionAlgorithm.A special
CertificateException which allows to specify which error code is included in the
SSL Record.A client-side
SslContext which uses OpenSSL's SSL/TLS implementation.This class will use a finalizer to ensure native resources are automatically cleaned up.
Deprecated.
Implements a
SSLEngine using
OpenSSL BIO abstractions.Deprecated.
Allow to customize private key signing / decrypting (when using RSA).
A server-side
SslContext which uses OpenSSL's SSL/TLS implementation.OpenSslSessionContext implementation which offers extra methods which are only useful for the server-side.SSLSession sub-type that is used by our native implementation.OpenSSL specific
SSLSessionContext implementation.Stats exposed by an OpenSSL session context.
Session Ticket Key
Special
KeyManagerFactory that pre-compute the keymaterial used when SslProvider.OPENSSL or
SslProvider.OPENSSL_REFCNT is used and so will improve handshake times and its performance.OptionalSslHandler is a utility decoder to support both SSL and non-SSL handlers
based on the first message received.Marker interface for
EventExecutors that will process all submitted tasks in an ordered / serial fashion.OutOfMemoryError that is throws if PlatformDependent.allocateDirectNoCleaner(int) can not allocate
a new ByteBuffer due memory restrictions.PcapWriteHandler captures ByteBuf from SocketChannel / ServerChannel
or DatagramPacket and writes it into Pcap OutputStream.Builder for
PcapWriteHandlerUser credentials discovered for the peer unix domain socket.
This is a special purpose implementation of a
PrivateKey which allows the
user to pass PEM/PKCS#8 encoded key material straight into OpenSslContext
without having to parse and re-encode bytes in Java land.This is a special purpose implementation of a
X509Certificate which allows
the user to pass PEM/PKCS#8 encoded data straight into OpenSslContext without
having to parse and re-encode bytes in Java land.Some pending write which should be picked up later.
A queue of write operations which are pending for later execution.
permessage-deflate
handshake implementation.
permessage-deflate
handshake implementation.
Web Socket frame containing binary data.
Utility that detects various properties specific to the current runtime
environment, such as Java version and the availability of the
sun.misc.Unsafe object.Web Socket frame containing binary data.
Expose metrics for an arena.
Metrics for a list of chunks.
Metrics for a chunk.
Exposed metric for
PooledByteBufAllocator.Metrics for a sub-page.
Wraps another
ByteBufAllocator and use heapbuffers everywhere except when a direct buffer is explicit
requested.A
CodecException which is thrown when a Channel is closed unexpectedly before
the codec finishes handling the current message, such as missing response while waiting for a
request.Provides methods for
DefaultPriorityQueue to maintain internal state.A
Future which is used to indicate the progress of an operation.Special
ProgressiveFuture which is writable.Special
Future which is writable.Deprecated.
A promise combiner monitors the outcome of a number of discrete futures, then notifies a final, aggregate promise
when all of the combined futures are finished.
Internal utilities to notify
Promises.GenericFutureListener implementation which takes other Promises
and notifies them on completion.A decoder that splits the received
ByteBufs dynamically by the
value of the Google Protocol Buffers
Base
128 Varints integer length field in the message.An encoder that prepends the Google Protocol Buffers
Base
128 Varints integer length field.
Result of detecting a protocol.
The state of the current detection.
A common abstraction for protocols that establish blind forwarding proxy tunnels.
Configuration used for setup
qlog.
A strategy that determines when to send acknowledgment of new table
entries on the QPACK decoder stream.
Exception thrown if an error happens during QPACK processing.
Splits an HTTP query string into a path string and key-value parameter pairs.
Creates a URL-encoded URI from a path string and key-value parameter pairs.
A QUIC
Channel.Bootstrap that helps to bootstrap
QuicChannels and connecting these to remote peers.A QUIC
ChannelConfig.ChannelOptions specific to QUIC.QuicCodecBuilder that configures and builds a ChannelHandler that should be added to the
ChannelPipeline of a QUIC client.Special
QuicClosedChannelException which also provides extra info if the close was a result of a
QuicConnectionCloseEvent that was triggered by the remote peer.Abstract base class for
QUIC codec builders.Special
ChannelHandler that should be used to init Channels that will be used
for QUIC while SO_REUSEPORT is used to
bind to same InetSocketAddress multiple times.Available congestion control algorithms to use.
A
QuicConnectionAddress that can be used to connect too.Event that is generated if the remote peer sends a
CLOSE_CONNECTION frame.
Creates new connection id instances.
Statistics about a path of the
QUIC connection.Statistics about the
QUIC connection.Used when the remote peer supports the
QUIC DATAGRAM extension.
Marker interface for events that will be passed through the
ChannelPipeline via
ChannelPipeline.fireUserEventTriggered(Object) to notify the user about QUIC
specific events.Exception produced while processing
QUIC.Marker interface for events that will be passed through the
ChannelPipeline via
ChannelPipeline.fireUserEventTriggered(Object) to notify the user about supported
QUIC extensions by the remote peer.Parses the QUIC packet header and notifies a callback once parsing was successful.
Called when a QUIC packet and its header could be parsed.
The type of the
QUIC packet.
A network path specific
QuicEvent.Generate
stateless reset tokens to use.
QuicCodecBuilder that configures and builds a ChannelHandler that should be added to the
ChannelPipeline of a QUIC server.Special
SslContext that can be used for QUIC.Builder for configuring a new SslContext for creation.
An
SSLEngine that can be used for QUIC.SSLSessionContext which also supports advanced operations.A
SocketAddress for QUIC stream.A QUIC stream.
Allows to bootstrap outgoing
QuicStreamChannels.DuplexChannelConfig for QUIC streams.A QUIC STREAM_FRAME.
Event fired once the stream limit of a
QuicChannel changes.The priority of a
QuicStreamChannel.Signals a stream reset.
The type of a
QuicStreamChannel.Special
ClosedChannelException that is used in case of closure caused by the idle timeout.Handle token related operations.
Transport parameters for QUIC.
WebSocketFrameMaskGenerator implementation which returns a random int for masking.Deprecated.
Do not use.
A variant of
Http2Headers which only supports read-only methods.A variant of
HttpHeaders which only supports read-only methods.A
TimeoutException raised by ReadTimeoutHandler when no data
was read within a certain period of time.Raises a
ReadTimeoutException when no data was read within a certain
period of time.Allocates a new receive buffer whose capacity is probably large enough to read all inbound data and small enough
not to waste its space.
A
RecvByteBufAllocator.Handle which delegates all call to some other RecvByteBufAllocator.Handle.Deprecated.
A simple list which is recyclable.
Light-weight object pool based on a thread-local stack.
Aggregates
RedisMessage parts into ArrayRedisMessage.A
ChannelHandler that aggregates an BulkStringHeaderRedisMessage
and its following BulkStringRedisContents into a single FullBulkStringRedisMessage
with no following BulkStringRedisContents.Decodes the Redis protocol into
RedisMessage objects following
RESP (REdis Serialization Protocol).Encodes
RedisMessage into bytes following
RESP (REdis Serialization Protocol).RedisMessage is base interface for codec-redis.
A strategy interface for caching
RedisMessages.Type of RESP (REdis Serialization Protocol).
Monomorphic reference counter implementation that always use the most efficient available atomic updater.
A reference-counted object that requires explicit deallocation.
A client-side
SslContext which uses OpenSSL's SSL/TLS implementation.An implementation of
SslContext which works with libraries that support the
OpenSsl C library API.Implements a
SSLEngine using
OpenSSL BIO abstractions.A server-side
SslContext which uses OpenSSL's SSL/TLS implementation.Deprecated.
Instead of extending this class, prefer instead to include a
RefCnt field and delegate to that.Collection of method to handle objects that may implement
ReferenceCounted.A
ChannelFactory that instantiates a new Channel by invoking its default constructor reflectively.Similar to
RejectedExecutionHandler but specific to SingleThreadEventExecutor.Expose helper methods which create different
RejectedExecutionHandlers.A specialized variation of
ByteToMessageDecoder which enables implementation
of a non-blocking decoder in the blocking I/O paradigm.ChannelOutboundHandlerAdapter which will resolve the SocketAddress that is passed to
ResolveAddressHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise) if it is not already resolved
and the AddressResolver supports the type of SocketAddress.Defined resolved address types.
Deprecated.
please use
ResourceLeakTracker as it may lead to false-positives.Represents the level of resource leak detection.
This static factory should be used to load
ResourceLeakDetectors as neededDeprecated.
This class will be removed in the future version.
A hint object that provides human-readable message for easier resource leak tracking.
A utility class that provides various common operations and constants
related to loading resources
An interface that
TrustManager instances can implement, to be notified of resumed SSL sessions.A simple HTTP server that serves Certificate Revocation Lists.
A
AddressResolverGroup of DnsNameResolvers that supports random selection of destination addresses if
multiple are provided by the nameserver.A
NameResolver that resolves InetAddress and force Round Robin by choosing a single address
randomly in SimpleNameResolver.resolve(String) and SimpleNameResolver.resolve(String, Promise)
if multiple are returned by the NameResolver.Decodes
ByteBufs into RTSP messages represented in
HttpMessages.Standard RTSP header names.
Deprecated.
Use
RtspHeaderNames or RtspHeaderValues instead.Deprecated.
Use
RtspHeaderNames instead.Deprecated.
Use
RtspHeaderValues instead.Standard RTSP header names.
The request getMethod of RTSP.
Deprecated.
Use
RtspDecoder instead.Deprecated.
Use
RtspEncoder instead.Deprecated.
Use
RtspDecoder directly insteadDeprecated.
Use
RtspEncoder directly insteadDeprecated.
Use
RtspDecoder directly insteadDeprecated.
Use
RtspEncoder directly insteadThe getStatus code and its description of a RTSP response.
The version of RTSP.
This class allows one to filter new
Channels based on the
IpFilterRules passed to its constructor.Deprecated.
this transport will be removed in the next major version.
Deprecated.
this transport will be removed in the next major version.
Deprecated.
this transport will be removed in the next major version.
Deprecated.
this transport will be removed in the next major version.
The result of a scheduled asynchronous operation.
A SCTP/IP
Channel interface for single SCTP association.A
ChannelConfig for a SctpChannel.Option for configuring the SCTP transport
A ChannelHandler which receives
SctpMessages which belong to a application protocol form a specific
SCTP Stream and decode it as ByteBuf.Representation of SCTP Data Chunk
MessageToMessageDecoder which will take care of handle fragmented SctpMessages, so
only complete SctpMessages will be forwarded to the next
ChannelInboundHandler.AbstractNotificationHandler implementation which will handle all Notifications by trigger a
Notification user event in the ChannelPipeline of a SctpChannel.A ChannelHandler which transform
ByteBuf to SctpMessage and send it through a specific stream
with given protocol identifier.A SCTP/IP
ServerChannel which accepts incoming SCTP/IP associations.A
ChannelConfig for a SctpServerChannelConfig.Interface for
ByteProcessor that implements string search.Deprecated.
Allows to use GSO
if the underlying OS supports it.
Used to allocate datagram packets that use UDP_SEGMENT (GSO).
Select strategy interface.
Factory that creates a new
SelectStrategy every time.Deprecated.
Use the
CertificateBuilder from netty-pkitesting instead.A
DnsServerAddressStreamProvider which is backed by a sequential list of DNS servers.Bootstrap sub-class which allows easy bootstrap of ServerChannelExposes the configuration of a
ServerBootstrapConfig.MaxMessagesRecvByteBufAllocator implementation which should be used for ServerChannels.A RFC6265 compliant cookie decoder to be used server side.
A RFC6265 compliant cookie encoder to be used server side,
so some fields are sent (Version is typically ignored).
Deprecated.
Use
ServerCookieEncoder insteadA TCP/IP
ServerChannel which accepts incoming TCP/IP connections.A
ChannelConfig for a ServerSocketChannel.Utilities for short-based primitive collections.
A hash map implementation of
ShortObjectMap that uses open addressing for keys.Interface for a primitive map that uses
shorts as keys.A primitive entry in the map, provided by the iterator from
ShortObjectMap.entries()A special
Error which is used to signal some state or request by throwing it.ChannelInboundHandlerAdapter which allows to explicit only handle a specific type of messages.Simple
ChannelPool implementation which will create new Channels if someone tries to acquire
a Channel but none is in the pool atm.Helps to implement a custom
KeyManagerFactory.A skeletal
NameResolver implementation.Simple Strings of RESP.
Helps to implement a custom
TrustManagerFactory.ChannelInboundHandlerAdapter which allows to conveniently only handle a specific type of user events.Abstract base class for
OrderedEventExecutor's that execute all its submitted tasks in a single thread.Deprecated.
override
SingleThreadEventExecutor.wakesUpForTask(Runnable) to re-create this behaviourAbstract base class for
EventLoops that execute all its submitted tasks in a single thread.IoEventLoop implementation that execute all its submitted tasks in a single thread using the provided
IoHandler.A
DnsServerAddressStreamProvider which always uses a single DNS server for resolution.Expose metrics for an SizeClasses.
Logger factory which creates a SLF4J
logger.
Deprecated.
Do not use.
The command part of a
SmtpRequest.Content that is sent after the
DATA request.An SMTP request.
Encoder for SMTP requests.
Provides utility methods to create
SmtpRequests.A SMTP response
Decoder for SMTP responses.
Deprecated.
Use
SnappyFrameDecoder instead.Uncompresses a
ByteBuf encoded with the Snappy framing format.Deprecated.
Use
SnappyFrameEncoder instead.Compresses a
ByteBuf using the Snappy framing format.SnappyOptions holds config for
Snappy compression.Event that is fired once we did a selection of a
SslContext based on the SNI hostname,
which may be because it was successful or there was an error.Enables SNI
(Server Name Indication) extension for server side SSL.
Provides a JNI bridge to native socket operations.
A TCP/IP socket
Channel.A
ChannelConfig for a SocketChannel.ProtocolFamily implementation that is used by the different transport implementations.Provides socket operations with privileges enabled.
Decodes a single
Socks4CommandResponse from the inbound ByteBufs.Encodes a
Socks4CommandRequest into a ByteBuf.A SOCKS4a
CONNECT or BIND request.A SOCKS4a response.
The status of
Socks4CommandResponse.The type of
Socks4CommandRequest.A tag interface that all SOCKS4a protocol messages implement.
Handler that establishes a blind forwarding proxy tunnel using
SOCKS4 protocol.
Decodes a single
Socks4CommandRequest from the inbound ByteBufs.Encodes a
Socks4CommandResponse into a ByteBuf.Decodes a SOCKS5 address field into its string representation.
Encodes a SOCKS5 address into binary representation.
The type of address in
Socks5CommandRequest and Socks5CommandResponse.The authentication method of SOCKS5.
Encodes a client-side
Socks5Message into a ByteBuf.A SOCKS5 request detail message, as defined in
the section 4, RFC1928.
Decodes a single
Socks5CommandRequest from the inbound ByteBufs.A response to a SOCKS5 request detail message, as defined in
the section 6, RFC1928.
Decodes a single
Socks5CommandResponse from the inbound ByteBufs.The status of
Socks5CommandResponse.The type of
Socks5CommandRequest.An initial SOCKS5 authentication method selection request, as defined in
the section 3, RFC1928.
Decodes a single
Socks5InitialRequest from the inbound ByteBufs.An initial SOCKS5 authentication method selection request, as defined in
the section 3, RFC1928.
Decodes a single
Socks5InitialResponse from the inbound ByteBufs.A tag interface that all SOCKS5 protocol messages implement.
A SOCKS5 subnegotiation request for username-password authentication, as defined in
the section 2, RFC1929.
Decodes a single
Socks5PasswordAuthRequest from the inbound ByteBufs.A SOCKS5 subnegotiation response for username-password authentication, as defined in
the section 2, RFC1929.
Decodes a single
Socks5PasswordAuthResponse from the inbound ByteBufs.The status of
Socks5PasswordAuthResponse.A SOCKS5 subnegotiation request for private authentication.
Decodes a single
Socks5PrivateAuthRequest from the inbound ByteBufs.A SOCKS5 subnegotiation response for private authentication.
Decodes a single
Socks5PrivateAuthResponse from the inbound ByteBufs.The status of a SOCKS5 private authentication response.
Handler that establishes a blind forwarding proxy tunnel using
SOCKS Protocol Version 5.
Encodes a server-side
Socks5Message into a ByteBuf.An socks auth request.
Decodes
ByteBufs into SocksAuthRequest.An socks auth response.
Decodes
ByteBufs into SocksAuthResponse.An socks cmd request.
Decodes
ByteBufs into SocksCmdRequest.A socks cmd response.
Decodes
ByteBufs into SocksCmdResponse.An socks init request.
Decodes
ByteBufs into SocksInitRequest.An socks init response.
Decodes
ByteBufs into SocksInitResponse.An abstract class that defines a SocksMessage, providing common properties for
SocksRequest and SocksResponse.An interface that all SOCKS protocol messages implement.
Encodes an
SocksMessage into a ByteBuf.Detects the version of the current SOCKS connection and initializes the pipeline with
Socks4ServerDecoder or Socks5InitialRequestDecoder.An abstract class that defines a SocksRequest, providing common properties for
SocksInitRequest, SocksAuthRequest, SocksCmdRequest and UnknownSocksRequest.Type of socks request
An abstract class that defines a SocksResponse, providing common properties for
SocksInitResponse, SocksAuthResponse, SocksCmdResponse and UnknownSocksResponse.Type of socks response
The version of SOCKS protocol.
A SPDY Protocol DATA Frame
A SPDY Protocol Frame
A
ChannelHandler that encodes and decodes SPDY Frames.Decodes
ByteBufs into SPDY Frames.Callback interface for
SpdyFrameDecoder.Encodes a SPDY Frame into a
ByteBuf.A SPDY Protocol GOAWAY Frame
Super-class for SPDY header-block decoders.
Super-class for SPDY header-block encoders.
Provides the constants for the standard SPDY HTTP header names and commonly
used utility methods that access a
SpdyHeadersFrame.SPDY HTTP header names
A SPDY Protocol HEADERS Frame
A combination of
SpdyHttpDecoder and SpdyHttpEncoderDecodes
SpdySynStreamFrames, SpdySynReplyFrames,
and SpdyDataFrames into FullHttpRequests and FullHttpResponses.Encodes
HttpRequests, HttpResponses, and HttpContents
into SpdySynStreamFrames and SpdySynReplyFrames.Provides the constants for the header names and the utility methods
used by the
SpdyHttpDecoder and SpdyHttpEncoder.SPDY HTTP header names
MessageToMessageCodec that takes care of adding the right SpdyHttpHeaders.Names.STREAM_ID to the
HttpMessage if one is not present.A SPDY Protocol PING Frame
A SPDY Protocol RST_STREAM Frame
Manages streams within a SPDY session.
The SPDY session status code and its description.
A SPDY Protocol SETTINGS Frame
A SPDY Protocol Frame that is associated with an individual SPDY Stream
The SPDY stream status code and its description.
A SPDY Protocol SYN_REPLY Frame
A SPDY Protocol SYN_STREAM Frame
A SPDY Control frame.
A SPDY Protocol WINDOW_UPDATE Frame
ByteToMessageDecoder which allows to be notified once a full ClientHello was received.Event that is fired once the close_notify was received or if an failure happens before it was received.
SSLException which signals that the exception was caused by an SSLEngine which was
closed already.A secure socket protocol implementation which acts as a factory for
SSLEngine and SslHandler.Builder for configuring a new SslContext for creation.
A
SslContextOption allows to configure a SslContext in a type-safe
way.Event which is fired once it's possible to send early data on the client-side.
Event that is fired once the SSL handshake is complete, which may be because it was successful or there
was an error.
SSLHandshakeException that is used when a handshake failed due a configured timeout.The
SslMasterKeyHandler is a channel-handler you can include in your pipeline to consume the master key
invalid input: '&' session identifier for a TLS session.SSL/TLS protocols
An enumeration of SSL/TLS protocol providers.
Session Ticket Key
STOMP command
An STOMP chunk which is used for STOMP chunked transfer-encoding.
Combines
StompHeadersSubframe and LastStompContentSubframe into one
frame.The multimap data structure for the STOMP header names and values.
An interface that defines a
StompFrame's command and headers.Defines a common interface for all
StompSubframe implementations.A
ChannelHandler that aggregates an StompHeadersSubframe
and its following StompContentSubframes into a single StompFrame.Deprecated.
this should never be used by an user!
Implementation of a
Http2ConnectionEncoder that dispatches all method call to another
Http2ConnectionEncoder, until SETTINGS_MAX_CONCURRENT_STREAMS is reached.Thrown if buffered streams are terminated due to this encoder being closed.
Thrown by
StreamBufferingEncoder if buffered streams are terminated due to
receipt of a GOAWAY.An object (used by remote flow control) that is responsible for distributing the bytes to be
written across the streams in the connection.
State information for the stream, indicating the number of bytes that are currently
streamable.
Object that performs the writing of the bytes that have been allocated for a stream.
String utility class.
The
CompleteFuture which is succeeded already.This class will filter all requested ciphers out that are not supported by the current
SSLEngine.Annotation to suppress forbidden-apis errors inside a whole class, a method, or a field.
Deprecated.
Annotation to suppress the Java 8 source code requirement checks for a method.
Deprecated.
use the Little Endian accessors, e.g.
Utility class for SWAR (SIMD within a register) operations.
A collection of utility methods to retrieve and parse the values of the Java system properties.
Web Socket text frame.
Executor that is aware its execution thread.
Deprecated.
will be removed in the next major release
Allow to retrieve the
EventExecutor for the calling Thread.UnmarshallerProvider implementation which use a ThreadLocal to store references
to Marshaller instances.Deprecated.
UnmarshallerProvider implementation which use a ThreadLocal to store references
to Unmarshaller instances.Deprecated.
this will be remove in the next-major release.
Deprecated.
this will be remove in the next-major release.
Expose details for a
Thread.A nanosecond-based time source, e.g.
A
TimeoutException when no data was either read or written within a
certain period of time.Schedules
TimerTasks for one-time future execution in a background
thread.A task which is executed after the delay specified with
Timer.newTimeout(TimerTask, long, TimeUnit).An
DecoderException which is thrown when the length of the frame
decoded is greater than the allowed maximum.An
TooLongFrameException which is thrown when the length of the
content decoded is greater than the allowed maximum.An
TooLongFrameException which is thrown when the length of the
header decoded is greater than the allowed maximum.An
TooLongFrameException which is thrown when the length of the
line decoded is greater than the allowed maximum.Counts the number of read and written bytes for rate-limiting traffic.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
The UDT transport is no longer maintained and will be removed.
Deprecated.
Represents a supplier of
boolean-valued results which doesn't throw any checked exceptions.A
StreamByteDistributor that ignores stream priority and uniformly allocates bytes to all
streams.This class allows one to ensure that at all times for every IP address there is at most one
Channel connected to the server.Tells if
netty-transport-native-unix is
supported.Channel that expose operations that are only present on UNIX like systems.Able to parse files such as /etc/resolv.conf and
/etc/resolver to respect the system default domain servers.
An unknown socks request.
An unknown socks response.
This provider is responsible to get an
Unmarshaller for a ChannelHandlerContextDeprecated.
The behavior of this event executor deviates from the typical Netty execution model
and can cause subtle issues as a result.
Creates a new
ByteBuf by allocating new space or by wrapping
or copying existing byte arrays, byte buffers and a string.Simplistic
ByteBufAllocator implementation that does not pool anything.A NIO
ByteBuffer based buffer.Big endian Java heap buffer implementation.
A NIO
ByteBuffer based buffer.Big endian Java heap buffer implementation.
Indicates a public API that can change at any time (even in minor/bugfix releases).
Thrown if an unsupported message is received by an codec.
UnsupportedOperationException will be thrown from all ValueConverter methods.Converts to/from a generic object to the type.
Retrieves the version information of available Netty artifacts.
A address for a
VM sockets (Linux VSOCK address family).
Decodes
ByteBufs into WebSocketFrames.Encodes a
WebSocketFrame into a ByteBuf.Decodes a web socket frame from wire protocol version 7 format.
Encodes a web socket frame into wire protocol version 7 format.
Decodes a web socket frame from wire protocol version 8 format.
Encodes a web socket frame into wire protocol version 8 format.
Decodes a web socket frame from wire protocol version 13 format.
Encodes a web socket frame into wire protocol version 13 format.
A
ChunkedInput that fetches data chunk by chunk for use with WebSocket chunked transfers.Extends io.netty.handler.codec.http.websocketx.extensions.compression.WebSocketClientExtensionHandler
to handle the most common WebSocket Compression Extensions.
Created once the handshake phase is done.
This handler negotiates and initializes the WebSocket Extensions.
Handshakes a client extension with the server.
Client exception during handshaking process.
Base class for web socket client handshake implementations
Performs client side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
00
Performs client side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
10
Performs client side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
10
Performs client side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
17
Creates a new
WebSocketClientHandshaker of desired protocol version.WebSocket server configuration.
This handler does all the heavy lifting for you to run a websocket client.
Events that are fired to notify about handshake status
WebSocket status codes specified in RFC-6455.
Frames decoder configuration.
Created once the handshake phase is done.
A WebSocket Extension data from the Sec-WebSocket-Extensions header.
Convenient class for io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension decoder.
Convenient class for io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension encoder.
Filter that is responsible to skip the evaluation of a certain extension
according to standard.
Extension filter provider that is responsible to provide filters for a certain
WebSocketExtension extension.Base class for web socket frames.
Handler that aggregate fragmented WebSocketFrame's.
Marker interface which all WebSocketFrame decoders need to implement.
Marker interface which all WebSocketFrame encoders need to implement.
Allows to customize how the mask is generated that is used to mask the
WebSocketFrame.Exception during handshaking process
Defines the common schemes used for the WebSocket protocol as defined by
rfc6455.
Extends io.netty.handler.codec.http.websocketx.extensions.compression.WebSocketServerExtensionHandler
to handle the most common WebSocket Compression Extensions.
Created once the handshake phase is done.
This handler negotiates and initializes the WebSocket Extensions.
Handshakes a client extension based on this server capabilities.
Server exception during handshaking process.
Base class for server side web socket opening and closing handshakes
Performs server side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
00
Performs server side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
10
Performs server side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
10
Performs server side opening and closing handshakes for RFC 6455
(originally web socket specification draft-ietf-hybi-thewebsocketprotocol-17).
Auto-detects the version of the Web Socket protocol in use and creates a new proper
WebSocketServerHandshaker.WebSocket server configuration.
This handler does all the heavy lifting for you to run a websocket server.
The Handshake was completed successfully and the channel was upgraded to websockets.
Events that are fired to notify about handshake status
Versions of the web socket specification.
A
StreamByteDistributor that is sensitive to stream priority and uses
Weighted Fair Queueing approach for distributing
bytes.Wraps another
ByteBuf.WriteBufferWaterMark is used to set low water mark and high water mark for the write buffer.
A
TimeoutException raised by WriteTimeoutHandler when a write operation
cannot finish in a certain period of time.Raises a
WriteTimeoutException when a write operation cannot finish in a certain period of time.A certificate bundle is a private key and a full certificate path, all the way to the root certificate.
XML attributes, it is part of
XmlElementXML CDATA ...
XML characters, e.g.
XML Comment
XML Content is base class for XML CDATA, Comments, Characters and Space
Async XML decoder based on Aalto XML parser.
End of XML document
Beginning of the XML document ... i.e.
DTD (Document Type Definition)
Generic XML element in document,
XmlElementStart represents open element and provides access to attributes,
XmlElementEnd represents closing element.Specific
XmlElement representing end of element.Specific
XmlElement representing beginning of element.XML entity reference ...
A frame decoder for single separate XML based message streams.
XML namespace is part of XML element.
XML processing instruction
White space characters
Creates a new
ZlibEncoder and a new ZlibDecoder.Decompresses a
ByteBuf using the deflate algorithm.Compresses a
ByteBuf using the deflate algorithm.The container file formats that wrap the stream compressed by the DEFLATE
algorithm.
Decompresses a compressed block
ByteBuf using the Zstandard algorithm.Compresses a
ByteBuf using the Zstandard algorithm.ZstdOptions holds compressionLevel for
Zstd compression.