All Classes and Interfaces
Class
Description
A skeletal
AddressResolver implementation.Decoder for both
BinaryMemcacheRequest and BinaryMemcacheResponse.Contains all states this decoder can possibly be in.
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(java.lang.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.Returns the flow-control size for DATA frames, and 9 for all other frames.
ChannelConfig so that the high and low writebuffer watermarks can reflect the outbound flow control
window, without having to create a new WriteBufferWaterMark object whenever the flow control window
changes.The current status of the read-processing for a
AbstractHttp2StreamChannel.Http2FrameStreamVisitor that fires the user event for every active stream pipeline.Abstract implementation of
Http2StreamFrame.Abstract HttpData implementation
A skeletal builder implementation of
InboundHttp2ToHttpAdapter and its subtypes.A skeletal implementation of
InternalLogger.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 derived
ByteBuf implementations.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.Class to implement setReadable at fix time
Special
SwappedByteBuf for ByteBufs that is using unsafe.An auto-tuning pooling
ByteBufAllocator, that follows an anti-generational hypothesis.An auto-tuning pooling allocator, that follows an anti-generational hypothesis.
The strategy for how
AdaptivePoolingAllocator should allocate chunk buffers.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 a way to get the application-level protocol name from ALPN or NPN.
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.
Utility class for application protocol common operations.
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.
A collection of utility methods that is related with handling
AsciiString.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.
AuthoritativeDnsServerCache implementation which delegates all operations to a wrapped DnsCache.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.Contains methods that can be used to detect if BouncyCastle is usable.
Generates a self-signed certificate using Bouncy Castle.
A socket which provides access BSD native methods.
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.
on OpenJDK Adler32 and CRC32 both calls ZipUtils.loadLibrary on class init.
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.
An empty map.
An unmodifiable wrapper around a
ByteObjectMap.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 an
other Message type.Cumulate
ByteBufs.An bit reader that allows the reading of single bit booleans, bit strings of
arbitrary length (up to 32 bits), and bit aligned 32-bit integers.
A bit writer that allows the writing of single bit booleans, unary numbers, bit strings
of arbitrary length (up to 32 bits), and bit aligned 32-bit integers.
Compresses and writes a single Bzip2 block.
Block encoding consists of the following stages:
1.
Block encoding consists of the following stages:
1.
Reads and decompresses a single Bzip2 block.
Block decoding consists of the following stages:
1.
Block decoding consists of the following stages:
1.
Constants for both the
Bzip2Encoder and the Bzip2Decoder.Uncompresses a
ByteBuf encoded with the Bzip2 format.Current state of stream.
DivSufSort suffix array generator.
Based on libdivsufsort 1.2.3 patched to support Bzip2.
This is a simple conversion of the original C with two minor bugfixes applied (see "BUGFIX" comments within the class).
Based on libdivsufsort 1.2.3 patched to support Bzip2.
This is a simple conversion of the original C with two minor bugfixes applied (see "BUGFIX" comments within the class).
Compresses a
ByteBuf using the Bzip2 algorithm.Current state of stream.
An in-place, length restricted Canonical Huffman code length allocator.
Based on the algorithm proposed by R.
Based on the algorithm proposed by R.
A decoder for the Bzip2 Huffman coding stage.
An encoder for the Bzip2 Huffman encoding stage.
A 256 entry Move To Front transform.
An encoder for the Bzip2 Move To Front Transform and Run-Length Encoding[2] stages.
Although conceptually these two stages are separate, it is computationally efficient to perform them in one pass.
Although conceptually these two stages are separate, it is computationally efficient to perform them in one pass.
Random numbers for decompress Bzip2 blocks.
Abstract cache that automatically removes entries for a hostname once the TTL for an entry is reached.
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.Indicates that the annotated event handler method in
ChannelHandler will not be invoked by
ChannelPipeline and so MUST only be used when the ChannelHandler
method does nothing except forward to the next ChannelHandler in the pipeline.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.
The configurable facade that decides what
ChannelInitializerExtensions to load and where to find them.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.
An empty map.
An unmodifiable wrapper around a
CharObjectMap.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.
Used to store nullable values in a CHM
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
Allows to free direct
ByteBuffers.Allows to free direct
ByteBuffer by using Cleaner.Provide a way to clean a ByteBuffer on Java9+.
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.Special
AbstractList implementation which is used within our codec base classes.Will add multiple values for the same header as single header with a comma separated list of values.
Escapes comma separated values (CSV).
Deprecated.
Deprecated.
Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
A skeletal
ChannelFuture implementation which represents a
ChannelFuture which has been completed already.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.Compression Encoder Factory for create
MessageToByteEncoder
used to compress http contentAn
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.
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.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.
Deprecated.
Duplicate of package private $
CookieUtilAn
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.This class is used for preflight HTTP response values that do not need to be
generated, but instead the value is "static" in that the same value will be returned
for each call.
This callable is used for the DATE preflight HTTP response HTTP header.
Handles Cross Origin Resource Sharing (CORS) requests.
A CRC32 calculator.
Implements CRC32-C as defined in:
"Optimization of Cyclic Redundancy-CHeck Codes with 24 and 32 Parity Bits",
IEEE Transactions on Communications 41(6): 883-892 (1993).
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
ChannelGroupFuture 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.MultithreadEventLoopGroup which must be used for the local transport.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.Allows events which would modify the collection of active streams to be queued while iterating via
DefaultHttp2Connection.forEachActiveStream(Http2StreamVisitor).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.An abstraction which provides specific extensions used by local flow control.
The default
Http2PingFrame implementation.Default implementation of Http2PriorityFrame
Default implementation of
Http2PushPromiseFrameBasic implementation of
Http2RemoteFlowController.The default
Http2ResetFrame implementation.The default
Http2SettingsAckFrame implementation.The default
Http2SettingsFrame implementation.The default
Http2WindowUpdateFrame implementation.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.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.Default select strategy.
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
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.Deflate implementation of a payload decompressor for
io.netty.handler.codec.http.websocketx.WebSocketFrame.
Deflate implementation of a payload compressor for
io.netty.handler.codec.http.websocketx.WebSocketFrame.
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.Provides the state for stream
DATA frame decompression.Adapter class which allows to wrap another
SslContext and init SSLEngine instances.DeleteFileOnExitHook.
A decoder that splits the received
ByteBufs by one or more
delimiters.A set of commonly used delimiters for
DelimiterBasedFrameDecoder.Disk implementation of Attributes
Disk FileUpload implementation that stores file into real files
Decodes an
InetAddress from an A or AAAA DnsRawRecord.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.Provides some utility methods for DNS message implementations.
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.
Special data-structure that will allow to retrieve the next query id to use, while still guarantee some sort
of randomness.
Provides a query if from a range of possible ids.
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.
Holds the closed DNS Servers for a domain.
Represent the
dns_resolver_t struct.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.
Immutable mapping from domain name pattern to its associated value object.
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.A dummy
ChannelId implementation.An empty
ByteBuf whose capacity and maximum capacity are all 0.Deprecated.
An
CodecException which is thrown by an encoder.Wraps an existing
X509ExtendedTrustManager and enhances the CertificateException that is thrown
because of hostname validation.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.
EventLoop which uses epoll under the covers.EventLoopGroup which uses epoll under the covers.The epoll mode to use.
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!
This class is necessary to break the following cyclic dependency:
JNI_OnLoad
JNI Calls FindClass because RegisterNatives (used to register JNI methods) requires a class
FindClass loads the class, but static members variables of that class attempt to call a JNI method which has not
yet been registered.
java.lang.UnsatisfiedLinkError is thrown because native method has not yet been registered.
Static members which call JNI methods must not be declared in this class!
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.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.Delegates all operations to a wrapped
OpenSslSession except the methods defined by ExtendedSSLSession
itself.The
CompleteChannelFuture which is failed already.The
CompleteFuture which is failed already.Core of FastLZ compression algorithm.
Uncompresses a
ByteBuf encoded by FastLzFrameEncoder using the FastLZ algorithm.Current state of decompression.
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.A recyclable
ArrayDeque.ChannelDuplexHandler which consolidates Channel.flush() / ChannelHandlerContext.flush()
operations (which also includes
ChannelOutboundInvoker.writeAndFlush(Object) / ChannelOutboundInvoker.writeAndFlush(Object, ChannelPromise) and
ChannelOutboundInvoker.writeAndFlush(Object) /
ChannelOutboundInvoker.writeAndFlush(Object, ChannelPromise)).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.Class to implement monitoring at fix delay.
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.Convert java naming to OpenSSL naming if possible and if not return the original name.
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.Bucket that stores HashedWheelTimeouts.
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.Utility class for heap buffers.
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.
HTTP/2 header types.
An HPACK encoder.
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.
Provides the ability to associate the outcome of multiple
ChannelPromise
objects into a single ChannelPromise object.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
Http2FrameListenerCloses the channel when the future completes.
Builder which builds
Http2ConnectionHandler objects.Signifies that the connection preface and
the initial SETTINGS frame have been sent.
DecoratingHttp2ConnectionEncoder which guards against a remote peer that will trigger a massive amount
of control frames but will not consume our responses to these.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.
Enforce a limit on the maximum number of consecutive empty DATA frames (without end_of_stream flag) that are allowed
before the connection will be closed.
Enforce a limit on the maximum number of consecutive empty DATA frames (without end_of_stream flag) that are allowed
before the connection will be closed.
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.This API is very immature. The Http2Connection-based API is currently preferred over this API.
Http2FrameStream implementation.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.Enforce a limit on the maximum number of RST frames that are allowed per a window
before the connection will be closed with a GO_AWAY frame.
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.
ChannelId implementation which is used by our
Http2StreamChannel implementation.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.
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 the HTTP header extensions used to carry HTTP/2 information in HTTP objects
Utility which translates HTTP/2 headers to HTTP/1 headers.
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 insteadFirst obsolete format
Second obsolete format
Standard 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.Provides some utility methods for HTTP message implementations.
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.The internal state of
HttpObjectDecoder.Shared Static object between HttpMessageDecoder, HttpPostRequestDecoder and HttpPostRequestEncoder
This class intends to decrease the CPU in seeking ahead some bytes in
HttpPostRequestDecoder
Allowed mechanism for multipart
mechanism := "7bit"
/ "8bit"
/ "binary"
Not allowed: "quoted-printable"
/ "base64"
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
...
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.
Allows messages to be sent up the pipeline before the next phase in the
HTTP message flow is detected.
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.
An insecure
TrustManagerFactory that trusts all X.509 certificates without any verification.Utilities for int-based primitive collections.
An empty map.
An unmodifiable wrapper around a
IntObjectMap.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.
This Attribute is only for Encoder use to insert special command between object if needed
(like Multipart Mixed mode)
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.Internet Protocol (IP) families used by the
DatagramChannelA 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()Internal primitive priority queue, used by
PoolChunk.Represents a supplier of
int-valued results.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.This comparator is only used for searching.
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.Common base class for
JdkApplicationProtocolNegotiator classes to inherit from.The
JdkApplicationProtocolNegotiator to use if you do not care about NPN or ALPN and are using
SslProvider.JDK.java.util.logging
logger.
Logger factory which creates a
java.util.logging
logger.
Deprecated.
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.
Represents an array of kevent structures, backed by offheap memory.
EventLoop which uses kqueue under the covers.This class is necessary to break the following cyclic dependency:
JNI_OnLoad
JNI Calls FindClass because RegisterNatives (used to register JNI methods) requires a class
FindClass loads the class, but static members variables of that class attempt to call a JNI method which has not
yet been registered.
java.lang.UnsatisfiedLinkError is thrown because native method has not yet been registered.
Static members which call JNI methods must not be declared in this class!
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 batchA 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.
This class is necessary to break the following cyclic dependency:
JNI_OnLoad
JNI Calls FindClass because RegisterNatives (used to register JNI methods) requires a class
FindClass loads the class, but static members variables of that class attempt to call a JNI method which has not
yet been registered.
java.lang.UnsatisfiedLinkError is thrown because native method has not yet been registered.
Static members which call JNI methods must not be declared in this class!
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.
Use
DefaultEventLoopGroup instead.A
ServerChannel for the local transport which allows in VM communication.SLF4J logger which is location aware and so will log the correct origin of the
logging event by filter out the wrapper itself.
Apache Log4J
logger.
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.
An empty map.
An unmodifiable wrapper around a
LongObjectMap.Counter for long.
Internal primitive map implementation that is specifically optimised for the runs availability map use case in
PoolChunk.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()DnsServerAddressStreamProvider implementation which makes use of the same mechanism as
Apple's open source mDNSResponder to retrieve the
current nameserver configuration of the system.Maintains the mapping from the objects of one type to the objects of the other type.
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
See MQTTV3.1/connack
Variable header of
MqttConnectMessageSee MQTTV3.1/connect
Payload of
MqttConnectMessageReturn Code of
MqttConnAckMessageVariable Header for the
MqttConnectMessageStates of the decoder.
A
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
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.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
Native helper methods
Support sendmmsg(...) on linux with GLIBC 2.14+
Internal usage only!
Helper class to load JNI resources.
A Utility to Call the
System.load(String) or System.loadLibrary(String).This class is necessary to break the following cyclic dependency:
JNI_OnLoad
JNI Calls FindClass because RegisterNatives (used to register JNI methods) requires a class
FindClass loads the class, but static members variables of that class attempt to call a JNI method which has not
yet been registered.
java.lang.UnsatisfiedLinkError is thrown because native method has not yet been registered.
Static members which call JNI methods must not be declared in this class!
A utility class for wrapping calls to
Runtime.Holder class for available processors to enable testing.
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>.The default
NioDatagramChannelConfig implementation.DuplexChannel which uses NIO selector based implementation to support
UNIX Domain Sockets.SingleThreadEventLoop implementation which register the Channel's to a
Selector and so does the multi-plexing of these in the event loop.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.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.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.Creates a new Object which references the given
ObjectPool.Handle and calls ObjectPool.Handle.recycle(Object) once
it can be re-used.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.
Generates a self-signed certificate using
sun.security.x509 package provided by OpenJDK.Tells if
netty-tcnative and its OpenSSL support
are available.Deprecated.
OpenSslKeyMaterialProvider that will cache the OpenSslKeyMaterial to reduce the overhead
of parsing the chain and the key for generation of the material.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.OpenSslSessionCache that is used by the client-side.Host / Port tuple used to find a
OpenSslSession in the cache.This class will use a finalizer to ensure native resources are automatically cleaned up.
Deprecated.
Implements a
SSLEngine using
OpenSSL BIO abstractions.Holds references to the native key-material that is used by OpenSSL.
Provides
OpenSslKeyMaterial for a given alias.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 that is specific to our native implementation.SSLSessionCache implementation for our native SSL implementation.OpenSslSession implementation which wraps the native SSL_SESSION* while in cache.OpenSSL specific
SSLSessionContext implementation.Represent the session ID used by an
OpenSslSession.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.OpenSslKeyMaterialProvider implementation that pre-compute the OpenSslKeyMaterial for
all aliases.Utility which allows to wrap
X509TrustManager implementations with the internal implementation used by
SSLContextImpl that provides extended verification.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.
A marker interface for PEM encoded values.
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.Reads a PEM file and converts it into a list of DERs so that they are imported into a
KeyStore easily.A PEM encoded value.
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.
Holds all meta-data and construct the linked-list structure.
Per-frame implementation of deflate decompressor.
Per-frame implementation of deflate compressor.
permessage-deflate
handshake implementation.
Per-message implementation of deflate decompressor.
Per-message implementation of deflate compressor.
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.The
PlatformDependent operations which requires access to sun.misc.*.Web Socket frame containing binary data.
Expose metrics for an arena.
Description of algorithm for PageRun/PoolSubpage allocation from PoolChunk
Notation: The following terms are important to understand the code
> page - a page is the smallest unit of memory chunk that can be allocated
> run - a run is a collection of pages
> chunk - a chunk is a collection of runs
> in this code chunkSize = maxPages * pageSize
To begin we allocate a byte array of size = chunkSize
Whenever a ByteBuf of given size needs to be created we search for the first position
in the byte array that has enough empty space to accommodate the requested size and
return a (long) handle that encodes this offset information, (this memory segment is then
marked as reserved so it is always used by exactly one ByteBuf and no more)
For simplicity all sizes are normalized according to
} method.
invalid @link
{@link PoolArena#sizeClass#size2SizeIdx(int)
Metrics for a list of chunks.
Metrics for a chunk.
Exposed metric for
PooledByteBufAllocator.Metrics for a sub-page.
Acts a Thread cache for allocations.
Cache used for buffers which are backed by NORMAL size.
Cache used for buffers which are backed by TINY or SMALL size.
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.Result of detecting a protocol.
The state of the current detection.
Helper class which convert the
InternetProtocolFamily.A common abstraction for protocols that establish blind forwarding proxy tunnels.
This pseudorandom function (PRF) takes as input a secret, a seed, and
an identifying label and produces an output of arbitrary length.
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.
Deprecated.
Do not use.
Read-only ByteBuf which wraps a read-only ByteBuffer.
A variant of
Http2Headers which only supports read-only methods.A variant of
HttpHeaders which only supports read-only methods.Read-only ByteBuf which wraps a read-only direct ByteBuffer and use unsafe for best performance.
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.
This is an implementation of
MessagePassingQueue, similar to what might be returned from
PlatformDependent.newMpscQueue(int), but intended to be used for debugging purpose.Aggregates
RedisMessage parts into ArrayRedisMessage.A
ChannelHandler that aggregates an BulkStringHeaderRedisMessage
and its following BulkStringRedisContents into a single FullBulkStringRedisMessage
with no following BulkStringRedisContents.Utilities for codec-redis.
Constant values for Redis encoder/decoder.
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).
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.Common logic for
ReferenceCounted implementationsCollection of method to handle objects that may implement
ReferenceCounted.Releases the objects when the thread that called
ReferenceCountUtil.releaseLater(Object) has been terminated.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.Special
ByteBuf implementation which is used by the ReplayingDecoderLooks up the
nameservers from the /etc/resolv.conf file, intended for Linux and macOS.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 neededDefault implementation that loads custom leak detector via system property
Deprecated.
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
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.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.
Select strategy interface.
Factory that creates a new
SelectStrategy every time.Generates a temporary self-signed certificate for testing purposes.
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.
An empty map.
An unmodifiable wrapper around a
ShortObjectMap.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.Converts OpenSSL signature Algorithm names to
Java signature Algorithm names.
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(java.lang.Runnable) to re-create this behaviourAbstract base class for
EventLoops that execute all its submitted tasks in a single thread.A
DnsServerAddressStreamProvider which always uses a single DNS server for resolution.SizeClasses requires
pageShifts to be defined prior to inclusion,
and it in turn defines:Expose metrics for an SizeClasses.
SLF4J logger.
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.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.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 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.Each call to SSL_write will introduce about ~100 bytes of overhead.
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.Record the session identifier and master key to the
InternalLogger named io.netty.wireshark.SSL/TLS protocols
An enumeration of SSL/TLS protocol providers.
Constants for SSL packets.
Cheap
ClosedChannelException that does not fill in the stacktrace.A
SSLHandshakeException that does not fill in the stack trace.Standard Compression Options for
GzipOptions and DeflateOptionsThe state of the
PcapWriteHandler.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
CompleteChannelFuture which is succeeded already.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.
Annotation to suppress the Java 6 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.
Deprecated.
will be removed in the next major release
Allow to retrieve the
EventExecutor for the calling Thread.Insecure
SecureRandom which relies on PlatformDependent.threadLocalRandom() for random number
generation.A thread local based address stream for a specific hostname.
A random number generator isolated to the current thread.
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
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.
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.A
DnsServerAddressStreamProvider which is backed by a single DnsServerAddresses.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.
Represents options defined in a file of the format etc/resolv.conf.
An unknown socks request.
An unknown socks response.
EventExecutor implementation which makes no guarantees about the ordering of task execution that
are submitted because there may be multiple threads executing these tasks.Deprecated.
This class will be removed in the future.
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.DuplicatedByteBuf implementation that can do optimizations because it knows the duplicated buffer
is of type AbstractByteBuf.Big endian Java heap buffer implementation.
A special
AbstractUnpooledSlicedByteBuf that can make optimizations because it knows the sliced buffer is of
type AbstractByteBuf.A NIO
ByteBuffer based buffer.Big endian Java heap buffer implementation.
A
ByteBuf implementation that wraps another buffer to prevent a user from increasing or decreasing the
wrapped buffer's reference count.All operations get and set as
ByteOrder.BIG_ENDIAN.Special
SwappedByteBuf for ByteBufs that use unsafe to access the byte array.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.Checks UTF8 bytes for validity
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.
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
Handles the HTTP handshake (the HTTP Upgrade request) for
WebSocketServerProtocolHandler.A utility class mainly for use by web sockets
Versions of the web socket specification.
A
StreamByteDistributor that is sensitive to stream priority and uses
Weighted Fair Queueing approach for distributing
bytes.Allows a correlation to be made between a stream and its old parent before a parent change occurs.
A comparator for
WeightedFairQueueByteDistributor.State which has no associated Http2Stream object.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.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 ...
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.Utility methods used by
JZlibEncoder and JZlibDecoder.The container file formats that wrap the stream compressed by the DEFLATE
algorithm.