SftpClient.java

/**
 * Copyright 2003-2016 SSHTOOLS Limited. All Rights Reserved.
 *
 * For product documentation visit https://www.sshtools.com/
 *
 * This file is part of J2SSH Maverick.
 *
 * J2SSH Maverick is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * J2SSH Maverick is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with J2SSH Maverick.  If not, see <http://www.gnu.org/licenses/>.
 */
package com.sshtools.sftp;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.StringTokenizer;
import java.util.Vector;

import com.sshtools.events.Event;
import com.sshtools.events.EventServiceImplementation;
import com.sshtools.events.J2SSHEventCodes;
import com.sshtools.logging.Log;
import com.sshtools.ssh.ChannelOpenException;
import com.sshtools.ssh.Client;
import com.sshtools.ssh.SshClient;
import com.sshtools.ssh.SshException;
import com.sshtools.ssh.SshIOException;
import com.sshtools.ssh.SshSession;
import com.sshtools.ssh2.Ssh2Session;
import com.sshtools.util.EOLProcessor;
import com.sshtools.util.IOUtil;
import com.sshtools.util.UnsignedInteger32;
import com.sshtools.util.UnsignedInteger64;

/**
 * <p>
 * Implements a Secure File Transfer (SFTP) client.
 * </p>
 * 
 * @author Lee David Painter
 */
public class SftpClient implements Client {
	SftpSubsystemChannel sftp;
	String cwd;
	String lcwd;

	private int blocksize = 4096;
	private int asyncRequests = 100;
	private int buffersize = -1;

	// Default permissions is determined by default_permissions ^ umask
	int umask = 0022;

	/*
	 * public static final int TYPE_REGULAR = 1; public static final int
	 * TYPE_DIRECTORY = 2; public static final int TYPE_SYMLINK = 3; public
	 * static final int TYPE_SPECIAL = 4; public static final int TYPE_UNKNOWN =
	 * 5;
	 */

	/**
	 * Instructs the client to use a binary transfer mode when used with {@link
	 * setTransferMode(int)}
	 */
	public static final int MODE_BINARY = 1;

	/**
	 * Instructs the client to use a text transfer mode when used with {@link
	 * setTransferMode(int)}.
	 */
	public static final int MODE_TEXT = 2;

	/**
	 * <p>
	 * Specifies that the remote server is using \r\n as its newline convention
	 * when used with {@link setRemoteEOL(int)}
	 * </p>
	 */
	public static final int EOL_CRLF = EOLProcessor.TEXT_CRLF;

	/**
	 * <p>
	 * Specifies that the remote server is using \n as its newline convention
	 * when used with {@link setRemoteEOL(int)}
	 * </p>
	 */
	public static final int EOL_LF = EOLProcessor.TEXT_LF;

	/**
	 * <p>
	 * Specifies that the remote server is using \r as its newline convention
	 * when used with {@link setRemoteEOL(int)}
	 * </p>
	 */
	public static final int EOL_CR = EOLProcessor.TEXT_CR;

	private int eolMode = EOL_CRLF;

	private int transferMode = MODE_BINARY;

	public SftpClient(SshClient ssh) throws SftpStatusException, SshException,
			ChannelOpenException {
		this(ssh, SftpSubsystemChannel.MAX_VERSION);
	}

	public SftpClient(SshSession session) throws SftpStatusException,
			SshException {
		this(session, SftpSubsystemChannel.MAX_VERSION);
	}

	public SftpClient(SshSession session, int Max_Version)
			throws SftpStatusException, SshException {
		initSftp(session, Max_Version);
	}

	/**
	 * <p>
	 * Constructs the SFTP client with a given channel event listener.
	 * </p>
	 * 
	 * @param ssh
	 *            the <code>SshClient</code> instance
	 * @param Max_Version
	 *            the maximum SFTP protocol version to use
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws ChannelOpenException
	 */
	public SftpClient(SshClient ssh, int Max_Version)
			throws SftpStatusException, SshException, ChannelOpenException {

		SshSession session = ssh.openSessionChannel();

		/**
		 * Start the SFTP server
		 */
		Ssh2Session ssh2 = (Ssh2Session) session;
		if (!ssh2.startSubsystem("sftp")) {
			if (Log.isDebugEnabled()) {
				Log.debug(this,
						"The SFTP subsystem failed to start, attempting to execute provider "
								+ ssh.getContext().getSFTPProvider());
			}
			// We could not start the subsystem try to fallback to the
			// provider specified by the user
			if (!ssh2.executeCommand(ssh.getContext().getSFTPProvider())) {
				ssh2.close();
				throw new SshException(
						"Failed to start SFTP subsystem or SFTP provider "
								+ ssh.getContext().getSFTPProvider(),
						SshException.CHANNEL_FAILURE);
			}
		}

		initSftp(session, Max_Version);
	}

	private void initSftp(SshSession session, int Max_Version)
			throws SftpStatusException, SshException {
		sftp = new SftpSubsystemChannel(session, Max_Version);

		try {
			sftp.initialize();
		} catch (UnsupportedEncodingException ex) {

		}
		// Get the users default directory
		cwd = sftp.getDefaultDirectory();
		String homeDir = "";
		try {
			homeDir = System.getProperty("user.home");
		} catch (SecurityException e) {
			// ignore
		}
		lcwd = homeDir;
		EventServiceImplementation.getInstance().fireEvent(
				new Event(this, J2SSHEventCodes.EVENT_SFTP_SESSION_STARTED,
						true));
	}

	/**
	 * Sets the block size used when transferring files, defaults to the
	 * optimized setting of 32768. You should not increase this value as the
	 * remote server may not be able to support higher blocksizes.
	 * 
	 * @param blocksize
	 */
	public void setBlockSize(int blocksize) {
		if (blocksize < 512) {
			throw new IllegalArgumentException(
					"Block size must be greater than 512");
		}
		this.blocksize = blocksize;
	}

	/**
	 * Returns the instance of the SftpSubsystemChannel used by this class
	 * 
	 * @return the SftpSubsystemChannel instance
	 */
	public SftpSubsystemChannel getSubsystemChannel() {
		return sftp;
	}

	/**
	 * <p>
	 * Sets the transfer mode for current operations. The valid modes are:<br>
	 * <br>
	 * {@link #MODE_BINARY} - Files are transferred in binary mode and no
	 * processing of text files is performed (default mode).<br>
	 * <br>
	 * {@link #MODE_TEXT} - For servers supporting version 4+ of the SFTP
	 * protocol files are transferred in text mode. For earlier protocol
	 * versions the files are transfered in binary mode but the client performs
	 * processing of text; if files are written to the remote server the client
	 * ensures that the line endings conform to the remote EOL mode set using
	 * {@link setRemoteEOL(int)}. For files retrieved from the server the EOL
	 * policy is based upon System policy as defined by the "line.seperator"
	 * system property.
	 * </p>
	 * 
	 * @param transferMode
	 *            int
	 */
	public void setTransferMode(int transferMode) {
		if (transferMode != MODE_BINARY && transferMode != MODE_TEXT)
			throw new IllegalArgumentException(
					"Mode can only be either binary or text");

		this.transferMode = transferMode;

		if (Log.isDebugEnabled()) {
			Log.debug(this, "Transfer mode set to "
					+ (transferMode == MODE_BINARY ? "binary" : "text"));
		}
	}

	/**
	 * <p>
	 * When connected to servers running SFTP version 3 (or less) the remote EOL
	 * type needs to be explicitly set because there is no reliable way for the
	 * client to determine the type of EOL for text files. In versions 4+ a
	 * mechanism is provided and this setting is overridden.
	 * </p>
	 * 
	 * <p>
	 * Valid values for this method are {@link EOL_CRLF} (default),
	 * {@link EOL_CR}, and {@link EOL_LF}.
	 * </p>
	 * 
	 * @param eolMode
	 *            int
	 */
	public void setRemoteEOL(int eolMode) {
		this.eolMode = eolMode;

		if (Log.isDebugEnabled()) {
			Log.debug(this, "Remote EOL set to "
					+ (eolMode == EOL_CRLF ? "CRLF" : (eolMode == EOL_CR ? "CR"
							: "LF")));
		}

	}

	/**
	 * 
	 * @return int
	 */
	public int getTransferMode() {
		return transferMode;
	}

	/**
	 * Set the size of the buffer which is used to read from the local file
	 * system. This setting is used to optimize the writing of files by allowing
	 * for a large chunk of data to be read in one operation from a local file.
	 * The previous version simply read each block of data before sending
	 * however this decreased performance, this version now reads the file into
	 * a temporary buffer in order to reduce the number of local filesystem
	 * reads. This increases performance and so this setting should be set to
	 * the highest value possible. The default setting is negative which means
	 * the entire file will be read into a temporary buffer.
	 * 
	 * @param buffersize
	 */
	public void setBufferSize(int buffersize) {
		this.buffersize = buffersize;

		if (Log.isDebugEnabled()) {
			Log.debug(this, "Buffer size set to " + buffersize);
		}

	}

	/**
	 * Set the maximum number of asynchronous requests that are outstanding at
	 * any one time. This setting is used to optimize the reading and writing of
	 * files to/from the remote file system when using the get and put methods.
	 * The default for this setting is 100.
	 * 
	 * @param asyncRequests
	 */
	public void setMaxAsyncRequests(int asyncRequests) {
		if (asyncRequests < 1) {
			throw new IllegalArgumentException(
					"Maximum asynchronous requests must be greater or equal to 1");
		}
		this.asyncRequests = asyncRequests;

		if (Log.isDebugEnabled()) {
			Log.debug(this, "Max async requests set to "
					+ asyncRequests);
		}

	}

	/**
	 * Sets the umask used by this client. <blockquote>
	 * 
	 * <pre>
	 * To give yourself full permissions for both files and directories and
	 * prevent the group and other users from having access:
	 * 
	 *   umask(077);
	 * 
	 * This subtracts 077 from the system defaults for files and directories
	 * 666 and 777. Giving a default access permissions for your files of
	 * 600 (rw-------) and for directories of 700 (rwx------).
	 * 
	 * To give all access permissions to the group and allow other users read
	 * and execute permission:
	 * 
	 *   umask(002);
	 * 
	 * This subtracts 002 from the system defaults to give a default access permission
	 * for your files of 664 (rw-rw-r--) and for your directories of 775 (rwxrwxr-x).
	 * 
	 * To give the group and other users all access except write access:
	 * 
	 *   umask(022);
	 * 
	 * This subtracts 022 from the system defaults to give a default access permission
	 * for your files of 644 (rw-r--r--) and for your directories of 755 (rwxr-xr-x).
	 * </pre>
	 * 
	 * </blockquote>
	 * 
	 * @param umask
	 * @return the previous umask value
	 */
	public int umask(int umask) {
		int old = this.umask;
		this.umask = umask;

		if (Log.isDebugEnabled()) {
			Log.debug(this, "umask " + umask);
		}

		return old;
	}

	public SftpFile openFile(String fileName) throws SftpStatusException,
			SshException {
		if (transferMode == MODE_TEXT && sftp.getVersion() > 3) {
			return sftp.openFile(resolveRemotePath(fileName),
					SftpSubsystemChannel.OPEN_READ
							| SftpSubsystemChannel.OPEN_TEXT);
		}
		return sftp.openFile(resolveRemotePath(fileName),
				SftpSubsystemChannel.OPEN_READ);
	}

	/**
	 * <p>
	 * Changes the working directory on the remote server, or the user's default
	 * directory if <code>null</code> or any empty string is provided as the
	 * directory path. The user's default directory is typically their home
	 * directory but is dependent upon server implementation.
	 * </p>
	 * 
	 * @param dir
	 *            the new working directory
	 * 
	 * @throws IOException
	 *             if an IO error occurs or the file does not exist
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public void cd(String dir) throws SftpStatusException, SshException {
		String actual;

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

		if (!actual.equals("")) {
			SftpFileAttributes attr = sftp.getAttributes(actual);

			if (!attr.isDirectory()) {
				throw new SftpStatusException(
						SftpStatusException.SSH_FX_FAILURE, dir
								+ " is not a directory");
			}
		}

		if (Log.isDebugEnabled()) {
			Log.debug(this, "Changing dir from " + cwd + " to "
					+ (actual.equals("") ? "user default dir" : actual));
		}

		cwd = actual;
	}

	// protected void finalize() throws Throwable {
	//
	// if(sftp!=null)
	// sftp.close();
	// sftp = null;
	// super.finalize();
	//
	// }

	/**
	 * <p>
	 * Get the default directory (or HOME directory)
	 * </p>
	 * 
	 * @return String
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public String getDefaultDirectory() throws SftpStatusException,
			SshException {
		return sftp.getDefaultDirectory();
	}

	/**
	 * Change the working directory to the parent directory
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public void cdup() throws SftpStatusException, SshException {

		SftpFile cd = sftp.getFile(cwd);

		SftpFile parent = cd.getParent();

		if (parent != null)
			cwd = parent.getAbsolutePath();

	}

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

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

		return f;
	}

	private boolean isWindowsRoot(String path) {
		path = path.trim();
		// true if path>2 and starts with a letter followed by a ':' followed by
		// '/' or '\\'
		return path.length() > 2
				&& (((path.charAt(0) >= 'a' && path.charAt(0) <= 'z') || (path
						.charAt(0) >= 'A' && path.charAt(0) <= 'Z'))
						&& path.charAt(1) == ':' && path.charAt(2) == '/' || path
						.charAt(2) == '\\');
	}

	/**
	 * some devices have unusual file system roots such as "flash:", customRoots
	 * contains these. If a device uses roots like this, and folder traversal on
	 * the device is required then it must have its root stored in customRoots
	 */
	private Vector<String> customRoots = new Vector<String>();

	/**
	 * Add a custom file system root path such as "flash:"
	 * 
	 * @param rootPath
	 */
	public void addCustomRoot(String rootPath) {
		customRoots.addElement(rootPath);
	}

	/**
	 * Remove a custom file system root path such as "flash:"
	 * 
	 * @param rootPath
	 */
	public void removeCustomRoot(String rootPath) {
		customRoots.removeElement(rootPath);
	}

	/**
	 * Tests whether path starts with a custom file system root.
	 * 
	 * @param path
	 * @return <em>true</em> if path starts with an element of customRoots,
	 *         <em>false</em> otherwise
	 */
	private boolean startsWithCustomRoot(String path) {
		for (Enumeration<String> it = customRoots.elements(); it != null
				&& it.hasMoreElements();) {
			if (path.startsWith(it.nextElement())) {
				return true;
			}
		}
		return false;
	}

	/**
	 * returns the canonical form of path, if path doesn't start with one of
	 * '/';cwd;a customRoot; or is a WindowsRoot then prepend cwd to path
	 * 
	 * @param path
	 * @return canonical form of path
	 * @throws SftpStatusException
	 */
	private String resolveRemotePath(String path) throws SftpStatusException {
		verifyConnection();

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

		if (!actual.equals("/") && actual.endsWith("/")) {
			return actual.substring(0, actual.length() - 1);
		} else {
			return actual;
		}
	}

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

	/**
	 * <p>
	 * Creates a new directory on the remote server. This method will throw an
	 * exception if the directory already exists. To create directories and
	 * disregard any errors use the <code>mkdirs</code> method.
	 * </p>
	 * 
	 * @param dir
	 *            the name of the new directory
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public void mkdir(String dir) throws SftpStatusException, SshException {
		String actual = resolveRemotePath(dir);

		if (Log.isDebugEnabled()) {
			Log.debug(this, "Creating dir " + dir);
		}

		try {
			sftp.getAttributes(actual);
		} catch (SftpStatusException ex) {
			// only create the directory if catch an exception with code file
			// not found
			SftpFileAttributes newattrs = new SftpFileAttributes(sftp,
					SftpFileAttributes.SSH_FILEXFER_TYPE_DIRECTORY);
			newattrs.setPermissions(new UnsignedInteger32(0777 ^ umask));
			sftp.makeDirectory(actual, newattrs);
			return;
		}

		if (Log.isDebugEnabled()) {
			Log.debug(this, "A file/folder with name " + dir
					+ " already exists!");
		}

		throw new SftpStatusException(SftpStatusException.SSH_FX_FAILURE,
				"File already exists named " + dir);

	}

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

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

			try {
				stat(path);
			} catch (SftpStatusException ex) {
				try {
					mkdir(path);
				} catch (SftpStatusException ex2) {
					if (ex2.getStatus() == SftpStatusException.SSH_FX_PERMISSION_DENIED)
						throw ex2;
				}
			}

			path += "/";
		}
	}

	/**
	 * Determine whether the file object is pointing to a symbolic link that is
	 * pointing to a directory.
	 * 
	 * @return boolean
	 */
	public boolean isDirectoryOrLinkedDirectory(SftpFile file)
			throws SftpStatusException, SshException {
		return file.isDirectory()
				|| (file.isLink() && stat(file.getAbsolutePath()).isDirectory());
	}

	/**
	 * <p>
	 * Returns the absolute path name of the current remote working directory.
	 * </p>
	 * 
	 * @return the absolute path of the remote working directory.
	 */
	public String pwd() {
		return cwd;
	}

	/**
	 * <p>
	 * List the contents of the current remote working directory.
	 * </p>
	 * 
	 * <p>
	 * Returns a list of <a
	 * href="../../maverick/ssh2/SftpFile.html">SftpFile</a> instances for the
	 * current working directory.
	 * </p>
	 * 
	 * @return a list of SftpFile for the current working directory
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * 
	 */
	public SftpFile[] ls() throws SftpStatusException, SshException {
		return ls(cwd);
	}

	/**
	 * <p>
	 * List the contents remote directory.
	 * </p>
	 * 
	 * <p>
	 * Returns a list of <a
	 * href="../../maverick/ssh2/SftpFile.html">SftpFile</a> instances for the
	 * remote directory.
	 * </p>
	 * 
	 * @param path
	 *            the path on the remote server to list
	 * 
	 * @return a list of SftpFile for the remote directory
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public SftpFile[] ls(String path) throws SftpStatusException, SshException {

		String actual = resolveRemotePath(path);

		if (Log.isDebugEnabled()) {
			Log.debug(this, "Listing files for " + actual);
		}

		SftpFile file = sftp.openDirectory(actual);
		Vector<SftpFile> children = new Vector<SftpFile>();
		while (sftp.listChildren(file, children) > -1) {
			;
		}
		file.close();
		SftpFile[] files = new SftpFile[children.size()];
		int index = 0;
		for (Enumeration<SftpFile> e = children.elements(); e.hasMoreElements();) {
			files[index++] = e.nextElement();
		}
		return files;
	}

	/**
	 * <p>
	 * Changes the local working directory.
	 * </p>
	 * 
	 * @param path
	 *            the path to the new working directory
	 * 
	 * @throws SftpStatusException
	 */
	public void lcd(String path) throws SftpStatusException {
		File actual;

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

		if (!actual.isDirectory()) {
			throw new SftpStatusException(SftpStatusException.SSH_FX_FAILURE,
					path + " is not a directory");
		}

		try {
			lcwd = actual.getCanonicalPath();
		} catch (IOException ex) {
			throw new SftpStatusException(SftpStatusException.SSH_FX_FAILURE,
					"Failed to canonicalize path " + path);
		}
	}

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

	/**
	 * <p>
	 * Returns the absolute path to the local working directory.
	 * </p>
	 * 
	 * @return the absolute path of the local working directory.
	 */
	public String lpwd() {
		return lcwd;
	}

	/**
	 * <p>
	 * Download the remote file to the local computer.
	 * </p>
	 * 
	 * @param path
	 *            the path to the remote file
	 * @param progress
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String path, FileTransferProgress progress)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		return get(path, progress, false);
	}

	/**
	 * <p>
	 * Download the remote file to the local computer.
	 * </p>
	 * 
	 * @param path
	 *            the path to the remote file
	 * @param progress
	 * @param resume
	 *            attempt to resume a interrupted download
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String path, FileTransferProgress progress,
			boolean resume) throws FileNotFoundException, SftpStatusException,
			SshException, TransferCancelledException {
		String localfile;

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

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

	/**
	 * <p>
	 * Download the remote file to the local computer
	 * 
	 * @param path
	 *            the path to the remote file
	 * @param resume
	 *            attempt to resume an interrupted download
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String path, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		return get(path, (FileTransferProgress) null, resume);
	}

	/**
	 * <p>
	 * Download the remote file to the local computer
	 * 
	 * @param path
	 *            the path to the remote file
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String path) throws FileNotFoundException,
			SftpStatusException, SshException, TransferCancelledException {
		return get(path, (FileTransferProgress) null);
	}

	// private void transferFile(InputStream in, OutputStream out,
	// FileTransferProgress progress) throws SftpStatusException,
	// SshException, TransferCancelledException {
	// try {
	// long bytesSoFar = 0;
	// byte[] buffer = new byte[blocksize];
	// int read;
	//
	// while ((read = in.read(buffer)) > -1) {
	// if ((progress != null) && progress.isCancelled()) {
	// throw new TransferCancelledException();
	// }
	//
	// if (read > 0) {
	// out.write(buffer, 0, read);
	// // out.flush();
	// bytesSoFar += read;
	//
	// if (progress != null) {
	// progress.progressed(bytesSoFar);
	// }
	// }
	// }
	// } catch (IOException ex) {
	// throw new SftpStatusException(SftpStatusException.SSH_FX_FAILURE,
	// "IO Error during data transfer: " + ex.getMessage());
	// } finally {
	// try {
	// in.close();
	// } catch (Throwable t) {
	// }
	//
	// try {
	// out.close();
	// } catch (Throwable ex) {
	// }
	// }
	// }

	/**
	 * <p>
	 * Download the remote file to the local computer. If the paths provided are
	 * not absolute the current working directory is used.
	 * </p>
	 * 
	 * @param remote
	 *            the path/name of the remote file
	 * @param local
	 *            the path/name to place the file on the local computer
	 * @param progress
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws SftpStatusException
	 * @throws FileNotFoundException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String remote, String local,
			FileTransferProgress progress) throws FileNotFoundException,
			SftpStatusException, SshException, TransferCancelledException {
		return get(remote, local, progress, false);
	}

	/**
	 * <p>
	 * Download the remote file to the local computer. If the paths provided are
	 * not absolute the current working directory is used.
	 * </p>
	 * 
	 * @param remote
	 *            the path/name of the remote file
	 * @param local
	 *            the path/name to place the file on the local computer
	 * @param progress
	 * @param resume
	 *            attempt to resume an interrupted download
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws SftpStatusException
	 * @throws FileNotFoundException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	@SuppressWarnings("resource")
	public SftpFileAttributes get(String remote, String local,
			FileTransferProgress progress, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {

		// Moved here to ensure that stream is closed in finally
		OutputStream out = null;
		SftpFileAttributes attrs = null;

		// Perform local file operations first, then if it throws an exception
		// the server hasn't been unnecessarily loaded.
		File localPath = resolveLocalPath(local);
		if (!localPath.exists()) {
			File parent = new File(localPath.getParent());
			parent.mkdirs();
		}

		if (localPath.isDirectory()) {
			int idx;
			if ((idx = remote.lastIndexOf('/')) > -1) {
				localPath = new File(localPath, remote.substring(idx));
			} else {
				localPath = new File(localPath, remote);
			}

		}

		// Check that file exists before we create a file
		stat(remote);

		long position = 0;

		try {

			// if resuming and the local file exists, then open as random access
			// file and seek to end of the file ready to continue writing
			if (resume && localPath.exists()) {

				position = localPath.length();

				RandomAccessFile file = new RandomAccessFile(localPath, "rw");
				file.seek(position);

				out = new RandomAccessFileOutputStream(file);
			} else {
				out = new FileOutputStream(localPath);
			}

			if (transferMode == MODE_TEXT) {

				// Default text mode handling for versions 3- of the SFTP
				// protocol
				int inputStyle = eolMode;
				int outputStyle = EOLProcessor.TEXT_SYSTEM;

				byte[] nl = null;

				if (sftp.getVersion() <= 3
						&& sftp.getExtension("newline@vandyke.com") != null) {
					nl = sftp.getExtension("newline@vandyke.com");
				} else if (sftp.getVersion() > 3) {
					nl = sftp.getCanonicalNewline();
				}

				// Setup text mode correctly if were using version 4+ of the
				// SFTP protocol
				if (nl != null) {
					switch (nl.length) {
					case 1:
						if (nl[0] == '\r')
							inputStyle = EOLProcessor.TEXT_CR;
						else if (nl[0] == '\n')
							inputStyle = EOLProcessor.TEXT_LF;
						else
							throw new SftpStatusException(
									SftpStatusException.INVALID_HANDLE,
									"Unsupported text mode: invalid newline character");
						break;
					case 2:
						if (nl[0] == '\r' && nl[1] == '\n')
							inputStyle = EOLProcessor.TEXT_CRLF;
						else
							throw new SftpStatusException(
									SftpStatusException.INVALID_HANDLE,
									"Unsupported text mode: invalid newline characters");
						break;
					default:
						throw new SftpStatusException(
								SftpStatusException.INVALID_HANDLE,
								"Unsupported text mode: newline length > 2");

					}

				}

				out = EOLProcessor.createOutputStream(inputStyle, outputStyle,
						out);
			}

			attrs = get(remote, out, progress, position);

			return attrs;

		} catch (IOException ex) {
			throw new SftpStatusException(SftpStatusException.SSH_FX_FAILURE,
					"Failed to open outputstream to " + local);
		} finally {
			try {
				if (out != null)
					out.close();

				// Try to set the last modified time on file using reflection so
				// that
				// the class is compatible with JDK 1.1
				if (attrs != null) {
					Method m = localPath.getClass().getMethod(
							"setLastModified", new Class[] { long.class });
					m.invoke(localPath, new Object[] { new Long(attrs
							.getModifiedTime().longValue() * 1000) });
				}

			} catch (Throwable ex) {
				// NOTE: should we ignore this?
			}
		}
	}

	/**
	 * Download the remote file into the local file.
	 * 
	 * @param remote
	 * @param local
	 * @param resume
	 *            attempt to resume an interrupted download
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String remote, String local, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		return get(remote, local, null, resume);
	}

	/**
	 * Download the remote file into the local file.
	 * 
	 * @param remote
	 * @param local
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String remote, String local)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		return get(remote, local, false);
	}

	/**
	 * <p>
	 * Download the remote file writing it to the specified
	 * <code>OutputStream</code>. The OutputStream is closed by this method even
	 * if the operation fails.
	 * </p>
	 * 
	 * @param remote
	 *            the path/name of the remote file
	 * @param local
	 *            the OutputStream to write
	 * @param progress
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String remote, OutputStream local,
			FileTransferProgress progress) throws SftpStatusException,
			SshException, TransferCancelledException {
		return get(remote, local, progress, 0);
	}

	/**
	 * make local copies of some of the variables, then call getfilematches,
	 * which calls get on each file that matches the regexp remote.
	 * 
	 * @param remote
	 * @param local
	 * @param progress
	 * @param position
	 * @return SftpFile[]
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	/*
	 * public SftpFile[] getFiles(String remote, OutputStream local,
	 * FileTransferProgress progress, long position) throws
	 * FileNotFoundException, SftpStatusException, SshException,
	 * TransferCancelledException { this.local = local; this.position =
	 * position; return getFileMatches(remote, progress, true); }
	 */
	/**
	 * make local copies of some of the variables, then call getfilematches,
	 * which calls get on each file that matches the regexp remote.
	 * 
	 * @param remote
	 * @param local
	 * @param progress
	 * @param resume
	 * @return SftpFile[]
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	/*
	 * public SftpFile[] getFiles(String remote, String local,
	 * FileTransferProgress progress) throws FileNotFoundException,
	 * SftpStatusException, SshException, TransferCancelledException { return
	 * getFileMatches(remote, progress); }
	 */

	/**
	 * constants for setting the regular expression syntax.
	 */
	public static final int NoSyntax = 0;
	public static final int GlobSyntax = 1;
	public static final int Perl5Syntax = 2;

	/**
	 * default regular expression syntax is to not perform regular expression
	 * matching on getFiles() and putFiles()
	 */
	private int RegExpSyntax = GlobSyntax;

	/**
	 * sets the type of regular expression matching to perform on gets and puts
	 * 
	 * @param syntax
	 *            , NoSyntax for no regular expression matching, GlobSyntax for
	 *            GlobSyntax, Perl5Syntax for Perl5Syntax
	 */
	public void setRegularExpressionSyntax(int syntax) {
		RegExpSyntax = syntax;
	}

	/**
	 * Called by getFileMatches() to do regular expression pattern matching on
	 * the files in 'remote''s parent directory.
	 * 
	 * @param remote
	 * @return SftpFile[]
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public SftpFile[] matchRemoteFiles(String remote)
			throws SftpStatusException, SshException {

		String actualDir;
		String actualSearch;
		int fileSeparatorIndex;
		if ((fileSeparatorIndex = remote.lastIndexOf("/")) > -1) {
			actualDir = remote.substring(0, fileSeparatorIndex);
			actualSearch = remote.length() > fileSeparatorIndex + 1 ? remote
					.substring(fileSeparatorIndex + 1) : "";
		} else {
			actualDir = cwd;
			actualSearch = remote;
		}

		SftpFile[] files;
		RegularExpressionMatching matcher;
		switch (RegExpSyntax) {
		case GlobSyntax:
			matcher = new GlobRegExpMatching();
			files = ls(actualDir);
			break;
		case Perl5Syntax:
			matcher = new Perl5RegExpMatching();
			files = ls(actualDir);
			break;
		default:
			matcher = new NoRegExpMatching();
			files = new SftpFile[1];
			String actual = resolveRemotePath(remote);
			files[0] = getSubsystemChannel().getFile(actual);
		}

		return matcher.matchFilesWithPattern(files, actualSearch);
	}

	/**
	 * If RegExpSyntax is set to GlobSyntax or Perl5Syntax then it pattern
	 * matches the files in the remote directory using "remote" as a glob or
	 * perl5 Regular Expression. For each matching file get() is called to copy
	 * the file to the local directory.
	 * 
	 * <p>
	 * If RegExpSyntax is set to NoSyntax then "remote" is treated as a filepath
	 * instead of a regular expression
	 * </p>
	 * 
	 * @param remote
	 * @param progress
	 * @param streamOrFile
	 * @return SftpFile[] of SftpFile's that have been retrieved
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	private SftpFile[] getFileMatches(String remote, String local,
			FileTransferProgress progress, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {

		// match with files using remote as regular expression.
		SftpFile[] matchedFiles = matchRemoteFiles(remote);

		Vector<SftpFile> retrievedFiles = new Vector<SftpFile>();
		// call get for each matched file, append the files attributes to a
		// vector to be returned at the end
		// call the correct get method depending on the get method that called
		// this
		for (int i = 0; i < matchedFiles.length; i++) {
			get(matchedFiles[i].getAbsolutePath(), local, progress, resume);
			retrievedFiles.addElement(matchedFiles[i]);
		}

		// return (SftpFile[]) retrievedFiles.toArray(new SftpFile[0]);
		SftpFile[] retrievedSftpFiles = new SftpFile[retrievedFiles.size()];
		retrievedFiles.copyInto(retrievedSftpFiles);
		return retrievedSftpFiles;
	}

	/**
	 * Called by putFileMatches() to do regular expression pattern matching on
	 * the files in 'local''s parent directory.
	 * 
	 * @param local
	 * @return String[]
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	private String[] matchLocalFiles(String local) throws SftpStatusException,
			SshException {

		// Resolve the search path as it may not be CWD
		String actualDir;
		String actualSearch;
		int fileSeparatorIndex;
		if ((fileSeparatorIndex = local.lastIndexOf(System
				.getProperty("file.separator"))) > -1
				|| (fileSeparatorIndex = local.lastIndexOf('/')) > -1) {
			actualDir = resolveLocalPath(local.substring(0, fileSeparatorIndex))
					.getAbsolutePath();
			actualSearch = (fileSeparatorIndex < local.length() - 1) ? local
					.substring(fileSeparatorIndex + 1) : "";
		} else {
			actualDir = lcwd;
			actualSearch = local;
		}

		File f;
		RegularExpressionMatching matcher;
		File[] files;
		switch (RegExpSyntax) {
		case GlobSyntax:
			f = new File(actualDir);
			matcher = new GlobRegExpMatching();
			files = listFiles(f);
			break;
		case Perl5Syntax:
			f = new File(actualDir);
			matcher = new Perl5RegExpMatching();
			files = listFiles(f);
			break;
		default:
			matcher = new NoRegExpMatching();
			files = new File[1];
			files[0] = new File(local);
		}

		return matcher.matchFileNamesWithPattern(files, actualSearch);
	}

	private File[] listFiles(File f) {
		String parentDir = f.getAbsolutePath();
		String[] fileNames = f.list();
		File[] files = new File[fileNames.length];
		for (int i = 0; i < fileNames.length; i++) {
			files[i] = new File(parentDir, fileNames[i]);
		}
		return files;
	}

	/**
	 * If RegExpSyntax is set to GlobSyntax or Perl5Syntax then it pattern
	 * matches the files in the local directory using "local" as a glob or perl5
	 * Regular Expression. For each matching file put() is called to copy the
	 * file to the remote directory.
	 * 
	 * <p>
	 * If RegExpSyntax is set to NoSyntax then "local" is treated as a filepath
	 * instead of a regular expression.
	 * </p>
	 * 
	 * @param local
	 * @param progress
	 * @param streamOrFile
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	private void putFileMatches(String local, String remote,
			FileTransferProgress progress, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {

		String remotePath = resolveRemotePath(remote);
		// Remote must be a valid remote directory

		SftpFileAttributes attrs = null;
		try {
			attrs = stat(remotePath);
		} catch (SftpStatusException ex) {
			throw new SftpStatusException(
					ex.getStatus(),
					"Remote path '"
							+ remote
							+ "' does not exist. It must be a valid directory and must already exist!");
		}

		if (!attrs.isDirectory())
			throw new SftpStatusException(
					SftpStatusException.SSH_FX_NO_SUCH_PATH, "Remote path '"
							+ remote + "' is not a directory!");

		String[] matchedFiles = matchLocalFiles(local);

		// call put for each matched file
		// call the correct put method depending on the put method that called
		// this

		for (int i = 0; i < matchedFiles.length; i++) {
			// use file exists once added rather than try catch
			try {
				put(matchedFiles[i], remotePath, progress, resume);
			} catch (SftpStatusException ex) {
				throw new SftpStatusException(ex.getStatus(), "Failed to put "
						+ matchedFiles[i] + " to " + remote + " ["
						+ ex.getMessage() + "]");
			}
		}
	}

	/**
	 * <p>
	 * Download the remote file writing it to the specified
	 * <code>OutputStream</code>. The OutputStream is closed by this method even
	 * if the operation fails.
	 * </p>
	 * 
	 * @param remote
	 *            the path/name of the remote file
	 * @param local
	 *            the OutputStream to write
	 * @param progress
	 * @param position
	 *            the position within the file to start reading from
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String remote, OutputStream local,
			FileTransferProgress progress, long position)
			throws SftpStatusException, SshException,
			TransferCancelledException {

		String remotePath = resolveRemotePath(remote);
		SftpFileAttributes attrs = sftp.getAttributes(remotePath);

		if (position > attrs.getSize().longValue()) {
			throw new SftpStatusException(
					SftpStatusException.INVALID_RESUME_STATE,
					"The local file size is greater than the remote file");
		}

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

		SftpFile file;

		if (transferMode == MODE_TEXT && sftp.getVersion() > 3) {
			file = sftp.openFile(remotePath, SftpSubsystemChannel.OPEN_READ
					| SftpSubsystemChannel.OPEN_TEXT);

		} else {
			file = sftp.openFile(remotePath, SftpSubsystemChannel.OPEN_READ);

		}

		try {
			sftp.performOptimizedRead(file.getHandle(), attrs.getSize()
					.longValue(), blocksize, local, asyncRequests, progress,
					position);
		} catch (TransferCancelledException tce) {
			throw tce;
		} finally {

			try {
				local.close();
			} catch (Throwable t) {
			}
			try {
				sftp.closeFile(file);
			} catch (SftpStatusException ex) {
			}
		}

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

		return attrs;
	}

	/**
	 * Create an InputStream for reading a remote file.
	 * 
	 * @param remotefile
	 * @param position
	 * @return InputStream
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public InputStream getInputStream(String remotefile, long position)
			throws SftpStatusException, SshException {
		String remotePath = resolveRemotePath(remotefile);
		sftp.getAttributes(remotePath);

		return new SftpFileInputStream(sftp.openFile(remotePath,
				SftpSubsystemChannel.OPEN_READ), position);

	}

	/**
	 * Create an InputStream for reading a remote file.
	 * 
	 * @param remotefile
	 * @return InputStream
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public InputStream getInputStream(String remotefile)
			throws SftpStatusException, SshException {
		return getInputStream(remotefile, 0);
	}

	/**
	 * Download the remote file into an OutputStream.
	 * 
	 * @param remote
	 * @param local
	 * @param position
	 *            the position from which to start reading the remote file
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String remote, OutputStream local,
			long position) throws SftpStatusException, SshException,
			TransferCancelledException {
		return get(remote, local, null, position);
	}

	/**
	 * Download the remote file into an OutputStream.
	 * 
	 * @param remote
	 * @param local
	 * 
	 * @return the downloaded file's attributes
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFileAttributes get(String remote, OutputStream local)
			throws SftpStatusException, SshException,
			TransferCancelledException {
		return get(remote, local, null, 0);
	}

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

	/**
	 * <p>
	 * Upload a file to the remote computer.
	 * </p>
	 * 
	 * @param local
	 *            the path/name of the local file
	 * @param progress
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void put(String local, FileTransferProgress progress, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		File f = new File(local);
		put(local, f.getName(), progress, resume);
	}

	/**
	 * <p>
	 * Upload a file to the remote computer.
	 * </p>
	 * 
	 * @param local
	 *            the path/name of the local file
	 * @param progress
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void put(String local, FileTransferProgress progress)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		put(local, progress, false);
	}

	/**
	 * Upload a file to the remote computer
	 * 
	 * @param local
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void put(String local) throws FileNotFoundException,
			SftpStatusException, SshException, TransferCancelledException {
		put(local, false);
	}

	/**
	 * Upload a file to the remote computer
	 * 
	 * @param local
	 * @param resume
	 *            attempt to resume after an interrupted transfer
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void put(String local, boolean resume) throws FileNotFoundException,
			SftpStatusException, SshException, TransferCancelledException {
		put(local, (FileTransferProgress) null, resume);
	}

	/**
	 * <p>
	 * Upload a file to the remote computer. If the paths provided are not
	 * absolute the current working directory is used.
	 * </p>
	 * 
	 * @param local
	 *            the path/name of the local file
	 * @param remote
	 *            the path/name of the destination file
	 * @param progress
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void put(String local, String remote, FileTransferProgress progress)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		put(local, remote, progress, false);
	}

	/**
	 * <p>
	 * Upload a file to the remote computer. If the paths provided are not
	 * absolute the current working directory is used.
	 * </p>
	 * 
	 * @param local
	 *            the path/name of the local file
	 * @param remote
	 *            the path/name of the destination file
	 * @param progress
	 * @param resume
	 *            attempt to resume after an interrupted transfer
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void put(String local, String remote, FileTransferProgress progress,
			boolean resume) throws FileNotFoundException, SftpStatusException,
			SshException, TransferCancelledException {
		File localPath = resolveLocalPath(local);

		InputStream in = new FileInputStream(localPath);
		// File f = new File(local);
		long position = 0;

		try {
			SftpFileAttributes attrs = stat(remote);
			if (attrs.isDirectory()) {
				remote += (remote.endsWith("/") ? "" : "/")
						+ localPath.getName();
				attrs = stat(remote);
			}

			if (resume) {
				if (localPath.length() <= attrs.getSize().longValue()) {
					try {
						in.close();
					} catch (IOException e) {
					}
					throw new SftpStatusException(
							SftpStatusException.INVALID_RESUME_STATE,
							"The remote file size is greater than the local file");
				}
				try {
					position = attrs.getSize().longValue();
					in.skip(position);
				} catch (IOException ex) {
					try {
						in.close();
					} catch (IOException e) {
					}
					throw new SftpStatusException(
							SftpStatusException.SSH_FX_NO_SUCH_FILE,
							ex.getMessage());
				}

			}
		} catch (SftpStatusException ex) {
			// file didnt exist so dont need to do above
		}

		put(in, remote, progress, position);

	}

	/**
	 * Upload a file to the remote computer
	 * 
	 * @param local
	 * @param remote
	 * @param resume
	 *            attempt to resume after an interrupted transfer
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void put(String local, String remote, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		put(local, remote, null, resume);
	}

	/**
	 * Upload a file to the remote computer
	 * 
	 * @param local
	 * @param remote
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void put(String local, String remote) throws FileNotFoundException,
			SftpStatusException, SshException, TransferCancelledException {
		put(local, remote, null, false);
	}

	/**
	 * <p>
	 * Upload a file to the remote computer reading from the specified <code>
	 * InputStream</code>. The InputStream is closed, even if the operation
	 * fails.
	 * </p>
	 * 
	 * @param in
	 *            the InputStream being read
	 * @param remote
	 *            the path/name of the destination file
	 * @param progress
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public void put(InputStream in, String remote, FileTransferProgress progress)
			throws SftpStatusException, SshException,
			TransferCancelledException {
		put(in, remote, progress, 0);
	}

	public void put(InputStream in, String remote,
			FileTransferProgress progress, long position)
			throws SftpStatusException, SshException,
			TransferCancelledException {
		String remotePath = resolveRemotePath(remote);

		SftpFileAttributes attrs = null;

		SftpFile file;

		if (transferMode == MODE_TEXT) {

			// Default text mode handling for versions 3- of the SFTP protocol
			int inputStyle = EOLProcessor.TEXT_SYSTEM;
			int outputStyle = eolMode;

			byte[] nl = null;

			if (sftp.getVersion() <= 3
					&& sftp.getExtension("newline@vandyke.com") != null) {
				nl = sftp.getExtension("newline@vandyke.com");
			} else if (sftp.getVersion() > 3) {
				nl = sftp.getCanonicalNewline();
			}
			// Setup text mode correctly if were using version 4+ of the
			// SFTP protocol
			if (nl != null) {
				switch (nl.length) {
				case 1:
					if (nl[0] == '\r')
						outputStyle = EOLProcessor.TEXT_CR;
					else if (nl[0] == '\n')
						outputStyle = EOLProcessor.TEXT_LF;
					else
						throw new SftpStatusException(
								SftpStatusException.INVALID_HANDLE,
								"Unsupported text mode: invalid newline character");
					break;
				case 2:
					if (nl[0] == '\r' && nl[1] == '\n')
						outputStyle = EOLProcessor.TEXT_CRLF;
					else
						throw new SftpStatusException(
								SftpStatusException.INVALID_HANDLE,
								"Unsupported text mode: invalid newline characters");
					break;
				default:
					throw new SftpStatusException(
							SftpStatusException.INVALID_HANDLE,
							"Unsupported text mode: newline length > 2");

				}
			}

			try {
				in = EOLProcessor
						.createInputStream(inputStyle, outputStyle, in);
			} catch (IOException ex) {
				throw new SshException(
						"Failed to create EOL processing stream",
						SshException.INTERNAL_ERROR);
			}
		}

		attrs = new SftpFileAttributes(sftp,
				SftpFileAttributes.SSH_FILEXFER_TYPE_REGULAR);

		attrs.setPermissions(new UnsignedInteger32(0666 ^ umask));

		if (position > 0) {

			if (transferMode == MODE_TEXT && sftp.getVersion() > 3) {
				throw new SftpStatusException(
						SftpStatusException.SSH_FX_OP_UNSUPPORTED,
						"Resume on text mode files is not supported");
			}

			file = sftp.openFile(remotePath, SftpSubsystemChannel.OPEN_APPEND
					| SftpSubsystemChannel.OPEN_WRITE, attrs);
		} else {
			if (transferMode == MODE_TEXT && sftp.getVersion() > 3) {
				file = sftp.openFile(remotePath,
						SftpSubsystemChannel.OPEN_CREATE
								| SftpSubsystemChannel.OPEN_TRUNCATE
								| SftpSubsystemChannel.OPEN_WRITE
								| SftpSubsystemChannel.OPEN_TEXT, attrs);
			} else {
				file = sftp.openFile(remotePath,
						SftpSubsystemChannel.OPEN_CREATE
								| SftpSubsystemChannel.OPEN_TRUNCATE
								| SftpSubsystemChannel.OPEN_WRITE, attrs);
			}
		}

		if (progress != null) {
			try {
				progress.started(in.available(), remotePath);
			} catch (IOException ex1) {
				throw new SshException("Failed to determine local file size",
						SshException.INTERNAL_ERROR);
			}
		}

		try {
			sftp.performOptimizedWrite(file.getHandle(), blocksize,
					asyncRequests, in, buffersize, progress, position);
		} finally {
			try {
				in.close();
			} catch (Throwable t) {
			}
			sftp.closeFile(file);
		}

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

	}

	/**
	 * Create an OutputStream for writing to a remote file.
	 * 
	 * @param remotefile
	 * @return OutputStream
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public OutputStream getOutputStream(String remotefile)
			throws SftpStatusException, SshException {

		String remotePath = resolveRemotePath(remotefile);
		return new SftpFileOutputStream(sftp.openFile(remotePath,
				SftpSubsystemChannel.OPEN_CREATE
						| SftpSubsystemChannel.OPEN_TRUNCATE
						| SftpSubsystemChannel.OPEN_WRITE));

	}

	/**
	 * Upload the contents of an InputStream to the remote computer.
	 * 
	 * @param in
	 * @param remote
	 * @param position
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public void put(InputStream in, String remote, long position)
			throws SftpStatusException, SshException,
			TransferCancelledException {
		put(in, remote, null, position);
	}

	/**
	 * Upload the contents of an InputStream to the remote computer.
	 * 
	 * @param in
	 * @param remote
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public void put(InputStream in, String remote) throws SftpStatusException,
			SshException, TransferCancelledException {
		put(in, remote, null, 0);
	}

	/**
	 * <p>
	 * Sets the user ID to owner for the file or directory.
	 * </p>
	 * 
	 * @param uid
	 *            numeric user id of the new owner
	 * @param path
	 *            the path to the remote file/directory
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * 
	 */
	public void chown(String uid, String path) throws SftpStatusException,
			SshException {
		String actual = resolveRemotePath(path);

		SftpFileAttributes attrs = sftp.getAttributes(actual);
		attrs.setUID(uid);
		sftp.setAttributes(actual, attrs);

	}

	/**
	 * <p>
	 * Sets the group ID for the file or directory.
	 * </p>
	 * 
	 * @param gid
	 *            the numeric group id for the new group
	 * @param path
	 *            the path to the remote file/directory
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public void chgrp(String gid, String path) throws SftpStatusException,
			SshException {
		String actual = resolveRemotePath(path);

		SftpFileAttributes attrs = sftp.getAttributes(actual);
		attrs.setGID(gid);
		sftp.setAttributes(actual, attrs);

	}

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

	/**
	 * Sets the umask for this client.<br>
	 * <blockquote>
	 * 
	 * <pre>
	 * To give yourself full permissions for both files and directories and
	 * prevent the group and other users from having access:
	 * 
	 *   umask("077");
	 * 
	 * This subtracts 077 from the system defaults for files and directories
	 * 666 and 777. Giving a default access permissions for your files of
	 * 600 (rw-------) and for directories of 700 (rwx------).
	 * 
	 * To give all access permissions to the group and allow other users read
	 * and execute permission:
	 * 
	 *   umask("002");
	 * 
	 * This subtracts 002 from the system defaults to give a default access permission
	 * for your files of 664 (rw-rw-r--) and for your directories of 775 (rwxrwxr-x).
	 * 
	 * To give the group and other users all access except write access:
	 * 
	 *   umask("022");
	 * 
	 * This subtracts 022 from the system defaults to give a default access permission
	 * for your files of 644 (rw-r--r--) and for your directories of 755 (rwxr-xr-x).
	 * </pre>
	 * 
	 * </blockquote>
	 * 
	 * @param umask
	 * @throws SshException
	 */
	public void umask(String umask) throws SshException {
		try {
			this.umask = Integer.parseInt(umask, 8);
		} catch (NumberFormatException ex) {
			throw new SshException(
					"umask must be 4 digit octal number e.g. 0022",
					SshException.BAD_API_USAGE);
		}
	}

	/**
	 * <p>
	 * Rename a file on the remote computer.
	 * </p>
	 * 
	 * @param oldpath
	 *            the old path
	 * @param newpath
	 *            the new path
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public void rename(String oldpath, String newpath)
			throws SftpStatusException, SshException {
		String from = resolveRemotePath(oldpath);
		String to = resolveRemotePath(newpath);

		SftpFileAttributes attrs = null;

		try {
			attrs = sftp.getAttributes(to);

		} catch (SftpStatusException ex) {
			sftp.renameFile(from, to);
			return;
		}

		if (attrs != null && attrs.isDirectory()) {
			sftp.renameFile(from, to);
		} else {
			throw new SftpStatusException(
					SftpStatusException.SSH_FX_FILE_ALREADY_EXISTS, newpath
							+ " already exists on the remote filesystem");
		}

	}

	/**
	 * <p>
	 * Remove a file or directory from the remote computer.
	 * </p>
	 * 
	 * @param path
	 *            the path of the remote file/directory
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public void rm(String path) throws SftpStatusException, SshException {
		String actual = resolveRemotePath(path);

		SftpFileAttributes attrs = sftp.getAttributes(actual);
		if (attrs.isDirectory()) {
			sftp.removeDirectory(actual);
		} else {
			sftp.removeFile(actual);
		}
	}

	/**
	 * Remove a file or directory on the remote computer with options to force
	 * deletion of existing files and recursion.
	 * 
	 * @param path
	 * @param force
	 * @param recurse
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public void rm(String path, boolean force, boolean recurse)
			throws SftpStatusException, SshException {
		String actual = resolveRemotePath(path);

		SftpFileAttributes attrs = null;

		attrs = sftp.getAttributes(actual);

		SftpFile file;

		if (attrs.isDirectory()) {
			SftpFile[] list = ls(path);

			if (!force && (list.length > 0)) {
				throw new SftpStatusException(
						SftpStatusException.SSH_FX_FAILURE,
						"You cannot delete non-empty directory, use force=true to overide");
			}
			for (int i = 0; i < list.length; i++) {
				file = list[i];

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

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

	/**
	 * <p>
	 * Create a symbolic link on the remote computer.
	 * </p>
	 * 
	 * @param path
	 *            the path to the existing file
	 * @param link
	 *            the new link
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public void symlink(String path, String link) throws SftpStatusException,
			SshException {
		String actualPath = resolveRemotePath(path);
		String actualLink = resolveRemotePath(link);

		sftp.createSymbolicLink(actualLink, actualPath);
	}

	/**
	 * <p>
	 * Returns the attributes of the file from the remote computer.
	 * </p>
	 * 
	 * @param path
	 *            the path of the file on the remote computer
	 * 
	 * @return the attributes
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public SftpFileAttributes stat(String path) throws SftpStatusException,
			SshException {
		String actual = resolveRemotePath(path);
		return sftp.getAttributes(actual);
	}

	/**
	 * <p>
	 * Returns the attributes of a link on the remote computer.
	 * </p>
	 * 
	 * @param path
	 *            the path of the file on the remote computer
	 * 
	 * @return the attributes
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public SftpFileAttributes statLink(String path) throws SftpStatusException,
			SshException {
		String actual = resolveRemotePath(path);
		return sftp.getLinkAttributes(actual);
	}

	/**
	 * Get the absolute path for a file.
	 * 
	 * @param path
	 * 
	 * @return String
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 */
	public String getAbsolutePath(String path) throws SftpStatusException,
			SshException {
		String actual = resolveRemotePath(path);
		return sftp.getAbsolutePath(actual);
	}

	/**
	 * <p>
	 * Close the SFTP client.
	 * </p>
	 * 
	 */
	public void quit() throws SshException {
		try {
			sftp.close();
		} catch (SshIOException ex) {
			throw ex.getRealException();
		} catch (IOException ex1) {
			throw new SshException(ex1.getMessage(),
					SshException.CHANNEL_FAILURE);
		}

	}

	/**
	 * <p>
	 * Close the SFTP client.
	 * </p>
	 * 
	 */
	public void exit() throws SshException {
		try {
			sftp.close();
		} catch (SshIOException ex) {
			throw ex.getRealException();
		} catch (IOException ex1) {
			throw new SshException(ex1.getMessage(),
					SshException.CHANNEL_FAILURE);
		}

	}

	/**
	 * Copy the contents of a local directory into a remote directory.
	 * 
	 * @param localdir
	 *            the path to the local directory
	 * @param remotedir
	 *            the remote directory which will receive the contents
	 * @param recurse
	 *            recurse through child folders
	 * @param sync
	 *            synchronize the directories by removing files on the remote
	 *            server that do not exist locally
	 * @param commit
	 *            actually perform the operation. If <tt>false</tt> a <a
	 *            href="DirectoryOperation.html">DirectoryOperation</a> will be
	 *            returned so that the operation can be evaluated and no actual
	 *            files will be created/transfered.
	 * @param progress
	 * 
	 * @return DirectoryOperation
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public DirectoryOperation copyLocalDirectory(String localdir,
			String remotedir, boolean recurse, boolean sync, boolean commit,
			FileTransferProgress progress) throws FileNotFoundException,
			SftpStatusException, SshException, TransferCancelledException {
		DirectoryOperation op = new DirectoryOperation();

		// Record the previous
		// String pwd = pwd();
		// String lpwd = lpwd();

		File local = resolveLocalPath(localdir);

		remotedir = resolveRemotePath(remotedir);
		remotedir += (remotedir.endsWith("/") ? "" : "/");

		// Setup the remote directory if were committing
		if (commit) {
			try {
				sftp.getAttributes(remotedir);
			} catch (SftpStatusException ex) {
				mkdirs(remotedir);
			}
		}

		// List the local files and verify against the remote server
		String[] ls = local.list();
		File source;
		if (ls != null) {
			for (int i = 0; i < ls.length; i++) {
				source = new File(local, ls[i]);
				if (source.isDirectory() && !source.getName().equals(".")
						&& !source.getName().equals("..")) {
					if (recurse) {
						// File f = new File(local, source.getName());
						op.addDirectoryOperation(
								copyLocalDirectory(source.getAbsolutePath(),
										remotedir + source.getName(), recurse,
										sync, commit, progress), source);
					}
				} else if (source.isFile()) {

					boolean newFile = false;
					boolean unchangedFile = false;

					try {
						SftpFileAttributes attrs = sftp.getAttributes(remotedir
								+ source.getName());
						unchangedFile = ((source.length() == attrs.getSize()
								.longValue()) && ((source.lastModified() / 1000) == attrs
								.getModifiedTime().longValue()));

					} catch (SftpStatusException ex) {
						newFile = true;
					}

					try {

						if (commit && !unchangedFile) { // BPS - Added
							// !unChangedFile test.
							// Why would want to
							// copy that has been
							// determined to be
							// unchanged?
							put(source.getAbsolutePath(),
									remotedir + source.getName(), progress);
							SftpFileAttributes attrs = sftp
									.getAttributes(remotedir + source.getName());
							attrs.setTimes(
									new UnsignedInteger64(
											source.lastModified() / 1000),
									new UnsignedInteger64(
											source.lastModified() / 1000));
							sftp.setAttributes(remotedir + source.getName(),
									attrs);
						}

						if (unchangedFile) {
							op.addUnchangedFile(source);
						} else if (!newFile) {
							op.addUpdatedFile(source);
						} else {
							op.addNewFile(source);
						}

					} catch (SftpStatusException ex) {
						op.addFailedTransfer(source, ex);
					}
				}
			}
		}

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

				File f;

				for (int i = 0; i < files.length; i++) {
					file = files[i];

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

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

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

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

		// Return the operation details
		return op;
	}

	private void recurseMarkForDeletion(SftpFile file, DirectoryOperation op)
			throws SftpStatusException, SshException {
		SftpFile[] list = ls(file.getAbsolutePath());
		op.addDeletedFile(file);

		for (int i = 0; i < list.length; i++) {
			file = list[i];

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

	private void recurseMarkForDeletion(File file, DirectoryOperation op)
			throws SftpStatusException, SshException {
		String[] list = file.list();
		op.addDeletedFile(file);

		if (list != null) {
			for (int i = 0; i < list.length; i++) {
				file = new File(list[i]);

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

	/**
	 * Format a String with the details of the file. <blockquote>
	 * 
	 * <pre>
	 * -rwxr-xr-x   1 mjos     staff      348911 Mar 25 14:29 t-filexfer
	 * </pre>
	 * 
	 * </blockquote>
	 * 
	 * @param file
	 * @throws SftpStatusException
	 * @throws SshException
	 * @return String
	 */
	public static String formatLongname(SftpFile file)
			throws SftpStatusException, SshException {
		return formatLongname(file.getAttributes(), file.getFilename());
	}

	/**
	 * Format a String with the details of the file. <blockquote>
	 * 
	 * <pre>
	 * -rwxr-xr-x   1 mjos     staff      348911 Mar 25 14:29 t-filexfer
	 * </pre>
	 * 
	 * </blockquote>
	 * 
	 * @param attrs
	 * @param filename
	 * @return String
	 */
	public static String formatLongname(SftpFileAttributes attrs,
			String filename) {

		StringBuffer str = new StringBuffer();
		str.append(pad(10 - attrs.getPermissionsString().length())
				+ attrs.getPermissionsString());
		str.append("    1 ");
		str.append(attrs.getUID() + pad(8 - attrs.getUID().length())); // uid
		str.append(" ");
		str.append(attrs.getGID() + pad(8 - attrs.getGID().length())); // gid
		str.append(" ");
		str.append(pad(8 - attrs.getSize().toString().length())
				+ attrs.getSize().toString());
		str.append(" ");
		str.append(pad(12 - getModTimeString(attrs.getModifiedTime()).length())
				+ getModTimeString(attrs.getModifiedTime()));
		str.append(" ");
		str.append(filename);

		return str.toString();
	}

	private static String getModTimeString(UnsignedInteger64 mtime) {
		if (mtime == null) {
			return "";
		}

		SimpleDateFormat df;
		long mt = (mtime.longValue() * 1000L);
		long now = System.currentTimeMillis();

		if ((now - mt) > (6 * 30 * 24 * 60 * 60 * 1000L)) {
			df = new SimpleDateFormat("MMM dd  yyyy");
		} else {
			df = new SimpleDateFormat("MMM dd hh:mm");
		}

		return df.format(new Date(mt));
	}

	private static String pad(int num) {

		StringBuffer strBuf = new StringBuffer("");
		if (num > 0) {
			for (int i = 0; i < num; i++) {
				strBuf.append(" ");
			}
		}

		return strBuf.toString();
	}

	/**
	 * Copy the contents of a remote directory to a local directory
	 * 
	 * @param remotedir
	 *            the remote directory whose contents will be copied.
	 * @param localdir
	 *            the local directory to where the contents will be copied
	 * @param recurse
	 *            recurse into child folders
	 * @param sync
	 *            synchronized the directories by removing files and directories
	 *            that do not exist on the remote server.
	 * @param commit
	 *            actually perform the operation. If <tt>false</tt> the
	 *            operation will be processed and a <a
	 *            href="DirectoryOperation.html">DirectoryOperation</a> will be
	 *            returned without actually transfering any files.
	 * @param progress
	 * 
	 * @return DirectoryOperation
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public DirectoryOperation copyRemoteDirectory(String remotedir,
			String localdir, boolean recurse, boolean sync, boolean commit,
			FileTransferProgress progress) throws FileNotFoundException,
			SftpStatusException, SshException, TransferCancelledException {
		// Create an operation object to hold the information
		DirectoryOperation op = new DirectoryOperation();

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

		// Setup the local cwd
		String base = remotedir;

		if (base.endsWith("/"))
			base = base.substring(0, base.length() - 1);

		int idx = base.lastIndexOf('/');

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

		File local = new File(localdir);

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

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

		SftpFile[] files = ls();
		SftpFile file;
		File f;

		for (int i = 0; i < files.length; i++) {
			file = files[i];

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

				if (f.exists()
						&& (f.length() == file.getAttributes().getSize()
								.longValue())
						&& ((f.lastModified() / 1000) == file.getAttributes()
								.getModifiedTime().longValue())) {
					if (commit) {
						op.addUnchangedFile(f);
					} else {
						op.addUnchangedFile(file);
					}

					continue;
				}

				try {

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

					if (commit) {
						// Get the file
						get(file.getFilename(), f.getAbsolutePath(), progress);
					}

				} catch (SftpStatusException ex) {
					op.addFailedTransfer(f, ex);
				}
			}
		}

		if (sync) {
			// List the contents of the new local directory and remove any
			// files/directories that were not updated
			String[] contents = local.list();
			File f2;
			if (contents != null) {
				for (int i = 0; i < contents.length; i++) {
					f2 = new File(local, contents[i]);
					if (!op.containsFile(f2)) {
						op.addDeletedFile(f2);

						if (f2.isDirectory() && !f2.getName().equals(".")
								&& !f2.getName().equals("..")) {
							recurseMarkForDeletion(f2, op);

							if (commit) {
								IOUtil.recurseDeleteDirectory(f2);
							}
						} else if (commit) {
							f2.delete();
						}
					}
				}
			}
		}

		cd(pwd);

		return op;
	}

	/**
	 * <p>
	 * Download the remote files to the local computer
	 * </p>
	 * 
	 * <p>
	 * When RegExpSyntax is set to NoSyntax the getFiles() methods act
	 * identically to the get() methods except for a different return type.
	 * </p>
	 * 
	 * <p>
	 * When RegExpSyntax is set to GlobSyntax or Perl5Syntax, getFiles() treats
	 * 'remote' as a regular expression, and gets all the files in 'remote''s
	 * parent directory that match the pattern. The default parent directory of
	 * remote is the remote cwd unless 'remote' contains file seperators(/).
	 * </p>
	 * 
	 * <p>
	 * Examples can be found in SftpConnect.java
	 * 
	 * <p>
	 * Code Example: <blockquote>
	 * 
	 * <pre>
	 * // change reg exp syntax from default SftpClient.NoSyntax (no reg exp matching)
	 * // to SftpClient.GlobSyntax
	 * sftp.setRegularExpressionSyntax(SftpClient.GlobSyntax);
	 * // get all .doc files with 'rfc' in their names, in the 'docs/unsorted/' folder
	 * // relative to the remote cwd, and copy them to the local cwd.
	 * sftp.getFiles("docs/unsorted/*rfc*.doc");
	 * </pre>
	 * 
	 * </blockquote>
	 * </p>
	 * 
	 * @param remote
	 *            the regular expression path to the remote file
	 * 
	 * @return the downloaded files' attributes
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFile[] getFiles(String remote) throws FileNotFoundException,
			SftpStatusException, SshException, TransferCancelledException {
		return getFiles(remote, (FileTransferProgress) null);
	}

	/**
	 * <p>
	 * Download the remote files to the local computer
	 * 
	 * @param remote
	 *            the regular expression path to the remote file
	 * @param resume
	 *            attempt to resume an interrupted download
	 * 
	 * @return the downloaded files' attributes
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFile[] getFiles(String remote, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		return getFiles(remote, (FileTransferProgress) null, resume);
	}

	/**
	 * <p>
	 * Download the remote files to the local computer.
	 * </p>
	 * 
	 * @param remote
	 *            the regular expression path to the remote file
	 * @param progress
	 * 
	 * @return SftpFile[]
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFile[] getFiles(String remote, FileTransferProgress progress)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		return getFiles(remote, progress, false);
	}

	/**
	 * <p>
	 * Download the remote files to the local computer.
	 * </p>
	 * 
	 * @param remote
	 *            the regular expression path to the remote file
	 * @param progress
	 * @param resume
	 *            attempt to resume a interrupted download
	 * 
	 * @return SftpFile[]
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFile[] getFiles(String remote, FileTransferProgress progress,
			boolean resume) throws FileNotFoundException, SftpStatusException,
			SshException, TransferCancelledException {
		return getFiles(remote, lcwd, progress, resume);
	}

	/**
	 * Download the remote files into an OutputStream.
	 * 
	 * @param remote
	 * @param local
	 * 
	 * @return SftpFile[]
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	/*
	 * public SftpFile[] getFiles(String remote, OutputStream local) throws
	 * FileNotFoundException, SftpStatusException, SshException,
	 * TransferCancelledException { return getFiles(remote, local, null, 0); }
	 */

	/**
	 * <p>
	 * Download the remote files writing it to the specified
	 * <code>OutputStream</code>. The OutputStream is closed by this mehtod even
	 * if the operation fails.
	 * </p>
	 * 
	 * @param remote
	 *            the regular expression path/name of the remote file
	 * @param local
	 *            the OutputStream to write
	 * @param progress
	 * 
	 * @return SftpFile[]
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	/*
	 * public SftpFile[] getFiles(String remote, OutputStream local,
	 * FileTransferProgress progress) throws FileNotFoundException,
	 * SftpStatusException, SshException, TransferCancelledException { return
	 * getFiles(remote, local, progress, 0); }
	 */

	/**
	 * Download the remote files into an OutputStream.
	 * 
	 * @param remote
	 * @param local
	 * @param position
	 *            the position from which to start reading the remote file
	 * 
	 * @return SftpFile[]
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	/*
	 * public SftpFile[] getFiles(String remote, OutputStream local, long
	 * position) throws FileNotFoundException, SftpStatusException,
	 * SshException, TransferCancelledException { return getFiles(remote, local,
	 * null, position); }
	 */

	/**
	 * Download the remote files into the local file.
	 * 
	 * @param remote
	 * @param local
	 * 
	 * @return SftpFile[]
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFile[] getFiles(String remote, String local)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		return getFiles(remote, local, false);
	}

	/**
	 * Download the remote files into the local file.
	 * 
	 * @param remote
	 * @param local
	 * @param resume
	 *            attempt to resume an interrupted download
	 * 
	 * @return SftpFile[]
	 * 
	 * @throws FileNotFoundException
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFile[] getFiles(String remote, String local, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		return getFiles(remote, local, null, resume);
	}

	/**
	 * <p>
	 * Download the remote file to the local computer. If the paths provided are
	 * not absolute the current working directory is used.
	 * </p>
	 * 
	 * @param remote
	 *            the regular expression path/name of the remote files
	 * @param local
	 *            the path/name to place the file on the local computer
	 * @param progress
	 * 
	 * @return SftpFile[]
	 * 
	 * @throws SftpStatusException
	 * @throws FileNotFoundException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	public SftpFile[] getFiles(String remote, String local,
			FileTransferProgress progress, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		return getFileMatches(remote, local, progress, resume);
	}

	/**
	 * <p>
	 * Upload the contents of an InputStream to the remote computer.
	 * </p>
	 * 
	 * @param in
	 * @param remote
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	/*
	 * public void putFiles(InputStream in, String remote) throws
	 * FileNotFoundException, SftpStatusException, SshException,
	 * TransferCancelledException { putFiles(in, remote, null, 0); }
	 */

	/**
	 * <p>
	 * Upload files to the remote computer reading from the specified <code>
	 * InputStream</code>. The InputStream is closed, even if the operation
	 * fails.
	 * </p>
	 * 
	 * @param in
	 *            the InputStream being read
	 * @param remote
	 *            the path/name of the destination file
	 * @param progress
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	/*
	 * public void putFiles(InputStream in, String remote, FileTransferProgress
	 * progress) throws FileNotFoundException, SftpStatusException,
	 * SshException, TransferCancelledException { putFiles(in, remote, progress,
	 * 0); }
	 * 
	 * public void putFiles(InputStream in, String remote, FileTransferProgress
	 * progress, long position) throws FileNotFoundException,
	 * SftpStatusException, SshException, TransferCancelledException {
	 * this.localI = in; this.position = position; // putFileMatches(remote,
	 * progress, true); put(remote, progress, true);
	 * 
	 * }
	 */

	/**
	 * Upload the contents of an InputStream to the remote computer.
	 * 
	 * @param in
	 * @param remote
	 * @param position
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 */
	/*
	 * public void putFiles(InputStream in, String remote, long position) throws
	 * FileNotFoundException, SftpStatusException, SshException,
	 * TransferCancelledException { putFiles(in, remote, null, position); }
	 */

	/**
	 * <p>
	 * Upload the contents of an InputStream to the remote computer.
	 * </p>
	 * 
	 * <p>
	 * When RegExpSyntax is set to NoSyntax the putFiles() methods act
	 * identically to the put() methods except for a different return type.
	 * </p>
	 * 
	 * <p>
	 * When RegExpSyntax is set to GlobSyntax or Perl5Syntax, putFiles() treats
	 * 'local' as a regular expression, and gets all the files in 'local''s
	 * parent directory that match the pattern. The default parent directory of
	 * local is the local cwd unless 'local' contains file seperators.
	 * </p>
	 * 
	 * <p>
	 * Examples can be found in SftpConnect.java
	 * 
	 * <p>
	 * Code Example: <blockquote>
	 * 
	 * <pre>
	 * // change reg exp syntax from default SftpClient.NoSyntax (no reg exp matching)
	 * // to SftpClient.GlobSyntax
	 * sftp.setRegularExpressionSyntax(SftpClient.GlobSyntax);
	 * // put all .doc files with 'rfc' in their names, in the 'docs/unsorted/' folder
	 * // relative to the local cwd, and copy them to the remote cwd.
	 * sftp.putFiles("docs/unsorted/*rfc*.doc");
	 * </pre>
	 * 
	 * </blockquote>
	 * </p>
	 * 
	 * @param local
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void putFiles(String local) throws FileNotFoundException,
			SftpStatusException, SshException, TransferCancelledException {
		putFiles(local, false);
	}

	/**
	 * Upload files to the remote computer
	 * 
	 * @param local
	 * @param resume
	 *            attempt to resume after an interrupted transfer
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void putFiles(String local, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		putFiles(local, (FileTransferProgress) null, resume);
	}

	/**
	 * <p>
	 * Upload files to the remote computer
	 * </p>
	 * 
	 * @param local
	 *            the regular expression path/name of the local files
	 * @param progress
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void putFiles(String local, FileTransferProgress progress)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		putFiles(local, progress, false);
	}

	/**
	 * <p>
	 * Upload files to the remote computer
	 * </p>
	 * 
	 * @param local
	 *            the regular expression path/name of the local files
	 * @param progress
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void putFiles(String local, FileTransferProgress progress,
			boolean resume) throws FileNotFoundException, SftpStatusException,
			SshException, TransferCancelledException {
		putFiles(local, pwd(), progress, resume);
	}

	/**
	 * Upload files to the remote computer
	 * 
	 * @param local
	 * @param remote
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void putFiles(String local, String remote)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		putFiles(local, remote, null, false);
	}

	/**
	 * Upload files to the remote computer
	 * 
	 * @param local
	 * @param remote
	 * @param resume
	 *            attempt to resume after an interrupted transfer
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void putFiles(String local, String remote, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		putFiles(local, remote, null, resume);
	}

	/**
	 * <p>
	 * Upload files to the remote computer. If the paths provided are not
	 * absolute the current working directory is used.
	 * </p>
	 * 
	 * @param local
	 *            the regular expression path/name of the local files
	 * @param remote
	 *            the path/name of the destination file
	 * @param progress
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void putFiles(String local, String remote,
			FileTransferProgress progress) throws FileNotFoundException,
			SftpStatusException, SshException, TransferCancelledException {
		putFiles(local, remote, progress, false);
	}

	/**
	 * make local copies of some of the variables, then call putfilematches,
	 * which calls "put" on each file that matches the regexp local.
	 * 
	 * @param local
	 *            the regular expression path/name of the local files
	 * @param remote
	 *            the path/name of the destination file
	 * @param progress
	 * @param resume
	 *            attempt to resume after an interrupted transfer
	 * 
	 * @throws SftpStatusException
	 * @throws SshException
	 * @throws TransferCancelledException
	 * @throws FileNotFoundException
	 */
	public void putFiles(String local, String remote,
			FileTransferProgress progress, boolean resume)
			throws FileNotFoundException, SftpStatusException, SshException,
			TransferCancelledException {
		putFileMatches(local, remote, progress, resume);
	}

	/**
	 * A simple wrapper class to provide an OutputStream to a RandomAccessFile
	 * 
	 * @author Lee David Painter
	 */
	static class RandomAccessFileOutputStream extends OutputStream {

		RandomAccessFile file;

		RandomAccessFileOutputStream(RandomAccessFile file) {
			this.file = file;
		}

		public void write(int b) throws IOException {
			file.write(b);
		}

		public void write(byte[] buf, int off, int len) throws IOException {
			file.write(buf, off, len);
		}

		public void close() throws IOException {
			file.close();
		}
	}

}