All Classes and Interfaces

Class
Description
A skeletal AddressResolver implementation.
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.
Abstract 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 SelectableChannel
AbstractNioChannel 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.
Utility class for ByteBuf that encodes and decodes to and from Base64 notation.
 
Decodes a Base64-encoded ByteBuf or US-ASCII String into a ByteBuf.
Enumeration of supported Base64 dialects.
Encodes a ByteBuf into a Base64-encoded ByteBuf.
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.
A Bootstrap that makes it easy to bootstrap a Channel to use for clients.
 
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.
 
 
Checksum implementation which can directly act on a ByteBuf.
 
 
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.
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.
Reads and decompresses a single Bzip2 block.

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).
 
 
 
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.
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.
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.
A thread-safe Set that contains open Channels and provides various bulk operations on them.
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.
Called before a Channel will be returned via ChannelPool.acquire() or ChannelPool.acquire(Promise).
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 progress
An 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.
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.
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 skeletal Future implementation which represents a Future 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 content
An EncoderException that is raised when compression failed.
CompressionOptions provides compression options for various types of compressor types, like Brotli.
 
A decorating HTTP2 encoder that will compress data frames according to the content-encoding header for each stream.
Deprecated.
For removal in Netty 4.2.
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.
Parent of Client and Server side cookie encoders
 
Possible values for the SameSite attribute.
 
Deprecated.
Duplicate of package private $CookieUtil
An DecoderException which is thrown when the received frame data could not be decoded by an inbound handler.
An DecoderException which is thrown when the received WebSocketFrame data could not be decoded by an inbound handler.
Configuration for Cross-Origin Resource Sharing (CORS).
Deprecated.
Use CorsConfigBuilder instead.
Deprecated.
Removed without alternatives.
Builder used to configure and build a CorsConfig instance.
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 DnsQuery implementation for UDP/IP.
 
A DnsResponse implementation for UDP/IP.
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 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.
Default FileRegion implementation which transfer data from a FileChannel or File.
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 Http2FrameListener
 
Default 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 Http2PushPromiseFrame
Basic 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 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.
 
 
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.
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.
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.
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.
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.
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.
Factory used to create Queue instances that will be used to store tasks for an EventLoop.
 
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.
 
 
ByteBuf implementation which allows to wrap an array of ByteBuf in a read-only mode.
 
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.
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.
Class to implement monitoring at fix delay.
This implementation of the 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.
 
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 encountered
The 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 Http2FrameListener
Closes 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 calls
Logs 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 Http2FrameReader
 
A 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 Http2FrameWriter
HTTP/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 interface
Encodes Http2Headers into HPACK-encoded headers blocks.
Configuration related elements for the Http2HeadersEncoder interface
Determine 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.
 
Exception that can be used to wrap some Throwable and fire it through the pipeline.
Deprecated.
Deprecated.
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.
Decompresses an HttpMessage and an HttpContent compressed in gzip or deflate encoding.
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 instead
First 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.
A DecoderResult for HttpMessages as produced by an HttpObjectDecoder.
Provides some utility methods for HTTP message implementations.
The request method of HTTP or its derived protocols, such as RTSP and ICAP.
 
 
 
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.
 
 
 
Decodes ByteBufs into HttpMessages and HttpContents.
 
The internal state of HttpObjectDecoder.
Encodes an HttpMessage or an HttpContent into a ByteBuf.
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.
Decodes ByteBufs into HttpRequests and HttpContents.
Encodes an HttpRequest or an HttpContent into a ByteBuf.
An HTTP response.
Decodes ByteBufs into HttpResponses and HttpContents.
Encodes an HttpResponse or an HttpContent into a ByteBuf.
The response code and its description of HTTP or its derived protocols, such as RTSP and ICAP.
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.
Sends a 100 CONTINUE HttpResponse to HttpRequests which contain a 'expect: 100-continue' header.
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.
 
The version of HTTP or its derived protocols, such as RTSP and ICAP.
This class will not do any filtering of ciphers suites.
An Enum that represents the idle state of a Channel.
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.
Translates HTTP/1.x object reads into HTTP/2 frames.
A skeletal NameResolver implementation that resolves InetAddress.
 
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.
A GenericUnixChannelOption which uses an Integer as optval.
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 DatagramChannel
A hash map implementation of IntObjectMap that uses open addressing for keys.
Interface for a primitive map that uses ints as keys.
A primitive entry in the map, provided by the iterator from IntObjectMap.entries()
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.
Interface to define the role of an application protocol selector in the SSL handshake process.
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.
Logger factory which creates a java.util.logging logger.
Deprecated.
Deprecated.
Use SslContextBuilder to create JdkSslContext instances and only use JdkSslContext in your code.
An SslContext which uses JDK's SSL/TLS implementation.
 
 
Deprecated.
Use SslContextBuilder to create JdkSslContext instances and only use JdkSslContext in your code.
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 batch
 
 
A decoder that splits the received ByteBufs dynamically by the value of the length field in the message.
An encoder that prepends the length of the message.
 
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.
Apply a line separator to the requested String and encode it into a ByteBuf.
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.
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.
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
 
Variable header of MqttConnectMessage
Return Code of MqttConnAckMessage
Variable Header for the MqttConnectMessage
 
Decodes Mqtt messages from bytes, following the MQTT protocol specification v3.1 or v5.0, depending on the version specified in the CONNECT message that first goes through the channel.
States of the decoder.
 
Encodes Mqtt messages into bytes following the protocol specification v3.1 as described here MQTTV3.1 or v5.0 as described here MQTTv5.0 - depending on the version specified in the first CONNECT message that goes through the channel.
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
 
 
 
 
 
Variable Header of the MqttPublishMessage
Variable Header containing Packet Id, reason code and Properties as in MQTT v5 spec.
 
Variable Header for AUTH and DISCONNECT messages represented by MqttMessage
Provides 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.
Payload of the MqttSubAckMessage
Payload of the MqttSubscribeMessage
Model 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 MqttUnsubscribeMessage
Mqtt 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.
 
 
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.
 
MultithreadEventLoopGroup implementations which is used for NIO Selector based Channels.
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.
Allows a way to register some Runnable that will executed once there are no references to an Object anymore.
 
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.
Deprecated.
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.
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.
 
Holds references to the native key-material that is used by OpenSSL.
Manages key material for OpenSslEngines and so set the right PrivateKeys and X509Certificates.
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 PcapWriteHandler
 
 
 
 
User 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
invalid @link
{@link PoolArena#sizeClass#size2SizeIdx(int)
} method.
 
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.
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.
A GenericUnixChannelOption which uses an ByteBuffer as optval.
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.
 
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.
An Exception which is thrown by RedisEncoder or RedisDecoder.
Utilities for codec-redis.
Constant values for Redis encoder/decoder.
Decodes the Redis protocol into RedisMessage objects following RESP (REdis Serialization Protocol).
 
 
RedisMessage is base interface for codec-redis.
A strategy interface for caching RedisMessages.
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.
 
 
 
 
 
 
 
 
 
 
A server-side SslContext which uses OpenSSL's SSL/TLS implementation.
 
 
 
 
Common logic for ReferenceCounted implementations
Collection 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.
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 ReplayingDecoder
Looks up the nameservers from the /etc/resolv.conf file, intended for Linux and macOS.
 
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 needed
Default 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.
Encodes an RTSP message represented in HttpMessage or an HttpContent into a ByteBuf.
Standard RTSP header names.
Deprecated.
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 instead
Deprecated.
Use RtspEncoder directly instead
Deprecated.
Use RtspDecoder directly instead
Deprecated.
Use RtspEncoder directly instead
The 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.
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.
 
 
 
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 ServerChannel
 
Exposes the configuration of a ServerBootstrapConfig.
A Channel that accepts an incoming connection attempt and creates its child Channels by accepting them.
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.
A TCP/IP ServerChannel which accepts incoming TCP/IP connections.
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.
Abstract 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.
 
Uncompresses an input ByteBuf encoded with Snappy compression into an output ByteBuf.
 
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.
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.
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.
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.
 
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 SpdyHttpEncoder
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.
Adds SSL · TLS and StartTLS support to a Channel.
 
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 DeflateOptions
The 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!
 
Encodes a StompFrame or a StompSubframe into a ByteBuf.
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.
Decodes a received ByteBuf into a String.
Encodes the requested String into a ByteBuf.
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 handle associated with a TimerTask that is returned by a Timer.
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.
 
 
 
 
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 are backed by a memoryAddress.
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.
 
 
 
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 XmlElement
XML 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.