| java.lang.Object
 ch.ethz.ssh2.Connection
| Field Summary | |
| final public static String | identification
The identifier presented to the SSH-2 server. |
| Constructor Summary | |
| public | Connection(String hostname)
Prepares a fresh Connection object which can then be used
to establish a connection to the specified SSH-2 server.
Same as
Connection.Connection(String,int) Connection(hostname, 22) . | | public | Connection(String hostname, int port)
Prepares a fresh Connection object which can then be used
to establish a connection to the specified SSH-2 server. |
| Method Summary | |
| public synchronized void | addConnectionMonitor(ConnectionMonitor cmon)
Add a
ConnectionMonitor to this connection. | | public synchronized boolean | authenticateWithDSA(String user, String pem, String password)
After a successful connect, one has to authenticate oneself. | | public synchronized boolean | authenticateWithKeyboardInteractive(String user, InteractiveCallback cb)
A wrapper that calls
Connection.authenticateWithKeyboardInteractive(String,String[],InteractiveCallback)authenticateWithKeyboardInteractivewith a null submethod list.
Parameters:
user - A String holding the username.
Parameters:
cb - An InteractiveCallback which will be used todetermine the responses to the questions asked by the server. | | public synchronized boolean | authenticateWithKeyboardInteractive(String user, String[] submethods, InteractiveCallback cb)
After a successful connect, one has to authenticate oneself. | | public synchronized boolean | authenticateWithPassword(String user, String password)
After a successfull connect, one has to authenticate oneself. | | public synchronized boolean | authenticateWithPublicKey(String user, char[] pemPrivateKey, String password)
After a successful connect, one has to authenticate oneself.
The authentication method "publickey" works by signing a challenge
sent by the server. | | public synchronized boolean | authenticateWithPublicKey(String user, File pemFile, String password)
A convenience wrapper function which reads in a private key (PEM format, either DSA or RSA)
and then calls authenticateWithPublicKey(String, char[], String).
NOTE PUTTY USERS: Event though your key file may start with "-----BEGIN..."
it is not in the expected format. | | public synchronized void | cancelRemotePortForwarding(int bindPort)
Cancel an earlier requested remote port forwarding. | | public synchronized void | close()
Close the connection to the SSH-2 server. | | public synchronized ConnectionInfo | connect()
Same as
Connection.connect(ServerHostKeyVerifier,int,int) connect(null, 0, 0) . | | public synchronized ConnectionInfo | connect(ServerHostKeyVerifier verifier)
Same as
Connection.connect(ServerHostKeyVerifier,int,int) connect(verifier, 0, 0) . | | public synchronized ConnectionInfo | connect(ServerHostKeyVerifier verifier, int connectTimeout, int kexTimeout)
Connect to the SSH-2 server and, as soon as the server has presented its
host key, use the
ServerHostKeyVerifier.verifyServerHostKey(StringintStringbyte[]) ServerHostKeyVerifier.verifyServerHostKey() method of the verifier to ask for permission to proceed.
If verifier is null, then any host key will be
accepted - this is NOT recommended, since it makes man-in-the-middle attackes
VERY easy (somebody could put a proxy SSH server between you and the real server).
Note: The verifier will be called before doing any crypto calculations
(i.e., diffie-hellman). | | public synchronized LocalPortForwarder | createLocalPortForwarder(int local_port, String host_to_connect, int port_to_connect)
Creates a new
LocalPortForwarder . | | public synchronized LocalStreamForwarder | createLocalStreamForwarder(String host_to_connect, int port_to_connect)
Creates a new
LocalStreamForwarder . | | public synchronized SCPClient | createSCPClient()
Create a very basic
SCPClient that can be used to copy
files from/to the SSH-2 server. | | public synchronized void | forceKeyExchange()
Force an asynchronous key re-exchange (the call does not block). | | public static synchronized String[] | getAvailableCiphers()
Unless you know what you are doing, you will never need this. | | public static synchronized String[] | getAvailableMACs()
Unless you know what you are doing, you will never need this. | | public static synchronized String[] | getAvailableServerHostKeyAlgorithms()
Unless you know what you are doing, you will never need this. | | public synchronized ConnectionInfo | getConnectionInfo()
Returns a
ConnectionInfo object containing the details of
the connection. | | public synchronized String | getHostname()
Returns the hostname that was passed to the constructor. | | public synchronized int | getPort()
Returns the port that was passed to the constructor. | | public synchronized String[] | getRemainingAuthMethods(String user)
After a successful connect, one has to authenticate oneself. | | public synchronized boolean | isAuthMethodAvailable(String user, String method)
Checks if a specified authentication method is available. | | public synchronized boolean | isAuthenticationComplete()
Determines if the authentication phase is complete. | | public synchronized boolean | isAuthenticationPartialSuccess()
Returns true if there was at least one failed authentication request and
the last failed authentication request was marked with "partial success"
by the server. | | public synchronized Session | openSession()
Open a new
Session on this connection. | | public synchronized void | requestRemotePortForwarding(String bindAddress, int bindPort, String targetAddress, int targetPort)
Request a remote port forwarding.
If successful, then forwarded connections will be redirected to the given target address.
You can cancle a requested remote port forwarding by calling
Connection.cancelRemotePortForwarding(int) cancelRemotePortForwarding() .
A call of this method will block until the peer either agreed or disagreed to your request-
Note 1: this method typically fails if you
- pass a port number for which the used remote user has not enough permissions (i.e., port
< 1024)
- or pass a port number that is already in use on the remote server
- or if remote port forwarding is disabled on the server.
Note 2: (from the openssh man page): By default, the listening socket on the server will be
bound to the loopback interface only. | | public synchronized void | setClient2ServerCiphers(String[] ciphers)
Unless you know what you are doing, you will never need this. | | public synchronized void | setClient2ServerMACs(String[] macs)
Unless you know what you are doing, you will never need this. | | public synchronized void | setDHGexParameters(DHGexParameters dgp)
Sets the parameters for the diffie-hellman group exchange. | | public synchronized void | setProxyData(ProxyData proxyData)
Used to tell the library that the connection shall be established through a proxy server.
It only makes sense to call this method before calling the
Connection.connect() connect() method.
At the moment, only HTTP proxies are supported.
Note: This method can be called any number of times. | | public synchronized void | setSecureRandom(SecureRandom rnd)
Provide your own instance of SecureRandom. | | public synchronized void | setServer2ClientCiphers(String[] ciphers)
Unless you know what you are doing, you will never need this. | | public synchronized void | setServer2ClientMACs(String[] macs)
Unless you know what you are doing, you will never need this. | | public synchronized void | setServerHostKeyAlgorithms(String[] algos)
Define the set of allowed server host key algorithms to be used for
the following key exchange operations.
Unless you know what you are doing, you will never need this.
Parameters:
algos - An array of allowed server host key algorithms.SSH-2 defines ssh-dss and ssh-rsa.The entries of the array must be ordered after preference, i.e.,the entry at index 0 is the most preferred one. | | public synchronized void | setTCPNoDelay(boolean enable)
Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm) on the underlying socket.
Can be called at any time. |
| identification | | final public static String identification(Code) | | The identifier presented to the SSH-2 server.
|
| Connection | | public Connection(String hostname)(Code) | | Prepares a fresh Connection object which can then be used
to establish a connection to the specified SSH-2 server.
Same as
Connection.Connection(String,int) Connection(hostname, 22) .
Parameters:
hostname - the hostname of the SSH-2 server. |
| Connection | | public Connection(String hostname, int port)(Code) | | Prepares a fresh Connection object which can then be used
to establish a connection to the specified SSH-2 server.
Parameters:
hostname - the host where we later want to connect to.
Parameters:
port - port on the server, normally 22. |
| addConnectionMonitor | | public synchronized void addConnectionMonitor(ConnectionMonitor cmon)(Code) | | Add a
ConnectionMonitor to this connection. Can be invoked at any time,
but it is best to add connection monitors before invoking
connect() to avoid glitches (e.g., you add a connection monitor after
a successful connect(), but the connection has died in the mean time. Then,
your connection monitor won't be notified.)
You can add as many monitors as you like.
See Also: ConnectionMonitor
Parameters:
cmon - An object implementing the ConnectionMonitor interface. |
| authenticateWithDSA | | public synchronized boolean authenticateWithDSA(String user, String pem, String password) throws IOException(Code) | | After a successful connect, one has to authenticate oneself. This method
is based on DSA (it uses DSA to sign a challenge sent by the server).
If the authentication phase is complete, true will be
returned. If the server does not accept the request (or if further
authentication steps are needed), false is returned and
one can retry either by using this or any other authentication method
(use the getRemainingAuthMethods method to get a list of
the remaining possible methods).
Parameters:
user - A String holding the username.
Parameters:
pem - A String containing the DSA private key of theuser in OpenSSH key format (PEM, you can't miss the"-----BEGIN DSA PRIVATE KEY-----" tag). The string may containlinefeeds.
Parameters:
password - If the PEM string is 3DES encrypted ("DES-EDE3-CBC"), then youmust specify the password. Otherwise, this argument will beignored and can be set to null. whether the connection is now authenticated.
throws:
IOException - Connection.authenticateWithPublicKey(String,File,String) authenticateWithPublicKey() |
| authenticateWithKeyboardInteractive | | public synchronized boolean authenticateWithKeyboardInteractive(String user, String[] submethods, InteractiveCallback cb) throws IOException(Code) | | After a successful connect, one has to authenticate oneself. This method
is based on "keyboard-interactive", specified in
draft-ietf-secsh-auth-kbdinteract-XX. Basically, you have to define a
callback object which will be feeded with challenges generated by the
server. Answers are then sent back to the server. It is possible that the
callback will be called several times during the invocation of this
method (e.g., if the server replies to the callback's answer(s) with
another challenge...)
If the authentication phase is complete, true will be
returned. If the server does not accept the request (or if further
authentication steps are needed), false is returned and
one can retry either by using this or any other authentication method
(use the getRemainingAuthMethods method to get a list of
the remaining possible methods).
Note: some SSH servers advertise "keyboard-interactive", however, any
interactive request will be denied (without having sent any challenge to
the client).
Parameters:
user - A String holding the username.
Parameters:
submethods - An array of submethod names, seedraft-ietf-secsh-auth-kbdinteract-XX. May be nullto indicate an empty list.
Parameters:
cb - An InteractiveCallback which will be used todetermine the responses to the questions asked by the server. whether the connection is now authenticated.
throws:
IOException - |
| authenticateWithPassword | | public synchronized boolean authenticateWithPassword(String user, String password) throws IOException(Code) | | After a successfull connect, one has to authenticate oneself. This method
sends username and password to the server.
If the authentication phase is complete, true will be
returned. If the server does not accept the request (or if further
authentication steps are needed), false is returned and
one can retry either by using this or any other authentication method
(use the getRemainingAuthMethods method to get a list of
the remaining possible methods).
Note: if this method fails, then please double-check that it is actually
offered by the server (use
Connection.getRemainingAuthMethods(String) getRemainingAuthMethods() .
Often, password authentication is disabled, but users are not aware of it.
Many servers only offer "publickey" and "keyboard-interactive". However,
even though "keyboard-interactive" *feels* like password authentication
(e.g., when using the putty or openssh clients) it is *not* the same mechanism.
Parameters:
user -
Parameters:
password - if the connection is now authenticated.
throws:
IOException - |
| authenticateWithPublicKey | | public synchronized boolean authenticateWithPublicKey(String user, char[] pemPrivateKey, String password) throws IOException(Code) | | After a successful connect, one has to authenticate oneself.
The authentication method "publickey" works by signing a challenge
sent by the server. The signature is either DSA or RSA based - it
just depends on the type of private key you specify, either a DSA
or RSA private key in PEM format. And yes, this is may seem to be a
little confusing, the method is called "publickey" in the SSH-2 protocol
specification, however since we need to generate a signature, you
actually have to supply a private key =).
The private key contained in the PEM file may also be encrypted ("Proc-Type: 4,ENCRYPTED").
The library supports DES-CBC and DES-EDE3-CBC encryption, as well
as the more exotic PEM encrpytions AES-128-CBC, AES-192-CBC and AES-256-CBC.
If the authentication phase is complete, true will be
returned. If the server does not accept the request (or if further
authentication steps are needed), false is returned and
one can retry either by using this or any other authentication method
(use the getRemainingAuthMethods method to get a list of
the remaining possible methods).
NOTE PUTTY USERS: Event though your key file may start with "-----BEGIN..."
it is not in the expected format. You have to convert it to the OpenSSH
key format by using the "puttygen" tool (can be downloaded from the Putty
website). Simply load your key and then use the "Conversions/Export OpenSSH key"
functionality to get a proper PEM file.
Parameters:
user - A String holding the username.
Parameters:
pemPrivateKey - A char[] containing a DSA or RSA private key of theuser in OpenSSH key format (PEM, you can't miss the"-----BEGIN DSA PRIVATE KEY-----" or "-----BEGIN RSA PRIVATE KEY-----"tag). The char array may contain linebreaks/linefeeds.
Parameters:
password - If the PEM structure is encrypted ("Proc-Type: 4,ENCRYPTED") thenyou must specify a password. Otherwise, this argument will be ignoredand can be set to null. whether the connection is now authenticated.
throws:
IOException - |
| authenticateWithPublicKey | | public synchronized boolean authenticateWithPublicKey(String user, File pemFile, String password) throws IOException(Code) | | A convenience wrapper function which reads in a private key (PEM format, either DSA or RSA)
and then calls authenticateWithPublicKey(String, char[], String).
NOTE PUTTY USERS: Event though your key file may start with "-----BEGIN..."
it is not in the expected format. You have to convert it to the OpenSSH
key format by using the "puttygen" tool (can be downloaded from the Putty
website). Simply load your key and then use the "Conversions/Export OpenSSH key"
functionality to get a proper PEM file.
Parameters:
user - A String holding the username.
Parameters:
pemFile - A File object pointing to a file containing a DSA or RSAprivate key of the user in OpenSSH key format (PEM, you can't miss the"-----BEGIN DSA PRIVATE KEY-----" or "-----BEGIN RSA PRIVATE KEY-----"tag).
Parameters:
password - If the PEM file is encrypted then you must specify the password.Otherwise, this argument will be ignored and can be set to null. whether the connection is now authenticated.
throws:
IOException - |
| cancelRemotePortForwarding | | public synchronized void cancelRemotePortForwarding(int bindPort) throws IOException(Code) | | Cancel an earlier requested remote port forwarding.
Currently active forwardings will not be affected (e.g., disrupted).
Note that further connection forwarding requests may be received until
this method has returned.
Parameters:
bindPort - the allocated port number on the server
throws:
IOException - if the remote side refuses the cancel request or another lowlevel error occurs (e.g., the underlying connection is closed) |
| close | | public synchronized void close()(Code) | | Close the connection to the SSH-2 server. All assigned sessions will be
closed, too. Can be called at any time. Don't forget to call this once
you don't need a connection anymore - otherwise the receiver thread may
run forever.
|
| connect | | public synchronized ConnectionInfo connect(ServerHostKeyVerifier verifier, int connectTimeout, int kexTimeout) throws IOException(Code) | | Connect to the SSH-2 server and, as soon as the server has presented its
host key, use the
ServerHostKeyVerifier.verifyServerHostKey(StringintStringbyte[]) ServerHostKeyVerifier.verifyServerHostKey() method of the verifier to ask for permission to proceed.
If verifier is null, then any host key will be
accepted - this is NOT recommended, since it makes man-in-the-middle attackes
VERY easy (somebody could put a proxy SSH server between you and the real server).
Note: The verifier will be called before doing any crypto calculations
(i.e., diffie-hellman). Therefore, if you don't like the presented host key then
no CPU cycles are wasted (and the evil server has less information about us).
However, it is still possible that the server presented a fake host key: the server
cheated (typically a sign for a man-in-the-middle attack) and is not able to generate
a signature that matches its host key. Don't worry, the library will detect such
a scenario later when checking the signature (the signature cannot be checked before
having completed the diffie-hellman exchange).
Note 2: The
ServerHostKeyVerifier.verifyServerHostKey(StringintStringbyte[]) ServerHostKeyVerifier.verifyServerHostKey() method
will *NOT* be called from the current thread, the call is being made from a
background thread (there is a background dispatcher thread for every
established connection).
Note 3: This method will block as long as the key exchange of the underlying connection
has not been completed (and you have not specified any timeouts).
Note 4: If you want to re-use a connection object that was successfully connected,
then you must call the
Connection.close() method before invoking connect() again.
Parameters:
verifier - An object that implements theServerHostKeyVerifier interface. Pass nullto accept any server host key - NOT recommended.
Parameters:
connectTimeout - Connect the underlying TCP socket to the server with the given timeoutvalue (non-negative, in milliseconds). Zero means no timeout. If a proxy is beingused (see Connection.setProxyData(ProxyData)), then this timeout is used for theconnection establishment to the proxy.
Parameters:
kexTimeout - Timeout for complete connection establishment (non-negative,in milliseconds). Zero means no timeout. The timeout counts from themoment you invoke the connect() method and is cancelled as soon as thefirst key-exchange round has finished. It is possible thatthe timeout event will be fired during the invocation of theverifier callback, but it will only have an effect afterthe verifier returns. A ConnectionInfo object containing the details ofthe established connection.
throws:
IOException - If any problem occurs, e.g., the server's host key is notaccepted by the verifier or there is problem duringthe initial crypto setup (e.g., the signature sent by the server is wrong). In case of a timeout (either connectTimeout or kexTimeout)a SocketTimeoutException is thrown. An exception may also be thrown if the connection was already successfullyconnected (no matter if the connection broke in the mean time) and you invokeconnect() again without having called Connection.close() first. If a HTTP proxy is being used and the proxy refuses the connection,then a HTTPProxyException may be thrown, whichcontains the details returned by the proxy. If the proxy is buggy and doesnot return a proper HTTP response, then a normal IOException is thrown instead. |
| createLocalPortForwarder | | public synchronized LocalPortForwarder createLocalPortForwarder(int local_port, String host_to_connect, int port_to_connect) throws IOException(Code) | | Creates a new
LocalPortForwarder .
A LocalPortForwarder forwards TCP/IP connections that arrive at a local
port via the secure tunnel to another host (which may or may not be
identical to the remote SSH-2 server).
This method must only be called after one has passed successfully the authentication step.
There is no limit on the number of concurrent forwardings.
Parameters:
local_port - the local port the LocalPortForwarder shall bind to.
Parameters:
host_to_connect - target address (IP or hostname)
Parameters:
port_to_connect - target port A LocalPortForwarder object.
throws:
IOException - |
| createLocalStreamForwarder | | public synchronized LocalStreamForwarder createLocalStreamForwarder(String host_to_connect, int port_to_connect) throws IOException(Code) | | Creates a new
LocalStreamForwarder .
A LocalStreamForwarder manages an Input/Outputstream pair
that is being forwarded via the secure tunnel into a TCP/IP connection to another host
(which may or may not be identical to the remote SSH-2 server).
Parameters:
host_to_connect -
Parameters:
port_to_connect - A LocalStreamForwarder object.
throws:
IOException - |
| createSCPClient | | public synchronized SCPClient createSCPClient() throws IOException(Code) | | Create a very basic
SCPClient that can be used to copy
files from/to the SSH-2 server.
Works only after one has passed successfully the authentication step.
There is no limit on the number of concurrent SCP clients.
Note: This factory method will probably disappear in the future.
A SCPClient object.
throws:
IOException - |
| forceKeyExchange | | public synchronized void forceKeyExchange() throws IOException(Code) | | Force an asynchronous key re-exchange (the call does not block). The
latest values set for MAC, Cipher and DH group exchange parameters will
be used. If a key exchange is currently in progress, then this method has
the only effect that the so far specified parameters will be used for the
next (server driven) key exchange.
Note: This implementation will never start a key exchange (other than the initial one)
unless you or the SSH-2 server ask for it.
throws:
IOException - In case of any failure behind the scenes. |
| getAvailableCiphers | | public static synchronized String[] getAvailableCiphers()(Code) | | Unless you know what you are doing, you will never need this.
The list of supported cipher algorithms by this implementation. |
| getAvailableMACs | | public static synchronized String[] getAvailableMACs()(Code) | | Unless you know what you are doing, you will never need this.
The list of supported MAC algorthims by this implementation. |
| getAvailableServerHostKeyAlgorithms | | public static synchronized String[] getAvailableServerHostKeyAlgorithms()(Code) | | Unless you know what you are doing, you will never need this.
The list of supported server host key algorthims by this implementation. |
| getHostname | | public synchronized String getHostname()(Code) | | Returns the hostname that was passed to the constructor.
the hostname |
| getPort | | public synchronized int getPort()(Code) | | Returns the port that was passed to the constructor.
the TCP port |
| getRemainingAuthMethods | | public synchronized String[] getRemainingAuthMethods(String user) throws IOException(Code) | | After a successful connect, one has to authenticate oneself. This method
can be used to tell which authentication methods are supported by the
server at a certain stage of the authentication process (for the given
username).
Note 1: the username will only be used if no authentication step was done
so far (it will be used to ask the server for a list of possible
authentication methods). Otherwise, this method ignores the user name and
returns a cached method list (which is based on the information contained
in the last negative server response).
Note 2: the server may return method names that are not supported by this
implementation.
After a successful authentication, this method must not be called
anymore.
Parameters:
user - A String holding the username. a (possibly emtpy) array holding authentication method names.
throws:
IOException - |
| isAuthMethodAvailable | | public synchronized boolean isAuthMethodAvailable(String user, String method) throws IOException(Code) | | Checks if a specified authentication method is available. This method is
actually just a wrapper for
Connection.getRemainingAuthMethods(String)getRemainingAuthMethods() .
Parameters:
user - A String holding the username.
Parameters:
method - An authentication method name (e.g., "publickey", "password","keyboard-interactive") as specified by the SSH-2 standard. if the specified authentication method is currently available.
throws:
IOException - |
| isAuthenticationComplete | | public synchronized boolean isAuthenticationComplete()(Code) | | Determines if the authentication phase is complete. Can be called at any
time.
true if no further authentication steps areneeded. |
| isAuthenticationPartialSuccess | | public synchronized boolean isAuthenticationPartialSuccess()(Code) | | Returns true if there was at least one failed authentication request and
the last failed authentication request was marked with "partial success"
by the server. This is only needed in the rare case of SSH-2 server setups
that cannot be satisfied with a single successful authentication request
(i.e., multiple authentication steps are needed.)
If you are interested in the details, then have a look at
draft-ietf-secsh-userauth-XX.txt.
if the there was a failed authentication step and the last onewas marked as a "partial success". |
| openSession | | public synchronized Session openSession() throws IOException(Code) | | Open a new
Session on this connection. Works only after one has passed
successfully the authentication step. There is no limit on the number of
concurrent sessions.
A Session object.
throws:
IOException - |
| requestRemotePortForwarding | | public synchronized void requestRemotePortForwarding(String bindAddress, int bindPort, String targetAddress, int targetPort) throws IOException(Code) | | Request a remote port forwarding.
If successful, then forwarded connections will be redirected to the given target address.
You can cancle a requested remote port forwarding by calling
Connection.cancelRemotePortForwarding(int) cancelRemotePortForwarding() .
A call of this method will block until the peer either agreed or disagreed to your request-
Note 1: this method typically fails if you
- pass a port number for which the used remote user has not enough permissions (i.e., port
< 1024)
- or pass a port number that is already in use on the remote server
- or if remote port forwarding is disabled on the server.
Note 2: (from the openssh man page): By default, the listening socket on the server will be
bound to the loopback interface only. This may be overriden by specifying a bind address.
Specifying a remote bind address will only succeed if the server's GatewayPorts option
is enabled (see sshd_config(5)).
Parameters:
bindAddress - address to bind to on the server: - "" means that connections are to be accepted on all protocol familiessupported by the SSH implementation
- "0.0.0.0" means to listen on all IPv4 addresses
- "::" means to listen on all IPv6 addresses
- "localhost" means to listen on all protocol families supported by the SSHimplementation on loopback addresses only, [RFC3330] and RFC3513]
- "127.0.0.1" and "::1" indicate listening on the loopback interfaces forIPv4 and IPv6 respectively
Parameters:
bindPort - port number to bind on the server (must be > 0)
Parameters:
targetAddress - the target address (IP or hostname)
Parameters:
targetPort - the target port
throws:
IOException - |
| setClient2ServerCiphers | | public synchronized void setClient2ServerCiphers(String[] ciphers)(Code) | | Unless you know what you are doing, you will never need this.
Parameters:
ciphers - |
| setClient2ServerMACs | | public synchronized void setClient2ServerMACs(String[] macs)(Code) | | Unless you know what you are doing, you will never need this.
Parameters:
macs - |
| setDHGexParameters | | public synchronized void setDHGexParameters(DHGexParameters dgp)(Code) | | Sets the parameters for the diffie-hellman group exchange. Unless you
know what you are doing, you will never need this. Default values are
defined in the
DHGexParameters class.
Parameters:
dgp - DHGexParameters, non null. |
| setProxyData | | public synchronized void setProxyData(ProxyData proxyData)(Code) | | Used to tell the library that the connection shall be established through a proxy server.
It only makes sense to call this method before calling the
Connection.connect() connect() method.
At the moment, only HTTP proxies are supported.
Note: This method can be called any number of times. The
Connection.connect() connect() method will use the value set in the last preceding invocation of this method.
See Also: HTTPProxyData
Parameters:
proxyData - Connection information about the proxy. If null, thenno proxy will be used (non surprisingly, this is also the default). |
| setSecureRandom | | public synchronized void setSecureRandom(SecureRandom rnd)(Code) | | Provide your own instance of SecureRandom. Can be used, e.g., if you
want to seed the used SecureRandom generator manually.
The SecureRandom instance is used during key exchanges, public key authentication,
x11 cookie generation and the like.
Parameters:
rnd - a SecureRandom instance |
| setServer2ClientCiphers | | public synchronized void setServer2ClientCiphers(String[] ciphers)(Code) | | Unless you know what you are doing, you will never need this.
Parameters:
ciphers - |
| setServer2ClientMACs | | public synchronized void setServer2ClientMACs(String[] macs)(Code) | | Unless you know what you are doing, you will never need this.
Parameters:
macs - |
| setServerHostKeyAlgorithms | | public synchronized void setServerHostKeyAlgorithms(String[] algos)(Code) | | Define the set of allowed server host key algorithms to be used for
the following key exchange operations.
Unless you know what you are doing, you will never need this.
Parameters:
algos - An array of allowed server host key algorithms.SSH-2 defines ssh-dss and ssh-rsa.The entries of the array must be ordered after preference, i.e.,the entry at index 0 is the most preferred one. You must specifyat least one entry. |
| setTCPNoDelay | | public synchronized void setTCPNoDelay(boolean enable) throws IOException(Code) | | Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm) on the underlying socket.
Can be called at any time. If the connection has not yet been established
then the passed value will be stored and set after the socket has been set up.
The default value that will be used is false.
Parameters:
enable - the argument passed to the Socket.setTCPNoDelay() method.
throws:
IOException - |
|
|