Ssh2Client (Maverick Legacy - Client Assembly 1.7.53 API)

java.lang.Object
- com.maverick.ssh2.Ssh2Client

All Implemented Interfaces:

Client, SshClient
```
public class Ssh2Client
extends Object
implements SshClient
```
Implementation of an SshClient for the SSH2 protocol; this provides the ability to create custom channels and sending/receiving of global requests in addition to the standard SshClient contract.

Author:

Lee David Painter

Constructor Summary

Constructors
Constructor and Description

Ssh2Client()
Default constructor called by SshConnector.

Constructors
Constructor and Description
`Ssh2Client()` Default constructor called by SshConnector.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAttribute(String key, Object value)` Add an attribute to this connection object.
`void`	`addChannelFactory(ChannelFactory factory)` Installs a custom channel factory so that the client may respond to channel open requests.
`void`	`addListener(SshClientListener listener)` Add a listener to this client.
`void`	`addRequestHandler(GlobalRequestHandler handler)` Installs a global request handler so that the client may respond to global requests.
`int`	`authenticate(SshAuthentication auth)` Authenticate the user.
`boolean`	`cancelRemoteForwarding(String bindAddress, int bindPort)` Cancel a forwarding request.
`void`	`connect(SshTransport io, SshContext context, SshClientConnector connector, String username, String localIdentification, String remoteIdentification, boolean buffered)` Connect to an SSH server.
`protected TransportProtocol`	`createTransportProtocol(boolean buffered)`
`void`	`disconnect()` Disconnect from the remote computer.
`SshClient`	`duplicate()` Create an identical version of an SshClient using cached authentication information and the SshTransport duplicate method.
`void`	`exit()`
`void`	`forceKeyExchange()` The SSH transport protocol exchanges keys at the beginning of the session; the specification recommends that these keys be re-exchanged after each gigabyte of transmitted data or after each hour of connection time, whichever comes sooner.
`Object`	`getAttribute(String key)` Get a previously added attribute from this object.
`<T> T`	`getAttribute(String key, T defaultValue)` Get an attribute or default
`String[]`	`getAuthenticationMethods(String username)` Get a list of authentication methods for the user.
`Thread`	`getBackgroundThread()`
`int`	`getChannelCount()` Get the number of active channels.
`String`	`getCipherInUseCS()` Get the cipher algorithm used to encrypt data sent to the server.
`String`	`getCipherInUseSC()` Get the cipher algorithm used to decrypt data received from the server.
`String`	`getCompressionInUseCS()` Get the compression algorithm used to compress the clients outgoing data.
`String`	`getCompressionInUseSC()` Get the compression algorithm used to decompress the servers data.
`SshContext`	`getContext()` Get the context that created this client.
`String`	`getHost()` Public accessor method for getTransport().getHost().
`SshPublicKey`	`getHostKey()`
`String`	`getHostKeyInUse()` Returns the host key algorithm used in the last key exchange.
`String`	`getIdent()` The SSH identifier for this host.
`SshKeyExchangeClient`	`getKeyExchangeInstanceInUse()`
`String`	`getKeyExchangeInUse()` Returns the key exchange algorithm last used.
`String`	`getMacInUseCS()` Get the MAC algorithm used to verify data sent by the client.
`String`	`getMacInUseSC()` Get the MAC algorithm used to verify data sent by the server.
`String[]`	`getRemoteCiphersCS()`
`String[]`	`getRemoteCiphersSC()`
`String[]`	`getRemoteCompressionsCS()`
`String[]`	`getRemoteCompressionsSC()`
`String`	`getRemoteIdentification()` Returns the identification string supplied by the server during protocol negotiation.
`String[]`	`getRemoteKeyExchanges()`
`String[]`	`getRemoteMacsCS()`
`String[]`	`getRemoteMacsSC()`
`String[]`	`getRemotePublicKeys()`
`SshTransport`	`getTransport()` Get the transport this client is running over
`String`	`getUsername()` Return the username used for this connection
`String`	`getUuid()`
`int`	`getVersion()` Returns the version for this client.
`boolean`	`hasAttribute(String key)` Determine if connection already has an attribute for given key.
`boolean`	`hasBackgroundThread()`
`boolean`	`isAuthenticated()` Evaluate whether the user has been authenticated.
`boolean`	`isAuthenticationSupported(String method)` Iterate over support mechanisms and return true only if the method supplied is reported as supported by the remote device.
`boolean`	`isBuffered()` Identifies whether this client is in buffered mode
`boolean`	`isConnected()` Evaluate whether the connection is still alive.
`void`	`openChannel(Ssh2Channel channel, byte[] requestdata)` Additional method to open a custom SSH2 channel.
`void`	`openChannel(SshAbstractChannel channel)` Additional method to open a custom SSH2 channel.
`SshTunnel`	`openForwardingChannel(String hostname, int port, String listeningAddress, int listeningPort, String originatingHost, int originatingPort, SshTransport sock, ChannelEventListener listener)` Open a TCPIP forwarding channel to the remote computer.
`SshClient`	`openRemoteClient(String hostname, int port, String username)` Open up an SSH client from the remote machine to another remote server.
`SshClient`	`openRemoteClient(String hostname, int port, String username, SshClientConnector con)` Open up an SSH client from the remote machine to another remote server.
`SshSession`	`openSessionChannel()` Open a session on the remote computer.
`SshSession`	`openSessionChannel(ChannelEventListener listener)` Open a session on the remote computer.
`SshSession`	`openSessionChannel(ChannelEventListener listener, long timeout)` Open a session on the remote computer.
`Ssh2Session`	`openSessionChannel(int windowspace, int packetsize, ChannelEventListener listener)` Additional method to open a session with SSH2 specific features.
`Ssh2Session`	`openSessionChannel(int windowspace, int packetsize, ChannelEventListener listener, long timeout)`
`SshSession`	`openSessionChannel(long timeout)` Open a session on the remote computer.
`void`	`processMessages(long timeout)`
`int`	`requestRemoteForwarding(String bindAddress, int bindPort, String hostToConnect, int portToConnect, ForwardingRequestListener listener)` Requests that the remote computer accepts socket connections and forward them to the local computer.
`boolean`	`sendGlobalRequest(GlobalRequest request, boolean wantreply)` Sends a global request to the remote side.
`boolean`	`sendGlobalRequest(GlobalRequest request, boolean wantreply, long timeout)` Sends a global request to the remote side.
`String`	`toString()`

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

- Constructor Detail
  - Ssh2Client
```
public Ssh2Client()
```
    Default constructor called by SshConnector.
- Method Detail
  - getUuid
```
public String getUuid()
```
    Specified by:
    
    getUuid in interface SshClient
  - connect
```
public void connect(SshTransport io,
                    SshContext context,
                    SshClientConnector connector,
                    String username,
                    String localIdentification,
                    String remoteIdentification,
                    boolean buffered)
             throws SshException
```
    Description copied from interface: SshClient
    
    Connect to an SSH server.
    
    Specified by:
    
    connect in interface SshClient
    
    Parameters:
    
    io - the transport layer
    
    context - an SSH context
    
    username - the users name
    
    localIdentification - the local identification string
    
    remoteIdentification - the remotes identification string
    
    buffered - should the connection be buffered (threaded)
    
    Throws:
    
    SshException
  - createTransportProtocol
```
protected TransportProtocol createTransportProtocol(boolean buffered)
```
  - getAuthenticationMethods
```
public String[] getAuthenticationMethods(String username)
                                  throws SshException
```
    Get a list of authentication methods for the user.
    
    Parameters:
    
    username - the name of the user
    
    Returns:
    
    an array of authentication methods, for example { "password", "publickey" }
    
    Throws:
    
    SshException
  - addListener
```
public void addListener(SshClientListener listener)
```
    Description copied from interface: SshClient
    
    Add a listener to this client.
    
    Specified by:
    
    addListener in interface SshClient
  - isAuthenticationSupported
```
public boolean isAuthenticationSupported(String method)
                                  throws SshException
```
    Iterate over support mechanisms and return true only if the method supplied is reported as supported by the remote device.
    
    Parameters:
    
    method -
    
    Returns:
    
    Throws:
    
    SshException
  - authenticate
```
public int authenticate(SshAuthentication auth)
                 throws SshException
```
    Description copied from interface: SshClient
    
    Authenticate the user. Once connected call to authenticate the user. When a connection is made no other operations can be performed until the user has been authenticated.
    
    Specified by:
    
    authenticate in interface SshClient
    
    Parameters:
    
    auth - the authentication mechanism.
    
    Returns:
    
    one of the constants defined in SshAuthentication which indicates the state of the current authentication process.
    
    Throws:
    
    SshException
  - isAuthenticated
```
public boolean isAuthenticated()
```
    Description copied from interface: SshClient
    
    Evaluate whether the user has been authenticated. If the server does not require the user to authenticate; this may return true immediatley after connection. No other operations can be perform until the user has been authenticated.
    
    Specified by:
    
    isAuthenticated in interface SshClient
    
    Returns:
    
    true if the connection is authenticated, otherwise false
  - disconnect
```
public void disconnect()
```
    Description copied from interface: SshClient
    
    Disconnect from the remote computer.
    
    Specified by:
    
    disconnect in interface SshClient
  - exit
```
public void exit()
```
    Specified by:
    
    exit in interface Client
  - isConnected
```
public boolean isConnected()
```
    Description copied from interface: SshClient
    
    Evaluate whether the connection is still alive.
    
    Specified by:
    
    isConnected in interface SshClient
    
    Returns:
    
    true if connected, otherwise false
  - forceKeyExchange
```
public void forceKeyExchange()
                      throws SshException
```
    The SSH transport protocol exchanges keys at the beginning of the session; the specification recommends that these keys be re-exchanged after each gigabyte of transmitted data or after each hour of connection time, whichever comes sooner. This method can be called at anytime to begin the key exchange process.
    
    Throws:
    
    SshException
  - openSessionChannel
```
public SshSession openSessionChannel()
                              throws SshException,
                                     ChannelOpenException
```
    Description copied from interface: SshClient
    
    Open a session on the remote computer. This can only be called once the user has been authenticated. The session returned is uninitialized and will be opened when either a command is executed or the users shell has been started.
    
    Specified by:
    
    openSessionChannel in interface SshClient
    
    Returns:
    
    an uninitialized session instance.
    
    Throws:
    
    SshException
    
    ChannelOpenException
  - openSessionChannel
```
public SshSession openSessionChannel(long timeout)
                              throws SshException,
                                     ChannelOpenException
```
    Description copied from interface: SshClient
    
    Open a session on the remote computer. This can only be called once the user has been authenticated. The session returned is uninitialized and will be opened when either a command is executed or the users shell has been started.
    
    Specified by:
    
    openSessionChannel in interface SshClient
    
    Parameters:
    
    timeout - this is an advanced option and should be set to anything other than zero with caution. This is not a socket timeout.
    
    Returns:
    
    an uninitialized session instance.
    
    Throws:
    
    SshException
    
    ChannelOpenException
  - openSessionChannel
```
public SshSession openSessionChannel(ChannelEventListener listener,
                                     long timeout)
                              throws SshException,
                                     ChannelOpenException
```
    Description copied from interface: SshClient
    
    Open a session on the remote computer. This can only be called once the user has been authenticated. The session returned is uninitialized and will be opened when either a command is executed or the users shell has been started.
    
    Specified by:
    
    openSessionChannel in interface SshClient
    
    Parameters:
    
    listener - an event listener to add before opening
    
    Returns:
    
    an uninitialized session instance.
    
    Throws:
    
    SshException
    
    ChannelOpenException
  - openSessionChannel
```
public SshSession openSessionChannel(ChannelEventListener listener)
                              throws SshException,
                                     ChannelOpenException
```
    Description copied from interface: SshClient
    
    Open a session on the remote computer. This can only be called once the user has been authenticated. The session returned is uninitialized and will be opened when either a command is executed or the users shell has been started.
    
    Specified by:
    
    openSessionChannel in interface SshClient
    
    Parameters:
    
    listener - an event listener to add before opening
    
    Returns:
    
    an uninitialized session instance.
    
    Throws:
    
    SshException
    
    ChannelOpenException
  - openSessionChannel
```
public Ssh2Session openSessionChannel(int windowspace,
                                      int packetsize,
                                      ChannelEventListener listener)
                               throws ChannelOpenException,
                                      SshException
```
    Additional method to open a session with SSH2 specific features.
    
    Specified by:
    
    openSessionChannel in interface SshClient
    
    Parameters:
    
    windowspace - the initial amount of window space available
    
    packetsize - the maximum packet size
    
    listener - an event listener to add before opening
    
    Returns:
    
    an open session
    
    Throws:
    
    SshException
    
    ChannelOpenException
  - openSessionChannel
```
public Ssh2Session openSessionChannel(int windowspace,
                                      int packetsize,
                                      ChannelEventListener listener,
                                      long timeout)
                               throws ChannelOpenException,
                                      SshException
```
    Specified by:
    
    openSessionChannel in interface SshClient
    
    Returns:
    
    Throws:
    
    ChannelOpenException
    
    SshException
  - openRemoteClient
```
public SshClient openRemoteClient(String hostname,
                                  int port,
                                  String username,
                                  SshClientConnector con)
                           throws SshException,
                                  ChannelOpenException
```
    Description copied from interface: SshClient
    
    Open up an SSH client from the remote machine to another remote server. This method is useful if your firewall only forwards SSH connections to a single machine. Once connected to the exposed machine you can call this to obtain an SshClient instance to any other machine on the same network.
    
    Specified by:
    
    openRemoteClient in interface SshClient
    
    Parameters:
    
    hostname - the name of the remote host
    
    port - the port of the remote host
    
    username - the name of the user on the remote host
    
    con - an SshConnector instance that will be used to connect the client. This does not have to be the same instance that created this client.
    
    Returns:
    
    SshClient
    
    Throws:
    
    SshException
    
    ChannelOpenException
  - openRemoteClient
```
public SshClient openRemoteClient(String hostname,
                                  int port,
                                  String username)
                           throws SshException,
                                  ChannelOpenException
```
    Description copied from interface: SshClient
    
    Open up an SSH client from the remote machine to another remote server. This method is useful if your firewall only forwards SSH connections to a single machine. Once connected to the exposed machine you can call this to obtain an SshClient instance to any other machine on the same network.
    
    Specified by:
    
    openRemoteClient in interface SshClient
    
    Parameters:
    
    hostname - the name of the remote host
    
    port - the port of the remote host
    
    username - the name of the user on the remote host
    
    Returns:
    
    SshClient
    
    Throws:
    
    SshException
    
    ChannelOpenException
  - openForwardingChannel
```
public SshTunnel openForwardingChannel(String hostname,
                                       int port,
                                       String listeningAddress,
                                       int listeningPort,
                                       String originatingHost,
                                       int originatingPort,
                                       SshTransport sock,
                                       ChannelEventListener listener)
                                throws SshException,
                                       ChannelOpenException
```
    Description copied from interface: SshClient
    
    Open a TCPIP forwarding channel to the remote computer. If successful the remote computer will open a socket to the host/port specified and return a channel which can be used to forward TCPIP data from the local computer to the remotley connected socket.
    
    It should be noted that this is a low level API method and it does not connect the transport to the channel as this would require some threading. The transport is passed here so that it can be attached to the SshTunnel that is returned. If you want to have the API automatically connect the channel to the transport you should use the ForwardingClient which provides management of forwarding connections and threads.
    
    Specified by:
    
    openForwardingChannel in interface SshClient
    
    Parameters:
    
    hostname - the host to connect to
    
    port - the port to connect to
    
    originatingHost - the originating host (informational only)
    
    originatingPort - the originating port (informational only)
    
    listener - an event listener that will be added to the channel before opening.
    
    Returns:
    
    SshTunnel
    
    Throws:
    
    SshException
    
    ChannelOpenException
  - requestRemoteForwarding
```
public int requestRemoteForwarding(String bindAddress,
                                   int bindPort,
                                   String hostToConnect,
                                   int portToConnect,
                                   ForwardingRequestListener listener)
                            throws SshException
```
    Description copied from interface: SshClient
    
    Requests that the remote computer accepts socket connections and forward them to the local computer. The ForwardingRequestListener provides callback methods to create the connections and to initialize the tunnel.
    
    Specified by:
    
    requestRemoteForwarding in interface SshClient
    
    Parameters:
    
    bindAddress - the address that the remote computer should listen on
    
    bindPort - the port that the remote computer should listen on
    
    hostToConnect - the host to connect when a connection is established
    
    portToConnect - the port to connect when a connection is established
    
    listener - a callback interface
    
    Returns:
    
    int the port number bound on the remote server
    
    Throws:
    
    SshException
  - cancelRemoteForwarding
```
public boolean cancelRemoteForwarding(String bindAddress,
                                      int bindPort)
                               throws SshException
```
    Description copied from interface: SshClient
    
    Cancel a forwarding request.
    
    Specified by:
    
    cancelRemoteForwarding in interface SshClient
    
    Parameters:
    
    bindAddress - the address that the remote computer is listening on.
    
    bindPort - the port that the remote computer is listening on.
    
    Returns:
    
    true if the forwarding was cancelled, otherwise false
    
    Throws:
    
    SshException
  - openChannel
```
public void openChannel(Ssh2Channel channel,
                        byte[] requestdata)
                 throws SshException,
                        ChannelOpenException
```
    Additional method to open a custom SSH2 channel.
    
    Parameters:
    
    channel - the channel to open
    
    requestdata - the request data
    
    Throws:
    
    SshException
    
    ChannelOpenException
  - openChannel
```
public void openChannel(SshAbstractChannel channel)
                 throws SshException,
                        ChannelOpenException
```
    Additional method to open a custom SSH2 channel.
    
    Parameters:
    
    channel - the channel to open
    
    Throws:
    
    SshException
    
    ChannelOpenException
  - addChannelFactory
```
public void addChannelFactory(ChannelFactory factory)
                       throws SshException
```
    Installs a custom channel factory so that the client may respond to channel open requests.
    
    Parameters:
    
    factory - the channel factory
    
    Throws:
    
    SshException
  - getContext
```
public SshContext getContext()
```
    Description copied from interface: SshClient
    
    Get the context that created this client.
    
    Specified by:
    
    getContext in interface SshClient
    
    Returns:
    
    SshContext
  - addRequestHandler
```
public void addRequestHandler(GlobalRequestHandler handler)
                       throws SshException
```
    Installs a global request handler so that the client may respond to global requests.
    
    Parameters:
    
    handler - the global request handler
    
    Throws:
    
    SshException
  - sendGlobalRequest
```
public boolean sendGlobalRequest(GlobalRequest request,
                                 boolean wantreply)
                          throws SshException
```
    Sends a global request to the remote side.
    
    Parameters:
    
    request - the global request
    
    wantreply - specifies whether the remote side should send a success/failure message
    
    Returns:
    
    true if the request succeeded and wantreply=true, otherwise false
    
    Throws:
    
    SshException
  - sendGlobalRequest
```
public boolean sendGlobalRequest(GlobalRequest request,
                                 boolean wantreply,
                                 long timeout)
                          throws SshException
```
    Sends a global request to the remote side.
    
    Parameters:
    
    request - the global request
    
    wantreply - specifies whether the remote side should send a success/failure message
    
    timeout -
    
    Returns:
    
    true if the request succeeded and wantreply=true, otherwise false
    
    Throws:
    
    SshException
  - getRemoteIdentification
```
public String getRemoteIdentification()
```
    Description copied from interface: SshClient
    
    Returns the identification string supplied by the server during protocol negotiation.
    
    Specified by:
    
    getRemoteIdentification in interface SshClient
    
    Returns:
    
    the servers identification String, for example "SSH-1.99-OpenSSH_3.7p"
  - getUsername
```
public String getUsername()
```
    Description copied from interface: SshClient
    
    Return the username used for this connection
    
    Specified by:
    
    getUsername in interface SshClient
    
    Returns:
    
    the users name
  - duplicate
```
public SshClient duplicate()
                    throws SshException
```
    Description copied from interface: SshClient
    
    Create an identical version of an SshClient using cached authentication information and the SshTransport duplicate method.
    
    Specified by:
    
    duplicate in interface SshClient
    
    Returns:
    
    SshClient
    
    Throws:
    
    SshException
  - getChannelCount
```
public int getChannelCount()
```
    Description copied from interface: SshClient
    
    Get the number of active channels.
    
    Specified by:
    
    getChannelCount in interface SshClient
    
    Returns:
    
    int
  - getVersion
```
public int getVersion()
```
    Description copied from interface: SshClient
    
    Returns the version for this client. The value will be either 1 for SSH1 or 2 for SSH2.
    
    Specified by:
    
    getVersion in interface SshClient
    
    Returns:
    
    int
  - isBuffered
```
public boolean isBuffered()
```
    Description copied from interface: SshClient
    
    Identifies whether this client is in buffered mode
    
    Specified by:
    
    isBuffered in interface SshClient
    
    Returns:
    
    boolean
  - processMessages
```
public void processMessages(long timeout)
                     throws SshException
```
    Throws:
    
    SshException
  - getKeyExchangeInUse
```
public String getKeyExchangeInUse()
```
    Returns the key exchange algorithm last used.
    
    Returns:
    
    String
  - getKeyExchangeInstanceInUse
```
public SshKeyExchangeClient getKeyExchangeInstanceInUse()
```
  - getHostKeyInUse
```
public String getHostKeyInUse()
```
    Returns the host key algorithm used in the last key exchange.
    
    Returns:
    
    String
  - getHostKey
```
public SshPublicKey getHostKey()
```
  - getCipherInUseCS
```
public String getCipherInUseCS()
```
    Get the cipher algorithm used to encrypt data sent to the server.
    
    Returns:
    
    String
  - getCipherInUseSC
```
public String getCipherInUseSC()
```
    Get the cipher algorithm used to decrypt data received from the server.
    
    Returns:
    
    String
  - getMacInUseCS
```
public String getMacInUseCS()
```
    Get the MAC algorithm used to verify data sent by the client.
    
    Returns:
    
    String
  - getMacInUseSC
```
public String getMacInUseSC()
```
    Get the MAC algorithm used to verify data sent by the server.
    
    Returns:
    
    String
  - getCompressionInUseCS
```
public String getCompressionInUseCS()
```
    Get the compression algorithm used to compress the clients outgoing data.
    
    Returns:
    
    String
  - getCompressionInUseSC
```
public String getCompressionInUseSC()
```
    Get the compression algorithm used to decompress the servers data.
    
    Returns:
    
    String
  - getTransport
```
public SshTransport getTransport()
```
    Description copied from interface: SshClient
    
    Get the transport this client is running over
    
    Specified by:
    
    getTransport in interface SshClient
    
    Returns:
  - addAttribute
```
public void addAttribute(String key,
                         Object value)
```
    Description copied from interface: SshClient
    
    Add an attribute to this connection object.
    
    Specified by:
    
    addAttribute in interface SshClient
  - getAttribute
```
public Object getAttribute(String key)
```
    Description copied from interface: SshClient
    
    Get a previously added attribute from this object.
    
    Specified by:
    
    getAttribute in interface SshClient
    
    Returns:
  - getAttribute
```
public <T> T getAttribute(String key,
                          T defaultValue)
```
    Description copied from interface: SshClient
    
    Get an attribute or default
    
    Specified by:
    
    getAttribute in interface SshClient
    
    Returns:
  - hasAttribute
```
public boolean hasAttribute(String key)
```
    Description copied from interface: SshClient
    
    Determine if connection already has an attribute for given key.
    
    Specified by:
    
    hasAttribute in interface SshClient
    
    Returns:
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getRemoteKeyExchanges
```
public String[] getRemoteKeyExchanges()
```
  - getRemotePublicKeys
```
public String[] getRemotePublicKeys()
```
  - getRemoteCiphersCS
```
public String[] getRemoteCiphersCS()
```
  - getRemoteCiphersSC
```
public String[] getRemoteCiphersSC()
```
  - getRemoteMacsCS
```
public String[] getRemoteMacsCS()
```
  - getRemoteMacsSC
```
public String[] getRemoteMacsSC()
```
  - getRemoteCompressionsCS
```
public String[] getRemoteCompressionsCS()
```
  - getRemoteCompressionsSC
```
public String[] getRemoteCompressionsSC()
```
  - hasBackgroundThread
```
public boolean hasBackgroundThread()
```
  - getBackgroundThread
```
public Thread getBackgroundThread()
```
  - getIdent
```
public String getIdent()
```
    Description copied from interface: SshClient
    
    The SSH identifier for this host. This is a striped version of remote identification field that returns a consistent identifier to use to detect the remote software type and version e.g OpenSSH_8.1
    
    Specified by:
    
    getIdent in interface SshClient
    
    Returns:
  - getHost
```
public String getHost()
```
    Description copied from interface: SshClient
    
    Public accessor method for getTransport().getHost().
    
    Specified by:
    
    getHost in interface SshClient
    
    Returns:

Class Ssh2Client

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Ssh2Client

Method Detail

getUuid

connect

createTransportProtocol

getAuthenticationMethods

addListener

isAuthenticationSupported

authenticate

isAuthenticated

disconnect

exit

isConnected

forceKeyExchange

openSessionChannel

openSessionChannel

openSessionChannel

openSessionChannel

openSessionChannel

openSessionChannel

openRemoteClient

openRemoteClient

openForwardingChannel

requestRemoteForwarding

cancelRemoteForwarding

openChannel

openChannel

addChannelFactory

getContext

addRequestHandler

sendGlobalRequest

sendGlobalRequest

getRemoteIdentification

getUsername

duplicate

getChannelCount

getVersion

isBuffered

processMessages

getKeyExchangeInUse

getKeyExchangeInstanceInUse

getHostKeyInUse

getHostKey

getCipherInUseCS

getCipherInUseSC

getMacInUseCS

getMacInUseSC

getCompressionInUseCS

getCompressionInUseSC

getTransport

addAttribute

getAttribute

getAttribute

hasAttribute

toString

getRemoteKeyExchanges

getRemotePublicKeys

getRemoteCiphersCS

getRemoteCiphersSC

getRemoteMacsCS

getRemoteMacsSC

getRemoteCompressionsCS

getRemoteCompressionsSC

hasBackgroundThread

getBackgroundThread

getIdent

getHost