--- a/src/com/trilead/ssh2/AuthAgentCallback.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,64 +0,0 @@
-package com.trilead.ssh2;
-
-import java.security.KeyPair;
-import java.util.Map;
-
-/**
- * AuthAgentCallback.
- *
- * @author Kenny Root
- * @version $Id$
- */
-public interface AuthAgentCallback {
-
-    /**
-     * @return array of blobs containing the OpenSSH-format encoded public keys
-     */
-    Map<String, byte[]> retrieveIdentities();
-
-    /**
-     * @param key A <code>RSAPrivateKey</code> or <code>DSAPrivateKey</code>
-     *            containing a DSA or RSA private key of
-     *            the user in Trilead object format.
-     * @param comment comment associated with this key
-     * @param confirmUse whether to prompt before using this key
-     * @param lifetime lifetime in seconds for key to be remembered
-     * @return success or failure
-     */
-    boolean addIdentity(KeyPair pair, String comment, boolean confirmUse, int lifetime);
-
-    /**
-     * @param publicKey byte blob containing the OpenSSH-format encoded public key
-     * @return success or failure
-     */
-    boolean removeIdentity(byte[] publicKey);
-
-    /**
-     * @return success or failure
-     */
-    boolean removeAllIdentities();
-
-    /**
-     * @param publicKey byte blob containing the OpenSSH-format encoded public key
-     * @return A <code>RSAPrivateKey</code> or <code>DSAPrivateKey</code>
-     *         containing a DSA or RSA private key of
-     *         the user in Trilead object format.
-     */
-    KeyPair getKeyPair(byte[] publicKey);
-
-    /**
-     * @return
-     */
-    boolean isAgentLocked();
-
-    /**
-     * @param lockPassphrase
-     */
-    boolean setAgentLock(String lockPassphrase);
-
-    /**
-     * @param unlockPassphrase
-     * @return
-     */
-    boolean requestAgentUnlock(String unlockPassphrase);
-}

--- a/src/com/trilead/ssh2/ChannelCondition.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-
-package com.trilead.ssh2;
-
-/**
- * Contains constants that can be used to specify what conditions to wait for on
- * a SSH-2 channel (e.g., represented by a {@link Session}).
- *
- * @see Session#waitForCondition(int, long)
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: ChannelCondition.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
- */
-
-public abstract interface ChannelCondition {
-    /**
-     * A timeout has occurred, none of your requested conditions is fulfilled.
-     * However, other conditions may be true - therefore, NEVER use the "=="
-     * operator to test for this (or any other) condition. Always use
-     * something like <code>((cond & ChannelCondition.CLOSED) != 0)</code>.
-     */
-    public static final int TIMEOUT = 1;
-
-    /**
-     * The underlying SSH-2 channel, however not necessarily the whole connection,
-     * has been closed. This implies <code>EOF</code>. Note that there may still
-     * be unread stdout or stderr data in the local window, i.e, <code>STDOUT_DATA</code>
-     * or/and <code>STDERR_DATA</code> may be set at the same time.
-     */
-    public static final int CLOSED = 2;
-
-    /**
-     * There is stdout data available that is ready to be consumed.
-     */
-    public static final int STDOUT_DATA = 4;
-
-    /**
-     * There is stderr data available that is ready to be consumed.
-     */
-    public static final int STDERR_DATA = 8;
-
-    /**
-     * EOF on has been reached, no more _new_ stdout or stderr data will arrive
-     * from the remote server. However, there may be unread stdout or stderr
-     * data, i.e, <code>STDOUT_DATA</code> or/and <code>STDERR_DATA</code>
-     * may be set at the same time.
-     */
-    public static final int EOF = 16;
-
-    /**
-     * The exit status of the remote process is available.
-     * Some servers never send the exist status, or occasionally "forget" to do so.
-     */
-    public static final int EXIT_STATUS = 32;
-
-    /**
-     * The exit signal of the remote process is available.
-     */
-    public static final int EXIT_SIGNAL = 64;
-
-}

--- a/src/com/trilead/ssh2/Connection.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1585 +0,0 @@
-
-package com.trilead.ssh2;
-
-import java.io.CharArrayWriter;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.net.SocketTimeoutException;
-import java.security.KeyPair;
-import java.security.SecureRandom;
-import java.security.Security;
-import java.util.Set;
-import java.util.Vector;
-
-import com.trilead.ssh2.auth.AuthenticationManager;
-import com.trilead.ssh2.channel.ChannelManager;
-import com.trilead.ssh2.crypto.CryptoWishList;
-import com.trilead.ssh2.crypto.cipher.BlockCipherFactory;
-import com.trilead.ssh2.crypto.digest.MAC;
-import com.trilead.ssh2.log.Logger;
-import com.trilead.ssh2.packets.PacketIgnore;
-import com.trilead.ssh2.transport.KexManager;
-import com.trilead.ssh2.transport.TransportManager;
-import com.trilead.ssh2.util.TimeoutService;
-import com.trilead.ssh2.util.TimeoutService.TimeoutToken;
-
-/**
- * A <code>Connection</code> is used to establish an encrypted TCP/IP
- * connection to a SSH-2 server.
- * <p>
- * Typically, one
- * <ol>
- * <li>creates a {@link #Connection(String) Connection} object.</li>
- * <li>calls the {@link #connect() connect()} method.</li>
- * <li>calls some of the authentication methods (e.g.,
- * {@link #authenticateWithPublicKey(String, File, String) authenticateWithPublicKey()}).</li>
- * <li>calls one or several times the {@link #openSession() openSession()}
- * method.</li>
- * <li>finally, one must close the connection and release resources with the
- * {@link #close() close()} method.</li>
- * </ol>
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: Connection.java,v 1.3 2008/04/01 12:38:09 cplattne Exp $
- */
-
-public class Connection {
-    /**
-     * The identifier presented to the SSH-2 server.
-     */
-    public final static String identification = "TrileadSSH2Java_213";
-
-    /**
-     * Will be used to generate all random data needed for the current
-     * connection. Note: SecureRandom.nextBytes() is thread safe.
-     */
-    private SecureRandom generator;
-
-    /**
-     * Unless you know what you are doing, you will never need this.
-     *
-     * @return The list of supported cipher algorithms by this implementation.
-     */
-
-    public static synchronized String[] getAvailableCiphers() {
-        return BlockCipherFactory.getDefaultCipherList();
-    }
-
-    /**
-     * Unless you know what you are doing, you will never need this.
-     *
-     * @return The list of supported MAC algorthims by this implementation.
-     */
-
-    public static synchronized String[] getAvailableMACs() {
-        return MAC.getMacList();
-    }
-
-    /**
-     * Unless you know what you are doing, you will never need this.
-     *
-     * @return The list of supported server host key algorthims by this
-     *         implementation.
-     */
-
-    public static synchronized String[] getAvailableServerHostKeyAlgorithms() {
-        return KexManager.getDefaultServerHostkeyAlgorithmList();
-    }
-
-    private AuthenticationManager am;
-
-    private boolean authenticated = false;
-    private boolean compression = false;
-    private ChannelManager cm;
-
-    private CryptoWishList cryptoWishList = new CryptoWishList();
-
-    private DHGexParameters dhgexpara = new DHGexParameters();
-
-    private final String hostname;
-
-    private final int port;
-
-    private TransportManager tm;
-
-    private boolean tcpNoDelay = false;
-
-    private ProxyData proxyData = null;
-
-    private Vector<ConnectionMonitor> connectionMonitors = new Vector<ConnectionMonitor>();
-
-    /**
-     * Prepares a fresh <code>Connection</code> object which can then be used
-     * to establish a connection to the specified SSH-2 server.
-     * <p>
-     * Same as {@link #Connection(String, int) Connection(hostname, 22)}.
-     *
-     * @param hostname
-     *            the hostname of the SSH-2 server.
-     */
-    public Connection(String hostname) {
-        this(hostname, 22);
-    }
-
-    /**
-     * Prepares a fresh <code>Connection</code> object which can then be used
-     * to establish a connection to the specified SSH-2 server.
-     *
-     * @param hostname
-     *            the host where we later want to connect to.
-     * @param port
-     *            port on the server, normally 22.
-     */
-    public Connection(String hostname, int port) {
-        this.hostname = hostname;
-        this.port = port;
-    }
-
-    /**
-     * 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).
-     * <p>
-     * If the authentication phase is complete, <code>true</code> will be
-     * returned. If the server does not accept the request (or if further
-     * authentication steps are needed), <code>false</code> is returned and
-     * one can retry either by using this or any other authentication method
-     * (use the <code>getRemainingAuthMethods</code> method to get a list of
-     * the remaining possible methods).
-     *
-     * @param user
-     *            A <code>String</code> holding the username.
-     * @param pem
-     *            A <code>String</code> containing the DSA private key of the
-     *            user in OpenSSH key format (PEM, you can't miss the
-     *            "-----BEGIN DSA PRIVATE KEY-----" tag). The string may contain
-     *            linefeeds.
-     * @param password
-     *            If the PEM string is 3DES encrypted ("DES-EDE3-CBC"), then you
-     *            must specify the password. Otherwise, this argument will be
-     *            ignored and can be set to <code>null</code>.
-     *
-     * @return whether the connection is now authenticated.
-     * @throws IOException
-     *
-     * @deprecated You should use one of the
-     *             {@link #authenticateWithPublicKey(String, File, String) authenticateWithPublicKey()}
-     *             methods, this method is just a wrapper for it and will
-     *             disappear in future builds.
-     *
-     */
-
-    public synchronized boolean authenticateWithDSA(String user, String pem, String password) throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Connection is not established!");
-
-        if (authenticated)
-            throw new IllegalStateException("Connection is already authenticated!");
-
-        if (am == null)
-            am = new AuthenticationManager(tm);
-
-        if (cm == null)
-            cm = new ChannelManager(tm);
-
-        if (user == null)
-            throw new IllegalArgumentException("user argument is null");
-
-        if (pem == null)
-            throw new IllegalArgumentException("pem argument is null");
-
-        authenticated = am.authenticatePublicKey(user, pem.toCharArray(), password, getOrCreateSecureRND());
-        return authenticated;
-    }
-
-    /**
-     * A wrapper that calls
-     * {@link #authenticateWithKeyboardInteractive(String, String[], InteractiveCallback)
-     * authenticateWithKeyboardInteractivewith} a <code>null</code> submethod
-     * list.
-     *
-     * @param user
-     *            A <code>String</code> holding the username.
-     * @param cb
-     *            An <code>InteractiveCallback</code> which will be used to
-     *            determine the responses to the questions asked by the server.
-     * @return whether the connection is now authenticated.
-     * @throws IOException
-     */
-
-    public synchronized boolean authenticateWithKeyboardInteractive(String user, InteractiveCallback cb)
-    throws IOException {
-        return authenticateWithKeyboardInteractive(user, null, cb);
-    }
-
-    /**
-     * 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...)
-     * <p>
-     * If the authentication phase is complete, <code>true</code> will be
-     * returned. If the server does not accept the request (or if further
-     * authentication steps are needed), <code>false</code> is returned and
-     * one can retry either by using this or any other authentication method
-     * (use the <code>getRemainingAuthMethods</code> method to get a list of
-     * the remaining possible methods).
-     * <p>
-     * Note: some SSH servers advertise "keyboard-interactive", however, any
-     * interactive request will be denied (without having sent any challenge to
-     * the client).
-     *
-     * @param user
-     *            A <code>String</code> holding the username.
-     * @param submethods
-     *            An array of submethod names, see
-     *            draft-ietf-secsh-auth-kbdinteract-XX. May be <code>null</code>
-     *            to indicate an empty list.
-     * @param cb
-     *            An <code>InteractiveCallback</code> which will be used to
-     *            determine the responses to the questions asked by the server.
-     *
-     * @return whether the connection is now authenticated.
-     * @throws IOException
-     */
-
-    public synchronized boolean authenticateWithKeyboardInteractive(String user, String[] submethods,
-            InteractiveCallback cb) throws IOException {
-        if (cb == null)
-            throw new IllegalArgumentException("Callback may not ne NULL!");
-
-        if (tm == null)
-            throw new IllegalStateException("Connection is not established!");
-
-        if (authenticated)
-            throw new IllegalStateException("Connection is already authenticated!");
-
-        if (am == null)
-            am = new AuthenticationManager(tm);
-
-        if (cm == null)
-            cm = new ChannelManager(tm);
-
-        if (user == null)
-            throw new IllegalArgumentException("user argument is null");
-
-        authenticated = am.authenticateInteractive(user, submethods, cb);
-        return authenticated;
-    }
-
-    /**
-     * After a successful connect, one has to authenticate oneself. This method
-     * sends username and password to the server.
-     * <p>
-     * If the authentication phase is complete, <code>true</code> will be
-     * returned. If the server does not accept the request (or if further
-     * authentication steps are needed), <code>false</code> is returned and
-     * one can retry either by using this or any other authentication method
-     * (use the <code>getRemainingAuthMethods</code> method to get a list of
-     * the remaining possible methods).
-     * <p>
-     * Note: if this method fails, then please double-check that it is actually
-     * offered by the server (use
-     * {@link #getRemainingAuthMethods(String) getRemainingAuthMethods()}.
-     * <p>
-     * 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.
-     *
-     * @param user
-     * @param password
-     * @return if the connection is now authenticated.
-     * @throws IOException
-     */
-
-    public synchronized boolean authenticateWithPassword(String user, String password) throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Connection is not established!");
-
-        if (authenticated)
-            throw new IllegalStateException("Connection is already authenticated!");
-
-        if (am == null)
-            am = new AuthenticationManager(tm);
-
-        if (cm == null)
-            cm = new ChannelManager(tm);
-
-        if (user == null)
-            throw new IllegalArgumentException("user argument is null");
-
-        if (password == null)
-            throw new IllegalArgumentException("password argument is null");
-
-        authenticated = am.authenticatePassword(user, password);
-        return authenticated;
-    }
-
-    /**
-     * After a successful connect, one has to authenticate oneself. This method
-     * can be used to explicitly use the special "none" authentication method
-     * (where only a username has to be specified).
-     * <p>
-     * Note 1: The "none" method may always be tried by clients, however as by
-     * the specs, the server will not explicitly announce it. In other words,
-     * the "none" token will never show up in the list returned by
-     * {@link #getRemainingAuthMethods(String)}.
-     * <p>
-     * Note 2: no matter which one of the authenticateWithXXX() methods you
-     * call, the library will always issue exactly one initial "none"
-     * authentication request to retrieve the initially allowed list of
-     * authentication methods by the server. Please read RFC 4252 for the
-     * details.
-     * <p>
-     * If the authentication phase is complete, <code>true</code> will be
-     * returned. If further authentication steps are needed, <code>false</code>
-     * is returned and one can retry by any other authentication method (use the
-     * <code>getRemainingAuthMethods</code> method to get a list of the
-     * remaining possible methods).
-     *
-     * @param user
-     * @return if the connection is now authenticated.
-     * @throws IOException
-     */
-
-    public synchronized boolean authenticateWithNone(String user) throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Connection is not established!");
-
-        if (authenticated)
-            throw new IllegalStateException("Connection is already authenticated!");
-
-        if (am == null)
-            am = new AuthenticationManager(tm);
-
-        if (cm == null)
-            cm = new ChannelManager(tm);
-
-        if (user == null)
-            throw new IllegalArgumentException("user argument is null");
-
-        /* Trigger the sending of the PacketUserauthRequestNone packet */
-        /* (if not already done) */
-        authenticated = am.authenticateNone(user);
-        return authenticated;
-    }
-
-    /**
-     * 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 =).
-     * <p>
-     * 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.
-     * <p>
-     * If the authentication phase is complete, <code>true</code> will be
-     * returned. If the server does not accept the request (or if further
-     * authentication steps are needed), <code>false</code> is returned and
-     * one can retry either by using this or any other authentication method
-     * (use the <code>getRemainingAuthMethods</code> method to get a list of
-     * the remaining possible methods).
-     * <p>
-     * 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.
-     *
-     * @param user
-     *            A <code>String</code> holding the username.
-     * @param pemPrivateKey
-     *            A <code>char[]</code> containing a DSA or RSA private key of
-     *            the user 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.
-     * @param password
-     *            If the PEM structure is encrypted ("Proc-Type: 4,ENCRYPTED")
-     *            then you must specify a password. Otherwise, this argument
-     *            will be ignored and can be set to <code>null</code>.
-     *
-     * @return whether the connection is now authenticated.
-     * @throws IOException
-     */
-
-    public synchronized boolean authenticateWithPublicKey(String user, char[] pemPrivateKey, String password)
-    throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Connection is not established!");
-
-        if (authenticated)
-            throw new IllegalStateException("Connection is already authenticated!");
-
-        if (am == null)
-            am = new AuthenticationManager(tm);
-
-        if (cm == null)
-            cm = new ChannelManager(tm);
-
-        if (user == null)
-            throw new IllegalArgumentException("user argument is null");
-
-        if (pemPrivateKey == null)
-            throw new IllegalArgumentException("pemPrivateKey argument is null");
-
-        authenticated = am.authenticatePublicKey(user, pemPrivateKey, password, getOrCreateSecureRND());
-        return authenticated;
-    }
-
-    /**
-     * 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 =).
-     * <p>
-     * If the authentication phase is complete, <code>true</code> will be
-     * returned. If the server does not accept the request (or if further
-     * authentication steps are needed), <code>false</code> is returned and
-     * one can retry either by using this or any other authentication method
-     * (use the <code>getRemainingAuthMethods</code> method to get a list of
-     * the remaining possible methods).
-     *
-     * @param user
-     *            A <code>String</code> holding the username.
-     * @param key
-     *            A <code>RSAPrivateKey</code> or <code>DSAPrivateKey</code>
-     *            containing a DSA or RSA private key of
-     *            the user in Trilead object format.
-     *
-     * @return whether the connection is now authenticated.
-     * @throws IOException
-     */
-
-    public synchronized boolean authenticateWithPublicKey(String user, KeyPair pair)
-    throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Connection is not established!");
-
-        if (authenticated)
-            throw new IllegalStateException("Connection is already authenticated!");
-
-        if (am == null)
-            am = new AuthenticationManager(tm);
-
-        if (cm == null)
-            cm = new ChannelManager(tm);
-
-        if (user == null)
-            throw new IllegalArgumentException("user argument is null");
-
-        if (pair == null)
-            throw new IllegalArgumentException("Key pair argument is null");
-
-        authenticated = am.authenticatePublicKey(user, pair, getOrCreateSecureRND());
-        return authenticated;
-    }
-
-    /**
-     * A convenience wrapper function which reads in a private key (PEM format,
-     * either DSA or RSA) and then calls
-     * <code>authenticateWithPublicKey(String, char[], String)</code>.
-     * <p>
-     * 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.
-     *
-     * @param user
-     *            A <code>String</code> holding the username.
-     * @param pemFile
-     *            A <code>File</code> object pointing to a file containing a
-     *            DSA or RSA private key of the user in OpenSSH key format (PEM,
-     *            you can't miss the "-----BEGIN DSA PRIVATE KEY-----" or
-     *            "-----BEGIN RSA PRIVATE KEY-----" tag).
-     * @param password
-     *            If the PEM file is encrypted then you must specify the
-     *            password. Otherwise, this argument will be ignored and can be
-     *            set to <code>null</code>.
-     *
-     * @return whether the connection is now authenticated.
-     * @throws IOException
-     */
-
-    public synchronized boolean authenticateWithPublicKey(String user, File pemFile, String password)
-    throws IOException {
-        if (pemFile == null)
-            throw new IllegalArgumentException("pemFile argument is null");
-
-        char[] buff = new char[256];
-        CharArrayWriter cw = new CharArrayWriter();
-        FileReader fr = new FileReader(pemFile);
-
-        while (true) {
-            int len = fr.read(buff);
-
-            if (len < 0)
-                break;
-
-            cw.write(buff, 0, len);
-        }
-
-        fr.close();
-        return authenticateWithPublicKey(user, cw.toCharArray(), password);
-    }
-
-    /**
-     * Add a {@link ConnectionMonitor} to this connection. Can be invoked at any
-     * time, but it is best to add connection monitors before invoking
-     * <code>connect()</code> 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.)
-     * <p>
-     * You can add as many monitors as you like.
-     *
-     * @see ConnectionMonitor
-     *
-     * @param cmon
-     *            An object implementing the <code>ConnectionMonitor</code>
-     *            interface.
-     */
-
-    public synchronized void addConnectionMonitor(ConnectionMonitor cmon) {
-        if (cmon == null)
-            throw new IllegalArgumentException("cmon argument is null");
-
-        connectionMonitors.addElement(cmon);
-
-        if (tm != null)
-            tm.setConnectionMonitors(connectionMonitors);
-    }
-
-    /**
-     * Controls whether compression is used on the link or not.
-     * <p>
-     * Note: This can only be called before connect()
-     * @param enabled whether to enable compression
-     * @throws IOException
-     */
-
-    public synchronized void setCompression(boolean enabled) throws IOException {
-        if (tm != null)
-            throw new IOException("Connection to " + hostname + " is already in connected state!");
-
-        compression = enabled;
-    }
-
-    /**
-     * 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.
-     */
-
-    public synchronized void close() {
-        Throwable t = new Throwable("Closed due to user request.");
-        close(t, false);
-    }
-
-    private void close(Throwable t, boolean hard) {
-        if (cm != null)
-            cm.closeAllChannels();
-
-        if (tm != null) {
-            tm.close(t, hard == false);
-            tm = null;
-        }
-
-        am = null;
-        cm = null;
-        authenticated = false;
-    }
-
-    /**
-     * Same as
-     * {@link #connect(ServerHostKeyVerifier, int, int) connect(null, 0, 0)}.
-     *
-     * @return see comments for the
-     *         {@link #connect(ServerHostKeyVerifier, int, int) connect(ServerHostKeyVerifier, int, int)}
-     *         method.
-     * @throws IOException
-     */
-
-    public synchronized ConnectionInfo connect() throws IOException {
-        return connect(null, 0, 0);
-    }
-
-    /**
-     * Same as
-     * {@link #connect(ServerHostKeyVerifier, int, int) connect(verifier, 0, 0)}.
-     *
-     * @return see comments for the
-     *         {@link #connect(ServerHostKeyVerifier, int, int) connect(ServerHostKeyVerifier, int, int)}
-     *         method.
-     * @throws IOException
-     */
-
-    public synchronized ConnectionInfo connect(ServerHostKeyVerifier verifier) throws IOException {
-        return connect(verifier, 0, 0);
-    }
-
-    /**
-     * Connect to the SSH-2 server and, as soon as the server has presented its
-     * host key, use the
-     * {@link ServerHostKeyVerifier#verifyServerHostKey(String, int, String,
-     * byte[]) ServerHostKeyVerifier.verifyServerHostKey()} method of the
-     * <code>verifier</code> to ask for permission to proceed. If
-     * <code>verifier</code> is <code>null</code>, 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).
-     * <p>
-     * 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).
-     * <p>
-     * 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).
-     * <p>
-     * Note 2: The {@link ServerHostKeyVerifier#verifyServerHostKey(String, int,
-     * String, byte[]) 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).
-     * <p>
-     * 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).
-     * <p>
-     * Note 4: If you want to re-use a connection object that was successfully
-     * connected, then you must call the {@link #close()} method before invoking
-     * <code>connect()</code> again.
-     *
-     * @param verifier
-     *            An object that implements the {@link ServerHostKeyVerifier}
-     *            interface. Pass <code>null</code> to accept any server host
-     *            key - NOT recommended.
-     *
-     * @param connectTimeout
-     *            Connect the underlying TCP socket to the server with the given
-     *            timeout value (non-negative, in milliseconds). Zero means no
-     *            timeout. If a proxy is being used (see
-     *            {@link #setProxyData(ProxyData)}), then this timeout is used
-     *            for the connection establishment to the proxy.
-     *
-     * @param kexTimeout
-     *            Timeout for complete connection establishment (non-negative,
-     *            in milliseconds). Zero means no timeout. The timeout counts
-     *            from the moment you invoke the connect() method and is
-     *            cancelled as soon as the first key-exchange round has
-     *            finished. It is possible that the timeout event will be fired
-     *            during the invocation of the <code>verifier</code> callback,
-     *            but it will only have an effect after the
-     *            <code>verifier</code> returns.
-     *
-     * @return A {@link ConnectionInfo} object containing the details of the
-     *         established connection.
-     *
-     * @throws IOException
-     *             If any problem occurs, e.g., the server's host key is not
-     *             accepted by the <code>verifier</code> or there is problem
-     *             during the initial crypto setup (e.g., the signature sent by
-     *             the server is wrong).
-     *             <p>
-     *             In case of a timeout (either connectTimeout or kexTimeout) a
-     *             SocketTimeoutException is thrown.
-     *             <p>
-     *             An exception may also be thrown if the connection was already
-     *             successfully connected (no matter if the connection broke in
-     *             the mean time) and you invoke <code>connect()</code> again
-     *             without having called {@link #close()} first.
-     *             <p>
-     *             If a HTTP proxy is being used and the proxy refuses the
-     *             connection, then a {@link HTTPProxyException} may be thrown,
-     *             which contains the details returned by the proxy. If the
-     *             proxy is buggy and does not return a proper HTTP response,
-     *             then a normal IOException is thrown instead.
-     */
-
-    public synchronized ConnectionInfo connect(ServerHostKeyVerifier verifier, int connectTimeout, int kexTimeout)
-    throws IOException {
-        final class TimeoutState {
-            boolean isCancelled = false;
-            boolean timeoutSocketClosed = false;
-        }
-
-        if (tm != null)
-            throw new IOException("Connection to " + hostname + " is already in connected state!");
-
-        if (connectTimeout < 0)
-            throw new IllegalArgumentException("connectTimeout must be non-negative!");
-
-        if (kexTimeout < 0)
-            throw new IllegalArgumentException("kexTimeout must be non-negative!");
-
-        final TimeoutState state = new TimeoutState();
-        tm = new TransportManager(hostname, port);
-        tm.setConnectionMonitors(connectionMonitors);
-
-        // Don't offer compression if not requested
-        if (!compression) {
-            cryptoWishList.c2s_comp_algos = new String[] { "none" };
-            cryptoWishList.s2c_comp_algos = new String[] { "none" };
-        }
-
-        /*
-         * Make sure that the runnable below will observe the new value of "tm"
-         * and "state" (the runnable will be executed in a different thread,
-         * which may be already running, that is why we need a memory barrier
-         * here). See also the comment in Channel.java if you are interested in
-         * the details.
-         *
-         * OKOK, this is paranoid since adding the runnable to the todo list of
-         * the TimeoutService will ensure that all writes have been flushed
-         * before the Runnable reads anything (there is a synchronized block in
-         * TimeoutService.addTimeoutHandler).
-         */
-
-        synchronized (tm) {
-            /* We could actually synchronize on anything. */
-        }
-
-        try {
-            TimeoutToken token = null;
-
-            if (kexTimeout > 0) {
-                final Runnable timeoutHandler = new Runnable() {
-                    public void run() {
-                        synchronized (state) {
-                            if (state.isCancelled)
-                                return;
-
-                            state.timeoutSocketClosed = true;
-                            tm.close(new SocketTimeoutException("The connect timeout expired"), false);
-                        }
-                    }
-                };
-                long timeoutHorizont = System.currentTimeMillis() + kexTimeout;
-                token = TimeoutService.addTimeoutHandler(timeoutHorizont, timeoutHandler);
-            }
-
-            try {
-                tm.initialize(cryptoWishList, verifier, dhgexpara, connectTimeout, getOrCreateSecureRND(), proxyData);
-            }
-            catch (SocketTimeoutException se) {
-                throw(SocketTimeoutException) new SocketTimeoutException(
-                    "The connect() operation on the socket timed out.").initCause(se);
-            }
-
-            tm.setTcpNoDelay(tcpNoDelay);
-            /* Wait until first KEX has finished */
-            ConnectionInfo ci = tm.getConnectionInfo(1);
-
-            /* Now try to cancel the timeout, if needed */
-
-            if (token != null) {
-                TimeoutService.cancelTimeoutHandler(token);
-
-                /* Were we too late? */
-
-                synchronized (state) {
-                    if (state.timeoutSocketClosed)
-                        throw new IOException("This exception will be replaced by the one below =)");
-
-                    /*
-                     * Just in case the "cancelTimeoutHandler" invocation came
-                     * just a little bit too late but the handler did not enter
-                     * the semaphore yet - we can still stop it.
-                     */
-                    state.isCancelled = true;
-                }
-            }
-
-            return ci;
-        }
-        catch (SocketTimeoutException ste) {
-            throw ste;
-        }
-        catch (IOException e1) {
-            /* This will also invoke any registered connection monitors */
-            close(new Throwable("There was a problem during connect."), false);
-
-            synchronized (state) {
-                /*
-                 * Show a clean exception, not something like "the socket is
-                 * closed!?!"
-                 */
-                if (state.timeoutSocketClosed)
-                    throw new SocketTimeoutException("The kexTimeout (" + kexTimeout + " ms) expired.");
-            }
-
-            /* Do not wrap a HTTPProxyException */
-            if (e1 instanceof HTTPProxyException)
-                throw e1;
-
-            throw(IOException) new IOException("There was a problem while connecting to " + hostname + ":" + port)
-            .initCause(e1);
-        }
-    }
-
-    /**
-     * Creates a new {@link LocalPortForwarder}. A
-     * <code>LocalPortForwarder</code> 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).
-     * <p>
-     * This method must only be called after one has passed successfully the
-     * authentication step. There is no limit on the number of concurrent
-     * forwardings.
-     *
-     * @param local_port
-     *            the local port the LocalPortForwarder shall bind to.
-     * @param host_to_connect
-     *            target address (IP or hostname)
-     * @param port_to_connect
-     *            target port
-     * @return A {@link LocalPortForwarder} object.
-     * @throws IOException
-     */
-
-    public synchronized LocalPortForwarder createLocalPortForwarder(int local_port, String host_to_connect,
-            int port_to_connect) throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Cannot forward ports, you need to establish a connection first.");
-
-        if (!authenticated)
-            throw new IllegalStateException("Cannot forward ports, connection is not authenticated.");
-
-        return new LocalPortForwarder(cm, local_port, host_to_connect, port_to_connect);
-    }
-
-    /**
-     * Creates a new {@link LocalPortForwarder}. A
-     * <code>LocalPortForwarder</code> 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).
-     * <p>
-     * This method must only be called after one has passed successfully the
-     * authentication step. There is no limit on the number of concurrent
-     * forwardings.
-     *
-     * @param addr
-     *            specifies the InetSocketAddress where the local socket shall
-     *            be bound to.
-     * @param host_to_connect
-     *            target address (IP or hostname)
-     * @param port_to_connect
-     *            target port
-     * @return A {@link LocalPortForwarder} object.
-     * @throws IOException
-     */
-
-    public synchronized LocalPortForwarder createLocalPortForwarder(InetSocketAddress addr, String host_to_connect,
-            int port_to_connect) throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Cannot forward ports, you need to establish a connection first.");
-
-        if (!authenticated)
-            throw new IllegalStateException("Cannot forward ports, connection is not authenticated.");
-
-        return new LocalPortForwarder(cm, addr, host_to_connect, port_to_connect);
-    }
-
-    /**
-     * Creates a new {@link LocalStreamForwarder}. A
-     * <code>LocalStreamForwarder</code> 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).
-     *
-     * @param host_to_connect
-     * @param port_to_connect
-     * @return A {@link LocalStreamForwarder} object.
-     * @throws IOException
-     */
-
-    public synchronized LocalStreamForwarder createLocalStreamForwarder(String host_to_connect, int port_to_connect)
-    throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Cannot forward, you need to establish a connection first.");
-
-        if (!authenticated)
-            throw new IllegalStateException("Cannot forward, connection is not authenticated.");
-
-        return new LocalStreamForwarder(cm, host_to_connect, port_to_connect);
-    }
-
-    /**
-     * Creates a new {@link DynamicPortForwarder}. A
-     * <code>DynamicPortForwarder</code> forwards TCP/IP connections that arrive
-     * at a local port via the secure tunnel to another host that is chosen via
-     * the SOCKS protocol.
-     * <p>
-     * This method must only be called after one has passed successfully the
-     * authentication step. There is no limit on the number of concurrent
-     * forwardings.
-     *
-     * @param local_port
-     * @return A {@link DynamicPortForwarder} object.
-     * @throws IOException
-     */
-
-    public synchronized DynamicPortForwarder createDynamicPortForwarder(int local_port) throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Cannot forward ports, you need to establish a connection first.");
-
-        if (!authenticated)
-            throw new IllegalStateException("Cannot forward ports, connection is not authenticated.");
-
-        return new DynamicPortForwarder(cm, local_port);
-    }
-
-    /**
-     * Creates a new {@link DynamicPortForwarder}. A
-     * <code>DynamicPortForwarder</code> forwards TCP/IP connections that arrive
-     * at a local port via the secure tunnel to another host that is chosen via
-     * the SOCKS protocol.
-     * <p>
-     * This method must only be called after one has passed successfully the
-     * authentication step. There is no limit on the number of concurrent
-     * forwardings.
-     *
-     * @param addr
-     *            specifies the InetSocketAddress where the local socket shall
-     *            be bound to.
-     * @return A {@link DynamicPortForwarder} object.
-     * @throws IOException
-     */
-
-    public synchronized DynamicPortForwarder createDynamicPortForwarder(InetSocketAddress addr) throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Cannot forward ports, you need to establish a connection first.");
-
-        if (!authenticated)
-            throw new IllegalStateException("Cannot forward ports, connection is not authenticated.");
-
-        return new DynamicPortForwarder(cm, addr);
-    }
-
-    /**
-     * Create a very basic {@link SCPClient} that can be used to copy files
-     * from/to the SSH-2 server.
-     * <p>
-     * Works only after one has passed successfully the authentication step.
-     * There is no limit on the number of concurrent SCP clients.
-     * <p>
-     * Note: This factory method will probably disappear in the future.
-     *
-     * @return A {@link SCPClient} object.
-     * @throws IOException
-     */
-
-    public synchronized SCPClient createSCPClient() throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Cannot create SCP client, you need to establish a connection first.");
-
-        if (!authenticated)
-            throw new IllegalStateException("Cannot create SCP client, connection is not authenticated.");
-
-        return new SCPClient(this);
-    }
-
-    /**
-     * 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.
-     * <p>
-     * 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.
-     */
-
-    public synchronized void forceKeyExchange() throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("You need to establish a connection first.");
-
-        tm.forceKeyExchange(cryptoWishList, dhgexpara);
-    }
-
-    /**
-     * Returns the hostname that was passed to the constructor.
-     *
-     * @return the hostname
-     */
-
-    public synchronized String getHostname() {
-        return hostname;
-    }
-
-    /**
-     * Returns the port that was passed to the constructor.
-     *
-     * @return the TCP port
-     */
-
-    public synchronized int getPort() {
-        return port;
-    }
-
-    /**
-     * Returns a {@link ConnectionInfo} object containing the details of the
-     * connection. Can be called as soon as the connection has been established
-     * (successfully connected).
-     *
-     * @return A {@link ConnectionInfo} object.
-     * @throws IOException
-     *             In case of any failure behind the scenes.
-     */
-
-    public synchronized ConnectionInfo getConnectionInfo() throws IOException {
-        if (tm == null)
-            throw new IllegalStateException(
-                "Cannot get details of connection, you need to establish a connection first.");
-
-        return tm.getConnectionInfo(1);
-    }
-
-    /**
-     * 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).
-     * <p>
-     * 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 by sending the initial "none" request). 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).
-     * <p>
-     * Note 2: the server may return method names that are not supported by this
-     * implementation.
-     * <p>
-     * After a successful authentication, this method must not be called
-     * anymore.
-     *
-     * @param user
-     *            A <code>String</code> holding the username.
-     *
-     * @return a (possibly emtpy) array holding authentication method names.
-     * @throws IOException
-     */
-
-    public synchronized String[] getRemainingAuthMethods(String user) throws IOException {
-        if (user == null)
-            throw new IllegalArgumentException("user argument may not be NULL!");
-
-        if (tm == null)
-            throw new IllegalStateException("Connection is not established!");
-
-        if (authenticated)
-            throw new IllegalStateException("Connection is already authenticated!");
-
-        if (am == null)
-            am = new AuthenticationManager(tm);
-
-        if (cm == null)
-            cm = new ChannelManager(tm);
-
-        return am.getRemainingMethods(user);
-    }
-
-    /**
-     * Determines if the authentication phase is complete. Can be called at any
-     * time.
-     *
-     * @return <code>true</code> if no further authentication steps are
-     *         needed.
-     */
-
-    public synchronized boolean isAuthenticationComplete() {
-        return authenticated;
-    }
-
-    /**
-     * 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.)
-     * <p>
-     * If you are interested in the details, then have a look at RFC4252.
-     *
-     * @return if the there was a failed authentication step and the last one
-     *         was marked as a "partial success".
-     */
-
-    public synchronized boolean isAuthenticationPartialSuccess() {
-        if (am == null)
-            return false;
-
-        return am.getPartialSuccess();
-    }
-
-    /**
-     * Checks if a specified authentication method is available. This method is
-     * actually just a wrapper for {@link #getRemainingAuthMethods(String)
-     * getRemainingAuthMethods()}.
-     *
-     * @param user
-     *            A <code>String</code> holding the username.
-     * @param method
-     *            An authentication method name (e.g., "publickey", "password",
-     *            "keyboard-interactive") as specified by the SSH-2 standard.
-     * @return if the specified authentication method is currently available.
-     * @throws IOException
-     */
-
-    public synchronized boolean isAuthMethodAvailable(String user, String method) throws IOException {
-        if (method == null)
-            throw new IllegalArgumentException("method argument may not be NULL!");
-
-        String methods[] = getRemainingAuthMethods(user);
-
-        for (int i = 0; i < methods.length; i++) {
-            if (methods[i].compareTo(method) == 0)
-                return true;
-        }
-
-        return false;
-    }
-
-    private final SecureRandom getOrCreateSecureRND() {
-        if (generator == null)
-            generator = new SecureRandom();
-
-        return generator;
-    }
-
-    /**
-     * Open a new {@link Session} on this connection. Works only after one has
-     * passed successfully the authentication step. There is no limit on the
-     * number of concurrent sessions.
-     *
-     * @return A {@link Session} object.
-     * @throws IOException
-     */
-
-    public synchronized Session openSession() throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("Cannot open session, you need to establish a connection first.");
-
-        if (!authenticated)
-            throw new IllegalStateException("Cannot open session, connection is not authenticated.");
-
-        return new Session(cm, getOrCreateSecureRND());
-    }
-
-    /**
-     * Send an SSH_MSG_IGNORE packet. This method will generate a random data
-     * attribute (length between 0 (invlusive) and 16 (exclusive) bytes,
-     * contents are random bytes).
-     * <p>
-     * This method must only be called once the connection is established.
-     *
-     * @throws IOException
-     */
-
-    public synchronized void sendIgnorePacket() throws IOException {
-        SecureRandom rnd = getOrCreateSecureRND();
-        byte[] data = new byte[rnd.nextInt(16)];
-        rnd.nextBytes(data);
-        sendIgnorePacket(data);
-    }
-
-    /**
-     * Send an SSH_MSG_IGNORE packet with the given data attribute.
-     * <p>
-     * This method must only be called once the connection is established.
-     *
-     * @throws IOException
-     */
-
-    public synchronized void sendIgnorePacket(byte[] data) throws IOException {
-        if (data == null)
-            throw new IllegalArgumentException("data argument must not be null.");
-
-        if (tm == null)
-            throw new IllegalStateException(
-                "Cannot send SSH_MSG_IGNORE packet, you need to establish a connection first.");
-
-        PacketIgnore pi = new PacketIgnore();
-        pi.setData(data);
-        tm.sendMessage(pi.getPayload());
-    }
-
-    /**
-     * Removes duplicates from a String array, keeps only first occurence of
-     * each element. Does not destroy order of elements; can handle nulls. Uses
-     * a very efficient O(N^2) algorithm =)
-     *
-     * @param list
-     *            a String array.
-     * @return a cleaned String array.
-     */
-    private String[] removeDuplicates(String[] list) {
-        if ((list == null) || (list.length < 2))
-            return list;
-
-        String[] list2 = new String[list.length];
-        int count = 0;
-
-        for (int i = 0; i < list.length; i++) {
-            boolean duplicate = false;
-            String element = list[i];
-
-            for (int j = 0; j < count; j++) {
-                if (((element == null) && (list2[j] == null)) || ((element != null) && (element.equals(list2[j])))) {
-                    duplicate = true;
-                    break;
-                }
-            }
-
-            if (duplicate)
-                continue;
-
-            list2[count++] = list[i];
-        }
-
-        if (count == list2.length)
-            return list2;
-
-        String[] tmp = new String[count];
-        System.arraycopy(list2, 0, tmp, 0, count);
-        return tmp;
-    }
-
-    /**
-     * Unless you know what you are doing, you will never need this.
-     *
-     * @param ciphers
-     */
-
-    public synchronized void setClient2ServerCiphers(String[] ciphers) {
-        if ((ciphers == null) || (ciphers.length == 0))
-            throw new IllegalArgumentException();
-
-        ciphers = removeDuplicates(ciphers);
-        BlockCipherFactory.checkCipherList(ciphers);
-        cryptoWishList.c2s_enc_algos = ciphers;
-    }
-
-    /**
-     * Unless you know what you are doing, you will never need this.
-     *
-     * @param macs
-     */
-
-    public synchronized void setClient2ServerMACs(String[] macs) {
-        if ((macs == null) || (macs.length == 0))
-            throw new IllegalArgumentException();
-
-        macs = removeDuplicates(macs);
-        MAC.checkMacList(macs);
-        cryptoWishList.c2s_mac_algos = macs;
-    }
-
-    /**
-     * 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 {@link DHGexParameters} class.
-     *
-     * @param dgp
-     *            {@link DHGexParameters}, non null.
-     *
-     */
-
-    public synchronized void setDHGexParameters(DHGexParameters dgp) {
-        if (dgp == null)
-            throw new IllegalArgumentException();
-
-        dhgexpara = dgp;
-    }
-
-    /**
-     * Unless you know what you are doing, you will never need this.
-     *
-     * @param ciphers
-     */
-
-    public synchronized void setServer2ClientCiphers(String[] ciphers) {
-        if ((ciphers == null) || (ciphers.length == 0))
-            throw new IllegalArgumentException();
-
-        ciphers = removeDuplicates(ciphers);
-        BlockCipherFactory.checkCipherList(ciphers);
-        cryptoWishList.s2c_enc_algos = ciphers;
-    }
-
-    /**
-     * Unless you know what you are doing, you will never need this.
-     *
-     * @param macs
-     */
-
-    public synchronized void setServer2ClientMACs(String[] macs) {
-        if ((macs == null) || (macs.length == 0))
-            throw new IllegalArgumentException();
-
-        macs = removeDuplicates(macs);
-        MAC.checkMacList(macs);
-        cryptoWishList.s2c_mac_algos = macs;
-    }
-
-    /**
-     * Define the set of allowed server host key algorithms to be used for the
-     * following key exchange operations.
-     * <p>
-     * Unless you know what you are doing, you will never need this.
-     *
-     * @param algos
-     *            An array of allowed server host key algorithms. SSH-2 defines
-     *            <code>ssh-dss</code> and <code>ssh-rsa</code>. The
-     *            entries of the array must be ordered after preference, i.e.,
-     *            the entry at index 0 is the most preferred one. You must
-     *            specify at least one entry.
-     */
-
-    public synchronized void setServerHostKeyAlgorithms(String[] algos) {
-        if ((algos == null) || (algos.length == 0))
-            throw new IllegalArgumentException();
-
-        algos = removeDuplicates(algos);
-        KexManager.checkServerHostkeyAlgorithmsList(algos);
-        cryptoWishList.serverHostKeyAlgorithms = algos;
-    }
-
-    /**
-     * Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm) on the
-     * underlying socket.
-     * <p>
-     * 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 <code>false</code>.
-     *
-     * @param enable
-     *            the argument passed to the <code>Socket.setTCPNoDelay()</code>
-     *            method.
-     * @throws IOException
-     */
-
-    public synchronized void setTCPNoDelay(boolean enable) throws IOException {
-        tcpNoDelay = enable;
-
-        if (tm != null)
-            tm.setTcpNoDelay(enable);
-    }
-
-    /**
-     * 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 {@link #connect() connect()} method.
-     * <p>
-     * At the moment, only HTTP proxies are supported.
-     * <p>
-     * Note: This method can be called any number of times. The
-     * {@link #connect() connect()} method will use the value set in the last
-     * preceding invocation of this method.
-     *
-     * @see HTTPProxyData
-     *
-     * @param proxyData
-     *            Connection information about the proxy. If <code>null</code>,
-     *            then no proxy will be used (non surprisingly, this is also the
-     *            default).
-     */
-
-    public synchronized void setProxyData(ProxyData proxyData) {
-        this.proxyData = proxyData;
-    }
-
-    /**
-     * 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
-     * {@link #cancelRemotePortForwarding(int) cancelRemotePortForwarding()}.
-     * <p>
-     * A call of this method will block until the peer either agreed or
-     * disagreed to your request-
-     * <p>
-     * Note 1: this method typically fails if you
-     * <ul>
-     * <li>pass a port number for which the used remote user has not enough
-     * permissions (i.e., port &lt; 1024)</li>
-     * <li>or pass a port number that is already in use on the remote server</li>
-     * <li>or if remote port forwarding is disabled on the server.</li>
-     * </ul>
-     * <p>
-     * 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 <b>GatewayPorts</b> option is enabled
-     * (see sshd_config(5)).
-     *
-     * @param bindAddress
-     *            address to bind to on the server:
-     *            <ul>
-     *            <li>"" means that connections are to be accepted on all
-     *            protocol families supported by the SSH implementation</li>
-     *            <li>"0.0.0.0" means to listen on all IPv4 addresses</li>
-     *            <li>"::" means to listen on all IPv6 addresses</li>
-     *            <li>"localhost" means to listen on all protocol families
-     *            supported by the SSH implementation on loopback addresses
-     *            only, [RFC3330] and RFC3513]</li>
-     *            <li>"127.0.0.1" and "::1" indicate listening on the loopback
-     *            interfaces for IPv4 and IPv6 respectively</li>
-     *            </ul>
-     * @param bindPort
-     *            port number to bind on the server (must be &gt; 0)
-     * @param targetAddress
-     *            the target address (IP or hostname)
-     * @param targetPort
-     *            the target port
-     * @throws IOException
-     */
-
-    public synchronized void requestRemotePortForwarding(String bindAddress, int bindPort, String targetAddress,
-            int targetPort) throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("You need to establish a connection first.");
-
-        if (!authenticated)
-            throw new IllegalStateException("The connection is not authenticated.");
-
-        if ((bindAddress == null) || (targetAddress == null) || (bindPort <= 0) || (targetPort <= 0))
-            throw new IllegalArgumentException();
-
-        cm.requestGlobalForward(bindAddress, bindPort, targetAddress, targetPort);
-    }
-
-    /**
-     * 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.
-     *
-     * @param bindPort
-     *            the allocated port number on the server
-     * @throws IOException
-     *             if the remote side refuses the cancel request or another low
-     *             level error occurs (e.g., the underlying connection is
-     *             closed)
-     */
-
-    public synchronized void cancelRemotePortForwarding(int bindPort) throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("You need to establish a connection first.");
-
-        if (!authenticated)
-            throw new IllegalStateException("The connection is not authenticated.");
-
-        cm.requestCancelGlobalForward(bindPort);
-    }
-
-    /**
-     * Provide your own instance of SecureRandom. Can be used, e.g., if you want
-     * to seed the used SecureRandom generator manually.
-     * <p>
-     * The SecureRandom instance is used during key exchanges, public key
-     * authentication, x11 cookie generation and the like.
-     *
-     * @param rnd
-     *            a SecureRandom instance
-     */
-
-    public synchronized void setSecureRandom(SecureRandom rnd) {
-        if (rnd == null)
-            throw new IllegalArgumentException();
-
-        this.generator = rnd;
-    }
-
-    /**
-     * Enable/disable debug logging. <b>Only do this when requested by Trilead
-     * support.</b>
-     * <p>
-     * For speed reasons, some static variables used to check whether debugging
-     * is enabled are not protected with locks. In other words, if you
-     * dynamicaly enable/disable debug logging, then some threads may still use
-     * the old setting. To be on the safe side, enable debugging before doing
-     * the <code>connect()</code> call.
-     *
-     * @param enable
-     *            on/off
-     * @param logger
-     *            a {@link DebugLogger DebugLogger} instance, <code>null</code>
-     *            means logging using the simple logger which logs all messages
-     *            to to stderr. Ignored if enabled is <code>false</code>
-     */
-
-    public synchronized void enableDebugging(boolean enable, DebugLogger logger) {
-        Logger.enabled = enable;
-
-        if (enable == false) {
-            Logger.logger = null;
-        }
-        else {
-            if (logger == null) {
-                logger = new DebugLogger() {
-                    public void log(int level, String className, String message) {
-                        long now = System.currentTimeMillis();
-                        System.err.println(now + " : " + className + ": " + message);
-                    }
-                };
-            }
-
-            Logger.logger = logger;
-        }
-    }
-
-    /**
-     * This method can be used to perform end-to-end connection testing. It
-     * sends a 'ping' message to the server and waits for the 'pong' from the
-     * server.
-     * <p>
-     * When this method throws an exception, then you can assume that the
-     * connection should be abandoned.
-     * <p>
-     * Note: Works only after one has passed successfully the authentication
-     * step.
-     * <p>
-     * Implementation details: this method sends a SSH_MSG_GLOBAL_REQUEST
-     * request ('trilead-ping') to the server and waits for the
-     * SSH_MSG_REQUEST_FAILURE reply packet from the server.
-     *
-     * @throws IOException
-     *             in case of any problem
-     */
-
-    public synchronized void ping() throws IOException {
-        if (tm == null)
-            throw new IllegalStateException("You need to establish a connection first.");
-
-        if (!authenticated)
-            throw new IllegalStateException("The connection is not authenticated.");
-
-        cm.requestGlobalTrileadPing();
-    }
-}

--- a/src/com/trilead/ssh2/ConnectionInfo.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,52 +0,0 @@
-
-package com.trilead.ssh2;
-
-/**
- * In most cases you probably do not need the information contained in here.
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: ConnectionInfo.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
- */
-public class ConnectionInfo {
-    /**
-     * The used key exchange (KEX) algorithm in the latest key exchange.
-     */
-    public String keyExchangeAlgorithm;
-
-    /**
-     * The currently used crypto algorithm for packets from to the client to the
-     * server.
-     */
-    public String clientToServerCryptoAlgorithm;
-    /**
-     * The currently used crypto algorithm for packets from to the server to the
-     * client.
-     */
-    public String serverToClientCryptoAlgorithm;
-
-    /**
-     * The currently used MAC algorithm for packets from to the client to the
-     * server.
-     */
-    public String clientToServerMACAlgorithm;
-    /**
-     * The currently used MAC algorithm for packets from to the server to the
-     * client.
-     */
-    public String serverToClientMACAlgorithm;
-
-    /**
-     * The type of the server host key (currently either "ssh-dss" or
-     * "ssh-rsa").
-     */
-    public String serverHostKeyAlgorithm;
-    /**
-     * The server host key that was sent during the latest key exchange.
-     */
-    public byte[] serverHostKey;
-
-    /**
-     * Number of kex exchanges performed on this connection so far.
-     */
-    public int keyExchangeCounter = 0;
-}

--- a/src/com/trilead/ssh2/ConnectionMonitor.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,33 +0,0 @@
-
-package com.trilead.ssh2;
-
-/**
- * A <code>ConnectionMonitor</code> is used to get notified when the
- * underlying socket of a connection is closed.
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: ConnectionMonitor.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
- */
-
-public interface ConnectionMonitor {
-    /**
-     * This method is called after the connection's underlying
-     * socket has been closed. E.g., due to the {@link Connection#close()} request of the
-     * user, if the peer closed the connection, due to a fatal error during connect()
-     * (also if the socket cannot be established) or if a fatal error occured on
-     * an established connection.
-     * <p>
-     * This is an experimental feature.
-     * <p>
-     * You MUST NOT make any assumption about the thread that invokes this method.
-     * <p>
-     * <b>Please note: if the connection is not connected (e.g., there was no successful
-     * connect() call), then the invocation of {@link Connection#close()} will NOT trigger
-     * this method.</b>
-     *
-     * @see Connection#addConnectionMonitor(ConnectionMonitor)
-     *
-     * @param reason Includes an indication why the socket was closed.
-     */
-    public void connectionLost(Throwable reason);
-}
\ No newline at end of file

--- a/src/com/trilead/ssh2/DHGexParameters.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,114 +0,0 @@
-
-package com.trilead.ssh2;
-
-/**
- * A <code>DHGexParameters</code> object can be used to specify parameters for
- * the diffie-hellman group exchange.
- * <p>
- * Depending on which constructor is used, either the use of a
- * <code>SSH_MSG_KEX_DH_GEX_REQUEST</code> or <code>SSH_MSG_KEX_DH_GEX_REQUEST_OLD</code>
- * can be forced.
- *
- * @see Connection#setDHGexParameters(DHGexParameters)
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: DHGexParameters.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
- */
-
-public class DHGexParameters {
-    private final int min_group_len;
-    private final int pref_group_len;
-    private final int max_group_len;
-
-    private static final int MIN_ALLOWED = 1024;
-    private static final int MAX_ALLOWED = 8192;
-
-    /**
-     * Same as calling {@link #DHGexParameters(int, int, int) DHGexParameters(1024, 1024, 4096)}.
-     * This is also the default used by the Connection class.
-     *
-     */
-    public DHGexParameters() {
-        this(1024, 1024, 4096);
-    }
-
-    /**
-     * This constructor can be used to force the sending of a
-     * <code>SSH_MSG_KEX_DH_GEX_REQUEST_OLD</code> request.
-     * Internally, the minimum and maximum group lengths will
-     * be set to zero.
-     *
-     * @param pref_group_len has to be &gt= 1024 and &lt;= 8192
-     */
-    public DHGexParameters(int pref_group_len) {
-        if ((pref_group_len < MIN_ALLOWED) || (pref_group_len > MAX_ALLOWED))
-            throw new IllegalArgumentException("pref_group_len out of range!");
-
-        this.pref_group_len = pref_group_len;
-        this.min_group_len = 0;
-        this.max_group_len = 0;
-    }
-
-    /**
-     * This constructor can be used to force the sending of a
-     * <code>SSH_MSG_KEX_DH_GEX_REQUEST</code> request.
-     * <p>
-     * Note: older OpenSSH servers don't understand this request, in which
-     * case you should use the {@link #DHGexParameters(int)} constructor.
-     * <p>
-     * All values have to be &gt= 1024 and &lt;= 8192. Furthermore,
-     * min_group_len &lt;= pref_group_len &lt;= max_group_len.
-     *
-     * @param min_group_len
-     * @param pref_group_len
-     * @param max_group_len
-     */
-    public DHGexParameters(int min_group_len, int pref_group_len, int max_group_len) {
-        if ((min_group_len < MIN_ALLOWED) || (min_group_len > MAX_ALLOWED))
-            throw new IllegalArgumentException("min_group_len out of range!");
-
-        if ((pref_group_len < MIN_ALLOWED) || (pref_group_len > MAX_ALLOWED))
-            throw new IllegalArgumentException("pref_group_len out of range!");
-
-        if ((max_group_len < MIN_ALLOWED) || (max_group_len > MAX_ALLOWED))
-            throw new IllegalArgumentException("max_group_len out of range!");
-
-        if ((pref_group_len < min_group_len) || (pref_group_len > max_group_len))
-            throw new IllegalArgumentException("pref_group_len is incompatible with min and max!");
-
-        if (max_group_len < min_group_len)
-            throw new IllegalArgumentException("max_group_len must not be smaller than min_group_len!");
-
-        this.min_group_len = min_group_len;
-        this.pref_group_len = pref_group_len;
-        this.max_group_len = max_group_len;
-    }
-
-    /**
-     * Get the maximum group length.
-     *
-     * @return the maximum group length, may be <code>zero</code> if
-     *         SSH_MSG_KEX_DH_GEX_REQUEST_OLD should be requested
-     */
-    public int getMax_group_len() {
-        return max_group_len;
-    }
-
-    /**
-     * Get the minimum group length.
-     *
-     * @return minimum group length, may be <code>zero</code> if
-     *         SSH_MSG_KEX_DH_GEX_REQUEST_OLD should be requested
-     */
-    public int getMin_group_len() {
-        return min_group_len;
-    }
-
-    /**
-     * Get the preferred group length.
-     *
-     * @return the preferred group length
-     */
-    public int getPref_group_len() {
-        return pref_group_len;
-    }
-}

--- a/src/com/trilead/ssh2/DebugLogger.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-package com.trilead.ssh2;
-
-/**
- * An interface which needs to be implemented if you
- * want to capture debugging messages.
- *
- * @see Connection#enableDebugging(boolean, DebugLogger)
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: DebugLogger.java,v 1.1 2008/03/03 07:01:36 cplattne Exp $
- */
-public interface DebugLogger {
-
-    /**
-     * Log a debug message.
-     *
-     * @param level 0-99, 99 is a the most verbose level
-     * @param className the class that generated the message
-     * @param message the debug message
-     */
-    public void log(int level, String className, String message);
-}

--- a/src/com/trilead/ssh2/DynamicPortForwarder.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,63 +0,0 @@
-/*
- * ConnectBot: simple, powerful, open-source SSH client for Android
- * Copyright 2007 Kenny Root, Jeffrey Sharkey
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.trilead.ssh2;
-
-import java.io.IOException;
-import java.net.InetSocketAddress;
-
-import com.trilead.ssh2.channel.ChannelManager;
-import com.trilead.ssh2.channel.DynamicAcceptThread;
-
-/**
- * A <code>DynamicPortForwarder</code> forwards TCP/IP connections to a local
- * port via the secure tunnel to another host which is selected via the
- * SOCKS protocol. Checkout {@link Connection#createDynamicPortForwarder(int)}
- * on how to create one.
- *
- * @author Kenny Root
- * @version $Id: $
- */
-public class DynamicPortForwarder {
-    ChannelManager cm;
-
-    DynamicAcceptThread dat;
-
-    DynamicPortForwarder(ChannelManager cm, int local_port)
-    throws IOException {
-        this.cm = cm;
-        dat = new DynamicAcceptThread(cm, local_port);
-        dat.setDaemon(true);
-        dat.start();
-    }
-
-    DynamicPortForwarder(ChannelManager cm, InetSocketAddress addr) throws IOException {
-        this.cm = cm;
-        dat = new DynamicAcceptThread(cm, addr);
-        dat.setDaemon(true);
-        dat.start();
-    }
-
-    /**
-     * Stop TCP/IP forwarding of newly arriving connections.
-     *
-     * @throws IOException
-     */
-    public void close() throws IOException {
-        dat.stopWorking();
-    }
-}

--- a/src/com/trilead/ssh2/HTTPProxyData.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,79 +0,0 @@
-
-package com.trilead.ssh2;
-
-/**
- * A <code>HTTPProxyData</code> object is used to specify the needed connection data
- * to connect through a HTTP proxy.
- *
- * @see Connection#setProxyData(ProxyData)
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: HTTPProxyData.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
- */
-
-public class HTTPProxyData implements ProxyData {
-    public final String proxyHost;
-    public final int proxyPort;
-    public final String proxyUser;
-    public final String proxyPass;
-    public final String[] requestHeaderLines;
-
-    /**
-     * Same as calling {@link #HTTPProxyData(String, int, String, String) HTTPProxyData(proxyHost, proxyPort, <code>null</code>, <code>null</code>)}
-     *
-     * @param proxyHost Proxy hostname.
-     * @param proxyPort Proxy port.
-     */
-    public HTTPProxyData(String proxyHost, int proxyPort) {
-        this(proxyHost, proxyPort, null, null);
-    }
-
-    /**
-     * Same as calling {@link #HTTPProxyData(String, int, String, String, String[]) HTTPProxyData(proxyHost, proxyPort, <code>null</code>, <code>null</code>, <code>null</code>)}
-     *
-     * @param proxyHost Proxy hostname.
-     * @param proxyPort Proxy port.
-     * @param proxyUser Username for basic authentication (<code>null</code> if no authentication is needed).
-     * @param proxyPass Password for basic authentication (<code>null</code> if no authentication is needed).
-     */
-    public HTTPProxyData(String proxyHost, int proxyPort, String proxyUser, String proxyPass) {
-        this(proxyHost, proxyPort, proxyUser, proxyPass, null);
-    }
-
-    /**
-     * Connection data for a HTTP proxy. It is possible to specify a username and password
-     * if the proxy requires basic authentication. Also, additional request header lines can
-     * be specified (e.g., "User-Agent: CERN-LineMode/2.15 libwww/2.17b3").
-     * <p>
-     * Please note: if you want to use basic authentication, then both <code>proxyUser</code>
-     * and <code>proxyPass</code> must be non-null.
-     * <p>
-     * Here is an example:
-     * <p>
-     * <code>
-     * new HTTPProxyData("192.168.1.1", "3128", "proxyuser", "secret", new String[] {"User-Agent: TrileadBasedClient/1.0", "X-My-Proxy-Option: something"});
-     * </code>
-     *
-     * @param proxyHost Proxy hostname.
-     * @param proxyPort Proxy port.
-     * @param proxyUser Username for basic authentication (<code>null</code> if no authentication is needed).
-     * @param proxyPass Password for basic authentication (<code>null</code> if no authentication is needed).
-     * @param requestHeaderLines An array with additional request header lines (without end-of-line markers)
-     *        that have to be sent to the server. May be <code>null</code>.
-     */
-
-    public HTTPProxyData(String proxyHost, int proxyPort, String proxyUser, String proxyPass,
-                         String[] requestHeaderLines) {
-        if (proxyHost == null)
-            throw new IllegalArgumentException("proxyHost must be non-null");
-
-        if (proxyPort < 0)
-            throw new IllegalArgumentException("proxyPort must be non-negative");
-
-        this.proxyHost = proxyHost;
-        this.proxyPort = proxyPort;
-        this.proxyUser = proxyUser;
-        this.proxyPass = proxyPass;
-        this.requestHeaderLines = requestHeaderLines;
-    }
-}

--- a/src/com/trilead/ssh2/HTTPProxyException.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,27 +0,0 @@
-
-package com.trilead.ssh2;
-
-import java.io.IOException;
-
-/**
- * May be thrown upon connect() if a HTTP proxy is being used.
- *
- * @see Connection#connect()
- * @see Connection#setProxyData(ProxyData)
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: HTTPProxyException.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
- */
-
-public class HTTPProxyException extends IOException {
-    private static final long serialVersionUID = 2241537397104426186L;
-
-    public final String httpResponse;
-    public final int httpErrorCode;
-
-    public HTTPProxyException(String httpResponse, int httpErrorCode) {
-        super("HTTP Proxy Error (" + httpErrorCode + " " + httpResponse + ")");
-        this.httpResponse = httpResponse;
-        this.httpErrorCode = httpErrorCode;
-    }
-}

--- a/src/com/trilead/ssh2/InteractiveCallback.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,54 +0,0 @@
-
-package com.trilead.ssh2;
-
-/**
- * An <code>InteractiveCallback</code> is used to respond to challenges sent
- * by the server if authentication mode "keyboard-interactive" is selected.
- *
- * @see Connection#authenticateWithKeyboardInteractive(String,
- *      String[], InteractiveCallback)
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: InteractiveCallback.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
- */
-
-public interface InteractiveCallback {
-    /**
-     * This callback interface is used during a "keyboard-interactive"
-     * authentication. Every time the server sends a set of challenges (however,
-     * most often just one challenge at a time), this callback function will be
-     * called to give your application a chance to talk to the user and to
-     * determine the response(s).
-     * <p>
-     * Some copy-paste information from the standard: a command line interface
-     * (CLI) client SHOULD print the name and instruction (if non-empty), adding
-     * newlines. Then for each prompt in turn, the client SHOULD display the
-     * prompt and read the user input. The name and instruction fields MAY be
-     * empty strings, the client MUST be prepared to handle this correctly. The
-     * prompt field(s) MUST NOT be empty strings.
-     * <p>
-     * Please refer to draft-ietf-secsh-auth-kbdinteract-XX.txt for the details.
-     * <p>
-     * Note: clients SHOULD use control character filtering as discussed in
-     * RFC4251 to avoid attacks by including
-     * terminal control characters in the fields to be displayed.
-     *
-     * @param name
-     *            the name String sent by the server.
-     * @param instruction
-     *            the instruction String sent by the server.
-     * @param numPrompts
-     *            number of prompts - may be zero (in this case, you should just
-     *            return a String array of length zero).
-     * @param prompt
-     *            an array (length <code>numPrompts</code>) of Strings
-     * @param echo
-     *            an array (length <code>numPrompts</code>) of booleans. For
-     *            each prompt, the corresponding echo field indicates whether or
-     *            not the user input should be echoed as characters are typed.
-     * @return an array of reponses - the array size must match the parameter
-     *         <code>numPrompts</code>.
-     */
-    public String[] replyToChallenge(String name, String instruction, int numPrompts, String[] prompt, boolean[] echo)
-    throws Exception;
-}

--- a/src/com/trilead/ssh2/KnownHosts.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,759 +0,0 @@
-
-package com.trilead.ssh2;
-
-import java.io.BufferedReader;
-import java.io.CharArrayReader;
-import java.io.CharArrayWriter;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.io.UnsupportedEncodingException;
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.security.InvalidKeyException;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.security.PublicKey;
-import java.security.SecureRandom;
-import java.security.interfaces.DSAPublicKey;
-import java.security.interfaces.ECPublicKey;
-import java.security.interfaces.RSAPublicKey;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Locale;
-import java.util.Vector;
-
-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
-
-import com.trilead.ssh2.crypto.Base64;
-import com.trilead.ssh2.signature.DSASHA1Verify;
-import com.trilead.ssh2.signature.ECDSASHA2Verify;
-import com.trilead.ssh2.signature.RSASHA1Verify;
-
-
-/**
- * The <code>KnownHosts</code> class is a handy tool to verify received server hostkeys
- * based on the information in <code>known_hosts</code> files (the ones used by OpenSSH).
- * <p>
- * It offers basically an in-memory database for known_hosts entries, as well as some
- * helper functions. Entries from a <code>known_hosts</code> file can be loaded at construction time.
- * It is also possible to add more keys later (e.g., one can parse different
- * <code>known_hosts<code> files).
- * <p>
- * It is a thread safe implementation, therefore, you need only to instantiate one
- * <code>KnownHosts</code> for your whole application.
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: KnownHosts.java,v 1.2 2008/04/01 12:38:09 cplattne Exp $
- */
-
-public class KnownHosts {
-    public static final int HOSTKEY_IS_OK = 0;
-    public static final int HOSTKEY_IS_NEW = 1;
-    public static final int HOSTKEY_HAS_CHANGED = 2;
-
-    private class KnownHostsEntry {
-        String[] patterns;
-        PublicKey key;
-
-        KnownHostsEntry(String[] patterns, PublicKey key) {
-            this.patterns = patterns;
-            this.key = key;
-        }
-    }
-
-    private LinkedList<KnownHostsEntry> publicKeys = new LinkedList<KnownHostsEntry>();
-
-    public KnownHosts() {
-    }
-
-    public KnownHosts(char[] knownHostsData) throws IOException {
-        initialize(knownHostsData);
-    }
-
-    public KnownHosts(File knownHosts) throws IOException {
-        initialize(knownHosts);
-    }
-
-    /**
-     * Adds a single public key entry to the database. Note: this will NOT add the public key
-     * to any physical file (e.g., "~/.ssh/known_hosts") - use <code>addHostkeyToFile()</code> for that purpose.
-     * This method is designed to be used in a {@link ServerHostKeyVerifier}.
-     *
-     * @param hostnames a list of hostname patterns - at least one most be specified. Check out the
-     *        OpenSSH sshd man page for a description of the pattern matching algorithm.
-     * @param serverHostKeyAlgorithm as passed to the {@link ServerHostKeyVerifier}.
-     * @param serverHostKey as passed to the {@link ServerHostKeyVerifier}.
-     * @throws IOException
-     */
-    public void addHostkey(String hostnames[], String serverHostKeyAlgorithm, byte[] serverHostKey) throws IOException {
-        if (hostnames == null)
-            throw new IllegalArgumentException("hostnames may not be null");
-
-        if ("ssh-rsa".equals(serverHostKeyAlgorithm)) {
-            RSAPublicKey rpk = RSASHA1Verify.decodeSSHRSAPublicKey(serverHostKey);
-
-            synchronized (publicKeys) {
-                publicKeys.add(new KnownHostsEntry(hostnames, rpk));
-            }
-        }
-        else if ("ssh-dss".equals(serverHostKeyAlgorithm)) {
-            DSAPublicKey dpk = DSASHA1Verify.decodeSSHDSAPublicKey(serverHostKey);
-
-            synchronized (publicKeys) {
-                publicKeys.add(new KnownHostsEntry(hostnames, dpk));
-            }
-        }
-        else if (serverHostKeyAlgorithm.startsWith(ECDSASHA2Verify.ECDSA_SHA2_PREFIX)) {
-            ECPublicKey epk = ECDSASHA2Verify.decodeSSHECDSAPublicKey(serverHostKey);
-
-            synchronized (publicKeys) {
-                publicKeys.add(new KnownHostsEntry(hostnames, epk));
-            }
-        }
-        else
-            throw new IOException("Unknwon host key type (" + serverHostKeyAlgorithm + ")");
-    }
-
-    /**
-     * Parses the given known_hosts data and adds entries to the database.
-     *
-     * @param knownHostsData
-     * @throws IOException
-     */
-    public void addHostkeys(char[] knownHostsData) throws IOException {
-        initialize(knownHostsData);
-    }
-
-    /**
-     * Parses the given known_hosts file and adds entries to the database.
-     *
-     * @param knownHosts
-     * @throws IOException
-     */
-    public void addHostkeys(File knownHosts) throws IOException {
-        initialize(knownHosts);
-    }
-
-    /**
-     * Generate the hashed representation of the given hostname. Useful for adding entries
-     * with hashed hostnames to a known_hosts file. (see -H option of OpenSSH key-gen).
-     *
-     * @param hostname
-     * @return the hashed representation, e.g., "|1|cDhrv7zwEUV3k71CEPHnhHZezhA=|Xo+2y6rUXo2OIWRAYhBOIijbJMA="
-     */
-    public static final String createHashedHostname(String hostname) {
-        MessageDigest sha1;
-
-        try {
-            sha1 = MessageDigest.getInstance("SHA1");
-        }
-        catch (NoSuchAlgorithmException e) {
-            throw new RuntimeException("VM doesn't support SHA1", e);
-        }
-
-        byte[] salt = new byte[sha1.getDigestLength()];
-        new SecureRandom().nextBytes(salt);
-        byte[] hash = hmacSha1Hash(salt, hostname);
-        String base64_salt = new String(Base64.encode(salt));
-        String base64_hash = new String(Base64.encode(hash));
-        return new String("|1|" + base64_salt + "|" + base64_hash);
-    }
-
-    private static final byte[] hmacSha1Hash(byte[] salt, String hostname) {
-        Mac hmac;
-
-        try {
-            hmac = Mac.getInstance("HmacSHA1");
-
-            if (salt.length != hmac.getMacLength())
-                throw new IllegalArgumentException("Salt has wrong length (" + salt.length + ")");
-
-            hmac.init(new SecretKeySpec(salt, "HmacSHA1"));
-        }
-        catch (NoSuchAlgorithmException e) {
-            throw new RuntimeException("Unable to HMAC-SHA1", e);
-        }
-        catch (InvalidKeyException e) {
-            throw new RuntimeException("Unable to create SecretKey", e);
-        }
-
-        try {
-            hmac.update(hostname.getBytes("ISO-8859-1"));
-        }
-        catch (UnsupportedEncodingException ignore) {
-            /* Actually, ISO-8859-1 is supported by all correct
-             * Java implementations. But... you never know. */
-            hmac.update(hostname.getBytes());
-        }
-
-        return hmac.doFinal();
-    }
-
-    private final boolean checkHashed(String entry, String hostname) {
-        if (entry.startsWith("|1|") == false)
-            return false;
-
-        int delim_idx = entry.indexOf('|', 3);
-
-        if (delim_idx == -1)
-            return false;
-
-        String salt_base64 = entry.substring(3, delim_idx);
-        String hash_base64 = entry.substring(delim_idx + 1);
-        byte[] salt = null;
-        byte[] hash = null;
-
-        try {
-            salt = Base64.decode(salt_base64.toCharArray());
-            hash = Base64.decode(hash_base64.toCharArray());
-        }
-        catch (IOException e) {
-            return false;
-        }
-
-        try {
-            MessageDigest sha1 = MessageDigest.getInstance("SHA1");
-
-            if (salt.length != sha1.getDigestLength())
-                return false;
-        }
-        catch (NoSuchAlgorithmException e) {
-            throw new RuntimeException("VM does not support SHA1", e);
-        }
-
-        byte[] dig = hmacSha1Hash(salt, hostname);
-
-        for (int i = 0; i < dig.length; i++)
-            if (dig[i] != hash[i])
-                return false;
-
-        return true;
-    }
-
-    private int checkKey(String remoteHostname, PublicKey remoteKey) {
-        int result = HOSTKEY_IS_NEW;
-
-        synchronized (publicKeys) {
-            Iterator<KnownHostsEntry> i = publicKeys.iterator();
-
-            while (i.hasNext()) {
-                KnownHostsEntry ke = i.next();
-
-                if (hostnameMatches(ke.patterns, remoteHostname) == false)
-                    continue;
-
-                boolean res = matchKeys(ke.key, remoteKey);
-
-                if (res == true)
-                    return HOSTKEY_IS_OK;
-
-                result = HOSTKEY_HAS_CHANGED;
-            }
-        }
-
-        return result;
-    }
-
-    private Vector<PublicKey> getAllKeys(String hostname) {
-        Vector<PublicKey> keys = new Vector<PublicKey>();
-
-        synchronized (publicKeys) {
-            Iterator<KnownHostsEntry> i = publicKeys.iterator();
-
-            while (i.hasNext()) {
-                KnownHostsEntry ke = i.next();
-
-                if (hostnameMatches(ke.patterns, hostname) == false)
-                    continue;
-
-                keys.addElement(ke.key);
-            }
-        }
-
-        return keys;
-    }
-
-    /**
-     * Try to find the preferred order of hostkey algorithms for the given hostname.
-     * Based on the type of hostkey that is present in the internal database
-     * (i.e., either <code>ssh-rsa</code> or <code>ssh-dss</code>)
-     * an ordered list of hostkey algorithms is returned which can be passed
-     * to <code>Connection.setServerHostKeyAlgorithms</code>.
-     *
-     * @param hostname
-     * @return <code>null</code> if no key for the given hostname is present or
-     * there are keys of multiple types present for the given hostname. Otherwise,
-     * an array with hostkey algorithms is returned (i.e., an array of length 2).
-     */
-    public String[] getPreferredServerHostkeyAlgorithmOrder(String hostname) {
-        String[] algos = recommendHostkeyAlgorithms(hostname);
-
-        if (algos != null)
-            return algos;
-
-        InetAddress[] ipAdresses = null;
-
-        try {
-            ipAdresses = InetAddress.getAllByName(hostname);
-        }
-        catch (UnknownHostException e) {
-            return null;
-        }
-
-        for (int i = 0; i < ipAdresses.length; i++) {
-            algos = recommendHostkeyAlgorithms(ipAdresses[i].getHostAddress());
-
-            if (algos != null)
-                return algos;
-        }
-
-        return null;
-    }
-
-    private final boolean hostnameMatches(String[] hostpatterns, String hostname) {
-        boolean isMatch = false;
-        boolean negate = false;
-        hostname = hostname.toLowerCase(Locale.US);
-
-        for (int k = 0; k < hostpatterns.length; k++) {
-            if (hostpatterns[k] == null)
-                continue;
-
-            String pattern = null;
-
-            /* In contrast to OpenSSH we also allow negated hash entries (as well as hashed
-             * entries in lines with multiple entries).
-             */
-
-            if ((hostpatterns[k].length() > 0) && (hostpatterns[k].charAt(0) == '!')) {
-                pattern = hostpatterns[k].substring(1);
-                negate = true;
-            }
-            else {
-                pattern = hostpatterns[k];
-                negate = false;
-            }
-
-            /* Optimize, no need to check this entry */
-
-            if ((isMatch) && (negate == false))
-                continue;
-
-            /* Now compare */
-
-            if (pattern.charAt(0) == '|') {
-                if (checkHashed(pattern, hostname)) {
-                    if (negate)
-                        return false;
-
-                    isMatch = true;
-                }
-            }
-            else {
-                pattern = pattern.toLowerCase(Locale.US);
-
-                if ((pattern.indexOf('?') != -1) || (pattern.indexOf('*') != -1)) {
-                    if (pseudoRegex(pattern.toCharArray(), 0, hostname.toCharArray(), 0)) {
-                        if (negate)
-                            return false;
-
-                        isMatch = true;
-                    }
-                }
-                else if (pattern.compareTo(hostname) == 0) {
-                    if (negate)
-                        return false;
-
-                    isMatch = true;
-                }
-            }
-        }
-
-        return isMatch;
-    }
-
-    private void initialize(char[] knownHostsData) throws IOException {
-        BufferedReader br = new BufferedReader(new CharArrayReader(knownHostsData));
-
-        while (true) {
-            String line = br.readLine();
-
-            if (line == null)
-                break;
-
-            line = line.trim();
-
-            if (line.startsWith("#"))
-                continue;
-
-            String[] arr = line.split(" ");
-
-            if (arr.length >= 3) {
-                if ((arr[1].compareTo("ssh-rsa") == 0) || (arr[1].compareTo("ssh-dss") == 0)) {
-                    String[] hostnames = arr[0].split(",");
-                    byte[] msg = Base64.decode(arr[2].toCharArray());
-                    addHostkey(hostnames, arr[1], msg);
-                }
-            }
-        }
-    }
-
-    private void initialize(File knownHosts) throws IOException {
-        char[] buff = new char[512];
-        CharArrayWriter cw = new CharArrayWriter();
-        knownHosts.createNewFile();
-        FileReader fr = new FileReader(knownHosts);
-
-        while (true) {
-            int len = fr.read(buff);
-
-            if (len < 0)
-                break;
-
-            cw.write(buff, 0, len);
-        }
-
-        fr.close();
-        initialize(cw.toCharArray());
-    }
-
-    private final boolean matchKeys(PublicKey key1, PublicKey key2) {
-        return key1.equals(key2);
-    }
-
-    private final boolean pseudoRegex(char[] pattern, int i, char[] match, int j) {
-        /* This matching logic is equivalent to the one present in OpenSSH 4.1 */
-        while (true) {
-            /* Are we at the end of the pattern? */
-            if (pattern.length == i)
-                return (match.length == j);
-
-            if (pattern[i] == '*') {
-                i++;
-
-                if (pattern.length == i)
-                    return true;
-
-                if ((pattern[i] != '*') && (pattern[i] != '?')) {
-                    while (true) {
-                        if ((pattern[i] == match[j]) && pseudoRegex(pattern, i + 1, match, j + 1))
-                            return true;
-
-                        j++;
-
-                        if (match.length == j)
-                            return false;
-                    }
-                }
-
-                while (true) {
-                    if (pseudoRegex(pattern, i, match, j))
-                        return true;
-
-                    j++;
-
-                    if (match.length == j)
-                        return false;
-                }
-            }
-
-            if (match.length == j)
-                return false;
-
-            if ((pattern[i] != '?') && (pattern[i] != match[j]))
-                return false;
-
-            i++;
-            j++;
-        }
-    }
-
-    private String[] recommendHostkeyAlgorithms(String hostname) {
-        String preferredAlgo = null;
-        Vector<PublicKey> keys = getAllKeys(hostname);
-
-        for (int i = 0; i < keys.size(); i++) {
-            String thisAlgo = null;
-
-            if (keys.elementAt(i) instanceof RSAPublicKey)
-                thisAlgo = "ssh-rsa";
-            else if (keys.elementAt(i) instanceof DSAPublicKey)
-                thisAlgo = "ssh-dss";
-            else
-                continue;
-
-            if (preferredAlgo != null) {
-                /* If we find different key types, then return null */
-                if (preferredAlgo.compareTo(thisAlgo) != 0)
-                    return null;
-
-                /* OK, we found the same algo again, optimize */
-                continue;
-            }
-        }
-
-        /* If we did not find anything that we know of, return null */
-
-        if (preferredAlgo == null)
-            return null;
-
-        /* Now put the preferred algo to the start of the array.
-         * You may ask yourself why we do it that way - basically, we could just
-         * return only the preferred algorithm: since we have a saved key of that
-         * type (sent earlier from the remote host), then that should work out.
-         * However, imagine that the server is (for whatever reasons) not offering
-         * that type of hostkey anymore (e.g., "ssh-rsa" was disabled and
-         * now "ssh-dss" is being used). If we then do not let the server send us
-         * a fresh key of the new type, then we shoot ourself into the foot:
-         * the connection cannot be established and hence the user cannot decide
-         * if he/she wants to accept the new key.
-         */
-
-        if (preferredAlgo.equals("ssh-rsa"))
-            return new String[] { "ssh-rsa", "ssh-dss" };
-
-        return new String[] { "ssh-dss", "ssh-rsa" };
-    }
-
-    /**
-     * Checks the internal hostkey database for the given hostkey.
-     * If no matching key can be found, then the hostname is resolved to an IP address
-     * and the search is repeated using that IP address.
-     *
-     * @param hostname the server's hostname, will be matched with all hostname patterns
-     * @param serverHostKeyAlgorithm type of hostkey, either <code>ssh-rsa</code> or <code>ssh-dss</code>
-     * @param serverHostKey the key blob
-     * @return <ul>
-     *         <li><code>HOSTKEY_IS_OK</code>: the given hostkey matches an entry for the given hostname</li>
-     *         <li><code>HOSTKEY_IS_NEW</code>: no entries found for this hostname and this type of hostkey</li>
-     *         <li><code>HOSTKEY_HAS_CHANGED</code>: hostname is known, but with another key of the same type
-     *         (man-in-the-middle attack?)</li>
-     *         </ul>
-     * @throws IOException if the supplied key blob cannot be parsed or does not match the given hostkey type.
-     */
-    public int verifyHostkey(String hostname, String serverHostKeyAlgorithm, byte[] serverHostKey) throws IOException {
-        PublicKey remoteKey = null;
-
-        if ("ssh-rsa".equals(serverHostKeyAlgorithm)) {
-            remoteKey = RSASHA1Verify.decodeSSHRSAPublicKey(serverHostKey);
-        }
-        else if ("ssh-dss".equals(serverHostKeyAlgorithm)) {
-            remoteKey = DSASHA1Verify.decodeSSHDSAPublicKey(serverHostKey);
-        }
-        else if (serverHostKeyAlgorithm.startsWith("ecdsa-sha2-")) {
-            remoteKey = ECDSASHA2Verify.decodeSSHECDSAPublicKey(serverHostKey);
-        }
-        else
-            throw new IllegalArgumentException("Unknown hostkey type " + serverHostKeyAlgorithm);
-
-        int result = checkKey(hostname, remoteKey);
-
-        if (result == HOSTKEY_IS_OK)
-            return result;
-
-        InetAddress[] ipAdresses = null;
-
-        try {
-            ipAdresses = InetAddress.getAllByName(hostname);
-        }
-        catch (UnknownHostException e) {
-            return result;
-        }
-
-        for (int i = 0; i < ipAdresses.length; i++) {
-            int newresult = checkKey(ipAdresses[i].getHostAddress(), remoteKey);
-
-            if (newresult == HOSTKEY_IS_OK)
-                return newresult;
-
-            if (newresult == HOSTKEY_HAS_CHANGED)
-                result = HOSTKEY_HAS_CHANGED;
-        }
-
-        return result;
-    }
-
-    /**
-     * Adds a single public key entry to the a known_hosts file.
-     * This method is designed to be used in a {@link ServerHostKeyVerifier}.
-     *
-     * @param knownHosts the file where the publickey entry will be appended.
-     * @param hostnames a list of hostname patterns - at least one most be specified. Check out the
-     *        OpenSSH sshd man page for a description of the pattern matching algorithm.
-     * @param serverHostKeyAlgorithm as passed to the {@link ServerHostKeyVerifier}.
-     * @param serverHostKey as passed to the {@link ServerHostKeyVerifier}.
-     * @throws IOException
-     */
-    public final static void addHostkeyToFile(File knownHosts, String[] hostnames, String serverHostKeyAlgorithm,
-            byte[] serverHostKey) throws IOException {
-        if ((hostnames == null) || (hostnames.length == 0))
-            throw new IllegalArgumentException("Need at least one hostname specification");
-
-        if ((serverHostKeyAlgorithm == null) || (serverHostKey == null))
-            throw new IllegalArgumentException();
-
-        CharArrayWriter writer = new CharArrayWriter();
-
-        for (int i = 0; i < hostnames.length; i++) {
-            if (i != 0)
-                writer.write(',');
-
-            writer.write(hostnames[i]);
-        }
-
-        writer.write(' ');
-        writer.write(serverHostKeyAlgorithm);
-        writer.write(' ');
-        writer.write(Base64.encode(serverHostKey));
-        writer.write("\n");
-        char[] entry = writer.toCharArray();
-        RandomAccessFile raf = new RandomAccessFile(knownHosts, "rw");
-        long len = raf.length();
-
-        if (len > 0) {
-            raf.seek(len - 1);
-            int last = raf.read();
-
-            if (last != '\n')
-                raf.write('\n');
-        }
-
-        raf.write(new String(entry).getBytes("ISO-8859-1"));
-        raf.close();
-    }
-
-    /**
-     * Generates a "raw" fingerprint of a hostkey.
-     *
-     * @param type either "md5" or "sha1"
-     * @param keyType either "ssh-rsa" or "ssh-dss"
-     * @param hostkey the hostkey
-     * @return the raw fingerprint
-     */
-    static final private byte[] rawFingerPrint(String type, String keyType, byte[] hostkey) {
-        MessageDigest dig = null;
-
-        try {
-            if ("md5".equals(type)) {
-                dig = MessageDigest.getInstance("MD5");
-            }
-            else if ("sha1".equals(type)) {
-                dig = MessageDigest.getInstance("SHA1");
-            }
-            else {
-                throw new IllegalArgumentException("Unknown hash type " + type);
-            }
-        }
-        catch (NoSuchAlgorithmException e) {
-            throw new IllegalArgumentException("Unknown hash type " + type);
-        }
-
-        if (keyType.startsWith("ecdsa-sha2-")) {
-        }
-        else if ("ssh-rsa".equals(keyType)) {
-        }
-        else if ("ssh-dss".equals(keyType)) {
-        }
-        else
-            throw new IllegalArgumentException("Unknown key type " + keyType);
-
-        if (hostkey == null)
-            throw new IllegalArgumentException("hostkey is null");
-
-        dig.update(hostkey);
-        return dig.digest();
-    }
-
-    /**
-     * Convert a raw fingerprint to hex representation (XX:YY:ZZ...).
-     * @param fingerprint raw fingerprint
-     * @return the hex representation
-     */
-    static final private String rawToHexFingerprint(byte[] fingerprint) {
-        final char[] alpha = "0123456789abcdef".toCharArray();
-        StringBuffer sb = new StringBuffer();
-
-        for (int i = 0; i < fingerprint.length; i++) {
-            if (i != 0)
-                sb.append(':');
-
-            int b = fingerprint[i] & 0xff;
-            sb.append(alpha[b >> 4]);
-            sb.append(alpha[b & 15]);
-        }
-
-        return sb.toString();
-    }
-
-    /**
-     * Convert a raw fingerprint to bubblebabble representation.
-     * @param raw raw fingerprint
-     * @return the bubblebabble representation
-     */
-    static final private String rawToBubblebabbleFingerprint(byte[] raw) {
-        final char[] v = "aeiouy".toCharArray();
-        final char[] c = "bcdfghklmnprstvzx".toCharArray();
-        StringBuffer sb = new StringBuffer();
-        int seed = 1;
-        int rounds = (raw.length / 2) + 1;
-        sb.append('x');
-
-        for (int i = 0; i < rounds; i++) {
-            if (((i + 1) < rounds) || ((raw.length) % 2 != 0)) {
-                sb.append(v[(((raw[2 * i] >> 6) & 3) + seed) % 6]);
-                sb.append(c[(raw[2 * i] >> 2) & 15]);
-                sb.append(v[((raw[2 * i] & 3) + (seed / 6)) % 6]);
-
-                if ((i + 1) < rounds) {
-                    sb.append(c[(((raw[(2 * i) + 1])) >> 4) & 15]);
-                    sb.append('-');
-                    sb.append(c[(((raw[(2 * i) + 1]))) & 15]);
-                    // As long as seed >= 0, seed will be >= 0 afterwards
-                    seed = ((seed * 5) + (((raw[2 * i] & 0xff) * 7) + (raw[(2 * i) + 1] & 0xff))) % 36;
-                }
-            }
-            else {
-                sb.append(v[seed % 6]); // seed >= 0, therefore index positive
-                sb.append('x');
-                sb.append(v[seed / 6]);
-            }
-        }
-
-        sb.append('x');
-        return sb.toString();
-    }
-
-    /**
-     * Convert a ssh2 key-blob into a human readable hex fingerprint.
-     * Generated fingerprints are identical to those generated by OpenSSH.
-     * <p>
-     * Example fingerprint: d0:cb:76:19:99:5a:03:fc:73:10:70:93:f2:44:63:47.
-
-     * @param keytype either "ssh-rsa" or "ssh-dss"
-     * @param publickey key blob
-     * @return Hex fingerprint
-     */
-    public final static String createHexFingerprint(String keytype, byte[] publickey) {
-        byte[] raw = rawFingerPrint("md5", keytype, publickey);
-        return rawToHexFingerprint(raw);
-    }
-
-    /**
-     * Convert a ssh2 key-blob into a human readable bubblebabble fingerprint.
-     * The used bubblebabble algorithm (taken from OpenSSH) generates fingerprints
-     * that are easier to remember for humans.
-     * <p>
-     * Example fingerprint: xofoc-bubuz-cazin-zufyl-pivuk-biduk-tacib-pybur-gonar-hotat-lyxux.
-     *
-     * @param keytype either "ssh-rsa" or "ssh-dss"
-     * @param publickey key data
-     * @return Bubblebabble fingerprint
-     */
-    public final static String createBubblebabbleFingerprint(String keytype, byte[] publickey) {
-        byte[] raw = rawFingerPrint("sha1", keytype, publickey);
-        return rawToBubblebabbleFingerprint(raw);
-    }
-}

--- a/src/com/trilead/ssh2/LocalPortForwarder.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,57 +0,0 @@
-
-package com.trilead.ssh2;
-
-import java.io.IOException;
-import java.net.InetSocketAddress;
-
-import com.trilead.ssh2.channel.ChannelManager;
-import com.trilead.ssh2.channel.LocalAcceptThread;
-
-
-/**
- * A <code>LocalPortForwarder</code> forwards TCP/IP connections to a local
- * port via the secure tunnel to another host (which may or may not be identical
- * to the remote SSH-2 server). Checkout {@link Connection#createLocalPortForwarder(int, String, int)}
- * on how to create one.
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: LocalPortForwarder.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
- */
-public class LocalPortForwarder {
-    ChannelManager cm;
-
-    String host_to_connect;
-
-    int port_to_connect;
-
-    LocalAcceptThread lat;
-
-    LocalPortForwarder(ChannelManager cm, int local_port, String host_to_connect, int port_to_connect)
-    throws IOException {
-        this.cm = cm;
-        this.host_to_connect = host_to_connect;
-        this.port_to_connect = port_to_connect;
-        lat = new LocalAcceptThread(cm, local_port, host_to_connect, port_to_connect);
-        lat.setDaemon(true);
-        lat.start();
-    }
-
-    LocalPortForwarder(ChannelManager cm, InetSocketAddress addr, String host_to_connect, int port_to_connect)
-    throws IOException {
-        this.cm = cm;
-        this.host_to_connect = host_to_connect;
-        this.port_to_connect = port_to_connect;
-        lat = new LocalAcceptThread(cm, addr, host_to_connect, port_to_connect);
-        lat.setDaemon(true);
-        lat.start();
-    }
-
-    /**
-     * Stop TCP/IP forwarding of newly arriving connections.
-     *
-     * @throws IOException
-     */
-    public void close() throws IOException {
-        lat.stopWorking();
-    }
-}

--- a/src/com/trilead/ssh2/LocalStreamForwarder.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,72 +0,0 @@
-
-package com.trilead.ssh2;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-
-import com.trilead.ssh2.channel.Channel;
-import com.trilead.ssh2.channel.ChannelManager;
-import com.trilead.ssh2.channel.LocalAcceptThread;
-
-
-/**
- * A <code>LocalStreamForwarder</code> forwards an Input- and Outputstream
- * pair via the secure tunnel to another host (which may or may not be identical
- * to the remote SSH-2 server).
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: LocalStreamForwarder.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
- */
-public class LocalStreamForwarder {
-    ChannelManager cm;
-
-    String host_to_connect;
-    int port_to_connect;
-    LocalAcceptThread lat;
-
-    Channel cn;
-
-    LocalStreamForwarder(ChannelManager cm, String host_to_connect, int port_to_connect) throws IOException {
-        this.cm = cm;
-        this.host_to_connect = host_to_connect;
-        this.port_to_connect = port_to_connect;
-        cn = cm.openDirectTCPIPChannel(host_to_connect, port_to_connect, "127.0.0.1", 0);
-    }
-
-    /**
-     * @return An <code>InputStream</code> object.
-     * @throws IOException
-     */
-    public InputStream getInputStream() throws IOException {
-        return cn.getStdoutStream();
-    }
-
-    /**
-     * Get the OutputStream. Please be aware that the implementation MAY use an
-     * internal buffer. To make sure that the buffered data is sent over the
-     * tunnel, you have to call the <code>flush</code> method of the
-     * <code>OutputStream</code>. To signal EOF, please use the
-     * <code>close</code> method of the <code>OutputStream</code>.
-     *
-     * @return An <code>OutputStream</code> object.
-     * @throws IOException
-     */
-    public OutputStream getOutputStream() throws IOException {
-        return cn.getStdinStream();
-    }
-
-    /**
-     * Close the underlying SSH forwarding channel and free up resources.
-     * You can also use this method to force the shutdown of the underlying
-     * forwarding channel. Pending output (OutputStream not flushed) will NOT
-     * be sent. Pending input (InputStream) can still be read. If the shutdown
-     * operation is already in progress (initiated from either side), then this
-     * call is a no-op.
-     *
-     * @throws IOException
-     */
-    public void close() throws IOException {
-        cm.closeChannel(cn, "Closed due to user request.", true);
-    }
-}

--- a/src/com/trilead/ssh2/ProxyData.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,14 +0,0 @@
-
-package com.trilead.ssh2;
-
-/**
- * An abstract marker interface implemented by all proxy data implementations.
- *
- * @see HTTPProxyData
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: ProxyData.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
- */
-
-public abstract interface ProxyData {
-}

--- a/src/com/trilead/ssh2/SCPClient.java	Thu Jul 31 15:53:40 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,644 +0,0 @@
-
-package com.trilead.ssh2;
-
-import java.io.BufferedInputStream;
-import java.io.BufferedOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-
-/**
- * A very basic <code>SCPClient</code> that can be used to copy files from/to
- * the SSH-2 server. On the server side, the "scp" program must be in the PATH.
- * <p>
- * This scp client is thread safe - you can download (and upload) different sets
- * of files concurrently without any troubles. The <code>SCPClient</code> is
- * actually mapping every request to a distinct {@link Session}.
- *
- * @author Christian Plattner, plattner@trilead.com
- * @version $Id: SCPClient.java,v 1.2 2008/04/01 12:38:09 cplattne Exp $
- */
-
-public class SCPClient {
-    Connection conn;
-
-    class LenNamePair {
-        long length;
-        String filename;
-    }
-
-    public SCPClient(Connection conn) {
-        if (conn == null)
-            throw new IllegalArgumentException("Cannot accept null argument!");
-
-        this.conn = conn;
-    }
-
-    private void readResponse(InputStream is) throws IOException {
-        int c = is.read();
-
-        if (c == 0)
-            return;
-
-        if (c == -1)
-            throw new IOException("Remote scp terminated unexpectedly.");
-
-        if ((c != 1) && (c != 2))
-            throw new IOException("Remote scp sent illegal error code.");
-
-        if (c == 2)
-            throw new IOException("Remote scp terminated with error.");
-
-        String err = receiveLine(is);
-        throw new IOException("Remote scp terminated with error (" + err + ").");
-    }
-
-    private String receiveLine(InputStream is) throws IOException {
-        StringBuffer sb = new StringBuffer(30);
-
-        while (true) {
-            /*
-             * This is a random limit - if your path names are longer, then
-             * adjust it
-             */
-            if (sb.length() > 8192)
-                throw new IOException("Remote scp sent a too long line");
-
-            int c = is.read();
-
-            if (c < 0)
-                throw new IOException("Remote scp terminated unexpectedly.");
-
-            if (c == '\n')
-                break;
-
-            sb.append((char) c);
-        }
-
-        return sb.toString();
-    }
-
-    private LenNamePair parseCLine(String line) throws IOException {
-        /* Minimum line: "xxxx y z" ---> 8 chars */
-        long len;
-
-        if (line.length() < 8)
-            throw new IOException("Malformed C line sent by remote SCP binary, line too short.");
-
-        if ((line.charAt(4) != ' ') || (line.charAt(5) == ' '))
-            throw new IOException("Malformed C line sent by remote SCP binary.");
-
-        int length_name_sep = line.indexOf(' ', 5);
-
-        if (length_name_sep == -1)
-            throw new IOException("Malformed C line sent by remote SCP binary.");
-
-        String length_substring = line.substring(5, length_name_sep);
-        String name_substring = line.substring(length_name_sep + 1);
-
-        if ((length_substring.length() <= 0) || (name_substring.length() <= 0))
-            throw new IOException("Malformed C line sent by remote SCP binary.");
-
-        if ((6 + length_substring.length() + name_substring.length()) != line.length())
-            throw new IOException("Malformed C line sent by remote SCP binary.");
-
-        try {
-            len = Long.parseLong(length_substring);
-        }
-        catch (NumberFormatException e) {
-            throw new IOException("Malformed C line sent by remote SCP binary, cannot parse file length.");
-        }
-
-        if (len < 0)
-            throw new IOException("Malformed C line sent by remote SCP binary, illegal file length.");
-
-        LenNamePair lnp = new LenNamePair();
-        lnp.length = len;
-        lnp.filename = name_substring;
-        return lnp;
-    }
-
-    private void sendBytes(Session sess, byte[] data, String fileName, String mode) throws IOException {
-        OutputStream os = sess.getStdin();
-        InputStream is = new BufferedInputStream(sess.getStdout(), 512);
-        readResponse(is);
-        String cline = "C" + mode + " " + data.length + " " + fileName + "\n";
-        os.write(cline.getBytes("ISO-8859-1"));
-        os.flush();
-        readResponse(is);
-        os.write(data, 0, data.length);
-        os.write(0);
-        os.flush();
-        readResponse(is);
-        os.write("E\n".getBytes("ISO-8859-1"));
-        os.flush();
-    }
-
-    private void sendFiles(Session sess, String[] files, String[] remoteFiles, String mode) throws IOException {
-        byte[] buffer = new byte[8192];
-        OutputStream os = new BufferedOutputStream(sess.getStdin(), 40000);
-        InputStream is = new BufferedInputStream(sess.getStdout(), 512);
-        readResponse(is);
-
-        for (int i = 0; i < files.length; i++) {
-            File f = new File(files[i]);
-            long remain = f.length();
-            String remoteName;
-
-            if ((remoteFiles != null) && (remoteFiles.length > i) && (remoteFiles[i] != null))
-                remoteName = remoteFiles[i];
-            else
-                remoteName = f.getName();
-
-            String cline = "C" + mode + " " + remain + " " + remoteName + "\n";
-            os.write(cline.getBytes("ISO-8859-1"));
-            os.flush();
-            readResponse(is);
-            FileInputStream fis = null;
-
-            try {
-                fis = new FileInputStream(f);
-
-                while (remain > 0) {
-                    int trans;
-
-                    if (remain > buffer.length)
-                        trans = buffer.length;
-                    else
-                        trans = (int) remain;
-
-                    if (fis.read(buffer, 0, trans) != trans)
-                        throw new IOException("Cannot read enough from local file " + files[i]);
-
-                    os.write(buffer, 0, trans);
-                    remain -= trans;
-                }
-            }
-            finally {
-                if (fis != null)
-                    fis.close();
-            }
-
-            os.write(0);
-            os.flush();
-            readResponse(is);
-        }
-
-        os.write("E\n".getBytes("ISO-8859-1"));
-        os.flush();
-    }
-
-    private void receiveFiles(Session sess, OutputStream[] targets) throws IOException {
-        byte[] buffer = new byte[8192];
-        OutputStream os = new BufferedOutputStream(sess.getStdin(), 512);
-        InputStream is = new BufferedInputStream(sess.getStdout(), 40000);
-        os.write(0x0);
-        os.flush();
-
-        for (int i = 0; i < targets.length; i++) {
-            LenNamePair lnp = null;
-
-            while (true) {
-                int c = is.read();
-
-                if (c < 0)
-                    throw new IOException("Remote scp terminated unexpectedly.");
-
-                String line = receiveLine(is);
-
-                if (c == 'T') {
-                    /* Ignore modification times */
-                    continue;
-                }
-
-                if ((c == 1) || (c == 2))
-                    throw new IOException("Remote SCP error: " + line);
-
-                if (c == 'C') {
-                    lnp = parseCLine(line);
-                    break;
-                }
-
-                throw new IOException("Remote SCP error: " + ((char) c) + line);
-            }
-
-            os.write(0x0);
-            os.flush();
-            long remain = lnp.length;
-
-            while (remain > 0) {
-                int trans;
-
-                if (remain > buffer.length)
-                    trans = buffer.length;
-                else
-                    trans = (int) remain;
-
-                int this_time_received = is.read(buffer, 0, trans);
-
-                if (this_time_received < 0) {
-                    throw new IOException("Remote scp terminated connection unexpectedly");
-                }
-
-                targets[i].write(buffer, 0, this_time_received);
-                remain -= this_time_received;
-            }
-
-            readResponse(is);
-            os.write(0x0);
-            os.flush();
-        }
-    }
-
-    private void receiveFiles(Session sess, String[] files, String target) throws IOException {
-        byte[] buffer = new byte[8192];
-        OutputStream os = new BufferedOutputStream(sess.getStdin(), 512);
-        InputStream is = new BufferedInputStream(sess.getStdout(), 40000);
-        os.write(0x0);
-        os.flush();
-
-        for (int i = 0; i < files.length; i++) {
-            LenNamePair lnp = null;
-
-            while (true) {
-                int c = is.read();
-
-                if (c < 0)
-                    throw new IOException("Remote scp terminated unexpectedly.");
-
-                String line = receiveLine(is);
-
-                if (c == 'T') {
-                    /* Ignore modification times */
-                    continue;
-                }
-
-                if ((c == 1) || (c == 2))
-                    throw new IOException("Remote SCP error: " + line);
-
-                if (c == 'C') {
-                    lnp = parseCLine(line);
-                    break;
-                }
-
-                throw new IOException("Remote SCP error: " + ((char) c) + line);
-            }
-
-            os.write(0x0);
-            os.flush();
-            File f = new File(target + File.separatorChar + lnp.filename);
-            FileOutputStream fop = null;
-
-            try {
-                fop = new FileOutputStream(f);
-                long remain = lnp.length;
-
-                while (remain > 0) {
-                    int trans;
-
-                    if (remain > buffer.length)
-                        trans = buffer.length;
-                    else
-                        trans = (int) remain;
-
-                    int this_time_received = is.read(buffer, 0, trans);
-
-                    if (this_time_received < 0) {
-                        throw new IOException("Remote scp terminated connection unexpectedly");
-                    }
-
-                    fop.write(buffer, 0, this_time_received);
-                    remain -= this_time_received;
-                }
-            }
-            finally {
-                if (fop != null)
-                    fop.close();
-            }
-
-            readResponse(is);
-            os.write(0x0);
-            os.flush();
-        }
-    }
-
-    /**
-     * Copy a local file to a remote directory, uses mode 0600 when creating the
-     * file on the remote side.
-     *
-     * @param localFile
-     *            Path and name of local file.
-     * @param remoteTargetDirectory
-     *            Remote target directory. Use an empty string to specify the
-     *            default directory.
-     *
-     * @throws IOException
-     */
-    public void put(String localFile, String remoteTargetDirectory) throws IOException {
-        put(new String[] { localFile }, remoteTargetDirectory, "0600");
-    }
-
-    /**
-     * Copy a set of local files to a remote directory, uses mode 0600 when
-     * creating files on the remote side.
-     *
-     * @param localFiles
-     *            Paths and names of local file names.
-     * @param remoteTargetDirectory
-     *            Remote target directory. Use an empty string to specify the
-     *            default directory.
-     *
-     * @throws IOException
-     */
-
-    public void put(String[] localFiles, String remoteTargetDirectory) throws IOException {
-        put(localFiles, remoteTargetDirectory, "0600");
-    }
-
-    /**
-     * Copy a local file to a remote directory, uses the specified mode when
-     * creating the file on the remote side.
-     *
-     * @param localFile
-     *            Path and name of local file.
-     * @param remoteTargetDirectory
-     *            Remote target directory. Use an empty string to specify the
-     *            default directory.
-     * @param mode
-     *            a four digit string (e.g., 0644, see "man chmod", "man open")
-     * @throws IOException
-     */
-    public void put(String localFile, String remoteTargetDirectory, String mode) throws IOException {
-        put(new String[] { localFile }, remoteTargetDirectory, mode);
-    }
-
-    /**
-     * Copy a local file to a remote directory, uses the specified mode and
-     * remote filename when creating the file on the remote side.
-     *
-     * @param localFile
-     *            Path and name of local file.
-     * @param remoteFileName
-     *            The name of the file which will be created in the remote
-     *            target directory.
-     * @param remoteTargetDirectory
-     *            Remote target directory. Use an empty string to specify the
-     *            default directory.
-     * @param mode
-     *            a four digit string (e.g., 0644, see "man chmod", "man open")
-     * @throws IOException
-     */
-    public void put(String localFile, String remoteFileName, String remoteTargetDirectory, String mode)
-    throws IOException {
-        put(new String[] { localFile }, new String[] { remoteFileName }, remoteTargetDirectory, mode);
-    }
-
-    /**
-     * Create a remote file and copy the contents of the passed byte array into
-     * it. Uses mode 0600 for creating the remote file.
-     *
-     * @param data
-     *            the data to be copied into the remote file.
-     * @param remoteFileName
-     *            The name of the file which will be created in the remote
-     *            target directory.
-     * @param remoteTargetDirectory
-     *            Remote target directory. Use an empty string to specify the
-     *            default directory.
-     * @throws IOException
-     */
-
-    public void put(byte[] data, String remoteFileName, String remoteTargetDirectory) throws IOException {
-        put(data, remoteFileName, remoteTargetDirectory, "0600");
-    }
-
-    /**
-     * Create a remote file and copy the contents of the passed byte array into
-     * it. The method use the specified mode when creating the file on the
-     * remote side.
-     *
-     * @param data
-     *            the data to be copied into the remote file.
-     * @param remoteFileName
-     *            The name of the file which will be created in the remote
-     *            target directory.
-     * @param remoteTargetDirectory
-     *            Remote target directory. Use an empty string to specify the
-     *            default directory.
-     * @param mode
-     *            a four digit string (e.g., 0644, see "man chmod", "man open")
-     * @throws IOException
-     */
-    public void put(byte[] data, String remoteFileName, String remoteTargetDirectory, String mode) throws IOException {
-        Session sess = null;
-
-        if ((remoteFileName == null) || (remoteTargetDirectory == null) || (mode == null))
-            throw new IllegalArgumentException("Null argument.");
-
-        if (mode.length() != 4)
-            throw new IllegalArgumentException("Invalid mode.");
-
-        for (int i = 0; i < mode.length(); i++)
-            if (Character.isDigit(mode.charAt(i)) == false)
-                throw new IllegalArgumentException("Invalid mode.");
-
-        remoteTargetDirectory = remoteTargetDirectory.trim();
-        remoteTargetDirectory = (remoteTargetDirectory.length() > 0) ? remoteTargetDirectory : ".";
-        String cmd = "scp -t -d " + remoteTargetDirectory;
-
-        try {
-            sess = conn.openSession();
-            sess.execCommand(cmd);
-            sendBytes(sess, data, remoteFileName, mode);
-        }
-        catch (IOException e) {
-            throw(IOException) new IOException("Error during SCP transfer.").initCause(e);
-        }
-        finally {
-            if (sess != null)
-                sess.close();
-        }
-    }
-
-    /**
-     * Copy a set of local files to a remote directory, uses the specified mode
-     * when creating the files on the remote side.
-     *
-     * @param localFiles
-     *            Paths and names of the local files.
-     * @param remoteTargetDirectory
-     *            Remote target directory. Use an empty string to specify the
-     *            default directory.
-     * @param mode
-     *            a four digit string (e.g., 0644, see "man chmod", "man open")
-     * @throws IOException
-     */
-    public void put(String[] localFiles, String remoteTargetDirectory, String mode) throws IOException {
-        put(localFiles, null, remoteTargetDirectory, mode);
-    }
-
-    public void put(String[] localFiles, String[] remoteFiles, String remoteTargetDirectory, String mode)
-    throws IOException {
-        Session sess = null;
-
-        /*
-         * remoteFiles may be null, indicating that the local filenames shall be
-         * used
-         */
-
-        if ((localFiles == null) || (remoteTargetDirectory == null) || (mode == null))
-            throw new IllegalArgumentException("Null argument.");
-
-        if (mode.length() != 4)
-            throw new IllegalArgumentException("Invalid mode.");
-
-        for (int i = 0; i < mode.length(); i++)
-            if (Character.isDigit(mode.charAt(i)) == false)
-                throw new IllegalArgumentException("Invalid mode.");
-
-        if (localFiles.length == 0)
-            return;
-
-        remoteTargetDirectory = remoteTargetDirectory.trim();
-        remoteTargetDirectory = (remoteTargetDirectory.length() > 0) ? remoteTargetDirectory : ".";
-        String cmd = "scp -t -d " + remoteTargetDirectory;
-
-        for (int i = 0; i < localFiles.length; i++) {
-            if (localFiles[i] == null)
-                throw new IllegalArgumentException("Cannot accept null filename.");
-        }
-
-        try {
-            sess = conn.openSession();
-            sess.execCommand(cmd);
-            sendFiles(sess, localFiles, remoteFiles, mode);
-        }
-        catch (IOException e) {
-            throw(IOException) new IOException("Error during SCP transfer.").initCause(e);
-        }
-        finally {
-            if (sess != null)
-                sess.close();
-        }
-    }
-
-    /**
-     * Download a file from the remote server to a local directory.
-     *
-     * @param remoteFile
-     *            Path and name of the remote file.
-     * @param localTargetDirectory
-     *            Local directory to put the downloaded file.
-     *
-     * @throws IOException
-     */
-    public void get(String remoteFile, String localTargetDirectory) throws IOException {
-        get(new String[] { remoteFile }, localTargetDirectory);
-    }
-
-    /**
-     * Download a file from the remote server and pipe its contents into an
-     * <code>OutputStream</code>. Please note that, to enable flexible usage
-     * of this method, the <code>OutputStream</code> will not be closed nor
-     * flushed.
-     *
-     * @param remoteFile
-     *            Path and name of the remote file.
-     * @param target
-     *            OutputStream where the contents of the file will be sent to.
-     * @throws IOException
-     */
-    public void get(String remoteFile, OutputStream target) throws IOException {
-        get(new String[] { remoteFile }, new OutputStream[] { target });
-    }
-
-    private void get(String remoteFiles[], OutputStream[] targets) throws IOException {
-        Session sess = null;
-
-        if ((remoteFiles == null) || (targets == null))
-            throw new IllegalArgumentException("Null argument.");
-
-        if (remoteFiles.length != targets.length)
-            throw new IllegalArgumentException("Length of arguments does not match.");
-
-        if (remoteFiles.length == 0)
-            return;
-
-        String cmd = "scp -f";
-
-        for (int i = 0; i < remoteFiles.length; i++) {
-            if (remoteFiles[i] == null)
-                throw new IllegalArgumentException("Cannot accept null filename.");
-
-            String tmp = remoteFiles[i].trim();
-
-            if (tmp.length() == 0)
-                throw new IllegalArgumentException("Cannot accept empty filename.");
-
-            cmd += (" " + tmp);
-        }
-
-        try {
-            sess = conn.openSession();
-            sess.execCommand(cmd);
-            receiveFiles(sess, targets);
-        }
-        catch (IOException e) {
-            throw(IOException) new IOException("Error during SCP transfer.").initCause(e);
-        }
-        finally {
-            if (sess != null)
-                sess.close();
-        }
-    }
-
-    /**
-     * Download a set of files from the remote server to a local directory.
-     *
-     * @param remoteFiles
-     *            Paths and names of the remote files.
-     * @param localTargetDirectory
-     *            Local directory to put the downloaded files.
-     *
-     * @throws IOException
-     */
-    public void get(String remoteFiles[], String localTargetDirectory) throws IOException {
-        Session sess = null;
-
-        if ((remoteFiles == null) || (localTargetDirectory == null))
-            throw new IllegalArgumentException("Null argument.");
-
-        if (remoteFiles.length == 0)
-            return;
-
-        String cmd = "scp -f";
-
-        for (int i = 0; i < remoteFiles.length; i++) {
-            if (remoteFiles[i] == null)
-                throw new IllegalArgumentException("Cannot accept null filename.");
-
-            String tmp = remoteFiles[i].trim();
-
-            if (tmp.length() == 0)
-                throw new IllegalArgumentException("Cannot accept empty filename.");
-
-            cmd += (" " + tmp);
-        }
-
-        try {
-            sess = conn.openSession();
-            sess.execCommand(cmd);
-            receiveFiles(sess, remoteFiles, localTargetDirectory);
-        }
-        catch (IOException e) {
-            throw(IOException) new IOException("Error during SCP transfer.").initCause(e);
-        }
-        finally {
-            if (sess != null)
-                sess.close();
-        }
-    }
-}