Recent changes to feature-requests

ability to send control signals to remote process

sid — Fri, 11 Apr 2008 13:07:15 -0000
Signals cannot be passed at present through OutputBuffer as they are not recognized by the console. We need a way to pass these signals.
ABRT
ALRM
FPE
HUP
ILL
INT
KILL
PIPE
QUIT
SEGV
TERM
USR1
USR2
similar to this function implemented in a proprietary package - http://www.sshtools.com/content/developer/maverick/docs/com/maverick/ssh2/Ssh2Session.html#signal\(java.lang.String)
Need changes for better performance of large file upload

nchawla — Mon, 11 Jun 2007 12:36:57 -0000
While using SSHTools in our project, we found that the performance for uploading large files ( > 1 MB) is very poor compared to what is possible by a manual transfer (via scp say) and even using another open source tool. As we have decided to use SSHTools, we did some changes in the code (for v 0.2.7) , and found that performance for this case is significantly faster now (possibly upto 10 times). I am detailing the defects we found that can hamper the performance for uploading large files, and attaching the changed files for v0.2.7 along with a README that explains the exact changes in each file that were done:
I found two inefficiencies –
1) The library is inefficient in sending the appropriate size of chunk of data to the server. So it ends up spending app. twice the time (in some cases) in encrypting and padding as opposed to what is actually required.
2) It blocks for the response from the server; this could be inefficient in some cases, such as upload of large files. Here you get ‘Window Adjust’ messages in between, and there may be a delay in the response for the data received from the server. But in such cases, the library will block; thus slowing it down considerably.
The attached zip contains the changed files. Can we have these changes incorporated into v0.2.7 (after your review of course), so that instead of we making any changes , we get these changes from the original writers, and have more faith in the product. I also believe these changes, if properly incorporated can help SSHTools library latest versions also (if these kind of changes are already not there).
Need a way to set/get packet size in SftpClient

Howard Ungar — Thu, 21 Sep 2006 19:44:55 -0000
I was unable to put via SFTP as I was getting a packet
too large error. In order to accomodate, I have
modified my local copy of SftpClient such that the
following methods exist (these would be very useful in
full version):
/**
* <p>
* Allows the packet size of 65535 or less to be
specified from the client
* (Default packet size is 65535)
* </p>
*
* @param packetSize Size of desired packet
* @since 0.2.0
*/
public void setPacketSize (int packetSize)
{ BLOCKSIZE = ( packetSize <= 65535 ?
packetSize : BLOCKSIZE); }
/**
* <p>
* Returns the currently defined packed size
* (Default packet size is 65535)
* </p>
*
* @return The current packet size
* @since 0.2.0
*/
public int getPacketSize()
{ return BLOCKSIZE; }
Support Certificate Authenticate

Iglezias,LM — Wed, 31 May 2006 12:29:01 -0000
Do you intend to support this type of Authentication
(Certificate Authentication) in J2SSH?? (if yes When?)
thanks
try chmod configurable for SftpClient

M_S_Hater — Fri, 03 Mar 2006 12:04:04 -0000
Adapt SshClient.java and SftpClient.java make it 
configurable to allow NOT to try a chmod for a new 
file/directory on remote server. This can give errors 
if chmod is not allowed \(dropbox on remote server with 
minimal rights\).

Adapted code SshClient.java :

/\*
\*  SSHTools - Java SSH2 API
\*
\*  Copyright \(C\) 2002-2003 Lee David Painter and 
Contributors.
\*
\*  Contributions made by:
\*
\*  Brett Smith
\*  Richard Pernavas
\*  Erwin Bolwidt
\*
\*  This program is free software; you can 
redistribute it and/or
\*  modify it under the terms of the GNU Library 
General Public License
\*  as published by the Free Software Foundation; 
either version 2 of
\*  the License, or \(at your option\) any later version.
\*
\*  You may also distribute it and/or modify it under 
the terms of the
\*  Apache style J2SSH Software License. A copy of 
which should have
\*  been provided with the distribution.
\*
\*  This program is distributed in the hope that it 
will be useful,
\*  but WITHOUT ANY WARRANTY; without even the implied 
warranty of
\*  MERCHANTABILITY or FITNESS FOR A PARTICULAR 
PURPOSE.  See the
\*  License document supplied with your distribution 
for more details.
\*
\*/
package com.sshtools.j2ssh;

import 
com.sshtools.j2ssh.authentication.AuthenticationProtoco
lClient;
import 
com.sshtools.j2ssh.authentication.AuthenticationProtoco
lState;
import 
com.sshtools.j2ssh.authentication.PublicKeyAuthenticati
onClient;
import 
com.sshtools.j2ssh.authentication.SshAuthenticationClie
nt;
import 
com.sshtools.j2ssh.configuration.SshConnectionPropertie
s;
import com.sshtools.j2ssh.connection.Channel;
import 
com.sshtools.j2ssh.connection.ChannelEventAdapter;
import 
com.sshtools.j2ssh.connection.ChannelEventListener;
import com.sshtools.j2ssh.connection.ChannelFactory;
import 
com.sshtools.j2ssh.connection.ConnectionProtocol;
import com.sshtools.j2ssh.forwarding.ForwardingClient;
import com.sshtools.j2ssh.net.TransportProvider;
import com.sshtools.j2ssh.net.TransportProviderFactory;
import com.sshtools.j2ssh.session.SessionChannelClient;
import com.sshtools.j2ssh.sftp.SftpSubsystemClient;
import 
com.sshtools.j2ssh.transport.ConsoleKnownHostsKeyVerifi
cation;
import 
com.sshtools.j2ssh.transport.HostKeyVerification;
import 
com.sshtools.j2ssh.transport.TransportProtocolClient;
import 
com.sshtools.j2ssh.transport.TransportProtocolState;
import 
com.sshtools.j2ssh.transport.publickey.SshPublicKey;
import com.sshtools.j2ssh.util.State;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.File;
import java.io.IOException;

import java.net.UnknownHostException;

import java.util.Iterator;
import java.util.List;
import java.util.Vector;


/\*\*
\* &lt;p&gt;
\* Implements an SSH client with methods to connect to 
a remote server and
\* perform all necersary SSH functions such as SCP, 
SFTP, executing commands,
\* starting the users shell and perform port 
forwarding.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* There are several steps to perform prior to 
performing the desired task.
\* This involves the making the initial connection, 
authenticating the user
\* and creating a session to execute a command, shell 
or subsystem and/or
\* configuring the port forwarding manager.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* To create a connection use the following code:&lt;br&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* // Create a instance and connect SshClient
\* ssh = new SshClient\(\);
\* ssh.connect\("hostname"\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\* Once this code has executed and returned
\* the connection is ready for authentication:&lt;br&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* PasswordAuthenticationClient pwd = new 
PasswordAuthenticationClient\(\);
\* pwd.setUsername\("foo"\);
\* pwd.setPassword\("xxxxx"\);
\* // Authenticate the user
\* int result = ssh.authenticate\(pwd\);
\* if\(result==AuthenticationProtocolState.COMPLETED\) \{
\*    // Authentication complete
\* \}
\* &lt;/pre&gt;&lt;/blockquote&gt;
\* Once authenticated the user's shell can be 
started:&lt;br&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* // Open a session channel
\* SessionChannelClient session =
\*                      ssh.openSessionChannel\(\);
\*
\* // Request a pseudo terminal, if you do not you may 
not see the prompt
\* if\(session.requestPseudoTerminal\("ansi", 80, 24, 0, 
0, ""\) \{
\*      // Start the users shell
\*      if\(session.startShell\(\)\) \{
\*         // Do something with the session output
\*         session.getOutputStream\(\).write\("echo 
message\n"\);
\*         ....
\*       \}
\* \}
\* &lt;/pre&gt;&lt;/blockquote&gt;
\* &lt;/p&gt;
\*
\* @author Lee David Painter
\* @version $Revision: 1.75 $
\*
\* @since 0.2.0
\*/
public class SshClient \{
private static Log log = LogFactory.getLog
\(SshClient.class\);

/\*\*
\* The SSH Authentication protocol implementation 
for this SSH client. The
\* SSH Authentication protocol runs over the SSH 
Transport protocol as a
\* transport protocol service.
\*/
protected AuthenticationProtocolClient 
authentication;

/\*\*
\* The SSH Connection protocol implementation for 
this SSH client. The
\* connection protocol runs over the SSH Transport 
protocol as a transport
\* protocol service and is started by the 
authentication protocol after a
\* successful authentication.
\*/
protected ConnectionProtocol connection;

/\*\* Provides a high level management interface for 
SSH port forwarding. \*/
protected ForwardingClient forwarding;

/\*\* The SSH Transport protocol implementation for 
this SSH Client. \*/
protected TransportProtocolClient transport;

/\*\* The current state of the authentication for 
the current connection. \*/
protected int authenticationState = 
AuthenticationProtocolState.READY;

/\*\*
\* The timeout in milliseconds for the underlying 
transport provider
\* \(typically a Socket\).
\*/
protected int socketTimeout = 0;

/\*\*
\* A Transport protocol event handler instance 
that receives notifications
\* of transport layer events such as Socket 
timeouts and disconnection.
\*/
protected SshEventAdapter eventHandler = null;

/\*\* The currently active channels for this SSH 
Client connection. \*/
protected Vector activeChannels = new Vector\(\);

/\*\*
\* An channel event listener implemention to 
maintain the active channel
\* list.
\*/
protected ActiveChannelEventListener 
activeChannelListener = new ActiveChannelEventListener
\(\);

/\*\*
\* Flag indicating whether the forwarding instance 
is created when the
\* connection is made.
\*/
protected boolean useDefaultForwarding = true;

/\*\* The currently active Sftp clients \*/
private Vector activeSftpClients = new Vector\(\);

/\*\*
\* &lt;p&gt;
\* Contructs an unitilialized SshClient ready for 
connecting.
\* &lt;/p&gt;
\*/
public SshClient\(\) \{
\}

/\*\*
\* &lt;p&gt;
\* Returns the server's authentication banner.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* In some jurisdictions, sending a warning 
message before authentication
\* may be relevant for getting legal protection.  
Many UNIX machines, for
\* example, normally display text from 
\`/etc/issue', or use "tcp wrappers"
\* or similar software to display a banner before 
issuing a login prompt.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* The server may or may not send this message. 
Call this method to
\* retrieve the message, specifying a timeout 
limit to wait for the
\* message.
\* &lt;/p&gt;
\*
\* @param timeout The number of milliseconds to 
wait for the banner message
\*        before returning
\*
\* @return The server's banner message
\*
\* @exception IOException If an IO error occurs 
reading the message
\*
\* @since 0.2.0
\*/
public String getAuthenticationBanner\(int timeout\)
throws IOException \{
if \(authentication == null\) \{
return "";
\} else \{
return authentication.getBannerMessage
\(timeout\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Returns the list of available authentication 
methods for a given user.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* A client may request a list of authentication 
methods that may continue
\* by using the "none" authentication method.This 
method calls the "none"
\* method and returns the available authentication 
methods.
\* &lt;/p&gt;
\*
\* @param username The name of the account for 
which you require the
\*        available authentication methods
\*
\* @return A list of Strings, for 
example "password", "publickey" &
\*         "keyboard-interactive"
\*
\* @exception IOException If an IO error occurs 
during the operation
\*
\* @since 0.2.0
\*/
public List getAvailableAuthMethods\(String 
username\)
throws IOException \{
if \(authentication \!= null\) \{
return authentication.getAvailableAuths
\(username,
connection.getServiceName\(\)\);
\} else \{
return null;
\}
\}

/\*\*
\* &lt;p&gt;
\* Returns the connection state of the client.
\* &lt;/p&gt;
\*
\* @return true if the client is connected, false 
otherwise
\*
\* @since 0.2.0
\*/
public boolean isConnected\(\) \{
State state = \(transport == null\) ? null : 
transport.getState\(\);
int value = \(state == null\) ? 
TransportProtocolState.DISCONNECTED
: state.getValue\(\);

return \(\(value == 
TransportProtocolState.CONNECTED\) ||
\(value == 
TransportProtocolState.PERFORMING\_KEYEXCHANGE\)\);
\}

/\*\*
\* &lt;p&gt;
\* Evaluate whether the client has successfully 
authenticated.
\* &lt;/p&gt;
\*
\* @return true if the client is authenticated, 
otherwise false
\*/
public boolean isAuthenticated\(\) \{
return authenticationState == 
AuthenticationProtocolState.COMPLETE;
\}

/\*\*
\* &lt;p&gt;
\* Returns the identification string sent by the 
server during protocol
\* negotiation. For example "SSH-2.0-OpenSSH\_p3.4".
\* &lt;/p&gt;
\*
\* @return The server's identification string.
\*
\* @since 0.2.0
\*/
public String getServerId\(\) \{
return transport.getRemoteId\(\);
\}

/\*\*
\* &lt;p&gt;
\* Returns the server's public key supplied during 
key exchange.
\* &lt;/p&gt;
\*
\* @return the server's public key
\*
\* @since 0.2.0
\*/
public SshPublicKey getServerHostKey\(\) \{
return transport.getServerHostKey\(\);
\}

/\*\*
\* &lt;p&gt;
\* Returns the transport protocol's connection 
state.
\* &lt;/p&gt;
\*
\* @return The transport protocol's state
\*
\* @since 0.2.0
\*/
public TransportProtocolState getConnectionState\(\) 
\{
return transport.getState\(\);
\}

/\*\*
\* &lt;p&gt;
\* Returns the default port forwarding manager.
\* &lt;/p&gt;
\*
\* @return This connection's forwarding client
\*
\* @since 0.2.0
\*/
public ForwardingClient getForwardingClient\(\) \{
return forwarding;
\}

/\*\*
\* &lt;p&gt;
\* Return's a rough guess at the server's EOL 
setting. This is simply
\* derived from the identification string and 
should not be used as a cast
\* iron proof on the EOL setting.
\* &lt;/p&gt;
\*
\* @return The transport protocol's EOL constant
\*
\* @since 0.2.0
\*/
public int getRemoteEOL\(\) \{
return transport.getRemoteEOL\(\);
\}

/\*\*
\* &lt;p&gt;
\* Set the event handler for the underlying 
transport protocol.
\* &lt;/p&gt;
\* &lt;blockquote&gt;
\* &lt;pre&gt;
\* ssh.setEventHandler\(new 
TransportProtocolEventHandler\(\) \{
\*
\*   public void onSocketTimeout\(TransportProtocol 
transport\) \{&lt;br&gt;
\*     // Do something to handle the socket 
timeout&lt;br&gt;
\*   \}
\*
\*   public void onDisconnect\(TransportProtocol 
transport\) \{
\*     // Perhaps some clean up?
\*   \}
\* \}\);
\* &lt;/pre&gt;
\* &lt;/blockquote&gt;
\*
\* @param eventHandler The event handler instance 
to receive transport
\*        protocol events
\*
\* @see 
com.sshtools.j2ssh.transport.TransportProtocolEventHand
ler
\* @since 0.2.0
\*/
public void addEventHandler\(SshEventAdapter 
eventHandler\) \{
// If were connected then add, otherwise store 
for later connection
if \(transport \!= null\) \{
transport.addEventHandler\(eventHandler\);
authentication.addEventListener
\(eventHandler\);
\} else \{
this.eventHandler = eventHandler;
\}
\}

/\*\*
\* &lt;p&gt;
\* Set's the socket timeout \(in milliseconds\) for 
the underlying transport
\* provider. This MUST be called prior to connect.
\* &lt;/p&gt;
\* &lt;blockquote&gt;
\* SshClient ssh = new SshClient\(\);
\* ssh.setSocketTimeout\(30000\);
\* ssh.connect\("hostname"\);
\* &lt;/blockquote&gt;
\*
\* @param milliseconds The number of milliseconds 
without activity before
\*        the timeout event occurs
\*
\* @since 0.2.0
\*/
public void setSocketTimeout\(int milliseconds\) \{
this.socketTimeout = milliseconds;
\}

/\*\*
\* &lt;p&gt;
\* Return's a rough guess at the server's EOL 
setting. This is simply
\* derived from the identification string and 
should not be used as a cast
\* iron proof on the EOL setting.
\* &lt;/p&gt;
\*
\* @return The EOL string
\*
\* @since 0.2.0
\*/
public String getRemoteEOLString\(\) \{
return \(\(transport.getRemoteEOL\(\) == 
TransportProtocolClient.EOL\_CRLF\)
? "\r\n" : "\n"\);
\}

/\*\*
\* Get the connection properties for this 
connection.
\*
\* @return
\*/
public SshConnectionProperties 
getConnectionProperties\(\) \{
return transport.getProperties\(\);
\}

/\*\*
\* &lt;p&gt;
\* Authenticate the user on the remote host.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* To authenticate the user, create an 
&lt;code&gt;SshAuthenticationClient&lt;/code&gt;
\* instance and configure it with the 
authentication details.
\* &lt;/p&gt;
\* &lt;code&gt; PasswordAuthenticationClient pwd = new
\* PasswordAuthenticationClient\(\); pwd.setUsername
\("root"\);
\* pwd.setPassword\("xxxxxxxxx"\); int result = 
ssh.authenticate\(pwd\);
\* &lt;/code&gt;
\*
\* &lt;p&gt;
\* The method returns a result value will one of 
the public static values
\* defined in 
&lt;code&gt;AuthenticationProtocolState&lt;/code&gt;. These are&lt;br&gt;
\* &lt;br&gt;
\* COMPLETED - The authentication succeeded.&lt;br&gt;
\* PARTIAL   - The authentication succeeded but a 
further authentication
\* method is required.&lt;br&gt;
\* FAILED    - The authentication failed.&lt;br&gt;
\* CANCELLED - The user cancelled authentication 
\(can only be returned
\* when the user is prompted for information.&lt;br&gt;
\* &lt;/p&gt;
\*
\* @param auth A configured 
SshAuthenticationClient instance ready for
\*        authentication
\*
\* @return The authentication result
\*
\* @exception IOException If an IO error occurs 
during authentication
\*
\* @since 0.2.0
\*/
public int authenticate\(SshAuthenticationClient 
auth\)
throws IOException \{
// Do the authentication
authenticationState = 
authentication.authenticate\(auth, connection\);

if \(\(authenticationState == 
AuthenticationProtocolState.COMPLETE\) &&
useDefaultForwarding\) \{
// Use some method to synchronize 
forwardings on the ForwardingClient
forwarding.synchronizeConfiguration
\(transport.getProperties\(\)\);
\}

return authenticationState;
\}

/\*\*
\* &lt;p&gt;
\* Determine whether a private/public key pair 
will be accepted for public
\* key authentication.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* When using public key authentication, the 
signing of data could take
\* some time depending upon the available machine 
resources. By calling
\* this method, you can determine whether the 
server will accept a key for
\* authentication by providing the public key. The 
server will verify the
\* key against the user's authorized keys and 
return true should the
\* public key be authorized. The caller can then 
proceed with the private
\* key operation.
\* &lt;/p&gt;
\*
\* @param username The username for authentication
\* @param key The public key for which 
authentication will be attempted
\*
\* @return true if the server will accept the key, 
otherwise false
\*
\* @exception IOException If an IO error occurs 
during the operation
\* @throws SshException
\*
\* @since 0.2.0
\*/
public boolean acceptsKey\(String username, 
SshPublicKey key\)
throws IOException \{
if \(authenticationState \!= 
AuthenticationProtocolState.COMPLETE\) \{
PublicKeyAuthenticationClient pk = new 
PublicKeyAuthenticationClient\(\);

return pk.acceptsKey\(authentication, 
username,
connection.getServiceName\(\), key\);
\} else \{
throw new SshException\("Authentication has 
been completed\!"\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Connect the client to the server using default 
connection properties.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* This call attempts to connect to the hostname 
specified on the standard
\* SSH port of 22 and uses all the default 
connection properties. This
\* call is the equivilent of calling:
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* SshConnectionProperties properties = new
\*                           
SshConnectionProperties\(\);
\* properties.setHostname\("hostname"\);
\* ssh.connect\(properties\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* @param hostname The hostname of the server to 
connect
\*
\* @exception IOException If an IO error occurs 
during the connect
\*            operation
\*
\* @see \#connect
\(com.sshtools.j2ssh.configuration.SshConnectionProperti
es\)
\* @since 0.2.0
\*/
public void connect\(String hostname\) throws 
IOException \{
connect\(hostname, 22, new 
ConsoleKnownHostsKeyVerification\(\)\);
\}

/\*\*
\* &lt;p&gt;
\* Connect the client to the server using the 
default connection
\* properties.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* This call attempts to connect to the hostname 
specified on the standard
\* SSH port of 22 and uses all the default 
connection properties. When
\* this method returns the connection has been 
established, the server's
\* identity been verified and the connection is 
ready for user
\* authentication. Host key verification will be 
performed using the host
\* key verification instance provided:
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* // Connect and consult $HOME/.ssh/known\_hosts
\* ssh.connect\("hostname", new 
ConsoleKnownHostsKeyVerification\(\)\);
\* // Connect and allow any host
\* ssh.connect\("hostname", new
\*                 IgnoreHostKeyVerification\(\)\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* &lt;p&gt;
\* You can provide your own host key verification 
process by implementing
\* the &lt;code&gt;HostKeyVerification&lt;/code&gt; interface.
\* &lt;/p&gt;
\*
\* @param hostname The hostname of the server to 
connect
\* @param hosts The host key verification instance 
to consult for host key
\*        validation
\*
\* @exception IOException If an IO error occurs 
during the connect
\*            operation
\*
\* @see \#connect
\(com.sshtools.j2ssh.configuration.SshConnectionProperti
es,
\*      
com.sshtools.j2ssh.transport.HostKeyVerification\)
\* @since 0.2.0
\*/
public void connect\(String hostname, 
HostKeyVerification hosts\)
throws IOException \{
connect\(hostname, 22, hosts\);
\}

/\*\*
\* &lt;p&gt;
\* Connect the client to the server on a specified 
port with default
\* connection properties.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* This call attempts to connect to the hostname 
and port specified. This
\* call is the equivilent of calling:
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;/pre&gt;
\* SshConnectionProperties properties = new
\*                               
SshConnectionProperties\(\);
\* properties.setHostname\("hostname"\);
\* properties.setPort\(10022\);
\* ssh.connect\(properties\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* @param hostname The hostname of the server to 
connect
\* @param port The port to connect
\*
\* @exception IOException If an IO error occurs 
during the connect
\*            operation
\*
\* @see \#connect
\(com.sshtools.j2ssh.configuration.SshConnectionProperti
es\)
\* @since 0.2.0
\*/
public void connect\(String hostname, int port\) 
throws IOException \{
connect\(hostname, port, new 
ConsoleKnownHostsKeyVerification\(\)\);
\}

/\*\*
\* &lt;p&gt;
\* Connect the client to the server on a specified 
port with default
\* connection properties.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* This call attempts to connect to the hostname 
and port specified. When
\* this method returns the connection has been 
established, the server's
\* identity been verified and the connection is 
ready for user
\* authentication. Host key verification will be 
performed using the host
\* key verification instance provided:
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* // Connect and consult $HOME/.ssh/known\_hosts
\* ssh.connect\("hostname", new 
ConsoleKnownHostsKeyVerification\(\)\);
\* // Connect and allow any host
\* ssh.connect\("hostname", new
\*                 IgnoreHostKeyVerification\(\)\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* &lt;p&gt;
\* You can provide your own host key verification 
process by implementing
\* the &lt;code&gt;HostKeyVerification&lt;/code&gt; interface.
\* &lt;/p&gt;
\*
\* @param hostname The hostname of the server to 
connect
\* @param port The port to connect
\* @param hosts The host key verification instance 
to consult for host key
\*        validation
\*
\* @exception IOException If an IO error occurs 
during the connect
\*            operation
\*
\* @see \#connect
\(com.sshtools.j2ssh.configuration.SshConnectionProperti
es,
\*      
com.sshtools.j2ssh.transport.HostKeyVerification\)
\* @since 0.2.0
\*/
public void connect\(String hostname, int port, 
HostKeyVerification hosts\)
throws IOException \{
SshConnectionProperties properties = new 
SshConnectionProperties\(\);
properties.setHost\(hostname\);
properties.setPort\(port\);
connect\(properties, hosts\);
\}

/\*\*
\* &lt;p&gt;
\* Connect the client to the server with the 
specified properties.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* This call attempts to connect to using the 
connection properties
\* specified. When this method returns the 
connection has been
\* established, the server's identity been 
verified and the connection is
\* ready for user authentication. To use this 
method first create a
\* properties instance and set the required fields.
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* SshConnectionProperties properties = new
\*                         SshConnectionProperties
\(\);
\* properties.setHostname\("hostname"\);
\* properties.setPort\(10022\);
\* properties.setPrefCSEncryption\("blowfish-cbc"\);
\* ssh.connect\(properties\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* &lt;p&gt;
\* Host key verification will be performed using
\* &lt;code&gt;ConsoleKnownHostsKeyVerification&lt;/code&gt; 
and so this call is the
\* equivilent of calling:
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* ssh.connect\("hostname", new 
ConsoleKnownHostsKeyVerification\(\)\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* &lt;p&gt;
\* If the key is not matched to any keys already 
in the
\* $HOME/.ssh/known\_hosts file, the user will be 
prompted via the console
\* to confirm the identity of the remote server. 
The user will receive the
\* following prompt.
\* &lt;/p&gt;
\* &lt;code&gt; The host shell.sourceforge.net is 
currently unknown to the system
\* The host key fingerprint is: 1024: 4c 68 3 d4 
5c 58 a6 1d 9d 17 13 24
\* 14 48 ba 99 Do you want to allow this host key? 
\[Yes|No|Always\]:
\* &lt;/code&gt;
\*
\* &lt;p&gt;
\* Selecting the "always" option will write the 
key to the known\_hosts
\* file.
\* &lt;/p&gt;
\*
\* @param properties The connection properties
\*
\* @exception IOException If an IO error occurs 
during the connect
\*            operation
\*
\* @since 0.2.0
\*/
public void connect\(SshConnectionProperties 
properties\)
throws IOException \{
connect\(properties, new 
ConsoleKnownHostsKeyVerification\(\)\);
\}

/\*\*
\* &lt;p&gt;
\* Connect the client to the server with the 
specified properties.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* This call attempts to connect to using the 
connection properties
\* specified. When this method returns the 
connection has been
\* established, the server's identity been 
verified and the connection is
\* ready for user authentication. To use this 
method first create a
\* properties instance and set the required fields.
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* SshConnectionProperties properties = new
\*                             
SshConnectionProperties\(\);
\* properties.setHostname\("hostname"\);
\* properties.setPort\(22\);             // Defaults 
to 22
\* // Set the prefered client-&gt;server encryption
\* ssh.setPrefCSEncryption\("blowfish-cbc"\);
\* // Set the prefered server-&gt;client encrpytion
\* ssh.setPrefSCEncrpyion\("3des-cbc"\);
\* ssh.connect\(properties\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* &lt;p&gt;
\* Host key verification will be performed using 
the host key verification
\* instance provided:&lt;br&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* // Connect and consult $HOME/.ssh/known\_hosts
\* ssh.connect\("hostname", new 
ConsoleKnownHostsKeyVerification\(\)\);
\* // Connect and allow any host
\* ssh.connect\("hostname", new
\*                 IgnoreHostKeyVerification\(\)\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\* You can provide your own host key verification 
process by implementing the
\* &lt;code&gt;HostKeyVerification&lt;/code&gt; interface.
\* &lt;/p&gt;
\*
\* @param properties The connection properties
\* @param hostVerification The host key 
verification instance to consult
\*        for host  key validation
\*
\* @exception UnknownHostException If the host is 
unknown
\* @exception IOException If an IO error occurs 
during the connect
\*            operation
\*
\* @since 0.2.0
\*/
public void connect\(SshConnectionProperties 
properties,
HostKeyVerification hostVerification\)
throws UnknownHostException, IOException \{
TransportProvider provider = 
TransportProviderFactory.connectTransportProvider
\(properties /\*, connectTimeout\*/,
socketTimeout\);

// Start the transport protocol
transport = new TransportProtocolClient
\(hostVerification\);
transport.addEventHandler\(eventHandler\);
transport.startTransportProtocol\(provider, 
properties\);

// Start the authentication protocol
authentication = new 
AuthenticationProtocolClient\(\);
authentication.addEventListener\(eventHandler\);
transport.requestService\(authentication\);
connection = new ConnectionProtocol\(\);

if \(useDefaultForwarding\) \{
forwarding = new ForwardingClient
\(connection\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Sets the timeout value for the key exchange.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* When this time limit is reached the transport 
protocol will initiate a
\* key re-exchange. The default value is one hour 
with the minumin timeout
\* being 60 seconds.
\* &lt;/p&gt;
\*
\* @param seconds The number of seconds beofre key 
re-exchange
\*
\* @exception IOException If the timeout value is 
invalid
\*
\* @since 0.2.0
\*/
public void setKexTimeout\(long seconds\) throws 
IOException \{
transport.setKexTimeout\(seconds\);
\}

/\*\*
\* &lt;p&gt;
\* Sets the key exchance transfer limit in 
kilobytes.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* Once this amount of data has been transfered 
the transport protocol will
\* initiate a key re-exchange. The default value 
is one gigabyte of data
\* with the mimimun value of 10 kilobytes.
\* &lt;/p&gt;
\*
\* @param kilobytes The data transfer limit in 
kilobytes
\*
\* @exception IOException If the data transfer 
limit is invalid
\*/
public void setKexTransferLimit\(long kilobytes\) 
throws IOException \{
transport.setKexTransferLimit\(kilobytes\);
\}

/\*\*
\* &lt;p&gt;
\* Set's the send ignore flag to send random data 
packets.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* If this flag is set to true, then the transport 
protocol will send
\* additional SSH\_MSG\_IGNORE packets with random 
data.
\* &lt;/p&gt;
\*
\* @param sendIgnore true if you want to turn on 
random packet data,
\*        otherwise false
\*
\* @since 0.2.0
\*/
public void setSendIgnore\(boolean sendIgnore\) \{
transport.setSendIgnore\(sendIgnore\);
\}

/\*\*
\* &lt;p&gt;
\* Turn the default forwarding manager on/off.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* If this flag is set to false before connection, 
the client will not
\* create a port forwarding manager. Use this to 
provide you own
\* forwarding implementation.
\* &lt;/p&gt;
\*
\* @param useDefaultForwarding Set to false if you 
not wish to use the
\*        default forwarding manager.
\*
\* @since 0.2.0
\*/
public void setUseDefaultForwarding\(boolean 
useDefaultForwarding\) \{
this.useDefaultForwarding = 
useDefaultForwarding;
\}

/\*\*
\* &lt;p&gt;
\* Disconnect the client.
\* &lt;/p&gt;
\*
\* @since 0.2.0
\*/
public void disconnect\(\) \{
if \(connection \!= null\) \{
connection.stop\(\);
\}

if \(transport \!= null\) \{
transport.disconnect\("Terminating 
connection"\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Returns the number of bytes transmitted to the 
remote server.
\* &lt;/p&gt;
\*
\* @return The number of bytes transmitted
\*
\* @since 0.2.0
\*/
public long getOutgoingByteCount\(\) \{
return transport.getOutgoingByteCount\(\);
\}

/\*\*
\* &lt;p&gt;
\* Returns the number of bytes received from the 
remote server.
\* &lt;/p&gt;
\*
\* @return The number of bytes received
\*
\* @since 0.2.0
\*/
public long getIncomingByteCount\(\) \{
return transport.getIncomingByteCount\(\);
\}

/\*\*
\* &lt;p&gt;
\* Returns the number of active channels for this 
client.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* This is the total count of sessions, port 
forwarding, sftp, scp and
\* custom channels currently open.
\* &lt;/p&gt;
\*
\* @return The number of active channels
\*
\* @since 0.2.0
\*/
public int getActiveChannelCount\(\) \{
synchronized \(activeChannels\) \{
return activeChannels.size\(\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Returns the list of active channels.
\* &lt;/p&gt;
\*
\* @return The list of active channels
\*
\* @since 0.2.0
\*/
public List getActiveChannels\(\) \{
synchronized \(activeChannels\) \{
return \(List\) activeChannels.clone\(\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Returns true if there is an active session 
channel of the specified
\* type.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* When a session is created, it is assigned a 
default type. For instance,
\* when a session is created it as a type 
of "uninitialized"; however when
\* a shell is started on the session, the type is 
set to "shell". This
\* also occurs for commands where the type is set 
to the command which is
\* executed and subsystems where the type is set 
to the subsystem name.
\* This allows each session to be saved in the 
active session channel's
\* list and recalled later. It is also possible to 
set the session
\* channel's type using the setSessionType method 
of the
\* &lt;code&gt;SessionChannelClient&lt;/code&gt; class.
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* if\(ssh.hasActiveSession\("shell"\)\) \{
\*      SessionChannelClient session =
\*           ssh.getActiveSession\("shell"\);
\* \}
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* @param type The string specifying the channel 
type
\*
\* @return true if an active session channel 
exists, otherwise false
\*
\* @since 0.2.0
\*/
public boolean hasActiveSession\(String type\) \{
Iterator it = activeChannels.iterator\(\);
Object obj;

while \(it.hasNext\(\)\) \{
obj = it.next\(\);

if \(obj instanceof SessionChannelClient\) \{
if \(\(\(SessionChannelClient\) 
obj\).getSessionType\(\).equals\(type\)\) \{
return true;
\}
\}
\}

return false;
\}

/\*\*
\* &lt;p&gt;
\* Returns the active session channel of the given 
type.
\* &lt;/p&gt;
\*
\* @param type The type fo session channel
\*
\* @return The session channel instance
\*
\* @exception IOException If the session type does 
not exist
\*
\* @since 0.2.0
\*/
public SessionChannelClient getActiveSession
\(String type\)
throws IOException \{
Iterator it = activeChannels.iterator\(\);
Object obj;

while \(it.hasNext\(\)\) \{
obj = it.next\(\);

if \(obj instanceof SessionChannelClient\) \{
if \(\(\(SessionChannelClient\) 
obj\).getSessionType\(\).equals\(type\)\) \{
return \(SessionChannelClient\) obj;
\}
\}
\}

throw new IOException\("There are no active " + 
type + " sessions"\);
\}

/\*\*
\* Determine whether the channel supplied is an 
active channel
\*
\* @param channel
\*
\* @return
\*/
public boolean isActiveChannel\(Channel channel\) \{
return activeChannels.contains\(channel\);
\}

/\*\*
\* &lt;p&gt;
\* Open's a session channel on the remote server.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* A session channel may be used to start the 
user's shell, execute a
\* command or start a subsystem such as SFTP.
\* &lt;/p&gt;
\*
\* @return An new session channel
\*
\* @exception IOException If authentication has 
not been completed, the
\*            server refuses to open the channel 
or a general IO error
\*            occurs
\*
\* @see 
com.sshtools.j2ssh.session.SessionChannelClient
\* @since 0.2.0
\*/
public SessionChannelClient openSessionChannel\(\) 
throws IOException \{
return openSessionChannel\(null\);
\}

/\*\*
\*
\* &lt;p&gt;
\* Open's a session channel on the remote server.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* A session channel may be used to start the 
user's shell, execute a
\* command or start a subsystem such as SFTP.
\* &lt;/p&gt;
\*
\* @param eventListener an event listner interface 
to add to the channel
\*
\* @return
\*
\* @throws IOException
\* @throws SshException
\*/
public SessionChannelClient openSessionChannel\(
ChannelEventListener eventListener\) throws 
IOException \{
if \(authenticationState \!= 
AuthenticationProtocolState.COMPLETE\) \{
throw new SshException\("Authentication has 
not been completed\!"\);
\}

SessionChannelClient session = new 
SessionChannelClient\(\);
session.addEventListener
\(activeChannelListener\);

if \(\!connection.openChannel\(session, 
eventListener\)\) \{
throw new SshException\("The server refused 
to open a session"\);
\}

return session;
\}

/\*\*
\* &lt;p&gt;
\* Open an SFTP client for file transfer 
operations.
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* SftpClient sftp = ssh.openSftpClient\(\);
\* sftp.cd\("foo"\);
\* sftp.put\("somefile.txt"\);
\* sftp.quit\(\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* @return Returns an initialized SFTP client
\*
\* @exception IOException If an IO error occurs 
during the operation
\*
\* @see SftpClient
\* @since 0.2.0
\*/
public SftpClient openSftpClient\(\) throws 
IOException \{
return openSftpClient\(null\);
\}


/\*\*
\* &lt;p&gt;
\* Open an SFTP client for file transfer 
operations.
\* &lt;/p&gt;
\* with configurable try chmod
\* &lt;blockquote&gt;&lt;pre&gt;
\* SftpClient sftp = ssh.openSftpClient\(\);
\* sftp.cd\("foo"\);
\* sftp.put\("somefile.txt"\);
\* sftp.quit\(\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* @return Returns an initialized SFTP client
\*
\* @exception IOException If an IO error occurs 
during the operation
\*
\* @see SftpClient
\* @since 0.2.0
\*/
public SftpClient openSftpClient\(boolean tryChmod\) 
throws IOException \{
return openSftpClient\(null, tryChmod\);
\}

/\*\*
\* &lt;p&gt;
\* Open an SFTP client for file transfer 
operations. Adds the supplied
\* event listener to the underlying channel.
\* &lt;/p&gt;
\*
\* @param eventListener
\*
\* @return
\*
\* @throws IOException
\*/
public SftpClient openSftpClient
\(ChannelEventListener eventListener\)
throws IOException \{
SftpClient sftp = new SftpClient\(this, 
eventListener\);
activeSftpClients.add\(sftp\);

return sftp;
\}

/\*\*
\* &lt;p&gt;
\* Open an SFTP client for file transfer 
operations. Adds the supplied
\* event listener to the underlying channel.
\* with configurable try chmod
\* &lt;/p&gt;
\*
\* @param eventListener
\*
\* @return
\*
\* @throws IOException
\*/
public SftpClient openSftpClient
\(ChannelEventListener eventListener, boolean tryChmod\)
throws IOException \{
SftpClient sftp = new SftpClient\(this, 
eventListener, tryChmod\);
activeSftpClients.add\(sftp\);

return sftp;
\}

/\*\*
\* Determine if there are existing sftp clients 
open
\*
\* @return
\*/
public boolean hasActiveSftpClient\(\) \{
synchronized \(activeSftpClients\) \{
return activeSftpClients.size\(\) &gt; 0;
\}
\}

/\*\*
\* Get an active sftp client
\*
\* @return
\*
\* @throws IOException
\* @throws SshException
\*/
public SftpClient getActiveSftpClient\(\) throws 
IOException \{
synchronized \(activeSftpClients\) \{
if \(activeSftpClients.size\(\) &gt; 0\) \{
return \(SftpClient\) 
activeSftpClients.get\(0\);
\} else \{
throw new SshException\("There are no 
active SFTP clients"\);
\}
\}
\}

/\*\*
\* &lt;p&gt;
\* Open an SCP client for file transfer operations 
where SFTP is not
\* supported.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* Sets the local working directory to the user's 
home directory
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* ScpClient scp = ssh.openScpClient\(\);
\* scp.put\("somefile.txt"\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* @return An initialized SCP client
\*
\* @exception IOException If an IO error occurs 
during the operation
\*
\* @see ScpClient
\* @since 0.2.0
\*/
public ScpClient openScpClient\(\) throws 
IOException \{
return new ScpClient\(new File
\(System.getProperty\("user.home"\)\), this,
false, activeChannelListener\);
\}

/\*\*
\* &lt;p&gt;
\* Open an SCP client for file transfer operations 
where SFTP is not
\* supported.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* This method sets a local current working 
directory.
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* ScpClient scp = ssh.openScpClient\("foo"\);
\* scp.put\("somefile.txt"\);
\* &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* @param cwd The local directory as the base for 
all local files
\*
\* @return An intialized SCP client
\*
\* @exception IOException If an IO error occurs 
during the operation
\*
\* @see SftpClient
\* @since 0.2.0
\*/
public ScpClient openScpClient\(File cwd\) throws 
IOException \{
return new ScpClient\(cwd, this, false, 
activeChannelListener\);
\}

/\*\*
\* &lt;p&gt;
\* Open's an Sftp channel.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* Use this sftp channel if you require a lower 
level api into the SFTP
\* protocol.
\* &lt;/p&gt;
\*
\* @return an initialized sftp subsystem instance
\*
\* @throws IOException if an IO error occurs or 
the channel cannot be
\*         opened
\*
\* @since 0.2.0
\*/
public SftpSubsystemClient openSftpChannel\(\) 
throws IOException \{
return openSftpChannel\(null\);
\}

/\*\*
\* Open an SftpSubsystemChannel. For advanced use 
only
\*
\* @param eventListener
\*
\* @return
\*
\* @throws IOException
\* @throws SshException
\*/
public SftpSubsystemClient openSftpChannel\(
ChannelEventListener eventListener\) throws 
IOException \{
SessionChannelClient session = 
openSessionChannel\(eventListener\);
SftpSubsystemClient sftp = new 
SftpSubsystemClient\(\);

if \(\!openChannel\(sftp\)\) \{
throw new SshException\("The SFTP subsystem 
failed to start"\);
\}

// Initialize SFTP
if \(\!sftp.initialize\(\)\) \{
throw new SshException\(
"The SFTP Subsystem could not be 
initialized"\);
\}

return sftp;
\}

/\*\*
\* &lt;p&gt;
\* Open's a channel.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* Call this method to open a custom channel. This 
method is used by all
\* other channel opening methods. For example the 
openSessionChannel
\* method could be implemented as:&lt;br&gt;
\* &lt;blockquote&gt;&lt;pre&gt;
\* SessionChannelClient session =
\*                 new SessionChannelClient\(\);
\* if\(ssh.openChannel\(session\)\) \{
\*    // Channel is now open
\* \}
\* &lt;/pre&gt;&lt;/blockquote&gt;
\* &lt;/p&gt;
\*
\* @param channel
\*
\* @return true if the channel was opened, 
otherwise false
\*
\* @exception IOException if an IO error occurs
\* @throws SshException
\*
\* @since 0.2.0
\*/
public boolean openChannel\(Channel channel\) throws 
IOException \{
if \(authenticationState \!= 
AuthenticationProtocolState.COMPLETE\) \{
throw new SshException\("Authentication has 
not been completed\!"\);
\}

// Open the channel providing our channel 
listener so we can track
return connection.openChannel\(channel, 
activeChannelListener\);
\}

/\*\*
\* &lt;p&gt;
\* Instructs the underlying connection protocol to 
allow channels of the
\* given type to be opened by the server.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* The client does not allow channels to be opened 
by default. Call this
\* method to allow the server to open channels by 
providing a
\* &lt;code&gt;ChannelFactory&lt;/code&gt; implementation to 
create instances upon
\* request.
\* &lt;/p&gt;
\*
\* @param channelName The channel type name
\* @param cf The factory implementation that will 
create instances of the
\*        channel when a channel open request is 
recieved.
\*
\* @exception IOException if an IO error occurs
\*
\* @since 0.2.0
\*/
public void allowChannelOpen\(String channelName, 
ChannelFactory cf\)
throws IOException \{
connection.addChannelFactory\(channelName, cf\);
\}

/\*\*
\* &lt;p&gt;
\* Stops the specified channel type from being 
opended.
\* &lt;/p&gt;
\*
\* @param channelName The channel type name
\*
\* @throws IOException if an IO error occurs
\*
\* @since 0.2.1
\*/
public void denyChannelOpen\(String channelName\) 
throws IOException \{
connection.removeChannelFactory\(channelName\);
\}

/\*\*
\* &lt;p&gt;
\* Send a global request to the server.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* The SSH specification provides a global request 
mechanism which is used
\* for starting/stopping remote forwarding. This 
is a general mechanism
\* which can be used for other purposes if the 
server supports the global
\* requests.
\* &lt;/p&gt;
\*
\* @param requestName The name of the global 
request
\* @param wantReply true if the server should send 
an explict reply
\* @param requestData the global request data
\*
\* @return true if the global request succeeded or 
wantReply==false,
\*         otherwise false
\*
\* @throws IOException if an IO error occurs
\*
\* @since 0.2.0
\*/
public byte\[\] sendGlobalRequest\(String 
requestName, boolean wantReply,
byte\[\] requestData\) throws IOException \{
return connection.sendGlobalRequest
\(requestName, wantReply, requestData\);
\}

/\*\*
\* &lt;p&gt;
\* Implements the 
&lt;code&gt;ChannelEventListener&lt;/code&gt; interface to provide
\* real time tracking of active channels.
\* &lt;/p&gt;
\*/
class ActiveChannelEventListener extends 
ChannelEventAdapter \{
/\*\*
\* &lt;p&gt;
\* Adds the channel to the active channel list.
\* &lt;/p&gt;
\*
\* @param channel The channel being opened
\*/
public void onChannelOpen\(Channel channel\) \{
synchronized \(activeChannels\) \{
activeChannels.add\(channel\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Removes the closed channel from the clients 
active channels list.
\* &lt;/p&gt;
\*
\* @param channel The channle being closed
\*/
public void onChannelClose\(Channel channel\) \{
synchronized \(activeChannels\) \{
activeChannels.remove\(channel\);
\}
\}
\}
\}


Adapted code SftpClient.java :


/\*
\*  SSHTools - Java SSH2 API
\*
\*  Copyright \(C\) 2002-2003 Lee David Painter and 
Contributors.
\*
\*  Contributions made by:
\*
\*  Brett Smith
\*  Richard Pernavas
\*  Erwin Bolwidt
\*
\*  This program is free software; you can 
redistribute it and/or
\*  modify it under the terms of the GNU Library 
General Public License
\*  as published by the Free Software Foundation; 
either version 2 of
\*  the License, or \(at your option\) any later version.
\*
\*  You may also distribute it and/or modify it under 
the terms of the
\*  Apache style J2SSH Software License. A copy of 
which should have
\*  been provided with the distribution.
\*
\*  This program is distributed in the hope that it 
will be useful,
\*  but WITHOUT ANY WARRANTY; without even the implied 
warranty of
\*  MERCHANTABILITY or FITNESS FOR A PARTICULAR 
PURPOSE.  See the
\*  License document supplied with your distribution 
for more details.
\*
\*/
package com.sshtools.j2ssh;

import com.sshtools.j2ssh.connection.\*;
import com.sshtools.j2ssh.io.\*;
import com.sshtools.j2ssh.sftp.\*;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Vector;


/\*\*
\* &lt;p&gt;
\* Implements a Secure File Transfer \(SFTP\) client.
\* &lt;/p&gt;
\*
\* @author Lee David Painter
\* @version $Revision: 1.44 $
\*
\* @since 0.2.0
\*/
public class SftpClient \{
SftpSubsystemClient sftp;
String cwd;
String lcwd;
private int BLOCKSIZE = 65535;
boolean tryChmod = true ;

// Default permissions is determined by 
default\_permissions ^ umask
int umask = 0022;
int default\_permissions = 0777;

/\*\*
\* &lt;p&gt;
\* Constructs the SFTP client.
\* &lt;/p&gt;
\*
\* @param ssh the &lt;code&gt;SshClient&lt;/code&gt; instance
\*
\* @throws IOException if an IO error occurs
\*/
SftpClient\(SshClient ssh\) throws IOException \{
this\(ssh, null\);
\}

/\*\*
\* &lt;p&gt;
\* Constructs the SFTP client.
\* &lt;/p&gt;
\*
\* @param ssh the &lt;code&gt;SshClient&lt;/code&gt; instance
\* with configurable try chmod
\*
\* @throws IOException if an IO error occurs
\*/
SftpClient\(SshClient ssh, boolean tryChmod\) throws 
IOException \{
this\(ssh, null, tryChmod\);
\}

/\*\*
\* &lt;p&gt;
\* Constructs the SFTP client with a given channel 
event listener.
\* &lt;/p&gt;
\*
\* @param ssh the &lt;code&gt;SshClient&lt;/code&gt; instance
\* @param eventListener an event listener 
implementation
\*
\* @throws IOException if an IO error occurs
\*/
SftpClient\(SshClient ssh, ChannelEventListener 
eventListener\)
throws IOException \{
if \(\!ssh.isConnected\(\)\) \{
throw new IOException\("SshClient is not 
connected"\);
\}

this.sftp = ssh.openSftpChannel\(eventListener\);

// Get the users default directory
cwd = sftp.getDefaultDirectory\(\);
lcwd = System.getProperty\("user.home"\);
\}

/\*\*
\* &lt;p&gt;
\* Constructs the SFTP client with a given channel 
event listener.
\* &lt;/p&gt;
\*
\* @param ssh the &lt;code&gt;SshClient&lt;/code&gt; instance
\* @param eventListener an event listener 
implementation
\* with configurable try chmod
\*
\* @throws IOException if an IO error occurs
\*/
SftpClient\(SshClient ssh, ChannelEventListener 
eventListener, boolean tryChmod\)
throws IOException \{
if \(\!ssh.isConnected\(\)\) \{
throw new IOException\("SshClient is not 
connected"\);
\}

this.sftp = ssh.openSftpChannel\(eventListener\);
this.tryChmod = tryChmod ;

// Get the users default directory
cwd = sftp.getDefaultDirectory\(\);
lcwd = System.getProperty\("user.home"\);
\}

/\*\*
\* Sets the umask used by this client.
\* @param umask
\* @return the previous umask value
\*/
public int umask\(int umask\) \{
int old = umask;
this.umask = umask;

return old;
\}

/\*\*
\* &lt;p&gt;
\* Changes the working directory on the remote 
server.
\* &lt;/p&gt;
\*
\* @param dir the new working directory
\*
\* @throws IOException if an IO error occurs or 
the file does not exist
\* @throws FileNotFoundException
\*
\* @since 0.2.0
\*/
public void cd\(String dir\) throws IOException \{
try \{
String actual;

if \(dir.equals\(""\)\) \{
actual = sftp.getDefaultDirectory\(\);
\} else \{
actual = resolveRemotePath\(dir\);
actual = sftp.getAbsolutePath\(actual\);
\}

FileAttributes attr = sftp.getAttributes
\(actual\);

if \(\!attr.isDirectory\(\)\) \{
throw new IOException\(dir + " is not a 
directory"\);
\}

cwd = actual;
\} catch \(IOException ex\) \{
throw new FileNotFoundException\(dir + " 
could not be found"\);
\}
\}

private File resolveLocalPath\(String path\) throws 
IOException \{
File f = new File\(path\);

if \(\!f.isAbsolute\(\)\) \{
f = new File\(lcwd, path\);
\}

return f;
\}

private String resolveRemotePath\(String path\) 
throws IOException \{
verifyConnection\(\);

String actual;

if \(\!path.startsWith\("/"\)\) \{
actual = cwd + \(cwd.endsWith
\("/"\) ? "" : "/"\) + path;
\} else \{
actual = path;
\}

return actual;
\}

private void verifyConnection\(\) throws 
SshException \{
if \(sftp.isClosed\(\)\) \{
throw new SshException\("The SFTP 
connection has been closed"\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Creates a new directory on the remote server. 
This method will throw an
\* exception if the directory already exists. To 
create directories and
\* disregard any errors use the 
&lt;code&gt;mkdirs&lt;/code&gt; method.
\* &lt;/p&gt;
\*
\* @param dir the name of the new directory
\*
\* @throws IOException if an IO error occurs or if 
the directory already
\*         exists
\*
\* @since 0.2.0
\*/
public void mkdir\(String dir\) throws IOException \{
String actual = resolveRemotePath\(dir\);

try \{
FileAttributes attrs = stat\(actual\);

if \(\!attrs.isDirectory\(\)\) \{
throw new IOException\("File already 
exists named " + dir\);
\}
\} catch \(IOException ex\) \{
sftp.makeDirectory\(actual\);
if \(tryChmod\) chmod\(default\_permissions ^ 
umask, actual\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Create a directory or set of directories. This 
method will not fail even
\* if the directories exist. It is advisable to 
test whether the directory
\* exists before attempting an operation by using 
the &lt;code&gt;stat&lt;/code&gt;
\* method to return the directories attributes.
\* &lt;/p&gt;
\*
\* @param dir the path of directories to create.
\*/
public void mkdirs\(String dir\) \{
StringTokenizer tokens = new StringTokenizer
\(dir, "/"\);
String path = dir.startsWith\("/"\) ? "/" : "";

while \(tokens.hasMoreElements\(\)\) \{
path += \(String\) tokens.nextElement\(\);

try \{
stat\(path\);
\} catch \(IOException ex\) \{
try \{
mkdir\(path\);
\} catch \(IOException ex2\) \{
\}
\}

path += "/";
\}
\}

/\*\*
\* &lt;p&gt;
\* Returns the absolute path name of the current 
remote working directory.
\* &lt;/p&gt;
\*
\* @return the absolute path of the remote working 
directory.
\*
\* @since 0.2.0
\*/
public String pwd\(\) \{
return cwd;
\}

/\*\*
\* &lt;p&gt;
\* List the contents of the current remote working 
directory.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* Returns a list of &lt;code&gt;SftpFile&lt;/code&gt; 
instances for the current
\* working directory.
\* &lt;/p&gt;
\*
\* @return a list of SftpFile for the current 
working directory
\*
\* @throws IOException if an IO error occurs
\*
\* @see com.sshtools.j2ssh.sftp.SftpFile
\* @since 0.2.0
\*/
public List ls\(\) throws IOException \{
return ls\(cwd\);
\}

/\*\*
\* &lt;p&gt;
\* List the contents remote directory.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* Returns a list of &lt;code&gt;SftpFile&lt;/code&gt; 
instances for the remote
\* directory.
\* &lt;/p&gt;
\*
\* @param path the path on the remote server to 
list
\*
\* @return a list of SftpFile for the remote 
directory
\*
\* @throws IOException if an IO error occurs
\*
\* @see com.sshtools.j2ssh.sftp.SftpFile
\* @since 0.2.0
\*/
public List ls\(String path\) throws IOException \{
String actual = resolveRemotePath\(path\);
FileAttributes attrs = sftp.getAttributes
\(actual\);

if \(\!attrs.isDirectory\(\)\) \{
throw new IOException\(path + " is not a 
directory"\);
\}

SftpFile file = sftp.openDirectory\(actual\);
Vector children = new Vector\(\);

while \(sftp.listChildren\(file, children\) &gt; -1\) 
\{
;
\}

file.close\(\);

return children;
\}

/\*\*
\* &lt;p&gt;
\* Changes the local working directory.
\* &lt;/p&gt;
\*
\* @param path the path to the new working 
directory
\*
\* @throws IOException if an IO error occurs
\*
\* @since 0.2.0
\*/
public void lcd\(String path\) throws IOException \{
File actual;

if \(\!isLocalAbsolutePath\(path\)\) \{
actual = new File\(lcwd, path\);
\} else \{
actual = new File\(path\);
\}

if \(\!actual.isDirectory\(\)\) \{
throw new IOException\(path + " is not a 
directory"\);
\}

lcwd = actual.getCanonicalPath\(\);
\}

private static boolean isLocalAbsolutePath\(String 
path\) \{
return \(new File\(path\)\).isAbsolute\(\);
\}

/\*\*
\* &lt;p&gt;
\* Returns the absolute path to the local working 
directory.
\* &lt;/p&gt;
\*
\* @return the absolute path of the local working 
directory.
\*
\* @since 0.2.0
\*/
public String lpwd\(\) \{
return lcwd;
\}

/\*\*
\* &lt;p&gt;
\* Download the remote file to the local computer.
\* &lt;/p&gt;
\*
\* @param path the path to the remote file
\* @param progress
\*
\* @return
\*
\* @throws IOException if an IO error occurs of 
the file does not exist
\* @throws TransferCancelledException
\*
\* @since 0.2.0
\*/
public FileAttributes get\(String path, 
FileTransferProgress progress\)
throws IOException, TransferCancelledException 
\{
String localfile;

if \(path.lastIndexOf\("/"\) &gt; -1\) \{
localfile = path.substring\(path.lastIndexOf
\("/"\) + 1\);
\} else \{
localfile = path;
\}

return get\(path, localfile, progress\);
\}

/\*\*
\*
\*
\* @param path
\*
\* @return
\*
\* @throws IOException
\*/
public FileAttributes get\(String path\) throws 
IOException \{
return get\(path, \(FileTransferProgress\) null\);
\}

private void transferFile\(InputStream in, 
OutputStream out\)
throws IOException, TransferCancelledException 
\{
transferFile\(in, out, null\);
\}

private void transferFile\(InputStream in, 
OutputStream out,
FileTransferProgress progress\)
throws IOException, TransferCancelledException 
\{
try \{
long bytesSoFar = 0;
byte\[\] buffer = new byte\[BLOCKSIZE\];
int read;

while \(\(read = in.read\(buffer\)\) &gt; -1\) \{
if \(\(progress \!= null\) && 
progress.isCancelled\(\)\) \{
throw new 
TransferCancelledException\(\);
\}

if \(read &gt; 0\) \{
out.write\(buffer, 0, read\);

//out.flush\(\);
bytesSoFar += read;

if \(progress \!= null\) \{
progress.progressed
\(bytesSoFar\);
\}
\}
\}
\} finally \{
try \{
in.close\(\);
out.close\(\);
\} catch \(IOException ex\) \{
\}
\}
\}

/\*\*
\* &lt;p&gt;
\* Download the remote file to the local computer. 
If the paths provided
\* are not absolute the current working directory 
is used.
\* &lt;/p&gt;
\*
\* @param remote the path/name of the remote file
\* @param local the path/name to place the file on 
the local computer
\* @param progress
\*
\* @return
\*
\* @throws IOException if an IO error occurs or 
the file does not exist
\* @throws TransferCancelledException
\*
\* @since 0.2.0
\*/
public FileAttributes get\(String remote, String 
local,
FileTransferProgress progress\)
throws IOException, TransferCancelledException 
\{
File localPath = resolveLocalPath\(local\);

if \(\!localPath.exists\(\)\) \{
localPath.getParentFile\(\).mkdirs\(\);
localPath.createNewFile\(\);
\}

FileOutputStream out = new FileOutputStream
\(localPath\);

return get\(remote, out, progress\);
\}

/\*\*
\*
\*
\* @param remote
\* @param local
\*
\* @return
\*
\* @throws IOException
\*/
public FileAttributes get\(String remote, String 
local\)
throws IOException \{
return get\(remote, local, null\);
\}

/\*\*
\* &lt;p&gt;
\* Download the remote file writing it to the 
specified
\* &lt;code&gt;OutputStream&lt;/code&gt;. The OutputStream is 
closed by this mehtod
\* even if the operation fails.
\* &lt;/p&gt;
\*
\* @param remote the path/name of the remote file
\* @param local the OutputStream to write
\* @param progress
\*
\* @return
\*
\* @throws IOException if an IO error occurs or 
the file does not exist
\* @throws TransferCancelledException
\*
\* @since 0.2.0
\*/
public FileAttributes get\(String remote, 
OutputStream local,
FileTransferProgress progress\)
throws IOException, TransferCancelledException 
\{
String remotePath = resolveRemotePath\(remote\);
FileAttributes attrs = stat\(remotePath\);

if \(progress \!= null\) \{
progress.started\(attrs.getSize\(\).longValue
\(\), remotePath\);
\}

SftpFileInputStream in = new 
SftpFileInputStream\(sftp.openFile\(
remotePath, 
SftpSubsystemClient.OPEN\_READ\)\);
transferFile\(in, local, progress\);

if \(progress \!= null\) \{
progress.completed\(\);
\}

return attrs;
\}

/\*\*
\*
\*
\* @param remote
\* @param local
\*
\* @return
\*
\* @throws IOException
\*/
public FileAttributes get\(String remote, 
OutputStream local\)
throws IOException \{
return get\(remote, local, null\);
\}

/\*\*
\* &lt;p&gt;
\* Returns the state of the SFTP client. The 
client is closed if the
\* underlying session channel is closed. Invoking 
the &lt;code&gt;quit&lt;/code&gt;
\* method of this object will close the underlying 
session channel.
\* &lt;/p&gt;
\*
\* @return true if the client is still connected, 
otherwise false
\*
\* @since 0.2.0
\*/
public boolean isClosed\(\) \{
return sftp.isClosed\(\);
\}

/\*\*
\* &lt;p&gt;
\* Upload a file to the remote computer.
\* &lt;/p&gt;
\*
\* @param local the path/name of the local file
\* @param progress
\*
\* @return
\*
\* @throws IOException if an IO error occurs or 
the file does not exist
\* @throws TransferCancelledException
\*
\* @since 0.2.0
\*/
public void put\(String local, FileTransferProgress 
progress\)
throws IOException, TransferCancelledException 
\{
File f = new File\(local\);
put\(local, f.getName\(\), progress\);
\}

/\*\*
\*
\*
\* @param local
\*
\* @return
\*
\* @throws IOException
\*/
public void put\(String local\) throws IOException \{
put\(local, \(FileTransferProgress\) null\);
\}

/\*\*
\* &lt;p&gt;
\* Upload a file to the remote computer. If the 
paths provided are not
\* absolute the current working directory is used.
\* &lt;/p&gt;
\*
\* @param local the path/name of the local file
\* @param remote the path/name of the destination 
file
\* @param progress
\*
\* @return
\*
\* @throws IOException if an IO error occurs or 
the file does not exist
\* @throws TransferCancelledException
\*
\* @since 0.2.0
\*/
public void put\(String local, String remote, 
FileTransferProgress progress\)
throws IOException, TransferCancelledException 
\{
File localPath = resolveLocalPath\(local\);
FileInputStream in = new FileInputStream
\(localPath\);

try \{
FileAttributes attrs = stat\(remote\);

if \(attrs.isDirectory\(\)\) \{
File f = new File\(local\);
remote += \(\(remote.endsWith
\("/"\) ? "" : "/"\) + f.getName\(\)\);
\}
\} catch \(IOException ex\) \{
\}

put\(in, remote, progress\);
\}

/\*\*
\*
\*
\* @param local
\* @param remote
\*
\* @return
\*
\* @throws IOException
\*/
public void put\(String local, String remote\) 
throws IOException \{
put\(local, remote, null\);
\}

/\*\*
\* &lt;p&gt;
\* Upload a file to the remote computer reading 
from the specified &lt;code&gt;
\* InputStream&lt;/code&gt;. The InputStream is closed, 
even if the operation
\* fails.
\* &lt;/p&gt;
\*
\* @param in the InputStream being read
\* @param remote the path/name of the destination 
file
\* @param progress
\*
\* @return
\*
\* @throws IOException if an IO error occurs
\* @throws TransferCancelledException
\*
\* @since 0.2.0
\*/
public void put\(InputStream in, String remote, 
FileTransferProgress progress\)
throws IOException, TransferCancelledException 
\{
String remotePath = resolveRemotePath\(remote\);
SftpFileOutputStream out;
FileAttributes attrs;
boolean newfile = false;

try \{
attrs = stat\(remotePath\);
out = new SftpFileOutputStream
\(sftp.openFile\(remotePath,

SftpSubsystemClient.OPEN\_CREATE |

SftpSubsystemClient.OPEN\_TRUNCATE |

SftpSubsystemClient.OPEN\_WRITE\)\);
\} catch \(IOException ex\) \{
attrs = new FileAttributes\(\);
newfile = true;
attrs.setPermissions\(new UnsignedInteger32
\(default\_permissions ^
umask\)\);
out = new SftpFileOutputStream
\(sftp.openFile\(remotePath,

SftpSubsystemClient.OPEN\_CREATE |

SftpSubsystemClient.OPEN\_WRITE, attrs\)\);
\}

if \(progress \!= null\) \{
progress.started\(in.available\(\), 
remotePath\);
\}

transferFile\(in, out, progress\);

if \(progress \!= null\) \{
progress.completed\(\);
\}

// Set the permissions here since at creation 
they dont always work
if \(newfile\) \{
if \(tryChmod\) chmod\(default\_permissions ^ 
umask, remotePath\);
\}
\}

/\*\*
\*
\*
\* @param in
\* @param remote
\*
\* @return
\*
\* @throws IOException
\*/
public void put\(InputStream in, String remote\) 
throws IOException \{
put\(in, remote, null\);
\}

/\*\*
\* &lt;p&gt;
\* Sets the user ID to owner for the file or 
directory.
\* &lt;/p&gt;
\*
\* @param uid numeric user id of the new owner
\* @param path the path to the remote 
file/directory
\*
\* @throws IOException if an IO error occurs or 
the file does not exist
\*
\* @since 0.2.0
\*/
public void chown\(int uid, String path\) throws 
IOException \{
String actual = resolveRemotePath\(path\);
FileAttributes attrs = sftp.getAttributes
\(actual\);
attrs.setUID\(new UnsignedInteger32\(uid\)\);
sftp.setAttributes\(actual, attrs\);
\}

/\*\*
\* &lt;p&gt;
\* Sets the group ID for the file or directory.
\* &lt;/p&gt;
\*
\* @param gid the numeric group id for the new 
group
\* @param path the path to the remote 
file/directory
\*
\* @throws IOException if an IO error occurs or 
the file does not exist
\*
\* @since 0.2.0
\*/
public void chgrp\(int gid, String path\) throws 
IOException \{
String actual = resolveRemotePath\(path\);
FileAttributes attrs = sftp.getAttributes
\(actual\);
attrs.setGID\(new UnsignedInteger32\(gid\)\);
sftp.setAttributes\(actual, attrs\);
\}

/\*\*
\* &lt;p&gt;
\* Changes the access permissions or modes of the 
specified file or
\* directory.
\* &lt;/p&gt;
\*
\* &lt;p&gt;
\* Modes determine who can read, change or execute 
a file.
\* &lt;/p&gt;
\* &lt;blockquote&gt;&lt;pre&gt;Absolute modes are octal 
numbers specifying the complete list of
\* attributes for the files; you specify 
attributes by OR'ing together
\* these bits.
\*
\* 0400       Individual read
\* 0200       Individual write
\* 0100       Individual execute \(or list 
directory\)
\* 0040       Group read
\* 0020       Group write
\* 0010       Group execute
\* 0004       Other read
\* 0002       Other write
\* 0001       Other execute &lt;/pre&gt;&lt;/blockquote&gt;
\*
\* @param permissions the absolute mode of the 
file/directory
\* @param path the path to the file/directory on 
the remote server
\*
\* @throws IOException if an IO error occurs or 
the file if not found
\*
\* @since 0.2.0
\*/
public void chmod\(int permissions, String path\) 
throws IOException \{
String actual = resolveRemotePath\(path\);
sftp.changePermissions\(actual, permissions\);
\}

public void umask\(String umask\) throws IOException 
\{
try \{
this.umask = Integer.parseInt\(umask, 8\);
\} catch \(NumberFormatException ex\) \{
throw new IOException\(
"umask must be 4 digit octal number 
e.g. 0022"\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Rename a file on the remote computer.
\* &lt;/p&gt;
\*
\* @param oldpath the old path
\* @param newpath the new path
\*
\* @throws IOException if an IO error occurs
\*
\* @since 0.2.0
\*/
public void rename\(String oldpath, String newpath\)
throws IOException \{
String from = resolveRemotePath\(oldpath\);
String to = resolveRemotePath\(newpath\);
sftp.renameFile\(from, to\);
\}

/\*\*
\* &lt;p&gt;
\* Remove a file or directory from the remote 
computer.
\* &lt;/p&gt;
\*
\* @param path the path of the remote 
file/directory
\*
\* @throws IOException if an IO error occurs
\*
\* @since 0.2.0
\*/
public void rm\(String path\) throws IOException \{
String actual = resolveRemotePath\(path\);
FileAttributes attrs = sftp.getAttributes
\(actual\);

if \(attrs.isDirectory\(\)\) \{
sftp.removeDirectory\(actual\);
\} else \{
sftp.removeFile\(actual\);
\}
\}

/\*\*
\*
\*
\* @param path
\* @param force
\* @param recurse
\*
\* @throws IOException
\*/
public void rm\(String path, boolean force, boolean 
recurse\)
throws IOException \{
String actual = resolveRemotePath\(path\);
FileAttributes attrs = sftp.getAttributes
\(actual\);
SftpFile file;

if \(attrs.isDirectory\(\)\) \{
List list = ls\(path\);

if \(\!force && \(list.size\(\) &gt; 0\)\) \{
throw new IOException\(
"You cannot delete non-empty 
directory, use force=true to overide"\);
\} else \{
for \(Iterator it = list.iterator\(\); 
it.hasNext\(\);\) \{
file = \(SftpFile\) it.next\(\);

if \(file.isDirectory\(\) && \!
file.getFilename\(\).equals\("."\) &&
\!file.getFilename\(\).equals
\(".."\)\) \{
if \(recurse\) \{
rm\(file.getAbsolutePath\(\), 
force, recurse\);
\} else \{
throw new IOException\(
"Directory has 
contents, cannot delete without recurse=true"\);
\}
\} else if \(file.isFile\(\)\) \{
sftp.removeFile
\(file.getAbsolutePath\(\)\);
\}
\}
\}

sftp.removeDirectory\(actual\);
\} else \{
sftp.removeFile\(actual\);
\}
\}

/\*\*
\* &lt;p&gt;
\* Create a symbolic link on the remote computer.
\* &lt;/p&gt;
\*
\* @param path the path to the existing file
\* @param link the new link
\*
\* @throws IOException if an IO error occurs or 
the operation is not
\*         supported on the remote platform
\*
\* @since 0.2.0
\*/
public void symlink\(String path, String link\) 
throws IOException \{
String actualPath = resolveRemotePath\(path\);
String actualLink = resolveRemotePath\(link\);
sftp.createSymbolicLink\(actualPath, 
actualLink\);
\}

/\*\*
\* &lt;p&gt;
\* Returns the attributes of the file from the 
remote computer.
\* &lt;/p&gt;
\*
\* @param path the path of the file on the remote 
computer
\*
\* @return the attributes
\*
\* @throws IOException if an IO error occurs or 
the file does not exist
\*
\* @see com.sshtools.j2ssh.sftp.FileAttributes
\* @since 0.2.0
\*/
public FileAttributes stat\(String path\) throws 
IOException \{
String actual = resolveRemotePath\(path\);

return sftp.getAttributes\(actual\);
\}

/\*\*
\*
\*
\* @param path
\*
\* @return
\*
\* @throws IOException
\*/
public String getAbsolutePath\(String path\) throws 
IOException \{
String actual = resolveRemotePath\(path\);

return sftp.getAbsolutePath\(path\);
\}

/\*\*
\* &lt;p&gt;
\* Close the SFTP client.
\* &lt;/p&gt;
\*
\* @throws IOException
\*
\* @since 0.2.0
\*/
public void quit\(\) throws IOException \{
sftp.close\(\);
\}

/\*\*
\*
\*
\* @param localdir
\* @param remotedir
\* @param recurse
\* @param sync
\* @param commit
\* @param progress
\*
\* @return
\*
\* @throws IOException
\*/
public DirectoryOperation copyLocalDirectory
\(String localdir,
String remotedir, boolean recurse, boolean 
sync, boolean commit,
FileTransferProgress progress\) throws 
IOException \{
DirectoryOperation op = new DirectoryOperation
\(\);

// Record the previous
String pwd = pwd\(\);
String lpwd = lpwd\(\);
File local = resolveLocalPath\(localdir\);
remotedir = resolveRemotePath\(remotedir\);
remotedir += \(remotedir.endsWith
\("/"\) ? "" : "/"\);
remotedir += local.getName\(\);
remotedir += \(remotedir.endsWith
\("/"\) ? "" : "/"\);

// Setup the remote directory if were 
committing
if \(commit\) \{
try \{
FileAttributes attrs = stat\(remotedir\);
\} catch \(IOException ex\) \{
mkdir\(remotedir\);
\}
\}

// List the local files and verify against the 
remote server
File\[\] ls = local.listFiles\(\);

if \(ls \!= null\) \{
for \(int i = 0; i &lt; ls.length; i++\) \{
if \(ls\[i\].isDirectory\(\) && \!ls
\[i\].getName\(\).equals\("."\) &&
\!ls\[i\].getName\(\).equals\(".."\)\) 
\{
if \(recurse\) \{
File f = new File\(local, ls
\[i\].getName\(\)\);
op.addDirectoryOperation
\(copyLocalDirectory\(
f.getAbsolutePath\(\), 
remotedir, recurse, sync,
commit, progress\), f\);
\}
\} else if \(ls\[i\].isFile\(\)\) \{
try \{
FileAttributes attrs = stat
\(remotedir +
ls\[i\].getName\(\)\);

if \(\(ls\[i\].length\(\) == 
attrs.getSize\(\).longValue\(\)\) &&
\(\(ls\[i\].lastModified
\(\) / 1000\) == attrs.getModifiedTime\(\)

.longValue\(\)\)\) \{
op.addUnchangedFile\(ls\[i\]\);
\} else \{
op.addUpdatedFile\(ls\[i\]\);
\}
\} catch \(IOException ex1\) \{
op.addNewFile\(ls\[i\]\);
\}

if \(commit\) \{
put\(ls\[i\].getAbsolutePath\(\),
remotedir + ls\[i\].getName
\(\), progress\);

FileAttributes attrs = stat
\(remotedir +
ls\[i\].getName\(\)\);
attrs.setTimes\(new 
UnsignedInteger32\(
ls\[i\].lastModified\(\) / 
1000\),
new UnsignedInteger32\(ls
\[i\].lastModified\(\) / 1000\)\);
sftp.setAttributes\(remotedir + 
ls\[i\].getName\(\), attrs\);
\}
\}
\}
\}

if \(sync\) \{
// List the contents of the new local 
directory and remove any
// files/directories that were not updated
try \{
List files = ls\(remotedir\);
SftpFile file;
File f;

for \(Iterator it = files.iterator\(\); 
it.hasNext\(\);\) \{
file = \(SftpFile\) it.next\(\);

// Create a local file object to 
test for its existence
f = new File\(local, 
file.getFilename\(\)\);

if \(\!op.containsFile\(file\) &&
\!file.getFilename\(\).equals
\("."\) &&
\!file.getFilename\(\).equals
\(".."\)\) \{
op.addDeletedFile\(file\);

if \(commit\) \{
if \(file.isDirectory\(\)\) \{
// Recurse through the 
directory, deleting stuff
recurseMarkForDeletion
\(file, op\);

if \(commit\) \{
rm
\(file.getAbsolutePath\(\), true, true\);
\}
\} else if \(file.isFile\(\)\) \{
rm\(file.getAbsolutePath
\(\)\);
\}
\}
\}
\}
\} catch \(IOException ex2\) \{
// Ignorew since if it does not exist 
we cant delete it
\}
\}

// Return the operation details
return op;
\}

/\*\*
\*
\*
\* @param eventListener
\*/
public void addEventListener\(ChannelEventListener 
eventListener\) \{
sftp.addEventListener\(eventListener\);
\}

private void recurseMarkForDeletion\(SftpFile file, 
DirectoryOperation op\)
throws IOException \{
List list = ls\(file.getAbsolutePath\(\)\);
op.addDeletedFile\(file\);

for \(Iterator it = list.iterator\(\); it.hasNext
\(\);\) \{
file = \(SftpFile\) it.next\(\);

if \(file.isDirectory\(\) && \!file.getFilename
\(\).equals\("."\) &&
\!file.getFilename\(\).equals\(".."\)\) \{
recurseMarkForDeletion\(file, op\);
\} else if \(file.isFile\(\)\) \{
op.addDeletedFile\(file\);
\}
\}
\}

private void recurseMarkForDeletion\(File file, 
DirectoryOperation op\)
throws IOException \{
File\[\] list = file.listFiles\(\);
op.addDeletedFile\(file\);

if \(list \!= null\) \{
for \(int i = 0; i &lt; list.length; i++\) \{
file = list\[i\];

if \(file.isDirectory\(\) && \!file.getName
\(\).equals\("."\) &&
\!file.getName\(\).equals\(".."\)\) \{
recurseMarkForDeletion\(file, op\);
\} else if \(file.isFile\(\)\) \{
op.addDeletedFile\(file\);
\}
\}
\}
\}

/\*\*
\*
\*
\* @param remotedir
\* @param localdir
\* @param recurse
\* @param sync
\* @param commit
\* @param progress
\*
\* @return
\*
\* @throws IOException
\*/
public DirectoryOperation copyRemoteDirectory
\(String remotedir,
String localdir, boolean recurse, boolean 
sync, boolean commit,
FileTransferProgress progress\) throws 
IOException \{
// Create an operation object to hold the 
information
DirectoryOperation op = new DirectoryOperation
\(\);

// Record the previous working directoies
String pwd = pwd\(\);
String lpwd = lpwd\(\);
cd\(remotedir\);

// Setup the local cwd
String base = remotedir;
int idx = base.lastIndexOf\('/'\);

if \(idx \!= -1\) \{
base = base.substring\(idx + 1\);
\}

File local = new File\(localdir, base\);

//				File local = 
new File\(localdir, remotedir\);
if \(\!local.isAbsolute\(\)\) \{
local = new File\(lpwd\(\), localdir\);
\}

if \(\!local.exists\(\) && commit\) \{
local.mkdir\(\);
\}

List files = ls\(\);
SftpFile file;
File f;

for \(Iterator it = files.iterator\(\); it.hasNext
\(\);\) \{
file = \(SftpFile\) it.next\(\);

if \(file.isDirectory\(\) && \!file.getFilename
\(\).equals\("."\) &&
\!file.getFilename\(\).equals\(".."\)\) \{
if \(recurse\) \{
f = new File\(local, 
file.getFilename\(\)\);
op.addDirectoryOperation
\(copyRemoteDirectory\(
file.getFilename\(\), 
local.getAbsolutePath\(\),
recurse, sync, commit, 
progress\), f\);
\}
\} else if \(file.isFile\(\)\) \{
f = new File\(local, file.getFilename
\(\)\);

if \(f.exists\(\) &&
\(f.length\(\) == 
file.getAttributes\(\).getSize\(\).longValue\(\)\) &&
\(\(f.lastModified\(\) / 1000\) == 
file.getAttributes\(\)

.getModifiedTime\(\)

.longValue\(\)\)\) \{
if \(commit\) \{
op.addUnchangedFile\(f\);
\} else \{
op.addUnchangedFile\(file\);
\}

continue;
\}

if \(f.exists\(\)\) \{
if \(commit\) \{
op.addUpdatedFile\(f\);
\} else \{
op.addUpdatedFile\(file\);
\}
\} else \{
if \(commit\) \{
op.addNewFile\(f\);
\} else \{
op.addNewFile\(file\);
\}
\}

if \(commit\) \{
FileAttributes attrs = get
\(file.getFilename\(\),
f.getAbsolutePath\(\), 
progress\);
f.setLastModified
\(attrs.getModifiedTime\(\).longValue\(\) \* 1000\);
\}
\}
\}

if \(sync\) \{
// List the contents of the new local 
directory and remove any
// files/directories that were not updated
File\[\] contents = local.listFiles\(\);

if \(contents \!= null\) \{
for \(int i = 0; i &lt; contents.length; 
i++\) \{
if \(\!op.containsFile\(contents\[i\]\)\) 
\{
op.addDeletedFile\(contents\[i\]\);

if \(contents\[i\].isDirectory\(\) 
&&
\!contents\[i\].getName
\(\).equals\("."\) &&
\!contents\[i\].getName
\(\).equals\(".."\)\) \{
recurseMarkForDeletion
\(contents\[i\], op\);

if \(commit\) \{

IOUtil.recurseDeleteDirectory\(contents\[i\]\);
\}
\} else if \(commit\) \{
contents\[i\].delete\(\);
\}
\}
\}
\}
\}

cd\(pwd\);

return op;
\}
\}
Set input/output streams

Brad Mace — Tue, 16 Nov 2004 00:52:35 -0000
It would be extremely useful if alternate input/output
streams could be given so that everything isn't dealing
with System.in and System.out .
jdk 1.5 compliant

Perry — Thu, 14 Oct 2004 23:00:30 -0000
Just tiny changes to enable the package to be compiled
under jdk 1.5
enum is a reserved keyword for jdk 1.5, need to be
renamed it from 4 files
.getState() conflict with Thread.getState() under jdk
1.5, need to be renamed.
thus the package can be compiled under jdk 1.5. for
complete jdk 1.5 compliant, program code may need
significant changes.
Save dsa key file

newbeewan — Mon, 13 Sep 2004 15:07:31 -0000
Hi,
Is it possible to save the dsa file linked to a
connection saved as a file to prevent to reselect it
everytime you connect to the ssh server.
Thanks
Send input to multiple terminals

Bear — Mon, 22 Mar 2004 09:30:15 -0000
I would like to be able to group terminals and send key
events to them at once or individualy, for an example
of this check out multixterm or sun's ctelnet.
MacOSX installer anyone?

Vincent Keunen — Fri, 02 Jan 2004 17:20:13 -0000
If I'm correct, the linux installer does not work for
MacOSX. Could anyone knowledgeable build one?
Thanks
Vincent Keunen