Apache Mina SSHD 2.15.0 · org.apache.sshd.common.session.helpers.KeyExchangeMessageHandler

Modifier and Type	Field and Description
protected static ExecutorService	flushRunner An `ExecutorService` used to flush the queue asynchronously.
protected final AtomicBoolean	kexFlushed Indicates that all pending packets have been flushed.
protected final AtomicReference<DefaultKeyExchangeFuture>	kexFlushedFuture Never `null`.
protected final ReentrantReadWriteLock	lock We need the flushing thread to have priority over writing threads.
protected final Logger	log The `Logger` to use.
protected final Queue<PendingWriteFuture>	pendingPackets Queues up high-level packets written during an ongoing key exchange.
protected final AbstractSession	session The `AbstractSession` this `KeyExchangeMessageHandler` belongs to.
protected final AtomicBoolean	shutDown Indicates that the handler has been shut down.

Access	Constructor and Description
public	KeyExchangeMessageHandler(AbstractSession `AbstractSession` the new instance belongs to session, Logger `Logger` to use for writing log messages log) Creates a new `KeyExchangeMessageHandler` for the given `session`, using the given `Logger`.

Method Summary

Modifier and Type	Method and Description
private void	drainQueueTo(List<AbstractMap.SimpleImmutableEntry<PendingWriteFuture, IoWriteFuture>> pendingAborted, IoWriteFuture aborted)
protected PendingWriteFuture	Returns: the enqueued `PendingWriteFuture` enqueuePendingPacket(int the SSH command from the buffer cmd, Buffer the `Buffer` containing the packet to be sent buffer) Enqueues a packet to be written once a running key exchange terminates.
protected void	flushQueue(DefaultKeyExchangeFuture the future obtained from `getFlushedFuture`; will be fulfilled once all pending packets have been written flushDone) Flushes all packets enqueued while a key exchange was ongoing.
public DefaultKeyExchangeFuture	Returns: the previous `DefaultKeyExchangeFuture` indicating whether all pending packets were flushed. initNewKeyExchange() Initializes the state for a new key exchange.
protected boolean	Returns: `true` if the thread may be blocked; `false` if the packet written must be queued without blocking the thread isBlockAllowed(int SSH command of the buffer to be written cmd) Tells whether the calling thread may be blocked in `writePacket(Buffer, long, TimeUnit)`.
public void	shutdown() Pretends all pending packets had been written.
public AbstractMap.SimpleImmutableEntry<Integer, DefaultKeyExchangeFuture>	Returns: the current `DefaultKeyExchangeFuture` and the number of currently pending packets terminateKeyExchange() To be called when the key exchange is done.
public void	updateState(Runnable update)
public <V> V	updateState(Supplier<V> update)
protected IoWriteFuture	Returns: an `IoWriteFuture` that will be fulfilled once the packet has indeed been written. writeOrEnqueue(int SSH command from the buffer cmd, Buffer `Buffer` containing the packet to write buffer, long number of `TimeUnit`s to wait at most if the calling thread is blocked timeout, TimeUnit `TimeUnit` of `timeout` unit) Writes an SSH packet.
public IoWriteFuture	Returns: an `IoWriteFuture` that will be fulfilled once the packet has indeed been written. writePacket(Buffer packet to write buffer, long number of `TimeUnit`s to wait at most if the calling thread is blocked timeout, TimeUnit `TimeUnit` of `timeout` unit) Writes a packet.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

flushRunner back to summary

flushRunner	back to summary
protected static ExecutorService flushRunner An `ExecutorService` used to flush the queue asynchronously. See Also `flushQueue(DefaultKeyExchangeFuture)`

protected static ExecutorService flushRunner

An ExecutorService used to flush the queue asynchronously.

See Also: flushQueue(DefaultKeyExchangeFuture)

kexFlushed	back to summary
protected final AtomicBoolean kexFlushed Indicates that all pending packets have been flushed. Set to `true` by the flushing thread, or at the end of KEX if there are no packets to be flushed. Set to `false` when a new KEX starts. Initially `true`.

kexFlushedFuture back to summary

kexFlushedFuture	back to summary
protected final AtomicReference<DefaultKeyExchangeFuture> kexFlushedFuture Never `null`. Used to block some threads when writing packets while pending packets are still being flushed at the end of a KEX to avoid overrunning the flushing thread. Always set, initially fulfilled. At the beginning of a KEX a new future is installed, which is fulfilled at the end of the KEX once there are no more pending packets to be flushed.

protected final AtomicReference<DefaultKeyExchangeFuture> kexFlushedFuture

Never null. Used to block some threads when writing packets while pending packets are still being flushed at the end of a KEX to avoid overrunning the flushing thread. Always set, initially fulfilled. At the beginning of a KEX a new future is installed, which is fulfilled at the end of the KEX once there are no more pending packets to be flushed.

lock	back to summary
protected final ReentrantReadWriteLock lock We need the flushing thread to have priority over writing threads. So we use a lock that favors writers over readers, and any state updates and the flushing thread are writers, while writePacket() is a reader.

log	back to summary
protected final Logger log The `Logger` to use.

pendingPackets	back to summary
protected final Queue<PendingWriteFuture> pendingPackets Queues up high-level packets written during an ongoing key exchange.

session	back to summary
protected final AbstractSession session The `AbstractSession` this `KeyExchangeMessageHandler` belongs to.

shutDown	back to summary
protected final AtomicBoolean shutDown Indicates that the handler has been shut down.

Constructor Detail

KeyExchangeMessageHandler back to summary

KeyExchangeMessageHandler	back to summary
public KeyExchangeMessageHandler(AbstractSession session, Logger log) Creates a new `KeyExchangeMessageHandler` for the given `session`, using the given `Logger`. Parameters session:AbstractSession `AbstractSession` the new instance belongs to log:Logger `Logger` to use for writing log messages

public KeyExchangeMessageHandler(AbstractSession session, Logger log)

Creates a new KeyExchangeMessageHandler for the given session, using the given Logger.

Parameters

session:AbstractSession: AbstractSession the new instance belongs to
log:Logger: Logger to use for writing log messages

Method Detail

drainQueueTo	back to summary
private void drainQueueTo(List<AbstractMap.SimpleImmutableEntry<PendingWriteFuture, IoWriteFuture>> pendingAborted, IoWriteFuture aborted)

enqueuePendingPacket back to summary

enqueuePendingPacket	back to summary
protected PendingWriteFuture enqueuePendingPacket(int cmd, Buffer buffer) Enqueues a packet to be written once a running key exchange terminates. Parameters cmd:int the SSH command from the buffer buffer:Buffer the `Buffer` containing the packet to be sent Returns:PendingWriteFuture the enqueued `PendingWriteFuture`

protected PendingWriteFuture enqueuePendingPacket(int cmd, Buffer buffer)

Enqueues a packet to be written once a running key exchange terminates.

Parameters

cmd:int: the SSH command from the buffer
buffer:Buffer: the Buffer containing the packet to be sent

Returns:PendingWriteFuture

the enqueued PendingWriteFuture

flushQueue back to summary

flushQueue	back to summary
protected void flushQueue(DefaultKeyExchangeFuture flushDone) Flushes all packets enqueued while a key exchange was ongoing. If writing the pending packets triggers a new key exchange, flushing is stopped and is to be resumed by another call to this method when the new key exchange is done. Parameters flushDone:DefaultKeyExchangeFuture the future obtained from `getFlushedFuture`; will be fulfilled once all pending packets have been written

protected void flushQueue(DefaultKeyExchangeFuture flushDone)

Flushes all packets enqueued while a key exchange was ongoing. If writing the pending packets triggers a new key exchange, flushing is stopped and is to be resumed by another call to this method when the new key exchange is done.

Parameters

flushDone:DefaultKeyExchangeFuture: the future obtained from getFlushedFuture; will be fulfilled once all pending packets have been written

initNewKeyExchange back to summary

initNewKeyExchange	back to summary
public DefaultKeyExchangeFuture initNewKeyExchange() Initializes the state for a new key exchange. `allPacketsFlushed` will be `false`, and a new future to be fulfilled when all queued packets will be flushed once the key exchange is done is set. The currently set future from an earlier key exchange is returned. The returned future may or may not be fulfilled; if it isn't, there are still left-over pending packets to write from the previous key exchange, which will be written once the new key exchange flushes pending packets. Returns:DefaultKeyExchangeFuture the previous `DefaultKeyExchangeFuture` indicating whether all pending packets were flushed.

public DefaultKeyExchangeFuture initNewKeyExchange()

Initializes the state for a new key exchange. allPacketsFlushed will be false, and a new future to be fulfilled when all queued packets will be flushed once the key exchange is done is set. The currently set future from an earlier key exchange is returned. The returned future may or may not be fulfilled; if it isn't, there are still left-over pending packets to write from the previous key exchange, which will be written once the new key exchange flushes pending packets.

Returns:DefaultKeyExchangeFuture: the previous DefaultKeyExchangeFuture indicating whether all pending packets were flushed.

isBlockAllowed back to summary

isBlockAllowed	back to summary
protected boolean isBlockAllowed(int cmd) Tells whether the calling thread may be blocked in `writePacket(Buffer, long, TimeUnit)`. This implementation blocks writes of channel data packets unless written by an `internal thread`. Typically an internal thread is one of the reading threads of Apache MINA sshd handling an SSH protocol message: it's holding the `AbstractSession#decodeLock`; blocking it would mean we couldn't handle any other incoming message, not even disconnections or another key exchange triggered by having lots of data queued. Parameters cmd:int SSH command of the buffer to be written Returns:boolean `true` if the thread may be blocked; `false` if the packet written must be queued without blocking the thread

protected boolean isBlockAllowed(int cmd)

Tells whether the calling thread may be blocked in writePacket(Buffer, long, TimeUnit). This implementation blocks writes of channel data packets unless written by an internal thread.

Typically an internal thread is one of the reading threads of Apache MINA sshd handling an SSH protocol message: it's holding the AbstractSession#decodeLock; blocking it would mean we couldn't handle any other incoming message, not even disconnections or another key exchange triggered by having lots of data queued.

Parameters

cmd:int: SSH command of the buffer to be written

Returns:boolean

true if the thread may be blocked; false if the packet written must be queued without blocking the thread

shutdown	back to summary
public void shutdown() Pretends all pending packets had been written. To be called when the `AbstractSession` closes.

terminateKeyExchange back to summary

terminateKeyExchange	back to summary
public AbstractMap.SimpleImmutableEntry<Integer, DefaultKeyExchangeFuture> terminateKeyExchange() To be called when the key exchange is done. If there are any pending packets, returns a future that will be fulfilled when `flushQueue(DefaultKeyExchangeFuture)` with that future as argument has flushed all pending packets, if there are any. Returns:AbstractMap.SimpleImmutableEntry<Integer, DefaultKeyExchangeFuture> the current `DefaultKeyExchangeFuture` and the number of currently pending packets

public AbstractMap.SimpleImmutableEntry<Integer, DefaultKeyExchangeFuture> terminateKeyExchange()

To be called when the key exchange is done. If there are any pending packets, returns a future that will be fulfilled when flushQueue(DefaultKeyExchangeFuture) with that future as argument has flushed all pending packets, if there are any.

Returns:AbstractMap.SimpleImmutableEntry<Integer, DefaultKeyExchangeFuture>: the current DefaultKeyExchangeFuture and the number of currently pending packets

updateState	back to summary
public void updateState(Runnable update)

updateState	back to summary
public <V> V updateState(Supplier<V> update)

writeOrEnqueue back to summary

writeOrEnqueue	back to summary
protected IoWriteFuture writeOrEnqueue(int cmd, Buffer buffer, long timeout, TimeUnit unit) throws IOException Writes an SSH packet. If no KEX is ongoing and there are no pending packets queued to be written after KEX, the buffer is written directly. Otherwise, the write is enqueued or the calling thread is blocked until all pending packets have been written, depending on the result of `isBlockAllowed(int)`. If the calling thread holds the monitor of the session's `AbstractSession#getFutureLock()`, it is never blocked and the write is queued. If `timeout <= 0` or `unit == null`, a time-out of "forever" is assumed. Note that a timeout applies only if the calling thread is blocked. Parameters cmd:int SSH command from the buffer buffer:Buffer `Buffer` containing the packet to write timeout:long number of `TimeUnit`s to wait at most if the calling thread is blocked unit:TimeUnit `TimeUnit` of `timeout` Returns:IoWriteFuture an `IoWriteFuture` that will be fulfilled once the packet has indeed been written. Exceptions IOException: if an error occurs

protected IoWriteFuture writeOrEnqueue(int cmd, Buffer buffer, long timeout, TimeUnit unit) throws IOException

Writes an SSH packet. If no KEX is ongoing and there are no pending packets queued to be written after KEX, the buffer is written directly. Otherwise, the write is enqueued or the calling thread is blocked until all pending packets have been written, depending on the result of isBlockAllowed(int). If the calling thread holds the monitor of the session's AbstractSession#getFutureLock(), it is never blocked and the write is queued.

If timeout <= 0 or unit == null, a time-out of "forever" is assumed. Note that a timeout applies only if the calling thread is blocked.

Parameters

cmd:int: SSH command from the buffer
buffer:Buffer: Buffer containing the packet to write
timeout:long: number of TimeUnits to wait at most if the calling thread is blocked
unit:TimeUnit: TimeUnit of timeout

Returns:IoWriteFuture

an IoWriteFuture that will be fulfilled once the packet has indeed been written.

Exceptions

IOException:: if an error occurs

writePacket back to summary

writePacket	back to summary
public IoWriteFuture writePacket(Buffer buffer, long timeout, TimeUnit unit) throws IOException Writes a packet. If a key exchange is ongoing, only low-level messages are written directly; all other messages are queued and will be written once `flushQueue(DefaultKeyExchangeFuture)` is called when the key exchange is done. Packets written while there are still pending packets to be flushed will either be queued, too, or the calling thread will be blocked with the given timeout until all packets have been flushed. Whether a write will be blocked is determined by `isBlockAllowed(int)`. If a packet was written, a key exchange may be triggered via `AbstractSession#checkRekey()`. If `timeout <= 0` or `unit == null`, a time-out of "forever" is assumed. Note that a timeout applies only if the calling thread is blocked. Parameters buffer:Buffer packet to write timeout:long number of `TimeUnit`s to wait at most if the calling thread is blocked unit:TimeUnit `TimeUnit` of `timeout` Returns:IoWriteFuture an `IoWriteFuture` that will be fulfilled once the packet has indeed been written. Exceptions IOException: if an error occurs

public IoWriteFuture writePacket(Buffer buffer, long timeout, TimeUnit unit) throws IOException

Writes a packet. If a key exchange is ongoing, only low-level messages are written directly; all other messages are queued and will be written once flushQueue(DefaultKeyExchangeFuture) is called when the key exchange is done. Packets written while there are still pending packets to be flushed will either be queued, too, or the calling thread will be blocked with the given timeout until all packets have been flushed. Whether a write will be blocked is determined by isBlockAllowed(int).

If a packet was written, a key exchange may be triggered via AbstractSession#checkRekey().

If timeout <= 0 or unit == null, a time-out of "forever" is assumed. Note that a timeout applies only if the calling thread is blocked.

Parameters

buffer:Buffer: packet to write
timeout:long: number of TimeUnits to wait at most if the calling thread is blocked
unit:TimeUnit: TimeUnit of timeout

Returns:IoWriteFuture

an IoWriteFuture that will be fulfilled once the packet has indeed been written.

Exceptions

IOException:: if an error occurs

public Class KeyExchangeMessageHandler

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail