AbstractSession (Apache Mina SSHD

java.lang.Object
- org.apache.sshd.common.util.logging.AbstractLoggingBean
- - org.apache.sshd.common.util.closeable.IoBaseCloseable
  - - org.apache.sshd.common.util.closeable.AbstractCloseable
    - - org.apache.sshd.common.util.closeable.AbstractInnerCloseable
      - org.apache.sshd.common.kex.AbstractKexFactoryManager
        
        org.apache.sshd.common.session.helpers.AbstractSession

All Implemented Interfaces:

Closeable, AutoCloseable, Channel, AttributeStore, MutableUserHolder, UsernameHolder, ChannelListenerManager, FactoryManagerHolder, PortForwardingEventListenerManager, KexFactoryManager, KeyPairProviderHolder, PropertyResolver, ReservedSessionMessagesManager, Session, SessionListenerManager, SignatureFactoriesManager

Direct Known Subclasses:

AbstractClientSession, AbstractServerSession
```
public abstract class AbstractSession
extends AbstractKexFactoryManager
implements Session
```
The AbstractSession handles all the basic SSH protocol such as key exchange, authentication, encoding and decoding. Both server side and client side sessions should inherit from this abstract class. Some basic packet processing methods are defined but the actual call to these methods should be done from the handleMessage(Buffer) method, which is dependent on the state and side of this session.
TODO: if there is any very big packet, decoderBuffer and uncompressBuffer will get quite big and they won't be resized down at any time. Though the packet size is really limited by the channel max packet size

Author:

Apache MINA SSHD Project

Nested Class Summary
- Nested classes/interfaces inherited from class org.apache.sshd.common.util.closeable.AbstractCloseable
  AbstractCloseable.State
- Nested classes/interfaces inherited from interface org.apache.sshd.common.session.Session
  Session.TimeoutStatus
- Nested classes/interfaces inherited from interface org.apache.sshd.common.AttributeStore
  AttributeStore.AttributeKey<T>

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`authed` Boolean indicating if this session has been authenticated or not
`protected long`	`authTimeoutStart`
`protected ChannelListener`	`channelListenerProxy`
`protected Collection<ChannelListener>`	`channelListeners` Channel events listener container
`protected Map<KexProposalOption,String>`	`clientProposal`
`protected String`	`clientVersion`
`protected Service`	`currentService`
`protected Object`	`decodeLock`
`protected SessionWorkBuffer`	`decoderBuffer`
`protected int`	`decoderLength`
`protected int`	`decoderState`
`protected Object`	`encodeLock`
`protected Boolean`	`firstKexPacketFollows`
`protected byte[]`	`i_c`
`protected byte[]`	`i_s`
`protected long`	`idleTimeoutStart`
`protected int`	`ignorePacketDataLength`
`protected AtomicLong`	`ignorePacketsCount`
`protected long`	`ignorePacketsFrequency`
`protected int`	`ignorePacketsVariance`
`protected AtomicLong`	`inBlocksCount`
`protected AtomicLong`	`inBytesCount`
`protected Cipher`	`inCipher`
`protected int`	`inCipherSize`
`protected Compression`	`inCompression`
`protected Mac`	`inMac`
`protected byte[]`	`inMacResult`
`protected AtomicLong`	`inPacketsCount`
`protected IoSession`	`ioSession` The underlying MINA session
`protected boolean`	`isServer` Client or server side
`protected KeyExchange`	`kex`
`protected AtomicReference<DefaultKeyExchangeFuture>`	`kexFutureHolder`
`protected AtomicReference<KexState>`	`kexState`
`protected AtomicLong`	`lastKeyTimeValue`
`protected AtomicLong`	`maxRekeyBlocks`
`protected long`	`maxRekeyBytes`
`protected long`	`maxRekeyInterval`
`protected long`	`maxRekyPackets`
`protected Map<KexProposalOption,String>`	`negotiationResult`
`protected AtomicLong`	`outBlocksCount`
`protected AtomicLong`	`outBytesCount`
`protected Cipher`	`outCipher`
`protected int`	`outCipherSize`
`protected Compression`	`outCompression`
`protected Mac`	`outMac`
`protected AtomicLong`	`outPacketsCount`
`protected Queue<PendingWriteFuture>`	`pendingPackets`
`protected Random`	`random` The pseudo random generator
`protected Object`	`requestLock`
`protected long`	`seqi`
`protected long`	`seqo`
`protected Map<KexProposalOption,String>`	`serverProposal`
`protected String`	`serverVersion`
`static String`	`SESSION` Name of the property where this session is stored in the attributes of the underlying MINA session.
`protected byte[]`	`sessionId`
`protected SessionListener`	`sessionListenerProxy`
`protected Collection<SessionListener>`	`sessionListeners` Session listeners container
`protected AtomicReference<Session.TimeoutStatus>`	`timeoutStatus`
`protected PortForwardingEventListener`	`tunnelListenerProxy`
`protected Collection<PortForwardingEventListener>`	`tunnelListeners` Port forwarding events listener container
`protected SessionWorkBuffer`	`uncompressBuffer`
`protected String`	`username` The name of the authenticated user

Fields inherited from class org.apache.sshd.common.util.closeable.AbstractCloseable
closeFuture, lock, state

Fields inherited from class org.apache.sshd.common.util.logging.AbstractLoggingBean
log

Fields inherited from interface org.apache.sshd.common.session.Session
DEFAULT_SSH_VERSION_PREFIX, FALLBACK_SSH_VERSION_PREFIX, MAX_VERSION_LINE_LENGTH

Fields inherited from interface org.apache.sshd.common.PropertyResolver
EMPTY

Fields inherited from interface org.apache.sshd.common.Closeable
CLOSE_WAIT_TIMEOUT, DEFAULT_CLOSE_WAIT_TIMEOUT

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractSession(boolean isServer, FactoryManager factoryManager, IoSession ioSession)` Create a new session.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addChannelListener(ChannelListener listener)` Add a channel listener
`void`	`addPortForwardingEventListener(PortForwardingEventListener listener)` Add a port forwarding listener
`void`	`addSessionListener(SessionListener listener)` Add a session listener.
`static void`	`attachSession(IoSession ioSession, AbstractSession session)` Attach a session to the MINA session
`protected long`	`calculateNextIgnorePacketCount(Random r, long freq, int variance)`
`protected Pair<Session.TimeoutStatus,String>`	`checkAuthenticationTimeout(long now, long authTimeoutMs)` Checks if authentication timeout expired
`protected void`	`checkForTimeouts()` Checks whether the session has timed out (both auth and idle timeouts are checked).
`protected Pair<Session.TimeoutStatus,String>`	`checkIdleTimeout(long now, long idleTimeoutMs)` Checks if idle timeout expired
`protected abstract void`	`checkKeys()` Indicates the the key exchange is completed and the exchanged keys can now be verified - e.g., client can verify the server's key
`protected KeyExchangeFuture`	`checkRekey()` Checks if a re-keying is required and if so initiates it
`protected Pair<String,String>`	`comparePreferredKexProposalOption(KexProposalOption option)`
`Buffer`	`createBuffer(byte cmd)` Create a new buffer for the specified SSH packet and reserve the needed space (5 bytes) for the packet header.
`Buffer`	`createBuffer(byte cmd, int len)` Create a new buffer for the specified SSH packet and reserve the needed space (5 bytes) for the packet header.
`protected Map<KexProposalOption,String>`	`createProposal(String hostKeyTypes)` Create our proposal for SSH negotiation
`protected void`	`decode()` Decode the incoming buffer and handle packets as needed.
`void`	`disconnect(int reason, String msg)` Send a disconnect packet with the given reason and message.
`protected void`	`doHandleMessage(Buffer buffer)`
`protected List<String>`	`doReadIdentification(Buffer buffer, boolean server)` Read the remote identification from this buffer.
`protected IoWriteFuture`	`doWritePacket(Buffer buffer)`
`protected Buffer`	`encode(Buffer buffer)` Encode a buffer into the SSH protocol.
`void`	`exceptionCaught(Throwable t)` Handle any exceptions that occurred on this session.
`<T> T`	`getAttribute(AttributeStore.AttributeKey<T> key)` Returns the value of the user-defined attribute.
`long`	`getAuthTimeout()`
`ChannelListener`	`getChannelListenerProxy()`
`CipherInformation`	`getCipherInformation(boolean incoming)` Retrieves current cipher information - Note: may change if key re-exchange executed
`String`	`getClientVersion()` Retrieve the client version for this session.
`CompressionInformation`	`getCompressionInformation(boolean incoming)` Retrieves current compression information - Note: may change if key re-exchange executed
`FactoryManager`	`getFactoryManager()`
`long`	`getIdleTimeout()`
`protected Closeable`	`getInnerCloseable()`
`IoSession`	`getIoSession()`
`KeyExchange`	`getKex()`
`Object`	`getLock()`
`MacInformation`	`getMacInformation(boolean incoming)` Retrieves current MAC information - Note: may change if key re-exchange executed
`String`	`getNegotiatedKexParameter(KexProposalOption paramType)` Retrieve one of the negotiated values during the KEX stage
`PropertyResolver`	`getParentPropertyResolver()`
`PortForwardingEventListener`	`getPortForwardingEventListenerProxy()`
`Map<String,Object>`	`getProperties()` A map of properties that can be used to configure the SSH server or client.
`ReservedSessionMessagesHandler`	`getReservedSessionMessagesHandler()`
`String`	`getServerVersion()` Retrieve the server version for this session.
`<T extends Service> T`	`getService(Class<T> clazz)` Get the service of the specified type.
`protected List<Service>`	`getServices()`
`static AbstractSession`	`getSession(IoSession ioSession)` Retrieve the session from the MINA session.
`static AbstractSession`	`getSession(IoSession ioSession, boolean allowNull)` Retrieve the session from the MINA session.
`byte[]`	`getSessionId()`
`SessionListener`	`getSessionListenerProxy()`
`Session.TimeoutStatus`	`getTimeoutStatus()` Check if timeout has occurred.
`String`	`getUsername()`
`protected void`	`handleDebug(Buffer buffer)`
`protected void`	`handleDisconnect(Buffer buffer)`
`protected void`	`handleDisconnect(int code, String msg, String lang, Buffer buffer)`
`protected boolean`	`handleFirstKexPacketFollows(int cmd, Buffer buffer, boolean followFlag)`
`protected void`	`handleIgnore(Buffer buffer)`
`protected void`	`handleKexInit(Buffer buffer)`
`protected void`	`handleKexMessage(int cmd, Buffer buffer)`
`protected void`	`handleMessage(Buffer buffer)` Abstract method for processing incoming decoded packets.
`protected void`	`handleNewKeys(int cmd, Buffer buffer)`
`protected void`	`handleServiceAccept(Buffer buffer)`
`protected void`	`handleServiceAccept(String serviceName, Buffer buffer)`
`protected void`	`handleServiceRequest(Buffer buffer)`
`protected boolean`	`handleServiceRequest(String serviceName, Buffer buffer)`
`protected void`	`handleUnimplemented(Buffer buffer)`
`protected void`	`invokeSessionSignaller(Invoker<SessionListener,Void> invoker)`
`boolean`	`isAuthenticated()`
`protected boolean`	`isRekeyBlocksCountExceeded()`
`protected boolean`	`isRekeyDataSizeExceeded()`
`protected boolean`	`isRekeyPacketCountsExceeded()`
`protected boolean`	`isRekeyRequired()`
`protected boolean`	`isRekeyTimeIntervalExceeded()`
`protected Map<KexProposalOption,String>`	`mergeProposals(Map<KexProposalOption,String> current, Map<KexProposalOption,String> proposal)`
`void`	`messageReceived(Readable buffer)` Main input point for the MINA framework.
`protected Map<KexProposalOption,String>`	`negotiate()` Compute the negotiated proposals by merging the client and server proposal.
`protected IoWriteFuture`	`notImplemented()` Send a `SSH_MSG_UNIMPLEMENTED` packet.
`protected void`	`preClose()` preClose is guaranteed to be called before doCloseGracefully or doCloseImmediately.
`Buffer`	`prepareBuffer(byte cmd, Buffer buffer)` Prepare a new "clean" buffer while reserving the needed space (5 bytes) for the packet header.
`protected abstract boolean`	`readIdentification(Buffer buffer)` Read the other side identification.
`protected void`	`receiveKexInit(Buffer buffer)`
`protected byte[]`	`receiveKexInit(Buffer buffer, Map<KexProposalOption,String> proposal)` Receive the remote key exchange init message.
`protected abstract void`	`receiveKexInit(Map<KexProposalOption,String> proposal, byte[] seed)`
`protected void`	`receiveNewKeys()` Put new keys into use.
`KeyExchangeFuture`	`reExchangeKeys()` Initiate a new key exchange.
`protected void`	`refreshConfiguration()` Refresh whatever internal configuration is not `final`
`<T> T`	`removeAttribute(AttributeStore.AttributeKey<T> key)` Removes the user-defined attribute
`void`	`removeChannelListener(ChannelListener listener)` Remove a channel listener
`void`	`removePortForwardingEventListener(PortForwardingEventListener listener)` Remove a port forwarding listener
`void`	`removeSessionListener(SessionListener listener)` Remove a session listener.
`Buffer`	`request(String request, Buffer buffer, long timeout, TimeUnit unit)` Send a global request and wait for the response.
`protected void`	`requestFailure(Buffer buffer)` Indicates the reception of a `SSH_MSG_REQUEST_FAILURE` message
`protected KeyExchangeFuture`	`requestNewKeysExchange()` Initiates a new keys exchange if one not already in progress
`protected void`	`requestSuccess(Buffer buffer)` Indicates the reception of a `SSH_MSG_REQUEST_SUCCESS` message
`void`	`resetIdleTimeout()` Re-start idle timeout timer
`protected byte[]`	`resizeKey(byte[] e, int blockSize, Digest hash, byte[] k, byte[] h)` Method used while putting new keys into use that will resize the key used to initialize the cipher to the needed length.
`<T> T`	`resolveAttribute(AttributeStore.AttributeKey<T> key)` Attempts to resolve the associated value by going up the store's hierarchy (if any)
`protected String`	`resolveAvailableSignaturesProposal()`
`protected abstract String`	`resolveAvailableSignaturesProposal(FactoryManager manager)`
`protected String`	`resolveIdentificationString(String configPropName)` Resolves the identification to send to the peer session by consulting the associated `FactoryManager`.
`protected int`	`resolveIgnoreBufferDataLength()`
`protected SocketAddress`	`resolvePeerAddress(SocketAddress knownAddress)`
`protected ReservedSessionMessagesHandler`	`resolveReservedSessionMessagesHandler()`
`IoWriteFuture`	`sendDebugMessage(boolean display, Object msg, String lang)` Sends an `SSH_MSG_DEBUG` to the peer session
`protected IoWriteFuture`	`sendIdentification(String ident)` Send our identification.
`IoWriteFuture`	`sendIgnoreMessage(byte... data)` Sends an `SSH_MSG_IGNORE` to the peer session
`protected byte[]`	`sendKexInit()`
`protected byte[]`	`sendKexInit(Map<KexProposalOption,String> proposal)` Send the key exchange initialization packet.
`protected IoWriteFuture`	`sendNewKeys()` Send a message to put new keys into use.
`protected IoWriteFuture`	`sendNotImplemented(long seqNoValue)` Sends a `SSH_MSG_UNIMPLEMENTED` message
`<T> T`	`setAttribute(AttributeStore.AttributeKey<T> key, T value)` Sets a user-defined attribute.
`void`	`setAuthenticated()`
`protected abstract void`	`setKexSeed(byte... seed)`
`protected Map<KexProposalOption,String>`	`setNegotiationResult(Map<KexProposalOption,String> guess)`
`void`	`setReservedSessionMessagesHandler(ReservedSessionMessagesHandler handler)`
`void`	`setUsername(String username)`
`protected void`	`signalExceptionCaught(SessionListener listener, Throwable t)`
`protected void`	`signalExceptionCaught(Throwable t)`
`protected void`	`signalNegotiationEnd(Map<KexProposalOption,String> c2sOptions, Map<KexProposalOption,String> s2cOptions, Map<KexProposalOption,String> negotiatedGuess, Throwable reason)`
`protected void`	`signalNegotiationEnd(SessionListener listener, Map<KexProposalOption,String> c2sOptions, Map<KexProposalOption,String> s2cOptions, Map<KexProposalOption,String> negotiatedGuess, Throwable reason)`
`protected void`	`signalNegotiationStart(Map<KexProposalOption,String> c2sOptions, Map<KexProposalOption,String> s2cOptions)`
`protected void`	`signalNegotiationStart(SessionListener listener, Map<KexProposalOption,String> c2sOptions, Map<KexProposalOption,String> s2cOptions)`
`protected void`	`signalSessionClosed()`
`protected void`	`signalSessionClosed(SessionListener listener)`
`protected void`	`signalSessionCreated(IoSession ioSession)`
`protected void`	`signalSessionCreated(SessionListener listener)`
`protected void`	`signalSessionEvent(SessionListener.Event event)` Sends a session event to all currently registered session listeners
`protected void`	`signalSessionEvent(SessionListener listener, SessionListener.Event event)`
`String`	`toString()`
`protected void`	`validateKexState(int cmd, KexState expected)`
`protected <B extends Buffer> B`	`validateTargetBuffer(int cmd, B buffer)` Makes sure that the buffer used for output is not `null` or one of the session's internal ones used for decoding and uncompressing
`IoWriteFuture`	`writePacket(Buffer buffer)` Encode and send the given buffer.
`IoWriteFuture`	`writePacket(Buffer buffer, long timeout, TimeUnit unit)` Encode and send the given buffer with the specified timeout.

Methods inherited from class org.apache.sshd.common.kex.AbstractKexFactoryManager
getCipherFactories, getCompressionFactories, getKeyExchangeFactories, getKeyPairProvider, getMacFactories, getSignatureFactories, resolveEffectiveFactories, resolveEffectiveProvider, setCipherFactories, setCompressionFactories, setKeyExchangeFactories, setKeyPairProvider, setMacFactories, setSignatureFactories

Methods inherited from class org.apache.sshd.common.util.closeable.AbstractInnerCloseable
doCloseGracefully, doCloseImmediately

Methods inherited from class org.apache.sshd.common.util.closeable.AbstractCloseable
addCloseFutureListener, builder, close, isClosed, isClosing, removeCloseFutureListener

Methods inherited from class org.apache.sshd.common.util.logging.AbstractLoggingBean
getSimplifiedLogger

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.sshd.common.session.Session
isValidVersionPrefix, startService

Methods inherited from interface org.apache.sshd.common.keyprovider.KeyPairProviderHolder
getKeyPairProvider, setKeyPairProvider

Methods inherited from interface org.apache.sshd.common.signature.SignatureFactoriesManager
getSignatureFactories, getSignatureFactories, getSignatureFactoriesNameList, getSignatureFactoriesNames, resolveSignatureFactories, setSignatureFactories, setSignatureFactoriesNameList, setSignatureFactoriesNames, setSignatureFactoriesNames

Methods inherited from interface org.apache.sshd.common.PropertyResolver
getBoolean, getBooleanProperty, getInteger, getIntProperty, getLong, getLongProperty, getObject, getString, getStringProperty

Methods inherited from interface org.apache.sshd.common.AttributeStore
resolveAttribute, resolveAttribute, resolveAttribute

Methods inherited from interface org.apache.sshd.common.Closeable
addCloseFutureListener, close, close, close, getMaxCloseWaitTime, isClosed, isClosing, isOpen, removeCloseFutureListener

- Field Detail
  - SESSION
```
public static final String SESSION
```
    Name of the property where this session is stored in the attributes of the underlying MINA session. See getSession(IoSession, boolean) and attachSession(IoSession, AbstractSession).
    
    See Also:
    
    Constant Field Values
  - isServer
```
protected final boolean isServer
```
    Client or server side
  - ioSession
```
protected final IoSession ioSession
```
    The underlying MINA session
  - random
```
protected final Random random
```
    The pseudo random generator
  - authed
```
protected boolean authed
```
    Boolean indicating if this session has been authenticated or not
  - username
```
protected String username
```
    The name of the authenticated user
  - sessionListeners
```
protected final Collection<SessionListener> sessionListeners
```
    Session listeners container
  - sessionListenerProxy
```
protected final SessionListener sessionListenerProxy
```
  - channelListeners
```
protected final Collection<ChannelListener> channelListeners
```
    Channel events listener container
  - channelListenerProxy
```
protected final ChannelListener channelListenerProxy
```
  - tunnelListeners
```
protected final Collection<PortForwardingEventListener> tunnelListeners
```
    Port forwarding events listener container
  - tunnelListenerProxy
```
protected final PortForwardingEventListener tunnelListenerProxy
```
  - sessionId
```
protected byte[] sessionId
```
  - serverVersion
```
protected String serverVersion
```
  - clientVersion
```
protected String clientVersion
```
  - serverProposal
```
protected final Map<KexProposalOption,String> serverProposal
```
  - clientProposal
```
protected final Map<KexProposalOption,String> clientProposal
```
  - negotiationResult
```
protected final Map<KexProposalOption,String> negotiationResult
```
  - i_c
```
protected byte[] i_c
```
  - i_s
```
protected byte[] i_s
```
  - kex
```
protected KeyExchange kex
```
  - firstKexPacketFollows
```
protected Boolean firstKexPacketFollows
```
  - kexState
```
protected final AtomicReference<KexState> kexState
```
  - kexFutureHolder
```
protected final AtomicReference<DefaultKeyExchangeFuture> kexFutureHolder
```
  - outCipher
```
protected Cipher outCipher
```
  - inCipher
```
protected Cipher inCipher
```
  - outCipherSize
```
protected int outCipherSize
```
  - inCipherSize
```
protected int inCipherSize
```
  - outMac
```
protected Mac outMac
```
  - inMac
```
protected Mac inMac
```
  - inMacResult
```
protected byte[] inMacResult
```
  - outCompression
```
protected Compression outCompression
```
  - inCompression
```
protected Compression inCompression
```
  - seqi
```
protected long seqi
```
  - seqo
```
protected long seqo
```
  - uncompressBuffer
```
protected SessionWorkBuffer uncompressBuffer
```
  - decoderBuffer
```
protected final SessionWorkBuffer decoderBuffer
```
  - decoderState
```
protected int decoderState
```
  - decoderLength
```
protected int decoderLength
```
  - encodeLock
```
protected final Object encodeLock
```
  - decodeLock
```
protected final Object decodeLock
```
  - requestLock
```
protected final Object requestLock
```
  - authTimeoutStart
```
protected long authTimeoutStart
```
  - idleTimeoutStart
```
protected long idleTimeoutStart
```
  - timeoutStatus
```
protected final AtomicReference<Session.TimeoutStatus> timeoutStatus
```
  - inPacketsCount
```
protected final AtomicLong inPacketsCount
```
  - outPacketsCount
```
protected final AtomicLong outPacketsCount
```
  - inBytesCount
```
protected final AtomicLong inBytesCount
```
  - outBytesCount
```
protected final AtomicLong outBytesCount
```
  - inBlocksCount
```
protected final AtomicLong inBlocksCount
```
  - outBlocksCount
```
protected final AtomicLong outBlocksCount
```
  - lastKeyTimeValue
```
protected final AtomicLong lastKeyTimeValue
```
  - maxRekyPackets
```
protected long maxRekyPackets
```
  - maxRekeyBytes
```
protected long maxRekeyBytes
```
  - maxRekeyInterval
```
protected long maxRekeyInterval
```
  - pendingPackets
```
protected final Queue<PendingWriteFuture> pendingPackets
```
  - currentService
```
protected Service currentService
```
  - ignorePacketDataLength
```
protected int ignorePacketDataLength
```
  - ignorePacketsFrequency
```
protected long ignorePacketsFrequency
```
  - ignorePacketsVariance
```
protected int ignorePacketsVariance
```
  - maxRekeyBlocks
```
protected final AtomicLong maxRekeyBlocks
```
  - ignorePacketsCount
```
protected final AtomicLong ignorePacketsCount
```
- Constructor Detail
  - AbstractSession
```
protected AbstractSession(boolean isServer,
                          FactoryManager factoryManager,
                          IoSession ioSession)
```
    Create a new session.
    
    Parameters:
    
    isServer - true if this is a server session, false if client one
    
    factoryManager - the factory manager
    
    ioSession - the underlying MINA session
- Method Detail
  - signalSessionCreated
```
protected void signalSessionCreated(IoSession ioSession)
                             throws Exception
```
    Throws:
    
    Exception
  - signalSessionCreated
```
protected void signalSessionCreated(SessionListener listener)
```
  - getSession
```
public static AbstractSession getSession(IoSession ioSession)
```
    Retrieve the session from the MINA session. If the session has not been attached, an IllegalStateException will be thrown
    
    Parameters:
    
    ioSession - the MINA session
    
    Returns:
    
    the session attached to the MINA session
    
    See Also:
    
    getSession(IoSession, boolean)
  - getSession
```
public static AbstractSession getSession(IoSession ioSession,
                                         boolean allowNull)
```
    Retrieve the session from the MINA session. If the session has not been attached and allowNull is false, an IllegalStateException will be thrown, else a null will be returned
    
    Parameters:
    
    ioSession - the MINA session
    
    allowNull - if true, a null value may be returned if no session is attached
    
    Returns:
    
    the session attached to the MINA session or null
  - attachSession
```
public static void attachSession(IoSession ioSession,
                                 AbstractSession session)
```
    Attach a session to the MINA session
    
    Parameters:
    
    ioSession - the MINA session
    
    session - the session to attach
  - getServerVersion
```
public String getServerVersion()
```
    Description copied from interface: Session
    
    Retrieve the server version for this session.
    
    Specified by:
    
    getServerVersion in interface Session
    
    Returns:
    
    the server version.
  - getClientVersion
```
public String getClientVersion()
```
    Description copied from interface: Session
    
    Retrieve the client version for this session.
    
    Specified by:
    
    getClientVersion in interface Session
    
    Returns:
    
    the client version.
  - getKex
```
public KeyExchange getKex()
```
    Specified by:
    
    getKex in interface Session
  - getSessionId
```
public byte[] getSessionId()
```
    Specified by:
    
    getSessionId in interface Session
    
    Returns:
    
    The established session identifier - null if not yet established
  - getIoSession
```
public IoSession getIoSession()
```
    Specified by:
    
    getIoSession in interface Session
    
    Returns:
    
    the IoSession associated to this session
  - resolvePeerAddress
```
protected SocketAddress resolvePeerAddress(SocketAddress knownAddress)
```
    Parameters:
    
    knownAddress - Any externally set peer address - e.g., due to some proxy mechanism meta-data
    
    Returns:
    
    The external address if not null otherwise, the IoSession peer address
  - getFactoryManager
```
public FactoryManager getFactoryManager()
```
    Specified by:
    
    getFactoryManager in interface FactoryManagerHolder
    
    Returns:
    
    The currently associated FactoryManager
  - getParentPropertyResolver
```
public PropertyResolver getParentPropertyResolver()
```
    Specified by:
    
    getParentPropertyResolver in interface PropertyResolver
    
    Returns:
    
    The parent resolver that can be used to query for missing properties - null if no parent
  - getProperties
```
public Map<String,Object> getProperties()
```
    Description copied from interface: PropertyResolver
    
    A map of properties that can be used to configure the SSH server or client. This map will never be changed by either the server or client and is not supposed to be changed at runtime (changes are not bound to have any effect on a running client or server), though it may affect the creation of sessions later as these values are usually not cached.
    
    Note: the type of the mapped property should match the expected configuration value type - Long, Integer, Boolean, String, etc.... If it doesn't, the toString() result of the mapped value is used to convert it to the required type. E.g., if the mapped value is the string "1234" and the expected value is a long then it will be parsed into one. Also, if the mapped value is an Integer but a long is expected, then it will be converted into one.
    
    Specified by:
    
    getProperties in interface PropertyResolver
    
    Returns:
    
    a valid Map containing configuration values, never null
  - getNegotiatedKexParameter
```
public String getNegotiatedKexParameter(KexProposalOption paramType)
```
    Description copied from interface: Session
    
    Retrieve one of the negotiated values during the KEX stage
    
    Specified by:
    
    getNegotiatedKexParameter in interface Session
    
    Parameters:
    
    paramType - The request KexProposalOption value - ignored if null
    
    Returns:
    
    The negotiated parameter value - null if invalid parameter or no negotiated value
  - getCipherInformation
```
public CipherInformation getCipherInformation(boolean incoming)
```
    Description copied from interface: Session
    
    Retrieves current cipher information - Note: may change if key re-exchange executed
    
    Specified by:
    
    getCipherInformation in interface Session
    
    Parameters:
    
    incoming - If true then the cipher for the incoming data, otherwise for the outgoing data
    
    Returns:
    
    The CipherInformation - or null if not negotiated yet.
  - getCompressionInformation
```
public CompressionInformation getCompressionInformation(boolean incoming)
```
    Description copied from interface: Session
    
    Retrieves current compression information - Note: may change if key re-exchange executed
    
    Specified by:
    
    getCompressionInformation in interface Session
    
    Parameters:
    
    incoming - If true then the compression for the incoming data, otherwise for the outgoing data
    
    Returns:
    
    The CompressionInformation - or null if not negotiated yet.
  - getMacInformation
```
public MacInformation getMacInformation(boolean incoming)
```
    Description copied from interface: Session
    
    Retrieves current MAC information - Note: may change if key re-exchange executed
    
    Specified by:
    
    getMacInformation in interface Session
    
    Parameters:
    
    incoming - If true then the MAC for the incoming data, otherwise for the outgoing data
    
    Returns:
    
    The MacInformation - or null if not negotiated yet.
  - isAuthenticated
```
public boolean isAuthenticated()
```
    Specified by:
    
    isAuthenticated in interface Session
  - setAuthenticated
```
public void setAuthenticated()
                      throws IOException
```
    Specified by:
    
    setAuthenticated in interface Session
    
    Throws:
    
    IOException
  - messageReceived
```
public void messageReceived(Readable buffer)
                     throws Exception
```
    Main input point for the MINA framework.
    
    This method will be called each time new data is received on the socket and will append it to the input buffer before calling the decode() method.
    
    Parameters:
    
    buffer - the new buffer received
    
    Throws:
    
    Exception - if an error occurs while decoding or handling the data
  - refreshConfiguration
```
protected void refreshConfiguration()
```
    Refresh whatever internal configuration is not final
  - handleMessage
```
protected void handleMessage(Buffer buffer)
                      throws Exception
```
    Abstract method for processing incoming decoded packets. The given buffer will hold the decoded packet, starting from the command byte at the read position.
    
    Parameters:
    
    buffer - The Buffer containing the packet - it may be re-used to generate the response once request has been decoded
    
    Throws:
    
    Exception - if an exception occurs while handling this packet.
    
    See Also:
    
    doHandleMessage(Buffer)
  - doHandleMessage
```
protected void doHandleMessage(Buffer buffer)
                        throws Exception
```
    Throws:
    
    Exception
  - handleFirstKexPacketFollows
```
protected boolean handleFirstKexPacketFollows(int cmd,
                                              Buffer buffer,
                                              boolean followFlag)
```
  - comparePreferredKexProposalOption
```
protected Pair<String,String> comparePreferredKexProposalOption(KexProposalOption option)
```
  - handleKexMessage
```
protected void handleKexMessage(int cmd,
                                Buffer buffer)
                         throws Exception
```
    Throws:
    
    Exception
  - sendIgnoreMessage
```
public IoWriteFuture sendIgnoreMessage(byte... data)
                                throws IOException
```
    Description copied from interface: Session
    
    Sends an SSH_MSG_IGNORE to the peer session
    
    Specified by:
    
    sendIgnoreMessage in interface Session
    
    Parameters:
    
    data - The message data
    
    Returns:
    
    An IoWriteFuture that can be used to check when the packet has actually been sent
    
    Throws:
    
    IOException - if an error occurred when encoding sending the packet
    
    See Also:
    
    RFC 4253 - section 11.2
  - handleIgnore
```
protected void handleIgnore(Buffer buffer)
                     throws Exception
```
    Throws:
    
    Exception
  - handleUnimplemented
```
protected void handleUnimplemented(Buffer buffer)
                            throws Exception
```
    Throws:
    
    Exception
  - sendDebugMessage
```
public IoWriteFuture sendDebugMessage(boolean display,
                                      Object msg,
                                      String lang)
                               throws IOException
```
    Description copied from interface: Session
    
    Sends an SSH_MSG_DEBUG to the peer session
    
    Specified by:
    
    sendDebugMessage in interface Session
    
    Parameters:
    
    display - true if OK to display the message at the peer as-is
    
    msg - The message object whose toString() value to be used - if null then the "null" string is sent
    
    lang - The language - null/empty if some pre-agreed default is used
    
    Returns:
    
    An IoWriteFuture that can be used to check when the packet has actually been sent
    
    Throws:
    
    IOException - if an error occurred when encoding sending the packet
    
    See Also:
    
    RFC 4253 - section 11.3
  - handleDebug
```
protected void handleDebug(Buffer buffer)
                    throws Exception
```
    Throws:
    
    Exception
  - resolveReservedSessionMessagesHandler
```
protected ReservedSessionMessagesHandler resolveReservedSessionMessagesHandler()
```
  - handleDisconnect
```
protected void handleDisconnect(Buffer buffer)
                         throws Exception
```
    Throws:
    
    Exception
  - handleDisconnect
```
protected void handleDisconnect(int code,
                                String msg,
                                String lang,
                                Buffer buffer)
                         throws Exception
```
    Throws:
    
    Exception
  - handleServiceRequest
```
protected void handleServiceRequest(Buffer buffer)
                             throws Exception
```
    Throws:
    
    Exception
  - handleServiceRequest
```
protected boolean handleServiceRequest(String serviceName,
                                       Buffer buffer)
                                throws Exception
```
    Throws:
    
    Exception
  - handleServiceAccept
```
protected void handleServiceAccept(Buffer buffer)
                            throws Exception
```
    Throws:
    
    Exception
  - handleServiceAccept
```
protected void handleServiceAccept(String serviceName,
                                   Buffer buffer)
                            throws Exception
```
    Throws:
    
    Exception
  - handleKexInit
```
protected void handleKexInit(Buffer buffer)
                      throws Exception
```
    Throws:
    
    Exception
  - handleNewKeys
```
protected void handleNewKeys(int cmd,
                             Buffer buffer)
                      throws Exception
```
    Throws:
    
    Exception
  - validateKexState
```
protected void validateKexState(int cmd,
                                KexState expected)
```
  - exceptionCaught
```
public void exceptionCaught(Throwable t)
```
    Handle any exceptions that occurred on this session. The session will be closed and a disconnect packet will be sent before if the given exception is an SshException.
    
    Specified by:
    
    exceptionCaught in interface Session
    
    Parameters:
    
    t - the exception to process
  - signalExceptionCaught
```
protected void signalExceptionCaught(Throwable t)
```
  - signalExceptionCaught
```
protected void signalExceptionCaught(SessionListener listener,
                                     Throwable t)
```
  - getInnerCloseable
```
protected Closeable getInnerCloseable()
```
    Specified by:
    
    getInnerCloseable in class AbstractInnerCloseable
  - preClose
```
protected void preClose()
```
    Description copied from class: AbstractCloseable
    
    preClose is guaranteed to be called before doCloseGracefully or doCloseImmediately. When preClose() is called, isClosing() == true
    
    Overrides:
    
    preClose in class AbstractCloseable
  - signalSessionClosed
```
protected void signalSessionClosed()
```
  - signalSessionClosed
```
protected void signalSessionClosed(SessionListener listener)
```
  - getServices
```
protected List<Service> getServices()
```
  - getService
```
public <T extends Service> T getService(Class<T> clazz)
```
    Description copied from interface: Session
    
    Get the service of the specified type. If the service is not of the specified class, an IllegalStateException will be thrown.
    
    Specified by:
    
    getService in interface Session
    
    Type Parameters:
    
    T - The generic Service type
    
    Parameters:
    
    clazz - The service class
    
    Returns:
    
    The service instance
  - writePacket
```
public IoWriteFuture writePacket(Buffer buffer)
                          throws IOException
```
    Description copied from interface: Session
    
    Encode and send the given buffer. The buffer has to have 5 bytes free at the beginning to allow the encoding to take place. Also, the write position of the buffer has to be set to the position of the last byte to write.
    
    Specified by:
    
    writePacket in interface Session
    
    Parameters:
    
    buffer - the buffer to encode and send
    
    Returns:
    
    An IoWriteFuture that can be used to check when the packet has actually been sent
    
    Throws:
    
    IOException - if an error occurred when encoding sending the packet
  - writePacket
```
public IoWriteFuture writePacket(Buffer buffer,
                                 long timeout,
                                 TimeUnit unit)
                          throws IOException
```
    Description copied from interface: Session
    
    Encode and send the given buffer with the specified timeout. If the buffer could not be written before the timeout elapses, the returned IoWriteFuture will be set with a TimeoutException exception to indicate a timeout.
    
    Specified by:
    
    writePacket in interface Session
    
    Parameters:
    
    buffer - the buffer to encode and spend
    
    timeout - the timeout
    
    unit - the time unit of the timeout parameter
    
    Returns:
    
    a future that can be used to check when the packet has actually been sent
    
    Throws:
    
    IOException - if an error occurred when encoding sending the packet
  - doWritePacket
```
protected IoWriteFuture doWritePacket(Buffer buffer)
                               throws IOException
```
    Throws:
    
    IOException
  - resolveIgnoreBufferDataLength
```
protected int resolveIgnoreBufferDataLength()
```
  - calculateNextIgnorePacketCount
```
protected long calculateNextIgnorePacketCount(Random r,
                                              long freq,
                                              int variance)
```
  - request
```
public Buffer request(String request,
                      Buffer buffer,
                      long timeout,
                      TimeUnit unit)
               throws IOException
```
    Description copied from interface: Session
    
    Send a global request and wait for the response. This must only be used when sending a SSH_MSG_GLOBAL_REQUEST with a result expected, else it will time out
    
    Specified by:
    
    request in interface Session
    
    Parameters:
    
    request - the request name - used mainly for logging and debugging
    
    buffer - the buffer containing the global request
    
    timeout - The number of time units to wait - must be positive
    
    unit - The TimeUnit to wait for the response
    
    Returns:
    
    the return buffer if the request was successful, null otherwise.
    
    Throws:
    
    IOException - if an error occurred when encoding sending the packet
  - createBuffer
```
public Buffer createBuffer(byte cmd)
```
    Description copied from interface: Session
    
    Create a new buffer for the specified SSH packet and reserve the needed space (5 bytes) for the packet header.
    
    Specified by:
    
    createBuffer in interface Session
    
    Parameters:
    
    cmd - the SSH command
    
    Returns:
    
    a new buffer ready for write
  - createBuffer
```
public Buffer createBuffer(byte cmd,
                           int len)
```
    Description copied from interface: Session
    
    Create a new buffer for the specified SSH packet and reserve the needed space (5 bytes) for the packet header.
    
    Specified by:
    
    createBuffer in interface Session
    
    Parameters:
    
    cmd - The SSH command to initialize the buffer with
    
    len - Estimated number of bytes the buffer will hold, 0 if unknown.
    
    Returns:
    
    a new buffer ready for write
    
    See Also:
    
    Session.prepareBuffer(byte, Buffer)
  - prepareBuffer
```
public Buffer prepareBuffer(byte cmd,
                            Buffer buffer)
```
    Description copied from interface: Session
    
    Prepare a new "clean" buffer while reserving the needed space (5 bytes) for the packet header.
    
    Specified by:
    
    prepareBuffer in interface Session
    
    Parameters:
    
    cmd - The SSH command to initialize the buffer with
    
    buffer - The Buffer instance to initialize
    
    Returns:
    
    The initialized buffer
  - validateTargetBuffer
```
protected <B extends Buffer> B validateTargetBuffer(int cmd,
                                                    B buffer)
```
    Makes sure that the buffer used for output is not null or one of the session's internal ones used for decoding and uncompressing
    
    Type Parameters:
    
    B - The Buffer type being validated
    
    Parameters:
    
    cmd - The most likely command this buffer refers to (not guaranteed to be correct)
    
    buffer - The buffer to be examined
    
    Returns:
    
    The validated target instance - default same as input
    
    Throws:
    
    IllegalArgumentException - if any of the conditions is violated
  - encode
```
protected Buffer encode(Buffer buffer)
                 throws IOException
```
    Encode a buffer into the SSH protocol. This method need to be called into a synchronized block around encodeLock
    
    Parameters:
    
    buffer - the buffer to encode
    
    Returns:
    
    The encoded buffer - may be different than original if input buffer does not have enough room for SshConstants.SSH_PACKET_HEADER_LEN, in which a substitute buffer will be created and used.
    
    Throws:
    
    IOException - if an exception occurs during the encoding process
  - decode
```
protected void decode()
               throws Exception
```
    Decode the incoming buffer and handle packets as needed.
    
    Throws:
    
    Exception - If failed to decode
  - resolveIdentificationString
```
protected String resolveIdentificationString(String configPropName)
```
    Resolves the identification to send to the peer session by consulting the associated FactoryManager. If a value is set, then it is appended to the standard Session.DEFAULT_SSH_VERSION_PREFIX. Otherwise a default value is returned consisting of the prefix and the core artifact name + version in uppercase - e.g.,' "SSH-2.0-SSHD-CORE-1.2.3.4"
    
    Parameters:
    
    configPropName - The property used to query the factory manager
    
    Returns:
    
    The resolved identification value
  - sendIdentification
```
protected IoWriteFuture sendIdentification(String ident)
```
    Send our identification.
    
    Parameters:
    
    ident - our identification to send
    
    Returns:
    
    IoWriteFuture that can be used to wait for notification that identification has been send
  - readIdentification
```
protected abstract boolean readIdentification(Buffer buffer)
                                       throws IOException
```
    Read the other side identification. This method is specific to the client or server side, but both should call doReadIdentification(Buffer, boolean) and store the result in the needed property.
    
    Parameters:
    
    buffer - The Buffer containing the remote identification
    
    Returns:
    
    true if the identification has been fully read or false if more data is needed
    
    Throws:
    
    IOException - if an error occurs such as a bad protocol version
  - doReadIdentification
```
protected List<String> doReadIdentification(Buffer buffer,
                                            boolean server)
```
    Read the remote identification from this buffer. If more data is needed, the buffer will be reset to its original state and a null value will be returned. Else the identification string will be returned and the data read will be consumed from the buffer.
    
    Parameters:
    
    buffer - the buffer containing the identification string
    
    server - true if it is called by the server session, false if by the client session
    
    Returns:
    
    A List of all received remote identification lines until the version line was read or null if more data is needed. The identification line is the last one in the list
  - createProposal
```
protected Map<KexProposalOption,String> createProposal(String hostKeyTypes)
```
    Create our proposal for SSH negotiation
    
    Parameters:
    
    hostKeyTypes - The comma-separated list of supported host key types
    
    Returns:
    
    The proposal Map
  - sendKexInit
```
protected byte[] sendKexInit(Map<KexProposalOption,String> proposal)
                      throws IOException
```
    Send the key exchange initialization packet. This packet contains random data along with our proposal.
    
    Parameters:
    
    proposal - our proposal for key exchange negotiation
    
    Returns:
    
    the sent packet data which must be kept for later use when deriving the session keys
    
    Throws:
    
    IOException - if an error occurred sending the packet
  - receiveKexInit
```
protected byte[] receiveKexInit(Buffer buffer,
                                Map<KexProposalOption,String> proposal)
```
    Receive the remote key exchange init message. The packet data is returned for later use.
    
    Parameters:
    
    buffer - the Buffer containing the key exchange init packet
    
    proposal - the remote proposal to fill
    
    Returns:
    
    the packet data
  - sendNewKeys
```
protected IoWriteFuture sendNewKeys()
                             throws IOException
```
    Send a message to put new keys into use.
    
    Returns:
    
    An IoWriteFuture that can be used to wait and check the result of sending the packet
    
    Throws:
    
    IOException - if an error occurs sending the message
  - receiveNewKeys
```
protected void receiveNewKeys()
                       throws Exception
```
    Put new keys into use. This method will initialize the ciphers, digests, macs and compression according to the negotiated server and client proposals.
    
    Throws:
    
    Exception - if an error occurs
  - resizeKey
```
protected byte[] resizeKey(byte[] e,
                           int blockSize,
                           Digest hash,
                           byte[] k,
                           byte[] h)
                    throws Exception
```
    Method used while putting new keys into use that will resize the key used to initialize the cipher to the needed length.
    
    Parameters:
    
    e - the key to resize
    
    blockSize - the cipher block size (in bytes)
    
    hash - the hash algorithm
    
    k - the key exchange k parameter
    
    h - the key exchange h parameter
    
    Returns:
    
    the resized key
    
    Throws:
    
    Exception - if a problem occur while resizing the key
  - disconnect
```
public void disconnect(int reason,
                       String msg)
                throws IOException
```
    Description copied from interface: Session
    
    Send a disconnect packet with the given reason and message. Once the packet has been sent, the session will be closed asynchronously.
    
    Specified by:
    
    disconnect in interface Session
    
    Parameters:
    
    reason - the reason code for this disconnect
    
    msg - the text message
    
    Throws:
    
    IOException - if an error occurred sending the packet
  - notImplemented
```
protected IoWriteFuture notImplemented()
                                throws IOException
```
    Send a SSH_MSG_UNIMPLEMENTED packet. This packet should contain the sequence id of the unsupported packet: this number is assumed to be the last packet received.
    
    Returns:
    
    An IoWriteFuture that can be used to wait for packet write completion
    
    Throws:
    
    IOException - if an error occurred sending the packet
    
    See Also:
    
    sendNotImplemented(long)
  - sendNotImplemented
```
protected IoWriteFuture sendNotImplemented(long seqNoValue)
                                    throws IOException
```
    Sends a SSH_MSG_UNIMPLEMENTED message
    
    Parameters:
    
    seqNoValue - The referenced sequence number
    
    Returns:
    
    An IoWriteFuture that can be used to wait for packet write completion
    
    Throws:
    
    IOException - if an error occurred sending the packet
  - negotiate
```
protected Map<KexProposalOption,String> negotiate()
```
    Compute the negotiated proposals by merging the client and server proposal. The negotiated proposal will also be stored in the negotiationResult property.
    
    Returns:
    
    The negotiated options Map
  - signalNegotiationStart
```
protected void signalNegotiationStart(Map<KexProposalOption,String> c2sOptions,
                                      Map<KexProposalOption,String> s2cOptions)
```
  - signalNegotiationStart
```
protected void signalNegotiationStart(SessionListener listener,
                                      Map<KexProposalOption,String> c2sOptions,
                                      Map<KexProposalOption,String> s2cOptions)
```
  - signalNegotiationEnd
```
protected void signalNegotiationEnd(Map<KexProposalOption,String> c2sOptions,
                                    Map<KexProposalOption,String> s2cOptions,
                                    Map<KexProposalOption,String> negotiatedGuess,
                                    Throwable reason)
```
  - signalNegotiationEnd
```
protected void signalNegotiationEnd(SessionListener listener,
                                    Map<KexProposalOption,String> c2sOptions,
                                    Map<KexProposalOption,String> s2cOptions,
                                    Map<KexProposalOption,String> negotiatedGuess,
                                    Throwable reason)
```
  - setNegotiationResult
```
protected Map<KexProposalOption,String> setNegotiationResult(Map<KexProposalOption,String> guess)
```
  - requestSuccess
```
protected void requestSuccess(Buffer buffer)
                       throws Exception
```
    Indicates the reception of a SSH_MSG_REQUEST_SUCCESS message
    
    Parameters:
    
    buffer - The Buffer containing the message data
    
    Throws:
    
    Exception - If failed to handle the message
  - requestFailure
```
protected void requestFailure(Buffer buffer)
                       throws Exception
```
    Indicates the reception of a SSH_MSG_REQUEST_FAILURE message
    
    Parameters:
    
    buffer - The Buffer containing the message data
    
    Throws:
    
    Exception - If failed to handle the message
  - getAttribute
```
public <T> T getAttribute(AttributeStore.AttributeKey<T> key)
```
    Description copied from interface: AttributeStore
    
    Returns the value of the user-defined attribute.
    
    Specified by:
    
    getAttribute in interface AttributeStore
    
    Type Parameters:
    
    T - The generic attribute type
    
    Parameters:
    
    key - The key of the attribute; must not be null.
    
    Returns:
    
    null if there is no value associated with the specified key
  - setAttribute
```
public <T> T setAttribute(AttributeStore.AttributeKey<T> key,
                          T value)
```
    Description copied from interface: AttributeStore
    
    Sets a user-defined attribute.
    
    Specified by:
    
    setAttribute in interface AttributeStore
    
    Type Parameters:
    
    T - The generic attribute type
    
    Parameters:
    
    key - The key of the attribute; must not be null.
    
    value - The value of the attribute; must not be null.
    
    Returns:
    
    The old value of the attribute; null if it is new.
  - removeAttribute
```
public <T> T removeAttribute(AttributeStore.AttributeKey<T> key)
```
    Description copied from interface: AttributeStore
    
    Removes the user-defined attribute
    
    Specified by:
    
    removeAttribute in interface AttributeStore
    
    Type Parameters:
    
    T - The generic attribute type
    
    Parameters:
    
    key - The key of the attribute; must not be null.
    
    Returns:
    
    The removed value; null if no previous value
  - resolveAttribute
```
public <T> T resolveAttribute(AttributeStore.AttributeKey<T> key)
```
    Description copied from interface: AttributeStore
    
    Attempts to resolve the associated value by going up the store's hierarchy (if any)
    
    Specified by:
    
    resolveAttribute in interface AttributeStore
    
    Type Parameters:
    
    T - The generic attribute type
    
    Parameters:
    
    key - The key of the attribute; must not be null.
    
    Returns:
    
    null if there is no value associated with the specified key
  - getUsername
```
public String getUsername()
```
    Specified by:
    
    getUsername in interface UsernameHolder
    
    Returns:
    
    The attached username - may be null/empty if holder not yet initialized
  - setUsername
```
public void setUsername(String username)
```
    Specified by:
    
    setUsername in interface MutableUserHolder
  - getLock
```
public Object getLock()
```
  - getReservedSessionMessagesHandler
```
public ReservedSessionMessagesHandler getReservedSessionMessagesHandler()
```
    Specified by:
    
    getReservedSessionMessagesHandler in interface ReservedSessionMessagesManager
    
    Returns:
    
    The currently registered ReservedSessionMessagesHandler - may be null
  - setReservedSessionMessagesHandler
```
public void setReservedSessionMessagesHandler(ReservedSessionMessagesHandler handler)
```
    Specified by:
    
    setReservedSessionMessagesHandler in interface ReservedSessionMessagesManager
    
    Parameters:
    
    handler - The ReservedSessionMessagesHandler to use - may be null
  - addSessionListener
```
public void addSessionListener(SessionListener listener)
```
    Description copied from interface: SessionListenerManager
    
    Add a session listener.
    
    Specified by:
    
    addSessionListener in interface SessionListenerManager
    
    Parameters:
    
    listener - The SessionListener to add - not null
  - removeSessionListener
```
public void removeSessionListener(SessionListener listener)
```
    Description copied from interface: SessionListenerManager
    
    Remove a session listener.
    
    Specified by:
    
    removeSessionListener in interface SessionListenerManager
    
    Parameters:
    
    listener - The SessionListener to remove
  - getSessionListenerProxy
```
public SessionListener getSessionListenerProxy()
```
    Specified by:
    
    getSessionListenerProxy in interface SessionListenerManager
    
    Returns:
    
    A (never null proxy SessionListener that represents all the currently registered listeners. Any method invocation on the proxy is replicated to the currently registered listeners
  - addChannelListener
```
public void addChannelListener(ChannelListener listener)
```
    Description copied from interface: ChannelListenerManager
    
    Add a channel listener
    
    Specified by:
    
    addChannelListener in interface ChannelListenerManager
    
    Parameters:
    
    listener - The ChannelListener to add - not null
  - removeChannelListener
```
public void removeChannelListener(ChannelListener listener)
```
    Description copied from interface: ChannelListenerManager
    
    Remove a channel listener
    
    Specified by:
    
    removeChannelListener in interface ChannelListenerManager
    
    Parameters:
    
    listener - The ChannelListener to remove
  - getChannelListenerProxy
```
public ChannelListener getChannelListenerProxy()
```
    Specified by:
    
    getChannelListenerProxy in interface ChannelListenerManager
    
    Returns:
    
    A (never null proxy ChannelListener that represents all the currently registered listeners. Any method invocation on the proxy is replicated to the currently registered listeners
  - getPortForwardingEventListenerProxy
```
public PortForwardingEventListener getPortForwardingEventListenerProxy()
```
    Specified by:
    
    getPortForwardingEventListenerProxy in interface PortForwardingEventListenerManager
    
    Returns:
    
    A proxy listener representing all the currently registered listener through this manager
  - addPortForwardingEventListener
```
public void addPortForwardingEventListener(PortForwardingEventListener listener)
```
    Description copied from interface: PortForwardingEventListenerManager
    
    Add a port forwarding listener
    
    Specified by:
    
    addPortForwardingEventListener in interface PortForwardingEventListenerManager
    
    Parameters:
    
    listener - The PortForwardingEventListener to add - never null
  - removePortForwardingEventListener
```
public void removePortForwardingEventListener(PortForwardingEventListener listener)
```
    Description copied from interface: PortForwardingEventListenerManager
    
    Remove a port forwarding listener
    
    Specified by:
    
    removePortForwardingEventListener in interface PortForwardingEventListenerManager
    
    Parameters:
    
    listener - The PortForwardingEventListener to remove - ignored if null
  - signalSessionEvent
```
protected void signalSessionEvent(SessionListener.Event event)
                           throws IOException
```
    Sends a session event to all currently registered session listeners
    
    Parameters:
    
    event - The event to send
    
    Throws:
    
    IOException - If any of the registered listeners threw an exception.
  - signalSessionEvent
```
protected void signalSessionEvent(SessionListener listener,
                                  SessionListener.Event event)
                           throws IOException
```
    Throws:
    
    IOException
  - invokeSessionSignaller
```
protected void invokeSessionSignaller(Invoker<SessionListener,Void> invoker)
                               throws Throwable
```
    Throws:
    
    Throwable
  - reExchangeKeys
```
public KeyExchangeFuture reExchangeKeys()
                                 throws IOException
```
    Description copied from interface: Session
    
    Initiate a new key exchange.
    
    Specified by:
    
    reExchangeKeys in interface Session
    
    Returns:
    
    A KeyExchangeFuture for awaiting the completion of the exchange
    
    Throws:
    
    IOException - If failed to request keys re-negotiation
  - checkRekey
```
protected KeyExchangeFuture checkRekey()
                                throws IOException
```
    Checks if a re-keying is required and if so initiates it
    
    Returns:
    
    A KeyExchangeFuture to wait for the initiated exchange or null if no need to re-key or an exchange is already in progress
    
    Throws:
    
    IOException - If failed to send the request
    
    See Also:
    
    isRekeyRequired(), requestNewKeysExchange()
  - requestNewKeysExchange
```
protected KeyExchangeFuture requestNewKeysExchange()
                                            throws IOException
```
    Initiates a new keys exchange if one not already in progress
    
    Returns:
    
    A KeyExchangeFuture to wait for the initiated exchange or null if an exchange is already in progress
    
    Throws:
    
    IOException - If failed to send the request
  - isRekeyRequired
```
protected boolean isRekeyRequired()
```
  - isRekeyTimeIntervalExceeded
```
protected boolean isRekeyTimeIntervalExceeded()
```
  - isRekeyPacketCountsExceeded
```
protected boolean isRekeyPacketCountsExceeded()
```
  - isRekeyDataSizeExceeded
```
protected boolean isRekeyDataSizeExceeded()
```
  - isRekeyBlocksCountExceeded
```
protected boolean isRekeyBlocksCountExceeded()
```
  - sendKexInit
```
protected byte[] sendKexInit()
                      throws IOException
```
    Throws:
    
    IOException
  - setKexSeed
```
protected abstract void setKexSeed(byte... seed)
```
    Parameters:
    
    seed - The result of the KEXINIT handshake - required for correct session key establishment
  - resolveAvailableSignaturesProposal
```
protected String resolveAvailableSignaturesProposal()
```
    Returns:
    
    A comma-separated list of all the signature protocols to be included in the proposal - null/empty if no proposal
    
    See Also:
    
    getFactoryManager(), resolveAvailableSignaturesProposal(FactoryManager)
  - resolveAvailableSignaturesProposal
```
protected abstract String resolveAvailableSignaturesProposal(FactoryManager manager)
```
    Parameters:
    
    manager - The FactoryManager
    
    Returns:
    
    A comma-separated list of all the signature protocols to be included in the proposal - null/empty if no proposal
  - checkKeys
```
protected abstract void checkKeys()
                           throws IOException
```
    Indicates the the key exchange is completed and the exchanged keys can now be verified - e.g., client can verify the server's key
    
    Throws:
    
    IOException - If validation failed
  - receiveKexInit
```
protected void receiveKexInit(Buffer buffer)
                       throws IOException
```
    Throws:
    
    IOException
  - receiveKexInit
```
protected abstract void receiveKexInit(Map<KexProposalOption,String> proposal,
                                       byte[] seed)
                                throws IOException
```
    Throws:
    
    IOException
  - mergeProposals
```
protected Map<KexProposalOption,String> mergeProposals(Map<KexProposalOption,String> current,
                                                       Map<KexProposalOption,String> proposal)
```
  - checkForTimeouts
```
protected void checkForTimeouts()
                         throws IOException
```
    Checks whether the session has timed out (both auth and idle timeouts are checked). If the session has timed out, a DISCONNECT message will be sent.
    
    Throws:
    
    IOException - If failed to check
    
    See Also:
    
    checkAuthenticationTimeout(long, long), checkIdleTimeout(long, long)
  - checkAuthenticationTimeout
```
protected Pair<Session.TimeoutStatus,String> checkAuthenticationTimeout(long now,
                                                                        long authTimeoutMs)
```
    Checks if authentication timeout expired
    
    Parameters:
    
    now - The current time in millis
    
    authTimeoutMs - The configured timeout in millis - if non-positive then no timeout
    
    Returns:
    
    A Pair specifying the timeout status and disconnect reason message if timeout expired, null or NoTimeout if no timeout occurred
    
    See Also:
    
    getAuthTimeout()
  - checkIdleTimeout
```
protected Pair<Session.TimeoutStatus,String> checkIdleTimeout(long now,
                                                              long idleTimeoutMs)
```
    Checks if idle timeout expired
    
    Parameters:
    
    now - The current time in millis
    
    idleTimeoutMs - The configured timeout in millis - if non-positive then no timeout
    
    Returns:
    
    A Pair specifying the timeout status and disconnect reason message if timeout expired, null or NoTimeout if no timeout occurred
    
    See Also:
    
    getIdleTimeout()
  - resetIdleTimeout
```
public void resetIdleTimeout()
```
    Description copied from interface: Session
    
    Re-start idle timeout timer
    
    Specified by:
    
    resetIdleTimeout in interface Session
  - getTimeoutStatus
```
public Session.TimeoutStatus getTimeoutStatus()
```
    Description copied from interface: Session
    
    Check if timeout has occurred.
    
    Specified by:
    
    getTimeoutStatus in interface Session
    
    Returns:
    
    the timeout status, never null
  - getAuthTimeout
```
public long getAuthTimeout()
```
    Specified by:
    
    getAuthTimeout in interface Session
    
    Returns:
    
    Timeout value in milliseconds for authentication stage
  - getIdleTimeout
```
public long getIdleTimeout()
```
    Specified by:
    
    getIdleTimeout in interface Session
    
    Returns:
    
    Timeout value in milliseconds for communication
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class AbstractSession

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.sshd.common.util.closeable.AbstractCloseable

Nested classes/interfaces inherited from interface org.apache.sshd.common.session.Session

Nested classes/interfaces inherited from interface org.apache.sshd.common.AttributeStore

Field Summary

Fields inherited from class org.apache.sshd.common.util.closeable.AbstractCloseable

Fields inherited from class org.apache.sshd.common.util.logging.AbstractLoggingBean

Fields inherited from interface org.apache.sshd.common.session.Session

Fields inherited from interface org.apache.sshd.common.PropertyResolver

Fields inherited from interface org.apache.sshd.common.Closeable

Constructor Summary

Method Summary

Methods inherited from class org.apache.sshd.common.kex.AbstractKexFactoryManager

Methods inherited from class org.apache.sshd.common.util.closeable.AbstractInnerCloseable

Methods inherited from class org.apache.sshd.common.util.closeable.AbstractCloseable

Methods inherited from class org.apache.sshd.common.util.logging.AbstractLoggingBean

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.sshd.common.session.Session

Methods inherited from interface org.apache.sshd.common.kex.KexFactoryManager

Methods inherited from interface org.apache.sshd.common.keyprovider.KeyPairProviderHolder

Methods inherited from interface org.apache.sshd.common.signature.SignatureFactoriesManager

Methods inherited from interface org.apache.sshd.common.PropertyResolver

Methods inherited from interface org.apache.sshd.common.AttributeStore

Methods inherited from interface org.apache.sshd.common.Closeable

Field Detail

SESSION

isServer

ioSession

random

authed

username

sessionListeners

sessionListenerProxy

channelListeners

channelListenerProxy

tunnelListeners

tunnelListenerProxy

sessionId

serverVersion

clientVersion

serverProposal

clientProposal

negotiationResult

i_c

i_s

kex

firstKexPacketFollows

kexState

kexFutureHolder

outCipher

inCipher

outCipherSize

inCipherSize

outMac

inMac

inMacResult

outCompression

inCompression

seqi

seqo

uncompressBuffer

decoderBuffer

decoderState

decoderLength

encodeLock

decodeLock

requestLock

authTimeoutStart

idleTimeoutStart

timeoutStatus

inPacketsCount

outPacketsCount

inBytesCount

outBytesCount

inBlocksCount

outBlocksCount

lastKeyTimeValue

maxRekyPackets

maxRekeyBytes