/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.sshd.server.sftp;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Calendar;
import java.util.Date;
import java.util.EnumSet;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.apache.sshd.common.NamedFactory;
import org.apache.sshd.common.util.Buffer;
import org.apache.sshd.common.util.IoUtils;
import org.apache.sshd.common.util.SelectorUtils;
import org.apache.sshd.server.Command;
import org.apache.sshd.server.Environment;
import org.apache.sshd.server.ExitCallback;
import org.apache.sshd.common.file.FileSystemAware;
import org.apache.sshd.common.file.FileSystemView;
import org.apache.sshd.server.SessionAware;
import org.apache.sshd.common.file.SshFile;
import org.apache.sshd.server.session.ServerSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* SFTP subsystem
*
* @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
*/
public class SftpSubsystem implements Command, Runnable, SessionAware, FileSystemAware {
protected final Logger log = LoggerFactory.getLogger(getClass());
public static class Factory implements NamedFactory<Command> {
public Factory() {
}
public Command create() {
return new SftpSubsystem();
}
public String getName() {
return "sftp";
}
}
/**
* Properties key for the maximum of available open handles per session.
*/
public static final String MAX_OPEN_HANDLES_PER_SESSION = "max-open-handles-per-session";
public static final int LOWER_SFTP_IMPL = 3; // Working implementation from v3
public static final int HIGHER_SFTP_IMPL = 3; // .. up to
public static final String ALL_SFTP_IMPL = "3";
public static final int MAX_PACKET_LENGTH = 1024 * 16;
public static final int SSH_FXP_INIT = 1;
public static final int SSH_FXP_VERSION = 2;
public static final int SSH_FXP_OPEN = 3;
public static final int SSH_FXP_CLOSE = 4;
public static final int SSH_FXP_READ = 5;
public static final int SSH_FXP_WRITE = 6;
public static final int SSH_FXP_LSTAT = 7;
public static final int SSH_FXP_FSTAT = 8;
public static final int SSH_FXP_SETSTAT = 9;
public static final int SSH_FXP_FSETSTAT = 10;
public static final int SSH_FXP_OPENDIR = 11;
public static final int SSH_FXP_READDIR = 12;
public static final int SSH_FXP_REMOVE = 13;
public static final int SSH_FXP_MKDIR = 14;
public static final int SSH_FXP_RMDIR = 15;
public static final int SSH_FXP_REALPATH = 16;
public static final int SSH_FXP_STAT = 17;
public static final int SSH_FXP_RENAME = 18;
public static final int SSH_FXP_READLINK = 19;
public static final int SSH_FXP_SYMLINK = 20;
public static final int SSH_FXP_STATUS = 101;
public static final int SSH_FXP_HANDLE = 102;
public static final int SSH_FXP_DATA = 103;
public static final int SSH_FXP_NAME = 104;
public static final int SSH_FXP_ATTRS = 105;
public static final int SSH_FXP_EXTENDED = 200;
public static final int SSH_FXP_EXTENDED_REPLY = 201;
public static final int SSH_FX_OK = 0;
public static final int SSH_FX_EOF = 1;
public static final int SSH_FX_NO_SUCH_FILE = 2;
public static final int SSH_FX_PERMISSION_DENIED = 3;
public static final int SSH_FX_FAILURE = 4;
public static final int SSH_FX_BAD_MESSAGE = 5;
public static final int SSH_FX_NO_CONNECTION = 6;
public static final int SSH_FX_CONNECTION_LOST = 7;
public static final int SSH_FX_OP_UNSUPPORTED = 8;
public static final int SSH_FILEXFER_ATTR_SIZE = 0x00000001;
public static final int SSH_FILEXFER_ATTR_UIDGID = 0x00000002;
public static final int SSH_FILEXFER_ATTR_PERMISSIONS = 0x00000004;
public static final int SSH_FILEXFER_ATTR_ACMODTIME = 0x00000008; //v3 naming convention
public static final int SSH_FILEXFER_ATTR_EXTENDED = 0x80000000;
public static final int SSH_FXF_READ = 0x00000001;
public static final int SSH_FXF_WRITE = 0x00000002;
public static final int SSH_FXF_APPEND = 0x00000004;
public static final int SSH_FXF_CREAT = 0x00000008;
public static final int SSH_FXF_TRUNC = 0x00000010;
public static final int SSH_FXF_EXCL = 0x00000020;
public static final int S_IFMT = 0170000; // bitmask for the file type bitfields
public static final int S_IFSOCK = 0140000; // socket
public static final int S_IFLNK = 0120000; // symbolic link
public static final int S_IFREG = 0100000; // regular file
public static final int S_IFBLK = 0060000; // block device
public static final int S_IFDIR = 0040000; // directory
public static final int S_IFCHR = 0020000; // character device
public static final int S_IFIFO = 0010000; // fifo
public static final int S_ISUID = 0004000; // set UID bit
public static final int S_ISGID = 0002000; // set GID bit
public static final int S_ISVTX = 0001000; // sticky bit
public static final int S_IRUSR = 0000400;
public static final int S_IWUSR = 0000200;
public static final int S_IXUSR = 0000100;
public static final int S_IRGRP = 0000040;
public static final int S_IWGRP = 0000020;
public static final int S_IXGRP = 0000010;
public static final int S_IROTH = 0000004;
public static final int S_IWOTH = 0000002;
public static final int S_IXOTH = 0000001;
private ExitCallback callback;
private InputStream in;
private OutputStream out;
private OutputStream err;
private Environment env;
private ServerSession session;
private boolean closed = false;
private FileSystemView root;
private int version;
private Map<String, Handle> handles = new HashMap<String, Handle>();
protected static abstract class Handle {
SshFile file;
public Handle(SshFile file) {
this.file = file;
}
public SshFile getFile() {
return file;
}
public void close() throws IOException {
file.handleClose();
}
}
protected static class DirectoryHandle extends Handle implements Iterator<SshFile> {
boolean done;
// the directory should be read once at "open directory"
List<SshFile> fileList = null;
int fileIndex;
public DirectoryHandle(SshFile file) {
super(file);
fileList = file.listSshFiles();
fileIndex = 0;
}
public boolean isDone() {
return done;
}
public void setDone(boolean done) {
this.done = done;
}
public boolean hasNext() {
return fileIndex < fileList.size();
}
public SshFile next() {
SshFile f = fileList.get(fileIndex);
fileIndex++;
return f;
}
public void remove() {
throw new UnsupportedOperationException();
}
public void clearFileList() {
// allow the garbage collector to do the job
fileList = null;
}
}
protected static class FileHandle extends Handle {
OutputStream output;
long outputPos;
InputStream input;
long inputPos;
long length;
public FileHandle(SshFile sshFile) {
super(sshFile);
}
public int read(byte[] data, long offset) throws IOException {
if (input != null && offset >= length) {
return -1;
}
if (input != null && offset != inputPos) {
IoUtils.closeQuietly(input);
input = null;
}
if (input == null) {
input = file.createInputStream(offset);
length = file.getSize();
inputPos = offset;
}
if (offset >= length) {
return -1;
}
int read = input.read(data);
inputPos += read;
return read;
}
public void write(byte[] data, long offset) throws IOException {
if (output != null && offset != outputPos) {
IoUtils.closeQuietly(output);
output = null;
}
if (output == null) {
output = file.createOutputStream(offset);
}
output.write(data);
outputPos += data.length;
}
@Override
public void close() throws IOException {
IoUtils.closeQuietly(output, input);
output = null;
input = null;
super.close();
}
}
public SftpSubsystem() {}
public void setSession(ServerSession session) {
this.session = session;
}
public void setFileSystemView(FileSystemView view) {
this.root = view;
}
public void setExitCallback(ExitCallback callback) {
this.callback = callback;
}
public void setInputStream(InputStream in) {
this.in = in;
}
public void setOutputStream(OutputStream out) {
this.out = out;
}
public void setErrorStream(OutputStream err) {
this.err = err;
}
public void start(Environment env) throws IOException {
this.env = env;
new Thread(this).start();
}
public void run() {
DataInputStream dis = null;
try {
dis = new DataInputStream(in);
while (true) {
int length = dis.readInt();
if (length < 5) {
throw new IllegalArgumentException();
}
Buffer buffer = new Buffer(length + 4);
buffer.putInt(length);
int nb = length;
while (nb > 0) {
int l = dis.read(buffer.array(), buffer.wpos(), nb);
if (l < 0) {
throw new IllegalArgumentException();
}
buffer.wpos(buffer.wpos() + l);
nb -= l;
}
process(buffer);
}
} catch (Throwable t) {
if (!closed && !(t instanceof EOFException)) { // Ignore han
log.error("Exception caught in SFTP subsystem", t);
}
} finally {
if (dis != null) {
try {
dis.close();
} catch (IOException ioe) {
log.error("Could not close DataInputStream", ioe);
}
}
if (handles != null) {
for (Map.Entry<String, Handle> entry : handles.entrySet()) {
Handle handle = entry.getValue();
try {
handle.close();
} catch (IOException ioe) {
log.error("Could not close open handle: " + entry.getKey(), ioe);
}
}
}
dis = null;
callback.onExit(0);
}
}
protected void process(Buffer buffer) throws IOException {
int length = buffer.getInt();
int type = buffer.getByte();
int id = buffer.getInt();
switch (type) {
case SSH_FXP_INIT: {
log.debug("Received SSH_FXP_INIT (version={})", version);
if (length != 5) {
throw new IllegalArgumentException();
}
version = id;
if (version >= LOWER_SFTP_IMPL) {
version = Math.min(version, HIGHER_SFTP_IMPL);
buffer.clear();
buffer.putByte((byte) SSH_FXP_VERSION);
buffer.putInt(version);
send(buffer);
} else {
// We only support version 3 (Version 1 and 2 are not common)
sendStatus(id, SSH_FX_OP_UNSUPPORTED, "SFTP server only support versions " + ALL_SFTP_IMPL);
}
break;
}
case SSH_FXP_OPEN: {
if (session.getFactoryManager().getProperties() != null) {
String maxHandlesString = session.getFactoryManager().getProperties().get(MAX_OPEN_HANDLES_PER_SESSION);
if (maxHandlesString != null) {
int maxHandleCount = Integer.parseInt(maxHandlesString);
if (handles.size() > maxHandleCount) {
sendStatus(id, SSH_FX_FAILURE, "Too many open handles");
break;
}
}
}
String path = buffer.getString();
int pflags = buffer.getInt();
Map<SshFile.Attribute, Object> attrs = readAttrs(buffer);
log.debug("Received SSH_FXP_OPEN (path={}, pflags={}, attrs={})", new Object[] { path, pflags, attrs });
try {
SshFile file = resolveFile(path);
if (file.doesExist()) {
if (((pflags & SSH_FXF_CREAT) != 0) && ((pflags & SSH_FXF_EXCL) != 0)) {
sendStatus(id, SSH_FX_FAILURE, path);
return;
}
} else {
if (((pflags & SSH_FXF_CREAT) != 0)) {
if (!file.isWritable()) {
sendStatus(id, SSH_FX_PERMISSION_DENIED, "Can not create " + path);
return;
}
file.create();
}
}
String acc = ((pflags & (SSH_FXF_READ | SSH_FXF_WRITE)) != 0 ? "r" : "") +
((pflags & SSH_FXF_WRITE) != 0 ? "w" : "");
if ((pflags & SSH_FXF_TRUNC) != 0) {
file.truncate();
}
if ((pflags & SSH_FXF_CREAT) != 0) {
file.setAttributes(attrs);
}
String handle = UUID.randomUUID().toString();
handles.put(handle, new FileHandle(file));
sendHandle(id, handle);
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage() == null ? "" : e.getMessage());
}
break;
}
case SSH_FXP_CLOSE: {
String handle = buffer.getString();
log.debug("Received SSH_FXP_CLOSE (handle={})", handle);
try {
Handle h = handles.get(handle);
if (h == null) {
sendStatus(id, SSH_FX_FAILURE, handle, "");
} else {
handles.remove(handle);
h.close();
sendStatus(id, SSH_FX_OK, "", "");
}
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_READ: {
String handle = buffer.getString();
long offset = buffer.getLong();
int len = buffer.getInt();
log.debug("Received SSH_FXP_READ (handle={}, offset={}, length={})", new Object[] { handle, offset, len });
try {
Handle p = handles.get(handle);
if (!(p instanceof FileHandle)) {
sendStatus(id, SSH_FX_FAILURE, handle);
} else {
FileHandle fh = (FileHandle) p;
byte[] b = new byte[Math.min(len, Buffer.MAX_LEN)];
len = fh.read(b, offset);
if (len >= 0) {
Buffer buf = new Buffer(len + 5);
buf.putByte((byte) SSH_FXP_DATA);
buf.putInt(id);
buf.putBytes(b, 0, len);
send(buf);
} else {
sendStatus(id, SSH_FX_EOF, "");
}
}
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_WRITE: {
String handle = buffer.getString();
long offset = buffer.getLong();
byte[] data = buffer.getBytes();
log.debug("Received SSH_FXP_WRITE (handle={}, offset={}, data=byte[{}])", new Object[] { handle, offset, data.length });
try {
Handle p = handles.get(handle);
if (!(p instanceof FileHandle)) {
sendStatus(id, SSH_FX_FAILURE, handle);
} else {
FileHandle fh = (FileHandle) p;
fh.write(data, offset);
SshFile sshFile = fh.getFile();
sshFile.setLastModified(new Date().getTime());
sendStatus(id, SSH_FX_OK, "");
}
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_LSTAT: {
String path = buffer.getString();
log.debug("Received SSH_FXP_LSTAT (path={})", path);
try {
SshFile p = resolveFile(path);
sendAttrs(id, p, false);
} catch (FileNotFoundException e) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, e.getMessage());
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_FSTAT: {
String handle = buffer.getString();
log.debug("Received SSH_FXP_FSTAT (handle={})", handle);
try {
Handle p = handles.get(handle);
if (p == null) {
sendStatus(id, SSH_FX_FAILURE, handle);
} else {
sendAttrs(id, p.getFile(), true);
}
} catch (FileNotFoundException e) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, e.getMessage());
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_SETSTAT: {
String path = buffer.getString();
Map<SshFile.Attribute, Object> attrs = readAttrs(buffer);
log.debug("Received SSH_FXP_SETSTAT (path={}, attrs={})", path, attrs);
try {
SshFile p = resolveFile(path);
p.setAttributes(attrs);
sendStatus(id, SSH_FX_OK, "");
} catch (FileNotFoundException e) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, e.getMessage());
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
} catch (UnsupportedOperationException e) {
sendStatus(id, SSH_FX_FAILURE, "");
}
break;
}
case SSH_FXP_FSETSTAT: {
String handle = buffer.getString();
Map<SshFile.Attribute, Object> attrs = readAttrs(buffer);
log.debug("Received SSH_FXP_FSETSTAT (handle={}, attrs={})", handle, attrs);
try {
Handle p = handles.get(handle);
if (p == null) {
sendStatus(id, SSH_FX_FAILURE, handle);
} else {
p.getFile().setAttributes(attrs);
sendStatus(id, SSH_FX_OK, "");
}
} catch (FileNotFoundException e) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, e.getMessage());
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
} catch (UnsupportedOperationException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_OPENDIR: {
String path = buffer.getString();
log.debug("Received SSH_FXP_OPENDIR (path={})", path);
try {
SshFile p = resolveFile(path);
if (!p.doesExist()) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, path);
} else if (!p.isDirectory()) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, path);
} else if (!p.isReadable()) {
sendStatus(id, SSH_FX_PERMISSION_DENIED, path);
} else {
String handle = UUID.randomUUID().toString();
handles.put(handle, new DirectoryHandle(p));
sendHandle(id, handle);
}
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_READDIR: {
String handle = buffer.getString();
log.debug("Received SSH_FXP_READDIR (handle={})", handle);
try {
Handle p = handles.get(handle);
if (!(p instanceof DirectoryHandle)) {
sendStatus(id, SSH_FX_FAILURE, handle);
} else if (((DirectoryHandle) p).isDone()) {
sendStatus(id, SSH_FX_EOF, "", "");
} else if (!p.getFile().doesExist()) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, p.getFile().getAbsolutePath());
} else if (!p.getFile().isDirectory()) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, p.getFile().getAbsolutePath());
} else if (!p.getFile().isReadable()) {
sendStatus(id, SSH_FX_PERMISSION_DENIED, p.getFile().getAbsolutePath());
} else {
DirectoryHandle dh = (DirectoryHandle) p;
if (dh.hasNext()) {
// There is at least one file in the directory.
// Send only a few files at a time to not create packets of a too
// large size or have a timeout to occur.
sendName(id, dh);
if (!dh.hasNext()) {
// if no more files to send
dh.setDone(true);
dh.clearFileList();
}
} else {
// empty directory
dh.setDone(true);
dh.clearFileList();
sendStatus(id, SSH_FX_EOF, "", "");
}
}
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_REMOVE: {
String path = buffer.getString();
log.debug("Received SSH_FXP_REMOVE (path={})", path);
try {
SshFile p = resolveFile(path);
if (!p.doesExist()) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, p.getAbsolutePath());
} else if (p.isDirectory()) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, p.getAbsolutePath());
} else if (!p.delete()) {
sendStatus(id, SSH_FX_FAILURE, "Failed to delete file");
} else {
sendStatus(id, SSH_FX_OK, "");
}
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_MKDIR: {
String path = buffer.getString();
log.debug("Received SSH_FXP_MKDIR (path={})", path);
// attrs
try {
SshFile p = resolveFile(path);
if (p.doesExist()) {
if (p.isDirectory()) {
sendStatus(id, SSH_FX_FAILURE, p.getAbsolutePath());
} else {
sendStatus(id, SSH_FX_NO_SUCH_FILE, p.getAbsolutePath());
}
} else if (!p.isWritable()) {
sendStatus(id, SSH_FX_PERMISSION_DENIED, p.getAbsolutePath());
} else if (!p.mkdir()) {
throw new IOException("Error creating dir " + path);
} else {
sendStatus(id, SSH_FX_OK, "");
}
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_RMDIR: {
String path = buffer.getString();
log.debug("Received SSH_FXP_RMDIR (path={})", path);
// attrs
try {
SshFile p = resolveFile(path);
if (p.isDirectory()) {
if (p.doesExist()) {
if (p.listSshFiles().size() == 0) {
if (p.delete()) {
sendStatus(id, SSH_FX_OK, "");
} else {
sendStatus(id, SSH_FX_FAILURE, "Unable to delete directory " + path);
}
} else {
sendStatus(id, SSH_FX_FAILURE, path);
}
} else {
sendStatus(id, SSH_FX_NO_SUCH_FILE, path);
}
} else {
sendStatus(id, SSH_FX_NO_SUCH_FILE, p.getAbsolutePath());
}
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_REALPATH: {
String path = buffer.getString();
log.debug("Received SSH_FXP_REALPATH (path={})", path);
if (path.trim().length() == 0) {
path = ".";
}
try {
SshFile p = resolveFile(path);
sendPath(id, p);
} catch (FileNotFoundException e) {
e.printStackTrace();
sendStatus(id, SSH_FX_NO_SUCH_FILE, e.getMessage());
} catch (IOException e) {
e.printStackTrace();
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_STAT: {
String path = buffer.getString();
log.debug("Received SSH_FXP_STAT (path={})", path);
try {
SshFile p = resolveFile(path);
sendAttrs(id, p, true);
} catch (FileNotFoundException e) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, e.getMessage());
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_RENAME: {
String oldPath = buffer.getString();
String newPath = buffer.getString();
log.debug("Received SSH_FXP_RENAME (oldPath={}, newPath={})", oldPath, newPath);
try {
SshFile o = resolveFile(oldPath);
SshFile n = resolveFile(newPath);
if (!o.doesExist()) {
sendStatus(id, SSH_FX_NO_SUCH_FILE, o.getAbsolutePath());
} else if (n.doesExist()) {
sendStatus(id, SSH_FX_FAILURE, n.getAbsolutePath());
} else if (!o.move(n)) {
sendStatus(id, SSH_FX_FAILURE, "Failed to rename file");
} else {
sendStatus(id, SSH_FX_OK, "");
}
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
case SSH_FXP_READLINK: {
String path = buffer.getString();
log.debug("Received SSH_FXP_READLINK (path={})", path);
try {
SshFile f = resolveFile(path);
String l = f.readSymbolicLink();
sendLink(id, l);
} catch (UnsupportedOperationException e) {
sendStatus(id, SSH_FX_OP_UNSUPPORTED, "Command " + type + " is unsupported or not implemented");
} catch (IOException e) {
sendStatus(id, SSH_FX_FAILURE, e.getMessage());
}
break;
}
default: {
log.error("Received: {}", type);
sendStatus(id, SSH_FX_OP_UNSUPPORTED, "Command " + type + " is unsupported or not implemented");
break;
}
}
}
protected void sendHandle(int id, String handle) throws IOException {
Buffer buffer = new Buffer();
buffer.putByte((byte) SSH_FXP_HANDLE);
buffer.putInt(id);
buffer.putString(handle);
send(buffer);
}
protected void sendAttrs(int id, SshFile file, boolean followLinks) throws IOException {
Buffer buffer = new Buffer();
buffer.putByte((byte) SSH_FXP_ATTRS);
buffer.putInt(id);
writeAttrs(buffer, file, followLinks);
send(buffer);
}
protected void sendPath(int id, SshFile f) throws IOException {
Buffer buffer = new Buffer();
buffer.putByte((byte) SSH_FXP_NAME);
buffer.putInt(id);
buffer.putInt(1);
//normalize the given path, use *nix style separator
String normalizedPath = SelectorUtils.normalizePath(f.getAbsolutePath(), "/");
if (normalizedPath.length() == 0) {
normalizedPath = "/";
}
buffer.putString(normalizedPath);
f = resolveFile(normalizedPath);
if (f.getName().length() == 0) {
f = resolveFile(".");
}
buffer.putString(getLongName(f)); // Format specified in the specs
buffer.putInt(0);
send(buffer);
}
protected void sendLink(int id, String link) throws IOException {
Buffer buffer = new Buffer();
buffer.putByte((byte) SSH_FXP_NAME);
buffer.putInt(id);
buffer.putInt(1);
//normalize the given path, use *nix style separator
buffer.putString(link);
buffer.putString(link);
buffer.putInt(0);
send(buffer);
}
protected void sendName(int id, Iterator<SshFile> files) throws IOException {
Buffer buffer = new Buffer();
buffer.putByte((byte) SSH_FXP_NAME);
buffer.putInt(id);
int wpos = buffer.wpos();
buffer.putInt(0);
int nb = 0;
while (files.hasNext() && buffer.wpos() < MAX_PACKET_LENGTH) {
SshFile f = files.next();
buffer.putString(f.getName());
buffer.putString(getLongName(f)); // Format specified in the specs
writeAttrs(buffer, f, false);
nb++;
}
int oldpos = buffer.wpos();
buffer.wpos(wpos);
buffer.putInt(nb);
buffer.wpos(oldpos);
send(buffer);
}
private String getLongName(SshFile f) throws IOException {
Map<SshFile.Attribute, Object> attributes = f.getAttributes(true);
String username = (String) attributes.get(SshFile.Attribute.Owner);
if (username.length() > 8) {
username = username.substring(0, 8);
} else {
for (int i = username.length(); i < 8; i++) {
username = username + " ";
}
}
String group = (String) attributes.get(SshFile.Attribute.Group);
if (group.length() > 8) {
group = group.substring(0, 8);
} else {
for (int i = group.length(); i < 8; i++) {
group = group + " ";
}
}
long length = (Long) attributes.get(SshFile.Attribute.Size);
String lengthString = String.format("%1$8s", length);
boolean isDirectory = (Boolean) attributes.get(SshFile.Attribute.IsDirectory);
boolean isLink = (Boolean) attributes.get(SshFile.Attribute.IsSymbolicLink);
int perms = getPermissions(attributes);
StringBuilder sb = new StringBuilder();
sb.append(isDirectory ? "d" : isLink ? "l" : "-");
sb.append((perms & S_IRUSR) != 0 ? "r" : "-");
sb.append((perms & S_IWUSR) != 0 ? "w" : "-");
sb.append((perms & S_IXUSR) != 0 ? "x" : "-");
sb.append((perms & S_IRGRP) != 0 ? "r" : "-");
sb.append((perms & S_IWGRP) != 0 ? "w" : "-");
sb.append((perms & S_IXGRP) != 0 ? "x" : "-");
sb.append((perms & S_IROTH) != 0 ? "r" : "-");
sb.append((perms & S_IWOTH) != 0 ? "w" : "-");
sb.append((perms & S_IXOTH) != 0 ? "x" : "-");
sb.append(" ");
sb.append(" 1");
sb.append(" ");
sb.append(username);
sb.append(" ");
sb.append(group);
sb.append(" ");
sb.append(lengthString);
sb.append(" ");
sb.append(getUnixDate((Long) attributes.get(SshFile.Attribute.LastModifiedTime)));
sb.append(" ");
sb.append(f.getName());
return sb.toString();
}
protected Map<SshFile.Attribute, Object> getPermissions(int perms) {
Map<SshFile.Attribute, Object> attrs = new HashMap<SshFile.Attribute, Object>();
if ((perms & S_IFMT) == S_IFREG) {
attrs.put(SshFile.Attribute.IsRegularFile, Boolean.TRUE);
}
if ((perms & S_IFMT) == S_IFDIR) {
attrs.put(SshFile.Attribute.IsDirectory, Boolean.TRUE);
}
if ((perms & S_IFMT) == S_IFLNK) {
attrs.put(SshFile.Attribute.IsSymbolicLink, Boolean.TRUE);
}
EnumSet<SshFile.Permission> p = EnumSet.noneOf(SshFile.Permission.class);
if ((perms & S_IRUSR) != 0) {
p.add(SshFile.Permission.UserRead);
}
if ((perms & S_IWUSR) != 0) {
p.add(SshFile.Permission.UserWrite);
}
if ((perms & S_IXUSR) != 0) {
p.add(SshFile.Permission.UserExecute);
}
if ((perms & S_IRGRP) != 0) {
p.add(SshFile.Permission.GroupRead);
}
if ((perms & S_IWGRP) != 0) {
p.add(SshFile.Permission.GroupWrite);
}
if ((perms & S_IXGRP) != 0) {
p.add(SshFile.Permission.GroupExecute);
}
if ((perms & S_IROTH) != 0) {
p.add(SshFile.Permission.OthersRead);
}
if ((perms & S_IWOTH) != 0) {
p.add(SshFile.Permission.OthersWrite);
}
if ((perms & S_IXOTH) != 0) {
p.add(SshFile.Permission.OthersExecute);
}
attrs.put(SshFile.Attribute.Permissions, p);
return attrs;
}
protected int getPermissions(Map<SshFile.Attribute, Object> attributes) {
boolean isReg = (Boolean) attributes.get(SshFile.Attribute.IsRegularFile);
boolean isDir = (Boolean) attributes.get(SshFile.Attribute.IsDirectory);
boolean isLnk = (Boolean) attributes.get(SshFile.Attribute.IsSymbolicLink);
int pf = 0;
EnumSet<SshFile.Permission> perms = (EnumSet<SshFile.Permission>) attributes.get(SshFile.Attribute.Permissions);
for (SshFile.Permission p : perms) {
switch (p) {
case UserRead: pf |= S_IRUSR; break;
case UserWrite: pf |= S_IWUSR; break;
case UserExecute: pf |= S_IXUSR; break;
case GroupRead: pf |= S_IRGRP; break;
case GroupWrite: pf |= S_IWGRP; break;
case GroupExecute: pf |= S_IXGRP; break;
case OthersRead: pf |= S_IROTH; break;
case OthersWrite: pf |= S_IWOTH; break;
case OthersExecute: pf |= S_IXOTH; break;
}
}
pf |= isReg ? S_IFREG : 0;
pf |= isDir ? S_IFDIR : 0;
pf |= isLnk ? S_IFLNK : 0;
return pf;
}
protected void writeAttrs(Buffer buffer, SshFile file, boolean followLinks) throws IOException {
if (!file.doesExist()) {
throw new FileNotFoundException(file.getAbsolutePath());
}
Map<SshFile.Attribute, Object> attributes = file.getAttributes(followLinks);
boolean isReg = getBool((Boolean) attributes.get(SshFile.Attribute.IsRegularFile));
boolean isDir = getBool((Boolean) attributes.get(SshFile.Attribute.IsDirectory));
boolean isLnk = getBool((Boolean) attributes.get(SshFile.Attribute.IsSymbolicLink));
int flags = 0;
if ((isReg || isLnk) && attributes.containsKey(SshFile.Attribute.Size)) {
flags |= SSH_FILEXFER_ATTR_SIZE;
}
if (attributes.containsKey(SshFile.Attribute.Uid) && attributes.containsKey(SshFile.Attribute.Gid)) {
flags |= SSH_FILEXFER_ATTR_UIDGID;
}
if (attributes.containsKey(SshFile.Attribute.Permissions)) {
flags |= SSH_FILEXFER_ATTR_PERMISSIONS;
}
if (attributes.containsKey(SshFile.Attribute.LastAccessTime) && attributes.containsKey(SshFile.Attribute.LastModifiedTime)) {
flags |= SSH_FILEXFER_ATTR_ACMODTIME;
}
buffer.putInt(flags);
if ((flags & SSH_FILEXFER_ATTR_SIZE) != 0) {
buffer.putLong((Long) attributes.get(SshFile.Attribute.Size));
}
if ((flags & SSH_FILEXFER_ATTR_UIDGID) != 0) {
buffer.putInt((Integer) attributes.get(SshFile.Attribute.Uid));
buffer.putInt((Integer) attributes.get(SshFile.Attribute.Gid));
}
if ((flags & SSH_FILEXFER_ATTR_PERMISSIONS) != 0) {
buffer.putInt(getPermissions(attributes));
}
if ((flags & SSH_FILEXFER_ATTR_ACMODTIME) != 0) {
buffer.putInt(((Long) attributes.get(SshFile.Attribute.LastAccessTime)) / 1000);
buffer.putInt(((Long) attributes.get(SshFile.Attribute.LastModifiedTime)) / 1000);
}
}
protected boolean getBool(Boolean bool) {
return bool != null && bool;
}
protected Map<SshFile.Attribute, Object> readAttrs(Buffer buffer) throws IOException {
Map<SshFile.Attribute, Object> attrs = new HashMap<SshFile.Attribute, Object>();
int flags = buffer.getInt();
if ((flags & SSH_FILEXFER_ATTR_SIZE) != 0) {
attrs.put(SshFile.Attribute.Size, buffer.getLong());
}
if ((flags & SSH_FILEXFER_ATTR_UIDGID) != 0) {
attrs.put(SshFile.Attribute.Uid, buffer.getInt());
attrs.put(SshFile.Attribute.Gid, buffer.getInt());
}
if ((flags & SSH_FILEXFER_ATTR_PERMISSIONS) != 0) {
attrs.putAll(getPermissions(buffer.getInt()));
}
if ((flags & SSH_FILEXFER_ATTR_ACMODTIME) != 0) {
attrs.put(SshFile.Attribute.LastAccessTime, ((long) buffer.getInt()) * 1000);
attrs.put(SshFile.Attribute.LastModifiedTime, ((long) buffer.getInt()) * 1000);
}
return attrs;
}
protected void sendStatus(int id, int substatus, String msg) throws IOException {
sendStatus(id, substatus, msg, "");
}
protected void sendStatus(int id, int substatus, String msg, String lang) throws IOException {
log.debug("Send SSH_FXP_STATUS (substatus={}, msg={})", substatus, msg);
Buffer buffer = new Buffer();
buffer.putByte((byte) SSH_FXP_STATUS);
buffer.putInt(id);
buffer.putInt(substatus);
buffer.putString(msg);
buffer.putString(lang);
send(buffer);
}
protected void send(Buffer buffer) throws IOException {
DataOutputStream dos = new DataOutputStream(out);
dos.writeInt(buffer.available());
dos.write(buffer.array(), buffer.rpos(), buffer.available());
dos.flush();
}
public void destroy() {
closed = true;
}
private SshFile resolveFile(String path) {
return this.root.getFile(path);
}
private final static String[] MONTHS = { "Jan", "Feb", "Mar", "Apr", "May",
"Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
/**
* Get unix style date string.
*/
private final static String getUnixDate(long millis) {
if (millis < 0) {
return "------------";
}
StringBuffer sb = new StringBuffer(16);
Calendar cal = new GregorianCalendar();
cal.setTimeInMillis(millis);
// month
sb.append(MONTHS[cal.get(Calendar.MONTH)]);
sb.append(' ');
// day
int day = cal.get(Calendar.DATE);
if (day < 10) {
sb.append(' ');
}
sb.append(day);
sb.append(' ');
long sixMonth = 15811200000L; // 183L * 24L * 60L * 60L * 1000L;
long nowTime = System.currentTimeMillis();
if (Math.abs(nowTime - millis) > sixMonth) {
// year
int year = cal.get(Calendar.YEAR);
sb.append(' ');
sb.append(year);
} else {
// hour
int hh = cal.get(Calendar.HOUR_OF_DAY);
if (hh < 10) {
sb.append('0');
}
sb.append(hh);
sb.append(':');
// minute
int mm = cal.get(Calendar.MINUTE);
if (mm < 10) {
sb.append('0');
}
sb.append(mm);
}
return sb.toString();
}
}