OpenJDK 27 · jdk.internal.net.http.quic.QuicConnectionImpl

Modifier and Type	Class and Description
protected class	QuicConnectionImpl.HandshakeFlow Keeps track of: - handshakeCF the handshake completable future - localInitial the local initial crypto writer queue - peerInitial the peer initial crypto flow - localHandshake the local handshake crypto queue - peerHandshake the peer handshake crypto flow
private static record	QuicConnectionImpl.IncomingDatagram
pack-priv class	QuicConnectionImpl.MaxInitialTimer A {link QuicTimedEvent} used to interrupt the handshake if no response to the first initial packet is received within a reasonable delay (default is ~ 30s).
pack-priv class	QuicConnectionImpl.OneRttFlowControlledReceivingQueue A class used to check that 1-RTT received data doesn't exceed the MAX_DATA of the connection
pack-priv class	QuicConnectionImpl.OneRttFlowControlledSendingQueue An event loop triggered when stream data is available for sending.
public static record	QuicConnectionImpl.PacketSpaces
public static record	QuicConnectionImpl.ProtectionRecord A protection record contains a packet to encrypt, and a datagram that may already contain encrypted packets.
protected class	QuicConnectionImpl.QuicCodingContext
public abstract static class	QuicConnectionImpl.QuicConnectionState An abstraction to represent the connection state as a bit mask.
protected class	QuicConnectionImpl.StateHandle A state handle is a mutable implementation of `QuicConnectionState` that allows to view the volatile connection int variable `state` as a `QuicConnectionState`, and provides methods to mutate it in a thread safe atomic way.

Modifier and Type	Field and Description
private final AtomicInteger	bbAllocated
private final AtomicInteger	bbInFlight
private final AtomicInteger	bbPeak
private final ConcurrentLinkedQueue<ByteBuffer>	bbPool
pack-priv final AtomicInteger	bbUnreleased
private final String	cachedToString
private final CodingContext	codingContext
pack-priv final QuicCongestionController	congestionController
private final QuicConnectionId	connectionId
private final String	dbgTag
protected final Logger	debug
private volatile QuicPacketDecoder	decoder
public static final int	DEFAULT_DATAGRAM_SIZE
public static final long	DEFAULT_INITIAL_MAX_DATA
public static final long	DEFAULT_INITIAL_STREAM_MAX_DATA
public static final int	DEFAULT_MAX_BIDI_STREAMS
public static final int	DEFAULT_MAX_INITIAL_TIMEOUT
public static final int	DEFAULT_MAX_UNI_STREAMS
private volatile QuicPacketEncoder	encoder
protected final QuicEndpoint	endpoint
private final QuicConnectionImpl.HandshakeFlow	handshakeFlow
private final ReentrantLock	handshakeLock
private final SequentialScheduler	handshakeScheduler
protected final IdleTimeoutManager	idleTimeoutManager
private final ConcurrentLinkedQueue<QuicConnectionImpl.IncomingDatagram>	incoming
private volatile QuicConnectionId	incomingInitialPacketSourceId
private final SequentialScheduler	incomingLoopScheduler
private volatile byte[]	initialToken
private final long	labelId
private final LocalConnIdManager	localConnIdManager
private final CryptoWriterQueue	localCryptoFlow
private volatile QuicTransportParameters	localTransportParameters
private final String	logTag
private static final int	MAX_DBB_POOL_SIZE
private static final int	MAX_INCOMING_CRYPTO_CAPACITY
private static final int	MAX_IPV4_MTU
private static final int	MAX_IPV6_MTU
private static final VarHandle	MAX_RCV_DATA
private static final VarHandle	MAX_SND_DATA
public static final long	MAX_STREAMS_VALUE_LIMIT
private final int	maxConnectionMTU
private volatile QuicConnectionImpl.MaxInitialTimer	maxInitialTimer
private int	maxPeerAdvertisedPayloadSize
private final QuicConnectionImpl.OneRttFlowControlledReceivingQueue	oneRttRcvQueue
private final QuicConnectionImpl.OneRttFlowControlledSendingQueue	oneRttSndQueue
private final QuicVersion	originalVersion
protected final Queue<QuicFrame>	outgoing1RTTFrames
private final QuicConnectionImpl.PacketSpaces	packetSpaces
private final Queue<PathChallengeFrame>	pathChallengeFrameQueue
private int	pathMTU
private volatile long	peerActiveConnIdsLimit
private final InetSocketAddress	peerAddress
private final PeerConnIdManager	peerConnIdManager
private final OrderedFlow.CryptoDataFlow	peerCryptoFlow
private volatile QuicTransportParameters	peerTransportParameters
private volatile boolean	processedVersionsPacket
private final QuicInstance	quicInstance
private final QuicTLSEngine	quicTLSEngine
private volatile QuicVersion	quicVersion
private static final Random	RANDOM
public static final int	RESET_TOKEN_LENGTH
pack-priv final QuicRttEstimator	rttEstimator
public static final int	SMALLEST_MAXIMUM_DATAGRAM_SIZE
private final AtomicBoolean	startHandshakeCalled
private static final VarHandle	STATE
private volatile int	state
private final QuicConnectionImpl.StateHandle	stateHandle The state of the quic connection.
protected final QuicConnectionStreams	streams
pack-priv final ConnectionTerminatorImpl	terminator
protected final QuicTransportParameters	transportParams
public static final boolean	USE_DIRECT_BUFFER_POOL
private static final VarHandle	VERSION_NEGOTIATED
private volatile boolean	versionCompatible
private volatile boolean	versionNegotiated

Access	Constructor and Description
protected	QuicConnectionImpl(final QuicVersion firstFlightVersion, final QuicInstance quicInstance, final InetSocketAddress peerAddress, final String peerName, final int peerPort, final SSLParameters sslParameters, final String logTagFormat, final long labelId)

Method Summary

Modifier and Type	Method and Description
public boolean	accepts(SocketAddress source) Overrides default jdk.internal.net.http.quic.QuicPacketReceiver.accepts. Returns whether this receiver accepts packets from the given source.
private List<QuicFrame>	ackOrPing(AckFrame ack, boolean sendPing)
public List<byte[]>	activeResetTokens() Implements jdk.internal.net.http.quic.QuicPacketReceiver.activeResetTokens. {@return a list of active peer stateless reset tokens for this connection)
public void	addRemoteStreamListener(Predicate<? super QuicReceiverStream> streamConsumer) Implements abstract jdk.internal.net.http.quic.QuicConnection.addRemoteStreamListener. Adds a listener that will be invoked when a remote stream is created.
protected ByteBuffer	Returns: a new `ByteBuffer` with sufficient space to encrypt the given packet. allocateDatagramForEncryption(QuicPacket the packet to encrypt packet) Allocate a `ByteBuffer` that can be used to encrypt the given packet.
protected ByteBuffer	buildInitialParameters()
public NetworkChannel	Returns: the underlying `NetworkChannel` used by this connection, which may be `null` if the endpoint has not been configured yet channel() Returns the underlying `NetworkChannel` used by this connection, which may be `null` if the endpoint has not been configured yet.
private void	checkAbort(QuicPacket.PacketNumberSpace packetNumberSpace)
public void	closeIncoming()
protected CodingContext	codingContext()
protected void	completeHandshakeCF()
protected final void	completeHandshakeCF(Executor executor)
pack-priv final Optional<QuicEndpoint.Datagram>	Returns: the datagram containing the QUIC packet with a CONNECTION_CLOSE frame or an empty Optional if the datagram couldn't be constructed. connectionCloseDatagram() Returns a `jdk.internal.net.http.quic.QuicEndpoint.Datagram` which contains an encrypted QUIC packet containing a CONNECTION_CLOSE frame.
public int	connectionIdLength()
public List<QuicConnectionId>	connectionIds() Implements jdk.internal.net.http.quic.QuicPacketReceiver.connectionIds. {@return a list of local connectionIds for this connection)
public ConnectionTerminator	connectionTerminator() Implements abstract jdk.internal.net.http.quic.QuicConnection.connectionTerminator. Returns the `ConnectionTerminator` for this connection.
protected void	consumeQuicParameters(final ByteBuffer byteBuffer)
private static boolean	Returns: true if the packet contains a CONNECTION_CLOSE frame, false otherwise containsConnectionClose(final QuicPacket the QUIC packet packet) Returns true if the packet contains a CONNECTION_CLOSE frame, false otherwise.
protected void	continueHandshake() Retrieves cryptographic messages from TLS engine, enqueues them for sending and starts the transmitter.
protected void	continueHandshake0()
private void	continueHandshake1()
private static QuicCongestionController	createCongestionController(String dbgTag, QuicRttEstimator rttEstimator)
public void	datagramDiscarded(QuicEndpoint.QuicDatagram datagram) Overrides default jdk.internal.net.http.quic.QuicPacketReceiver.datagramDiscarded. Called after a datagram has been discarded as a result of some error being raised, for instance, when an attempt to write it to the socket has failed, or if the encryption of a packet in the datagram has failed.
public void	datagramDropped(QuicEndpoint.QuicDatagram datagram) Overrides default jdk.internal.net.http.quic.QuicPacketReceiver.datagramDropped. Called after a datagram has been dropped.
protected void	datagramReleased(QuicEndpoint.QuicDatagram the released datagram datagram) Called when a datagram is being released, either from `datagramSent(QuicDatagram)`, `datagramDiscarded(QuicDatagram)`, or `datagramDropped(QuicDatagram)`.
public void	datagramSent(QuicEndpoint.QuicDatagram datagram) Overrides default jdk.internal.net.http.quic.QuicPacketReceiver.datagramSent. Called after a datagram has been written to the socket.
pack-priv static String	dbgTag(QuicInstance quicInstance, String logTag)
public String	dbgTag() Implements abstract jdk.internal.net.http.quic.QuicConnection.dbgTag. Returns a debug tag to be used with lower level logging.
protected QuicPacketDecoder	decoder()
private void	decrypt(ByteBuffer a byte buffer containing the incoming packet buffer) Schedule an incoming quic packet for decryption.
private long	Returns: the emitted packet number, or -1L if not applicable or not emitted emitAckPacket(final PacketSpace the packet space manager on behalf of which the acknowledgement should be sent. packetSpaceManager, final AckFrame the ACK frame to be sent. ackFrame, final boolean whether a PING frame should be sent. sendPing) Emit a possibly non ACK-eliciting packet containing the given ACK frame.
protected PacketEmitter	emitter()
protected QuicPacketEncoder	encoder()
public QuicEndpoint	endpoint()
protected void	enqueue1RTTFrame(final QuicFrame frame to send frame) Schedule a frame for sending in a 1-RTT packet.
protected QuicStream	Returns: the stream identified by the given `streamId`, or `null`. findStream(long the stream ID streamId) If a stream with this streamId was already created, returns it.
private void	frameAcknowledged(QuicFrame frame)
public final CompletableFuture<TerminationCause>	futureTerminationCause()
public QuicConnectionId	getIncomingInitialPacketSourceId()
protected long	Returns: the number of (active) connection ids that this endpoint is willing to accept from the peer for a given connection getLocalActiveConnIDLimit() Returns the number of (active) connection ids that this endpoint is willing to accept from the peer for a given connection.
public int	Returns: the maximum datagram size that can be used on the connection path getMaxDatagramSize() Returns the maximum datagram size that can be used on the connection path.
protected ByteBuffer	Returns: a new `ByteBuffer` to encode and encrypt packets in a datagram getOutgoingByteBuffer(int the maximum size of the datagram size) Returns a new `ByteBuffer` to encode and encrypt packets in a datagram.
protected long	Returns: the number of (active) connection ids that the peer is willing to accept for a given connection getPeerActiveConnIDLimit() Returns the number of (active) connection ids that the peer is willing to accept for a given connection.
private QuicReceiverStream	Returns: receiver stream, or null if stream is already gone getReceivingStream(long stream ID streamId, long received frame type. Used in QuicTransportException frameType) Gets a receiving stream instance for the given ID, used for processing incoming STREAM, RESET_STREAM and STREAM_DATA_BLOCKED frames.
private QuicSenderStream	Returns: sender stream, or null if stream is already gone getSendingStream(long stream ID streamId, long received frame type. Used in QuicTransportException frameType) Gets a sending stream instance for the given ID, used for processing incoming MAX_STREAM_DATA and STOP_SENDING frames.
public QuicTLSEngine	getTLSEngine() Implements abstract jdk.internal.net.http.quic.QuicConnection.getTLSEngine.
protected void	handleIncomingPeerTransportParams(final QuicTransportParameters the peer's new quic transport parameter params) Called when new quic transport parameters are available from the peer.
protected QuicConnectionImpl.HandshakeFlow	handshakeFlow()
public CompletableFuture<Void>	handshakeReachedPeer() Implements abstract jdk.internal.net.http.quic.QuicConnection.handshakeReachedPeer. {@return a `CompletableFuture` that gets completed when the peer has acknowledged, or replied to the first `INITIAL` packet
private boolean	Returns: true if queued frames are available for sending hasQueuedFrames() Returns true if queued frames are available for sending.
private void	incoming()
protected void	incoming1RTTFrame(final AckFrame ackFrame)
protected void	incoming1RTTFrame(final StreamFrame frame)
protected void	incoming1RTTFrame(final CryptoFrame frame)
protected void	incoming1RTTFrame(final ResetStreamFrame frame)
protected void	incoming1RTTFrame(final StreamDataBlockedFrame frame)
protected void	incoming1RTTFrame(final DataBlockedFrame frame)
protected void	incoming1RTTFrame(final StreamsBlockedFrame frame)
protected void	incoming1RTTFrame(final PaddingFrame frame)
protected void	incoming1RTTFrame(final MaxDataFrame frame)
protected void	incoming1RTTFrame(final MaxStreamDataFrame frame)
protected void	incoming1RTTFrame(final MaxStreamsFrame frame)
protected void	incoming1RTTFrame(final StopSendingFrame frame)
protected void	incoming1RTTFrame(final PingFrame frame)
protected void	incoming1RTTFrame(final ConnectionCloseFrame frame)
protected void	incoming1RTTFrame(final HandshakeDoneFrame frame)
protected void	incoming1RTTFrame(final NewConnectionIDFrame frame)
protected void	incoming1RTTFrame(final OneRttPacket oneRttPacket, final RetireConnectionIDFrame frame)
protected void	incoming1RTTFrame(final NewTokenFrame frame)
protected void	incoming1RTTFrame(final PathResponseFrame frame)
protected void	incoming1RTTFrame(final PathChallengeFrame frame)
protected void	incomingHandshakeFrame(final AckFrame frame)
protected int	incomingHandshakeFrame(final CryptoFrame frame)
protected void	incomingHandshakeFrame(final PaddingFrame frame)
protected void	incomingHandshakeFrame(final PingFrame frame)
protected void	incomingHandshakeFrame(final ConnectionCloseFrame frame)
protected void	incomingInitialFrame(final AckFrame frame)
protected int	incomingInitialFrame(final CryptoFrame frame)
protected void	incomingInitialFrame(final PaddingFrame frame)
protected void	incomingInitialFrame(final PingFrame frame)
protected void	incomingInitialFrame(final ConnectionCloseFrame frame)
public void	increaseProcessedData(long amount of data processed diff) Called when frame data is removed from the connection and the amount of data can be added to MAX_DATA window.
public void	increaseReceivedData(long diff, long type of frame received frameType) Called when frame data can be safely added to the amount of data received by the connection for MAX_DATA flow control purpose.
private QuicConnectionId	initialServerConnectionId()
private byte[]	initialToken()
public void	internalProcessIncoming(SocketAddress source, ByteBuffer destConnId, QuicPacket.HeadersType headersType, ByteBuffer buffer)
public boolean	Returns: true if this connection is a client connection isClientConnection() Returns true if this connection is a client connection.
protected boolean	Returns: a boolean value telling whether the datagram in the protection record is complete isDatagramComplete(QuicConnectionImpl.ProtectionRecord the protection record protectionRecord) Returns a boolean value telling whether the datagram in the protection record is complete.
protected boolean	isExistingStreamId(long the stream id streamId) Returns: true if this stream ID identifies a stream that was already opened
protected final boolean	Returns: true if this is a stream initiated locally, and false if this is a stream initiated by the peer isLocalStream(long a stream ID. streamId) Returns true if this is a stream initiated locally, and false if this is a stream initiated by the peer.
public boolean	isOpen() Implements abstract jdk.internal.net.http.quic.QuicConnection.isOpen. Returns true if this connection is open.
public long	largestAckedPN(QuicPacket.PacketNumberSpace packetSpace)
public long	largestProcessedPN(QuicPacket.PacketNumberSpace packetSpace)
public SocketAddress	Returns: the local address of the quic endpoint localAddress() Implements abstract jdk.internal.net.http.quic.QuicConnection.localAddress. Returns the local address of the quic endpoint.
public QuicConnectionId	Returns: the local connection id localConnectionId() Overrides jdk.internal.net.http.quic.QuicConnection.localConnectionId. Returns the local connection id.
pack-priv LocalConnIdManager	localConnectionIdManager()
public QuicTransportParameters	localTransportParameters()
public String	loggableState()
public final String	logTag() Implements abstract jdk.internal.net.http.quic.QuicConnection.logTag. Returns a debug tag.
private List<QuicFrame>	Returns: A list of `QuicFrame`. makeList(CryptoFrame the crypto frame crypto, AckFrame the ack frame ack) Compose a list of Quic frames containing a crypto frame and an ack frame, omitting null frames.
protected void	markVersionNegotiated(int the packet version packetVersion) Mark the version as negotiated.
protected void	newLocalTransportParameters(QuicTransportParameters params)
pack-priv final QuicPacket	newQuicPacket(final QuicTLSEngine.KeySpace keySpace, final List<QuicFrame> frames)
public long	Returns: the next (higher) max streams limit that should be advertised to the remote peer. Returns `0` if the limit should not be increased nextMaxStreamsLimit(final boolean true if bidirectional stream, false otherwise bidi) Returns the next (higher) max streams limit that should be advertised to the remote peer.
public void	notifyTerminalState(long the id of the stream streamId, QuicStream.StreamState the terminal state state) Called when the receiving part or the sending part of a stream reaches a terminal state.
protected QuicEndpoint	onHandshakeCompletion(final QuicTLSEngine.HandshakeState the result of the handshake result) This method is called when the handshake is successfully completed.
public void	onProcessingError(QuicPacket packet, Throwable the error that occurred t) Called when a packet couldn't be processed
public void	onWriteError(Throwable the error that occurred t) Implements jdk.internal.net.http.quic.QuicPacketReceiver.onWriteError. Called when a datagram scheduled for writing by this connection could not be written to the network.
public CompletableFuture<QuicBidiStream>	openNewLocalBidiStream(final Duration limitIncreaseDuration) Implements abstract jdk.internal.net.http.quic.QuicConnection.openNewLocalBidiStream. Creates a new locally initiated bidirectional stream.
public CompletableFuture<QuicSenderStream>	openNewLocalUniStream(final Duration limitIncreaseDuration) Implements abstract jdk.internal.net.http.quic.QuicConnection.openNewLocalUniStream. Creates a new locally initiated unidirectional stream.
protected QuicStream	Returns: the remote initiated stream identified by the given stream ID, or null openOrGetRemoteStream(long the id of the remote stream streamId, long type of the frame received, used in exceptions frameType) Get or open a peer initiated stream with the given stream ID
protected QuicConnectionId	Returns: the original connection id originalServerConnId() Returns the original connection id. This is the original destination connection id that the client generated when connecting to the server for the first time.
private void	packetAcknowledged(QuicPacket packet)
protected QuicConnectionImpl.PacketSpaces	packetNumberSpaces()
protected PacketSpace	packetSpace(QuicPacket.PacketNumberSpace packetNumberSpace)
public InetSocketAddress	Returns: the peer address that should be used when sending datagram to the peer peerAddress() Implements abstract jdk.internal.net.http.quic.QuicConnection.peerAddress. Returns the peer address that should be used when sending datagram to the peer.
public QuicConnectionId	Returns: the peer connection id peerConnectionId() Returns the peer connection id.
pack-priv PeerConnIdManager	peerConnectionIdManager()
public long	Returns: the computed PTO for the current packet number space, adjusted by our max ack delay peerPtoMs() Returns the computed PTO for the current packet number space, adjusted by our max ack delay.
public QuicTransportParameters	peerTransportParameters()
public void	processDecrypted(QuicPacket the decrypted quic packet quicPacket) Called when an incoming packet has been decrypted.
protected void	processHandshakePacket(final QuicPacket the handshake quic packet quicPacket) Called to process an `HandshakePacket` after it has been decrypted.
protected int	Returns: the total number of bytes consumed processHandshakePacketPayload(final HandshakePacket the incoming packet packet) Process the payload of an incoming handshake packet
public void	processIncoming(SocketAddress source, ByteBuffer destConnId, QuicPacket.HeadersType headersType, ByteBuffer buffer) Implements jdk.internal.net.http.quic.QuicPacketReceiver.processIncoming. Called when an incoming datagram is received.
protected void	processInitialPacket(final QuicPacket the Quic packet quicPacket) Called to process an `InitialPacket` after it has been decrypted.
protected int	Returns: the total number of bytes consumed processInitialPacketPayload(final InitialPacket the incoming packet packet) Process the payload of an incoming initial packet
protected void	processOneRTTPacket(final QuicPacket the Quic packet quicPacket) Called to process a `OneRttPacket` after it has been successfully decrypted
protected void	processRetryPacket(final QuicPacket the retry quic packet quicPacket) Called to process a `RetryPacket` after it has been decrypted.
public void	processStatelessReset() Implements jdk.internal.net.http.quic.QuicPacketReceiver.processStatelessReset. Called when a stateless reset token is received.
protected void	processVersionNegotiationPacket(final QuicPacket the `VersionNegotiationPacket` quicPacket) Called to process a received `VersionNegotiationPacket`
pack-priv final void	pushDatagram(final QuicConnectionImpl.ProtectionRecord a record containing a quic packet to encrypt, a destination byte buffer, and various offset information. protectionRecord) Encrypt an outgoing quic packet.
protected void	pushDatagram(final SocketAddress The destination of this datagram destination, final ByteBuffer The datagram datagram) Calls the `QuicEndpoint#pushDatagram(QuicPacketReceiver, SocketAddress, ByteBuffer)`
private void	pushEncryptedDatagram(final QuicConnectionImpl.ProtectionRecord the ProtectionRecord containing the datagram protectionRecord) Pushes the datagram contained in the `protectionRecord`, through the endpoint.
public QuicInstance	quicInstance()
public Stream<? extends QuicStream>	quicStreams() Implements abstract jdk.internal.net.http.quic.QuicConnection.quicStreams. Returns a stream of all currently opened `QuicStream` in the connection.
public QuicVersion	quicVersion()
private LinkedList<QuicFrame>	removeOutdatedFrames(List<QuicFrame> frames)
public boolean	removeRemoteStreamListener(Predicate<? super QuicReceiverStream> streamConsumer) Implements abstract jdk.internal.net.http.quic.QuicConnection.removeRemoteStreamListener. Removes a listener previously added with `addRemoteStreamListener(Predicate)`
public void	requestResetStream(long the id of the stream that should be reset streamId, long the application error code errorCode) Called to request sending of a RESET_STREAM frame.
public void	requestSendMaxStreamData(long the stream id to be cancelled streamId, long the new max data we are prepared to receive on this stream maxStreamData) Called to request sending of a MAX_STREAM_DATA frame.
public CompletableFuture<Long>	requestSendPing() Implements abstract jdk.internal.net.http.quic.QuicConnection.requestSendPing. Requests to send a PING frame to the peer.
private void	retransmit(PacketSpace the packet space manager on behalf of which the packet is being retransmitted packetSpaceManager, QuicPacket the unacknowledged packet which should be retransmitted packet, int attempts) Retransmit the given packet on behalf of the given packet space manager.
public void	runAppPacketSpaceTransmitter()
private void	scheduleForDecryption(QuicConnectionImpl.IncomingDatagram datagram)
public void	scheduleStopSendingFrame(long the stream id to be cancelled streamId, long the application error code errorCode) Called to request sending of a STOP_SENDING frame.
protected void	send1RTTPacket(final OneRttPacket The ONERTT packet to send. packet) Invoked to send a ONERTT packet containing stream data or control frames.
private boolean	sendData(QuicPacket.PacketNumberSpace packetNumberSpace)
private QuicConnectionImpl.HandshakeFlow	sendFirstInitialPacket(Void unused)
private boolean	sendInitialOrHandshakeData(final QuicPacket.PacketNumberSpace packetNumberSpace)
protected static void	setIntParamIfNotSet(final QuicTransportParameters params, final QuicTransportParameters.ParameterId paramId, final Supplier<Long> valueSupplier)
public void	shutdown() Implements jdk.internal.net.http.quic.QuicPacketReceiver.shutdown. Called to shut a closed connection down.
public final CompletableFuture<QuicEndpoint>	Returns: A completable future which will be completed when the handshake is completed. startHandshake() Implements abstract jdk.internal.net.http.quic.QuicConnection.startHandshake. Starts the Quic Handshake.
protected void	startInitialTimer()
protected final QuicConnectionImpl.StateHandle	stateHandle()
public void	streamDataAvailableForSending(final Set<Long> the stream ids streamIds) Signal the connection that some stream data is available for sending on one or more streams.
public String	streamDbgTag(long streamId, String direction)
protected boolean	Returns: true if switching to the new version was successful switchVersion(QuicVersion the new version that was negotiated negotiated) Switch to a new version after receiving a version negotiation packet.
public TerminationCause	terminationCause() Implements abstract jdk.internal.net.http.quic.QuicConnection.terminationCause. Returns the `TerminationCause` if the connection has closed or is being closed, otherwise returns null.
public String	toString() Overrides java.lang.Object.toString. Returns a string representation of the object.
public final long	uniqueId() Overrides jdk.internal.net.http.quic.QuicConnection.uniqueId. Returns a long identifier that can be used to uniquely identify a quic connection in the context of the `QuicInstance` that created it.
protected void	updatePeerConnectionId(InitialPacket initial)
protected boolean	verifyToken(QuicConnectionId destinationID, byte[] token)

public Class QuicConnectionImpl

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary