AbstractSession (Apache Mina SSHD

java.lang.Object
- org.apache.sshd.common.util.logging.AbstractLoggingBean
- - org.apache.sshd.common.util.CloseableUtils.IoBaseCloseable
  - - org.apache.sshd.common.util.CloseableUtils.AbstractCloseable
    - - org.apache.sshd.common.util.CloseableUtils.AbstractInnerCloseable
      - org.apache.sshd.common.session.AbstractSession

All Implemented Interfaces:

Closeable, AutoCloseable, Channel, Session

Direct Known Subclasses:

ClientSessionImpl, ServerSessionImpl
```
public abstract class AbstractSession
extends CloseableUtils.AbstractInnerCloseable
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(org.apache.sshd.common.util.buffer.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.CloseableUtils.AbstractCloseable
  CloseableUtils.AbstractCloseable.State
- Nested classes/interfaces inherited from interface org.apache.sshd.common.session.Session
  Session.AttributeKey<T>, Session.TimeoutStatus

Field Summary

Fields
Modifier and Type	Field and Description
`protected Map<Session.AttributeKey<?>,Object>`	`attributes`
`protected boolean`	`authed` Boolean indicating if this session has been authenticated or not
`protected long`	`authTimeoutMs`
`protected long`	`authTimeoutTimestamp`
`protected Map<KexProposalOption,String>`	`clientProposal`
`protected String`	`clientVersion`
`protected Service`	`currentService`
`protected Object`	`decodeLock`
`protected Buffer`	`decoderBuffer`
`protected int`	`decoderLength`
`protected int`	`decoderState`
`static String`	`DEFAULT_SSH_VERSION_PREFIX`
`protected long`	`disconnectTimeoutMs`
`protected Object`	`encodeLock`
`protected FactoryManager`	`factoryManager` The factory manager used to retrieve factories of Ciphers, Macs and other objects
`protected byte[]`	`i_c`
`protected byte[]`	`i_s`
`protected long`	`idleTimeoutMs`
`protected long`	`idleTimeoutTimestamp`
`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<KexState>`	`kexState`
`protected AtomicLong`	`lastKeyTimeValue`
`protected List<SessionListener>`	`listeners` Session listeners container
`protected Map<KexProposalOption,String>`	`negotiationResult`
`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 DefaultSshFuture`	`reexchangeFuture`
`protected Object`	`requestLock`
`protected AtomicReference<Buffer>`	`requestResult`
`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 AtomicReference<Session.TimeoutStatus>`	`timeoutStatus`
`protected Buffer`	`uncompressBuffer`
`protected String`	`username` The name of the authenticated user

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

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

Constructor Summary

Constructors
Constructor and Description

AbstractSession(boolean isServer, FactoryManager factoryManager, IoSession ioSession)
Create a new session.

Constructors
Constructor and Description
`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`	`addListener(SessionListener listener)` Add a session \|listener\|.
`static void`	`attachSession(IoSession ioSession, AbstractSession session)` Attach a session to the MINA session
`protected void`	`checkForTimeouts()` Checks whether the session has timed out (both auth and idle timeouts are checked).
`protected abstract void`	`checkKeys()`
`protected void`	`checkRekey()`
`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`	`doCloseImmediately()` doCloseImmediately is called once and only once with state == Immediate
`protected void`	`doHandleMessage(Buffer buffer)`
`protected String`	`doReadIdentification(Buffer buffer, boolean server)` Read the remote identification from this buffer.
`protected IoWriteFuture`	`doWritePacket(Buffer buffer)`
`void`	`exceptionCaught(Throwable t)` Handle any exceptions that occurred on this session.
`<T> T`	`getAttribute(Session.AttributeKey<T> key)` Returns the value of the user-defined attribute of this session.
`long`	`getAuthTimeout()` What is timeout value in milliseconds for authentication stage
`String`	`getClientVersion()` Retrieve the client version for this session.
`FactoryManager`	`getFactoryManager()`
`long`	`getIdleTimeout()` What is timeout value in milliseconds for communication
`protected Closeable`	`getInnerCloseable()`
`int`	`getIntProperty(String name, int defaultValue)` Retrieve a configuration property as an integer
`IoSession`	`getIoSession()`
`KeyExchange`	`getKex()`
`Object`	`getLock()`
`long`	`getLongProperty(String name, long defaultValue)`
`String`	`getNegotiatedKexParameter(KexProposalOption paramType)` Retrieve one of the negotiated values during the KEX stage
`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 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()`
`Session.TimeoutStatus`	`getTimeoutStatus()` Check if timeout has occurred.
`String`	`getUsername()` Retrieve the name of the user authenticated on this session or null if the session has not been authenticated yet.
`protected void`	`handleMessage(Buffer buffer)` Abstract method for processing incoming decoded packets.
`boolean`	`isAuthenticated()`
`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 void`	`notImplemented()` Send an unimplemented packet.
`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.
`SshFuture`	`reExchangeKeys()` Initiate a new key exchange.
`void`	`removeListener(SessionListener listener)` Remove a session \|listener\|.
`Buffer`	`request(Buffer buffer)` Send a global request and wait for the response.
`protected void`	`requestFailure(Buffer buffer)`
`protected void`	`requestSuccess(Buffer buffer)`
`void`	`resetIdleTimeout()`
`protected String`	`resolveAvailableSignaturesProposal()`
`protected abstract String`	`resolveAvailableSignaturesProposal(FactoryManager manager)`
`protected void`	`sendEvent(SessionListener.Event event)`
`protected void`	`sendIdentification(String ident)` Send our identification.
`protected byte[]`	`sendKexInit()`
`protected byte[]`	`sendKexInit(Map<KexProposalOption,String> proposal)` Send the key exchange initialization packet.
`protected void`	`sendNewKeys()` Send a message to put new keys into use.
`protected void`	`serviceAccept()`
`<T,E extends T> T`	`setAttribute(Session.AttributeKey<T> key, E value)` Sets a user-defined attribute.
`void`	`setAuthenticated()`
`protected abstract void`	`setKexSeed(byte... seed)`
`protected Map<KexProposalOption,String>`	`setNegotiationResult(Map<KexProposalOption,String> guess)`
`void`	`setUsername(String username)`
`String`	`toString()`
`protected void`	`validateKexState(int cmd, KexState expected)`
`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.util.CloseableUtils.AbstractInnerCloseable
doCloseGracefully

Methods inherited from class org.apache.sshd.common.util.CloseableUtils.AbstractCloseable
builder, close, isClosed, isClosing, preClose

Methods inherited from class org.apache.sshd.common.util.CloseableUtils.IoBaseCloseable
close, isOpen

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
startService

Methods inherited from interface org.apache.sshd.common.Closeable
close, isClosed, isClosing

Methods inherited from interface java.nio.channels.Channel
close, isOpen

- Field Detail
  - DEFAULT_SSH_VERSION_PREFIX
```
public static final String DEFAULT_SSH_VERSION_PREFIX
```
    See Also:
    
    Constant Field Values
  - 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
  - factoryManager
```
protected final FactoryManager factoryManager
```
    The factory manager used to retrieve factories of Ciphers, Macs and other objects
  - 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
  - listeners
```
protected final List<SessionListener> listeners
```
    Session listeners container
  - sessionListenerProxy
```
protected final SessionListener sessionListenerProxy
```
  - 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
```
  - kexState
```
protected final AtomicReference<KexState> kexState
```
  - reexchangeFuture
```
protected DefaultSshFuture reexchangeFuture
```
  - 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
```
  - decoderBuffer
```
protected Buffer decoderBuffer
```
  - uncompressBuffer
```
protected Buffer uncompressBuffer
```
  - decoderState
```
protected int decoderState
```
  - decoderLength
```
protected int decoderLength
```
  - encodeLock
```
protected final Object encodeLock
```
  - decodeLock
```
protected final Object decodeLock
```
  - requestLock
```
protected final Object requestLock
```
  - requestResult
```
protected final AtomicReference<Buffer> requestResult
```
  - attributes
```
protected final Map<Session.AttributeKey<?>,Object> attributes
```
  - authTimeoutTimestamp
```
protected long authTimeoutTimestamp
```
  - idleTimeoutTimestamp
```
protected long idleTimeoutTimestamp
```
  - authTimeoutMs
```
protected long authTimeoutMs
```
  - idleTimeoutMs
```
protected long idleTimeoutMs
```
  - disconnectTimeoutMs
```
protected long disconnectTimeoutMs
```
  - 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
```
  - lastKeyTimeValue
```
protected final AtomicLong lastKeyTimeValue
```
  - pendingPackets
```
protected final Queue<PendingWriteFuture> pendingPackets
```
  - currentService
```
protected Service currentService
```
- Constructor Detail
  - AbstractSession
```
public 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
  - 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
  - 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
  - getIoSession
```
public IoSession getIoSession()
```
    Specified by:
    
    getIoSession in interface Session
    
    Returns:
    
    the IoSession associated to this session
  - getFactoryManager
```
public FactoryManager getFactoryManager()
```
    Specified by:
    
    getFactoryManager in interface Session
    
    Returns:
    
    the FactoryManager that has created this session, can not be 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
  - 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
  - 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. Packets must be processed within this call or be copied because the given buffer is meant to be changed and updated when this method returns.
    
    Parameters:
    
    buffer - the buffer containing the packet
    
    Throws:
    
    Exception - if an exeption occurs while handling this packet.
  - doHandleMessage
```
protected void doHandleMessage(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
  - getInnerCloseable
```
protected Closeable getInnerCloseable()
```
    Specified by:
    
    getInnerCloseable in class CloseableUtils.AbstractInnerCloseable
  - doCloseImmediately
```
protected void doCloseImmediately()
```
    Description copied from class: CloseableUtils.AbstractCloseable
    
    doCloseImmediately is called once and only once with state == Immediate
    
    Overriding methods should always call the base implementation. It may be called concurrently while preClose() or doCloseGracefully is executing
    
    Overrides:
    
    doCloseImmediately in class CloseableUtils.AbstractInnerCloseable
  - getServices
```
protected 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
```
    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:
    
    a future that can be used to check when the packet has actually been sent
    
    Throws:
    
    IOException - if an error occured 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
  - request
```
public Buffer request(Buffer buffer)
               throws IOException
```
    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 wait forever.
    
    Specified by:
    
    request in interface Session
    
    Parameters:
    
    buffer - the buffer containing the global request
    
    Returns:
    
    true if the request was successful, false otherwise.
    
    Throws:
    
    IOException - if an error occured 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)
```
    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
    
    len - estimated number of bytes the buffer will hold, 0 if unknown.
    
    Returns:
    
    a new buffer ready for write
  - decode
```
protected void decode()
               throws Exception
```
    Decode the incoming buffer and handle packets as needed.
    
    Throws:
    
    Exception - If failed to decode
  - sendIdentification
```
protected void sendIdentification(String ident)
```
    Send our identification.
    
    Parameters:
    
    ident - our identification to 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(org.apache.sshd.common.util.buffer.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 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:
    
    the remote identification or null if more data is needed
  - 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 which must be kept for later use
    
    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 void sendNewKeys()
                    throws IOException
```
    Send a message to put new keys into use.
    
    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
  - 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 void notImplemented()
                       throws IOException
```
    Send an unimplemented packet. This packet should contain the sequence id of the unsupported packet: this number is assumed to be the last packet received.
    
    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
  - setNegotiationResult
```
protected Map<KexProposalOption,String> setNegotiationResult(Map<KexProposalOption,String> guess)
```
  - requestSuccess
```
protected void requestSuccess(Buffer buffer)
                       throws Exception
```
    Throws:
    
    Exception
  - requestFailure
```
protected void requestFailure(Buffer buffer)
                       throws Exception
```
    Throws:
    
    Exception
  - getIntProperty
```
public int getIntProperty(String name,
                          int defaultValue)
```
    Retrieve a configuration property as an integer
    
    Specified by:
    
    getIntProperty in interface Session
    
    Parameters:
    
    name - the name of the property
    
    defaultValue - the default value
    
    Returns:
    
    the value of the configuration property or the default value if not found
  - getLongProperty
```
public long getLongProperty(String name,
                            long defaultValue)
```
  - getAttribute
```
public <T> T getAttribute(Session.AttributeKey<T> key)
```
    Returns the value of the user-defined attribute of this session.
    
    Specified by:
    
    getAttribute in interface Session
    
    Type Parameters:
    
    T - The generic attribute type
    
    Parameters:
    
    key - the key of the attribute; must not be null.
    
    Returns:
    
    null if there is no attribute with the specified key
  - setAttribute
```
public <T,E extends T> T setAttribute(Session.AttributeKey<T> key,
                                      E value)
```
    Sets a user-defined attribute.
    
    Specified by:
    
    setAttribute in interface Session
    
    Type Parameters:
    
    T - The generic attribute type
    
    E - The generic value 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.
  - getUsername
```
public String getUsername()
```
    Description copied from interface: Session
    
    Retrieve the name of the user authenticated on this session or null if the session has not been authenticated yet.
    
    Specified by:
    
    getUsername in interface Session
    
    Returns:
    
    the user name.
  - setUsername
```
public void setUsername(String username)
```
    Specified by:
    
    setUsername in interface Session
  - getLock
```
public Object getLock()
```
  - addListener
```
public void addListener(SessionListener listener)
```
    Description copied from interface: Session
    
    Add a session |listener|.
    
    Specified by:
    
    addListener in interface Session
    
    Parameters:
    
    listener - the session listener to add
  - removeListener
```
public void removeListener(SessionListener listener)
```
    Description copied from interface: Session
    
    Remove a session |listener|.
    
    Specified by:
    
    removeListener in interface Session
    
    Parameters:
    
    listener - the session listener to remove
  - sendEvent
```
protected void sendEvent(SessionListener.Event event)
                  throws IOException
```
    Throws:
    
    IOException
  - reExchangeKeys
```
public SshFuture reExchangeKeys()
                         throws IOException
```
    Description copied from interface: Session
    
    Initiate a new key exchange.
    
    Specified by:
    
    reExchangeKeys in interface Session
    
    Returns:
    
    An SshFuture for awaiting the completion of the exchange
    
    Throws:
    
    IOException - If failed to negotiate keys
  - checkRekey
```
protected void checkRekey()
                   throws IOException
```
    Throws:
    
    IOException
  - 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
```
    Throws:
    
    IOException
  - 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)
```
  - serviceAccept
```
protected void serviceAccept()
                      throws IOException
```
    Throws:
    
    IOException
  - 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
  - resetIdleTimeout
```
public void resetIdleTimeout()
```
    Specified by:
    
    resetIdleTimeout in interface Session
  - getTimeoutStatus
```
public Session.TimeoutStatus getTimeoutStatus()
```
    Check if timeout has occurred.
    
    Specified by:
    
    getTimeoutStatus in interface Session
    
    Returns:
    
    The TimeoutStatus
  - getAuthTimeout
```
public long getAuthTimeout()
```
    What is timeout value in milliseconds for authentication stage
    
    Specified by:
    
    getAuthTimeout in interface Session
    
    Returns:
    
    The timeout value in milliseconds for authentication stage
  - getIdleTimeout
```
public long getIdleTimeout()
```
    What is timeout value in milliseconds for communication
    
    Specified by:
    
    getIdleTimeout in interface Session
    
    Returns:
    
    The 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.CloseableUtils.AbstractCloseable

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

Field Summary

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

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

Constructor Summary

Method Summary

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

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

Methods inherited from class org.apache.sshd.common.util.CloseableUtils.IoBaseCloseable

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.Closeable

Methods inherited from interface java.nio.channels.Channel

Field Detail

DEFAULT_SSH_VERSION_PREFIX

SESSION

isServer

factoryManager

ioSession

random

authed

username

listeners

sessionListenerProxy

sessionId

serverVersion

clientVersion

serverProposal

clientProposal

negotiationResult

i_c

i_s

kex

kexState

reexchangeFuture

outCipher

inCipher

outCipherSize

inCipherSize

outMac

inMac

inMacResult

outCompression

inCompression

seqi

seqo

decoderBuffer

uncompressBuffer

decoderState

decoderLength

encodeLock

decodeLock

requestLock

requestResult

attributes

authTimeoutTimestamp

idleTimeoutTimestamp

authTimeoutMs

idleTimeoutMs

disconnectTimeoutMs

timeoutStatus

inPacketsCount

outPacketsCount

inBytesCount

outBytesCount

lastKeyTimeValue

pendingPackets

currentService

Constructor Detail

AbstractSession

Method Detail

getSession

getSession

attachSession

getServerVersion

getClientVersion

getKex