You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mina.apache.org by lg...@apache.org on 2017/12/28 09:06:47 UTC
[2/3] mina-sshd git commit: [SSHD-790] Allow users to register a
custom SFTP client factory
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/DefaultSftpClient.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/DefaultSftpClient.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/DefaultSftpClient.java
deleted file mode 100644
index 0788b67..0000000
--- a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/DefaultSftpClient.java
+++ /dev/null
@@ -1,461 +0,0 @@
-/*
- * 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.client.subsystem.sftp;
-
-import java.io.ByteArrayOutputStream;
-import java.io.EOFException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InterruptedIOException;
-import java.io.OutputStream;
-import java.io.StreamCorruptedException;
-import java.net.SocketTimeoutException;
-import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.NavigableMap;
-import java.util.Objects;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import org.apache.sshd.client.channel.ChannelSubsystem;
-import org.apache.sshd.client.channel.ClientChannel;
-import org.apache.sshd.client.session.ClientSession;
-import org.apache.sshd.common.PropertyResolverUtils;
-import org.apache.sshd.common.SshException;
-import org.apache.sshd.common.subsystem.sftp.SftpConstants;
-import org.apache.sshd.common.subsystem.sftp.extensions.ParserUtils;
-import org.apache.sshd.common.subsystem.sftp.extensions.VersionsParser.Versions;
-import org.apache.sshd.common.util.GenericUtils;
-import org.apache.sshd.common.util.ValidateUtils;
-import org.apache.sshd.common.util.buffer.Buffer;
-import org.apache.sshd.common.util.buffer.BufferUtils;
-import org.apache.sshd.common.util.buffer.ByteArrayBuffer;
-
-/**
- * @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
- */
-public class DefaultSftpClient extends AbstractSftpClient {
- private final ClientSession clientSession;
- private final ChannelSubsystem channel;
- private final Map<Integer, Buffer> messages = new HashMap<>();
- private final AtomicInteger cmdId = new AtomicInteger(100);
- private final Buffer receiveBuffer = new ByteArrayBuffer();
- private final byte[] workBuf = new byte[Integer.BYTES];
- private final AtomicInteger versionHolder = new AtomicInteger(0);
- private final AtomicBoolean closing = new AtomicBoolean(false);
- private final NavigableMap<String, byte[]> extensions = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
- private final NavigableMap<String, byte[]> exposedExtensions = Collections.unmodifiableNavigableMap(extensions);
- private Charset nameDecodingCharset = DEFAULT_NAME_DECODING_CHARSET;
-
- public DefaultSftpClient(ClientSession clientSession) throws IOException {
- this.nameDecodingCharset = PropertyResolverUtils.getCharset(clientSession, NAME_DECODING_CHARSET, DEFAULT_NAME_DECODING_CHARSET);
- this.clientSession = Objects.requireNonNull(clientSession, "No client session");
- this.channel = clientSession.createSubsystemChannel(SftpConstants.SFTP_SUBSYSTEM_NAME);
- this.channel.setOut(new OutputStream() {
- private final byte[] singleByte = new byte[1];
- @Override
- public void write(int b) throws IOException {
- synchronized (singleByte) {
- singleByte[0] = (byte) b;
- write(singleByte);
- }
- }
-
- @Override
- public void write(byte[] b, int off, int len) throws IOException {
- data(b, off, len);
- }
- });
- this.channel.setErr(new ByteArrayOutputStream(Byte.MAX_VALUE));
-
- long initializationTimeout = clientSession.getLongProperty(SFTP_CHANNEL_OPEN_TIMEOUT, DEFAULT_CHANNEL_OPEN_TIMEOUT);
- this.channel.open().verify(initializationTimeout);
- this.channel.onClose(() -> {
- synchronized (messages) {
- closing.set(true);
- messages.notifyAll();
- }
-
- if (versionHolder.get() <= 0) {
- log.warn("onClose({}) closed before version negotiated", channel);
- }
- });
-
- try {
- init(initializationTimeout);
- } catch (IOException | RuntimeException e) {
- this.channel.close(true);
- throw e;
- }
- }
-
- @Override
- public int getVersion() {
- return versionHolder.get();
- }
-
- @Override
- public ClientSession getClientSession() {
- return clientSession;
- }
-
- @Override
- public ClientChannel getClientChannel() {
- return channel;
- }
-
- @Override
- public NavigableMap<String, byte[]> getServerExtensions() {
- return exposedExtensions;
- }
-
- @Override
- public Charset getNameDecodingCharset() {
- return nameDecodingCharset;
- }
-
- @Override
- public void setNameDecodingCharset(Charset nameDecodingCharset) {
- this.nameDecodingCharset = Objects.requireNonNull(nameDecodingCharset, "No charset provided");
- }
-
- @Override
- public boolean isClosing() {
- return closing.get();
- }
-
- @Override
- public boolean isOpen() {
- return this.channel.isOpen();
- }
-
- @Override
- public void close() throws IOException {
- if (isOpen()) {
- this.channel.close(false);
- }
- }
-
- /**
- * Receive binary data
- * @param buf The buffer for the incoming data
- * @param start Offset in buffer to place the data
- * @param len Available space in buffer for the data
- * @return Actual size of received data
- * @throws IOException If failed to receive incoming data
- */
- protected int data(byte[] buf, int start, int len) throws IOException {
- Buffer incoming = new ByteArrayBuffer(buf, start, len);
- // If we already have partial data, we need to append it to the buffer and use it
- if (receiveBuffer.available() > 0) {
- receiveBuffer.putBuffer(incoming);
- incoming = receiveBuffer;
- }
-
- // Process commands
- int rpos = incoming.rpos();
- for (int count = 1; receive(incoming); count++) {
- if (log.isTraceEnabled()) {
- log.trace("data({}) Processed {} data messages", getClientChannel(), count);
- }
- }
-
- int read = incoming.rpos() - rpos;
- // Compact and add remaining data
- receiveBuffer.compact();
- if (receiveBuffer != incoming && incoming.available() > 0) {
- receiveBuffer.putBuffer(incoming);
- }
-
- return read;
- }
-
- /**
- * Read SFTP packets from buffer
- *
- * @param incoming The received {@link Buffer}
- * @return {@code true} if data from incoming buffer was processed
- * @throws IOException if failed to process the buffer
- * @see #process(Buffer)
- */
- protected boolean receive(Buffer incoming) throws IOException {
- int rpos = incoming.rpos();
- int wpos = incoming.wpos();
- ClientSession session = getClientSession();
- session.resetIdleTimeout();
-
- if ((wpos - rpos) > 4) {
- int length = incoming.getInt();
- if (length < 5) {
- throw new IOException("Illegal sftp packet length: " + length);
- }
- if ((wpos - rpos) >= (length + 4)) {
- incoming.rpos(rpos);
- incoming.wpos(rpos + 4 + length);
- process(incoming);
- incoming.rpos(rpos + 4 + length);
- incoming.wpos(wpos);
- return true;
- }
- }
- incoming.rpos(rpos);
- return false;
- }
-
- /**
- * Process an SFTP packet
- *
- * @param incoming The received {@link Buffer}
- * @throws IOException if failed to process the buffer
- */
- protected void process(Buffer incoming) throws IOException {
- // create a copy of the buffer in case it is being re-used
- Buffer buffer = new ByteArrayBuffer(incoming.available() + Long.SIZE, false);
- buffer.putBuffer(incoming);
-
- int rpos = buffer.rpos();
- int length = buffer.getInt();
- int type = buffer.getUByte();
- Integer id = buffer.getInt();
- buffer.rpos(rpos);
-
- if (log.isTraceEnabled()) {
- log.trace("process({}) id={}, type={}, len={}",
- getClientChannel(), id, SftpConstants.getCommandMessageName(type), length);
- }
-
- synchronized (messages) {
- messages.put(id, buffer);
- messages.notifyAll();
- }
- }
-
- @Override
- public int send(int cmd, Buffer buffer) throws IOException {
- int id = cmdId.incrementAndGet();
- int len = buffer.available();
- if (log.isTraceEnabled()) {
- log.trace("send({}) cmd={}, len={}, id={}",
- getClientChannel(), SftpConstants.getCommandMessageName(cmd), len, id);
- }
-
- OutputStream dos = channel.getInvertedIn();
- BufferUtils.writeInt(dos, 1 /* cmd */ + Integer.BYTES /* id */ + len, workBuf);
- dos.write(cmd & 0xFF);
- BufferUtils.writeInt(dos, id, workBuf);
- dos.write(buffer.array(), buffer.rpos(), len);
- dos.flush();
- return id;
- }
-
- @Override
- public Buffer receive(int id) throws IOException {
- Integer reqId = id;
- synchronized (messages) {
- for (int count = 1;; count++) {
- if (isClosing() || (!isOpen())) {
- throw new SshException("Channel is being closed");
- }
-
- Buffer buffer = messages.remove(reqId);
- if (buffer != null) {
- return buffer;
- }
-
- try {
- messages.wait();
- } catch (InterruptedException e) {
- throw (IOException) new InterruptedIOException("Interrupted while waiting for messages at iteration #" + count).initCause(e);
- }
- }
- }
- }
-
- protected Buffer read() throws IOException {
- InputStream dis = channel.getInvertedOut();
- int length = BufferUtils.readInt(dis, workBuf);
- // must have at least command + length
- if (length < (1 + Integer.BYTES)) {
- throw new IllegalArgumentException("Bad length: " + length);
- }
-
- Buffer buffer = new ByteArrayBuffer(length + Integer.BYTES, false);
- buffer.putInt(length);
- int nb = length;
- while (nb > 0) {
- int readLen = dis.read(buffer.array(), buffer.wpos(), nb);
- if (readLen < 0) {
- throw new IllegalArgumentException("Premature EOF while read " + length + " bytes - remaining=" + nb);
- }
- buffer.wpos(buffer.wpos() + readLen);
- nb -= readLen;
- }
-
- return buffer;
- }
-
- protected void init(long initializationTimeout) throws IOException {
- ValidateUtils.checkTrue(initializationTimeout > 0L, "Invalid initialization timeout: %d", initializationTimeout);
-
- // Send init packet
- OutputStream dos = channel.getInvertedIn();
- BufferUtils.writeInt(dos, 5 /* total length */, workBuf);
- dos.write(SftpConstants.SSH_FXP_INIT);
- BufferUtils.writeInt(dos, SftpConstants.SFTP_V6, workBuf);
- dos.flush();
-
- Buffer buffer;
- Integer reqId;
- synchronized (messages) {
- /*
- * We need to use a timeout since if the remote server does not support
- * SFTP, we will not know it immediately. This is due to the fact that the
- * request for the subsystem does not contain a reply as to its success or
- * failure. Thus, the SFTP channel is created by the client, but there is
- * no one on the other side to reply - thus the need for the timeout
- */
- for (long remainingTimeout = initializationTimeout; (remainingTimeout > 0L) && messages.isEmpty() && (!isClosing()) && isOpen();) {
- try {
- long sleepStart = System.nanoTime();
- messages.wait(remainingTimeout);
- long sleepEnd = System.nanoTime();
- long sleepDuration = sleepEnd - sleepStart;
- long sleepMillis = TimeUnit.NANOSECONDS.toMillis(sleepDuration);
- if (sleepMillis < 1L) {
- remainingTimeout--;
- } else {
- remainingTimeout -= sleepMillis;
- }
- } catch (InterruptedException e) {
- throw (IOException) new InterruptedIOException("Interrupted init()").initCause(e);
- }
- }
-
- if (isClosing() || (!isOpen())) {
- throw new EOFException("Closing while await init message");
- }
-
- if (messages.isEmpty()) {
- throw new SocketTimeoutException("No incoming initialization response received within " + initializationTimeout + " msec.");
- }
-
- Collection<Integer> ids = messages.keySet();
- Iterator<Integer> iter = ids.iterator();
- reqId = iter.next();
- buffer = messages.remove(reqId);
- }
-
- int length = buffer.getInt();
- int type = buffer.getUByte();
- int id = buffer.getInt();
- if (log.isTraceEnabled()) {
- log.trace("init({}) id={} type={} len={}",
- getClientChannel(), id, SftpConstants.getCommandMessageName(type), length);
- }
-
- if (type == SftpConstants.SSH_FXP_VERSION) {
- if (id < SftpConstants.SFTP_V3) {
- throw new SshException("Unsupported sftp version " + id);
- }
- versionHolder.set(id);
-
- if (log.isTraceEnabled()) {
- log.trace("init({}) version={}", getClientChannel(), versionHolder);
- }
-
- while (buffer.available() > 0) {
- String name = buffer.getString();
- byte[] data = buffer.getBytes();
- if (log.isTraceEnabled()) {
- log.trace("init({}) added extension=", getClientChannel(), name);
- }
- extensions.put(name, data);
- }
- } else if (type == SftpConstants.SSH_FXP_STATUS) {
- int substatus = buffer.getInt();
- String msg = buffer.getString();
- String lang = buffer.getString();
- if (log.isTraceEnabled()) {
- log.trace("init({})[id={}] - status: {} [{}] {}",
- getClientChannel(), id, SftpConstants.getStatusName(substatus), lang, msg);
- }
-
- throwStatusException(SftpConstants.SSH_FXP_INIT, id, substatus, msg, lang);
- } else {
- handleUnexpectedPacket(SftpConstants.SSH_FXP_INIT, SftpConstants.SSH_FXP_VERSION, id, type, length, buffer);
- }
- }
-
- /**
- * @param selector The {@link SftpVersionSelector} to use - ignored if {@code null}
- * @return The selected version (may be same as current)
- * @throws IOException If failed to negotiate
- */
- public int negotiateVersion(SftpVersionSelector selector) throws IOException {
- int current = getVersion();
- if (selector == null) {
- return current;
- }
-
- Set<Integer> available = GenericUtils.asSortedSet(Collections.singleton(current));
- Map<String, ?> parsed = getParsedServerExtensions();
- Collection<String> extensions = ParserUtils.supportedExtensions(parsed);
- if ((GenericUtils.size(extensions) > 0) && extensions.contains(SftpConstants.EXT_VERSION_SELECT)) {
- Versions vers = GenericUtils.isEmpty(parsed) ? null : (Versions) parsed.get(SftpConstants.EXT_VERSIONS);
- Collection<String> reported = (vers == null) ? null : vers.getVersions();
- if (GenericUtils.size(reported) > 0) {
- for (String v : reported) {
- if (!available.add(Integer.valueOf(v))) {
- continue; // debug breakpoint
- }
- }
- }
- }
-
- int selected = selector.selectVersion(getClientSession(), current, new ArrayList<>(available));
- if (log.isDebugEnabled()) {
- log.debug("negotiateVersion({}) current={} {} -> {}", getClientChannel(), current, available, selected);
- }
-
- if (selected == current) {
- return current;
- }
-
- if (!available.contains(selected)) {
- throw new StreamCorruptedException("Selected version (" + selected + ") not part of available: " + available);
- }
-
- String verVal = String.valueOf(selected);
- Buffer buffer = new ByteArrayBuffer(Integer.BYTES + SftpConstants.EXT_VERSION_SELECT.length() // extension name
- + Integer.BYTES + verVal.length() + Byte.SIZE, false);
- buffer.putString(SftpConstants.EXT_VERSION_SELECT);
- buffer.putString(verVal);
- checkCommandStatus(SftpConstants.SSH_FXP_EXTENDED, buffer);
- versionHolder.set(selected);
- return selected;
- }
-}
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpAclFileAttributeView.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpAclFileAttributeView.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpAclFileAttributeView.java
index f3ca4f3..7cada6e 100644
--- a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpAclFileAttributeView.java
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpAclFileAttributeView.java
@@ -28,6 +28,8 @@ import java.nio.file.attribute.PosixFileAttributes;
import java.nio.file.attribute.UserPrincipal;
import java.util.List;
+import org.apache.sshd.client.subsystem.sftp.impl.AbstractSftpFileAttributeView;
+
/**
* @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
*/
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClient.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClient.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClient.java
index c835e35..c860cb4 100644
--- a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClient.java
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClient.java
@@ -496,7 +496,7 @@ public interface SftpClient extends SubsystemClient {
private final String longFilename;
private final Attributes attributes;
- DirEntry(String filename, String longFilename, Attributes attributes) {
+ public DirEntry(String filename, String longFilename, Attributes attributes) {
this.filename = filename;
this.longFilename = longFilename;
this.attributes = attributes;
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientCreator.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientCreator.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientCreator.java
index 8e41729..a282b87 100644
--- a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientCreator.java
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientCreator.java
@@ -61,15 +61,25 @@ public interface SftpClientCreator {
*/
SftpClient createSftpClient(SftpVersionSelector selector) throws IOException;
- FileSystem createSftpFileSystem() throws IOException;
+ default FileSystem createSftpFileSystem() throws IOException {
+ return createSftpFileSystem(SftpVersionSelector.CURRENT);
+ }
- FileSystem createSftpFileSystem(int version) throws IOException;
+ default FileSystem createSftpFileSystem(int version) throws IOException {
+ return createSftpFileSystem(SftpVersionSelector.fixedVersionSelector(version));
+ }
- FileSystem createSftpFileSystem(SftpVersionSelector selector) throws IOException;
+ default FileSystem createSftpFileSystem(SftpVersionSelector selector) throws IOException {
+ return createSftpFileSystem(selector, SftpClient.DEFAULT_READ_BUFFER_SIZE, SftpClient.DEFAULT_WRITE_BUFFER_SIZE);
+ }
- FileSystem createSftpFileSystem(int readBufferSize, int writeBufferSize) throws IOException;
+ default FileSystem createSftpFileSystem(int version, int readBufferSize, int writeBufferSize) throws IOException {
+ return createSftpFileSystem(SftpVersionSelector.fixedVersionSelector(version), readBufferSize, writeBufferSize);
+ }
- FileSystem createSftpFileSystem(int version, int readBufferSize, int writeBufferSize) throws IOException;
+ default FileSystem createSftpFileSystem(int readBufferSize, int writeBufferSize) throws IOException {
+ return createSftpFileSystem(SftpVersionSelector.CURRENT, readBufferSize, writeBufferSize);
+ }
FileSystem createSftpFileSystem(SftpVersionSelector selector, int readBufferSize, int writeBufferSize) throws IOException;
}
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientFactory.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientFactory.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientFactory.java
new file mode 100644
index 0000000..15e321f
--- /dev/null
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientFactory.java
@@ -0,0 +1,51 @@
+/*
+ * 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.client.subsystem.sftp;
+
+import java.io.IOException;
+import java.nio.file.FileSystem;
+
+import org.apache.sshd.client.session.ClientSession;
+
+/**
+ * TODO Add javadoc
+ *
+ * @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
+ */
+public interface SftpClientFactory {
+ /**
+ * @param session The {@link ClientSession} to which the SFTP client should be attached
+ * @param selector The {@link SftpVersionSelector} to use in order to negotiate the SFTP version
+ * @return The created {@link SftpClient} instance
+ * @throws IOException If failed to create the client
+ */
+ SftpClient createSftpClient(ClientSession session, SftpVersionSelector selector) throws IOException;
+
+ /**
+ * @param session The {@link ClientSession} to which the SFTP client backing the file system should be attached
+ * @param selector The {@link SftpVersionSelector} to use in order to negotiate the SFTP version
+ * @param readBufferSize Default I/O read buffer size
+ * @param writeBufferSize Default I/O write buffer size
+ * @return The created {@link FileSystem} instance
+ * @throws IOException If failed to create the instance
+ */
+ FileSystem createSftpFileSystem(
+ ClientSession session, SftpVersionSelector selector, int readBufferSize, int writeBufferSize)
+ throws IOException;
+}
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientFactoryManager.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientFactoryManager.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientFactoryManager.java
new file mode 100644
index 0000000..02bc5f6
--- /dev/null
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpClientFactoryManager.java
@@ -0,0 +1,37 @@
+/*
+ * 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.client.subsystem.sftp;
+
+/**
+ * TODO Add javadoc
+ *
+ * @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
+ */
+public interface SftpClientFactoryManager {
+ /**
+ * @return The (never {@code null}) {@link SftpClientFactory} instance
+ */
+ SftpClientFactory getSftpClientFactory();
+
+ /**
+ * @param sftpClientFactory The {@link SftpClientFactory} instance to use - if {@code null}
+ * then an internal default will be used
+ */
+ void setSftpClientFactory(SftpClientFactory sftpClientFactory);
+}
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpFileSystem.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpFileSystem.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpFileSystem.java
index f028a5b..1ca0283 100644
--- a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpFileSystem.java
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpFileSystem.java
@@ -42,6 +42,7 @@ import java.util.concurrent.atomic.AtomicInteger;
import org.apache.sshd.client.channel.ClientChannel;
import org.apache.sshd.client.session.ClientSession;
import org.apache.sshd.client.session.ClientSessionHolder;
+import org.apache.sshd.client.subsystem.sftp.impl.AbstractSftpClient;
import org.apache.sshd.common.file.util.BaseFileSystem;
import org.apache.sshd.common.subsystem.sftp.SftpConstants;
import org.apache.sshd.common.util.GenericUtils;
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpFileSystemProvider.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpFileSystemProvider.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpFileSystemProvider.java
index 5b2f49d..116282a 100644
--- a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpFileSystemProvider.java
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpFileSystemProvider.java
@@ -831,7 +831,7 @@ public class SftpFileSystemProvider extends FileSystemProvider {
return map;
}
- protected SftpClient.Attributes readRemoteAttributes(SftpPath path, LinkOption... options) throws IOException {
+ public SftpClient.Attributes readRemoteAttributes(SftpPath path, LinkOption... options) throws IOException {
SftpFileSystem fs = path.getFileSystem();
try (SftpClient client = fs.getClient()) {
try {
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpPosixFileAttributeView.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpPosixFileAttributeView.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpPosixFileAttributeView.java
index 13d2119..1fb614c 100644
--- a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpPosixFileAttributeView.java
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/SftpPosixFileAttributeView.java
@@ -29,6 +29,7 @@ import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.UserPrincipal;
import java.util.Set;
+import org.apache.sshd.client.subsystem.sftp.impl.AbstractSftpFileAttributeView;
import org.apache.sshd.common.util.GenericUtils;
/**
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/AbstractSftpClient.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/AbstractSftpClient.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/AbstractSftpClient.java
new file mode 100644
index 0000000..a1d2014
--- /dev/null
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/AbstractSftpClient.java
@@ -0,0 +1,1134 @@
+/*
+ * 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.client.subsystem.sftp.impl;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.attribute.FileTime;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.apache.sshd.client.channel.ClientChannel;
+import org.apache.sshd.client.subsystem.AbstractSubsystemClient;
+import org.apache.sshd.client.subsystem.sftp.RawSftpClient;
+import org.apache.sshd.client.subsystem.sftp.SftpClient;
+import org.apache.sshd.client.subsystem.sftp.extensions.BuiltinSftpClientExtensions;
+import org.apache.sshd.client.subsystem.sftp.extensions.SftpClientExtension;
+import org.apache.sshd.client.subsystem.sftp.extensions.SftpClientExtensionFactory;
+import org.apache.sshd.common.SshException;
+import org.apache.sshd.common.channel.Channel;
+import org.apache.sshd.common.subsystem.sftp.SftpConstants;
+import org.apache.sshd.common.subsystem.sftp.SftpException;
+import org.apache.sshd.common.subsystem.sftp.SftpHelper;
+import org.apache.sshd.common.subsystem.sftp.SftpUniversalOwnerAndGroup;
+import org.apache.sshd.common.subsystem.sftp.extensions.ParserUtils;
+import org.apache.sshd.common.util.GenericUtils;
+import org.apache.sshd.common.util.ValidateUtils;
+import org.apache.sshd.common.util.buffer.Buffer;
+import org.apache.sshd.common.util.buffer.ByteArrayBuffer;
+
+
+/**
+ * @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
+ */
+public abstract class AbstractSftpClient extends AbstractSubsystemClient implements SftpClient, RawSftpClient {
+ private final Attributes fileOpenAttributes = new Attributes();
+ private final AtomicReference<Map<String, Object>> parsedExtensionsHolder = new AtomicReference<>(null);
+
+ protected AbstractSftpClient() {
+ fileOpenAttributes.setType(SftpConstants.SSH_FILEXFER_TYPE_REGULAR);
+ }
+
+ @Override
+ public Channel getChannel() {
+ return getClientChannel();
+ }
+
+ @Override
+ public <E extends SftpClientExtension> E getExtension(Class<? extends E> extensionType) {
+ Object instance = getExtension(BuiltinSftpClientExtensions.fromType(extensionType));
+ if (instance == null) {
+ return null;
+ } else {
+ return extensionType.cast(instance);
+ }
+ }
+
+ @Override
+ public SftpClientExtension getExtension(String extensionName) {
+ return getExtension(BuiltinSftpClientExtensions.fromName(extensionName));
+ }
+
+ protected SftpClientExtension getExtension(SftpClientExtensionFactory factory) {
+ if (factory == null) {
+ return null;
+ }
+
+ Map<String, byte[]> extensions = getServerExtensions();
+ Map<String, Object> parsed = getParsedServerExtensions(extensions);
+ return factory.create(this, this, extensions, parsed);
+ }
+
+ protected Map<String, Object> getParsedServerExtensions() {
+ return getParsedServerExtensions(getServerExtensions());
+ }
+
+ protected Map<String, Object> getParsedServerExtensions(Map<String, byte[]> extensions) {
+ Map<String, Object> parsed = parsedExtensionsHolder.get();
+ if (parsed == null) {
+ parsed = ParserUtils.parse(extensions);
+ if (parsed == null) {
+ parsed = Collections.emptyMap();
+ }
+ parsedExtensionsHolder.set(parsed);
+ }
+
+ return parsed;
+ }
+
+ /**
+ * @param cmd The command that was sent whose response contains the name to be decoded
+ * @param buf The {@link Buffer} containing the encoded name
+ * @return The decoded referenced name
+ */
+ protected String getReferencedName(int cmd, Buffer buf) {
+ Charset cs = getNameDecodingCharset();
+ return buf.getString(cs);
+ }
+
+ /**
+ * Sends the specified command, waits for the response and then invokes {@link #checkResponseStatus(int, Buffer)}
+ * @param cmd The command to send
+ * @param request The request {@link Buffer}
+ * @throws IOException If failed to send, receive or check the returned status
+ * @see #send(int, Buffer)
+ * @see #receive(int)
+ * @see #checkResponseStatus(int, Buffer)
+ */
+ protected void checkCommandStatus(int cmd, Buffer request) throws IOException {
+ int reqId = send(cmd, request);
+ Buffer response = receive(reqId);
+ checkResponseStatus(cmd, response);
+ }
+
+ /**
+ * Checks if the incoming response is an {@code SSH_FXP_STATUS} one,
+ * and if so whether the substatus is {@code SSH_FX_OK}.
+ *
+ * @param cmd The sent command opcode
+ * @param buffer The received response {@link Buffer}
+ * @throws IOException If response does not carry a status or carries
+ * a bad status code
+ * @see #checkResponseStatus(int, int, int, String, String)
+ */
+ protected void checkResponseStatus(int cmd, Buffer buffer) throws IOException {
+ int length = buffer.getInt();
+ int type = buffer.getUByte();
+ int id = buffer.getInt();
+ if (type == SftpConstants.SSH_FXP_STATUS) {
+ int substatus = buffer.getInt();
+ String msg = buffer.getString();
+ String lang = buffer.getString();
+ checkResponseStatus(cmd, id, substatus, msg, lang);
+ } else {
+ //noinspection ThrowableResultOfMethodCallIgnored
+ handleUnexpectedPacket(cmd, SftpConstants.SSH_FXP_STATUS, id, type, length, buffer);
+ }
+ }
+
+ /**
+ * @param cmd The sent command opcode
+ * @param id The request id
+ * @param substatus The sub-status value
+ * @param msg The message
+ * @param lang The language
+ * @throws IOException if the sub-status is not {@code SSH_FX_OK}
+ * @see #throwStatusException(int, int, int, String, String)
+ */
+ protected void checkResponseStatus(int cmd, int id, int substatus, String msg, String lang) throws IOException {
+ if (log.isTraceEnabled()) {
+ log.trace("checkResponseStatus({})[id={}] cmd={} status={} lang={} msg={}",
+ getClientChannel(), id, SftpConstants.getCommandMessageName(cmd),
+ SftpConstants.getStatusName(substatus), lang, msg);
+ }
+
+ if (substatus != SftpConstants.SSH_FX_OK) {
+ throwStatusException(cmd, id, substatus, msg, lang);
+ }
+ }
+
+ protected void throwStatusException(int cmd, int id, int substatus, String msg, String lang) throws IOException {
+ throw new SftpException(substatus, msg);
+ }
+
+ /**
+ * @param cmd Command to be sent
+ * @param request The {@link Buffer} containing the request
+ * @return The received handle identifier
+ * @throws IOException If failed to send/receive or process the response
+ * @see #send(int, Buffer)
+ * @see #receive(int)
+ * @see #checkHandleResponse(int, Buffer)
+ */
+ protected byte[] checkHandle(int cmd, Buffer request) throws IOException {
+ int reqId = send(cmd, request);
+ Buffer response = receive(reqId);
+ return checkHandleResponse(cmd, response);
+ }
+
+ protected byte[] checkHandleResponse(int cmd, Buffer buffer) throws IOException {
+ int length = buffer.getInt();
+ int type = buffer.getUByte();
+ int id = buffer.getInt();
+ if (type == SftpConstants.SSH_FXP_HANDLE) {
+ return ValidateUtils.checkNotNullAndNotEmpty(buffer.getBytes(), "Null/empty handle in buffer", GenericUtils.EMPTY_OBJECT_ARRAY);
+ }
+
+ if (type == SftpConstants.SSH_FXP_STATUS) {
+ int substatus = buffer.getInt();
+ String msg = buffer.getString();
+ String lang = buffer.getString();
+ if (log.isTraceEnabled()) {
+ log.trace("checkHandleResponse({})[id={}] {} - status: {} [{}] {}",
+ getClientChannel(), id, SftpConstants.getCommandMessageName(cmd),
+ SftpConstants.getStatusName(substatus), lang, msg);
+ }
+ throwStatusException(cmd, id, substatus, msg, lang);
+ }
+
+ return handleUnexpectedHandlePacket(cmd, id, type, length, buffer);
+ }
+
+ protected byte[] handleUnexpectedHandlePacket(int cmd, int id, int type, int length, Buffer buffer) throws IOException {
+ handleUnexpectedPacket(cmd, SftpConstants.SSH_FXP_HANDLE, id, type, length, buffer);
+ throw new SshException("No handling for unexpected handle packet id=" + id
+ + ", type=" + SftpConstants.getCommandMessageName(type) + ", length=" + length);
+ }
+
+ /**
+ * @param cmd Command to be sent
+ * @param request Request {@link Buffer}
+ * @return The decoded response {@code Attributes}
+ * @throws IOException If failed to send/receive or process the response
+ * @see #send(int, Buffer)
+ * @see #receive(int)
+ * @see #checkAttributesResponse(int, Buffer)
+ */
+ protected Attributes checkAttributes(int cmd, Buffer request) throws IOException {
+ int reqId = send(cmd, request);
+ Buffer response = receive(reqId);
+ return checkAttributesResponse(cmd, response);
+ }
+
+ protected Attributes checkAttributesResponse(int cmd, Buffer buffer) throws IOException {
+ int length = buffer.getInt();
+ int type = buffer.getUByte();
+ int id = buffer.getInt();
+ if (type == SftpConstants.SSH_FXP_ATTRS) {
+ return readAttributes(cmd, buffer);
+ }
+
+ if (type == SftpConstants.SSH_FXP_STATUS) {
+ int substatus = buffer.getInt();
+ String msg = buffer.getString();
+ String lang = buffer.getString();
+ if (log.isTraceEnabled()) {
+ log.trace("checkAttributesResponse()[id={}] {} - status: {} [{}] {}",
+ getClientChannel(), id, SftpConstants.getCommandMessageName(cmd),
+ SftpConstants.getStatusName(substatus), lang, msg);
+ }
+ throwStatusException(cmd, id, substatus, msg, lang);
+ }
+
+ return handleUnexpectedAttributesPacket(cmd, id, type, length, buffer);
+ }
+
+ protected Attributes handleUnexpectedAttributesPacket(int cmd, int id, int type, int length, Buffer buffer) throws IOException {
+ IOException err = handleUnexpectedPacket(cmd, SftpConstants.SSH_FXP_ATTRS, id, type, length, buffer);
+ if (err != null) {
+ throw err;
+ }
+
+ return null;
+ }
+
+ /**
+ * @param cmd Command to be sent
+ * @param request The request {@link Buffer}
+ * @return The retrieved name
+ * @throws IOException If failed to send/receive or process the response
+ * @see #send(int, Buffer)
+ * @see #receive(int)
+ * @see #checkOneNameResponse(int, Buffer)
+ */
+ protected String checkOneName(int cmd, Buffer request) throws IOException {
+ int reqId = send(cmd, request);
+ Buffer response = receive(reqId);
+ return checkOneNameResponse(cmd, response);
+ }
+
+ protected String checkOneNameResponse(int cmd, Buffer buffer) throws IOException {
+ int length = buffer.getInt();
+ int type = buffer.getUByte();
+ int id = buffer.getInt();
+ if (type == SftpConstants.SSH_FXP_NAME) {
+ int len = buffer.getInt();
+ if (len != 1) {
+ throw new SshException("SFTP error: received " + len + " names instead of 1");
+ }
+ String name = getReferencedName(cmd, buffer);
+ String longName = null;
+ int version = getVersion();
+ if (version == SftpConstants.SFTP_V3) {
+ longName = getReferencedName(cmd, buffer);
+ }
+
+ Attributes attrs = readAttributes(cmd, buffer);
+ Boolean indicator = SftpHelper.getEndOfListIndicatorValue(buffer, version);
+ // TODO decide what to do if not-null and not TRUE
+ if (log.isTraceEnabled()) {
+ log.trace("checkOneNameResponse({})[id={}] {} ({})[{}] eol={}: {}",
+ getClientChannel(), id, SftpConstants.getCommandMessageName(cmd),
+ name, longName, indicator, attrs);
+ }
+ return name;
+ }
+
+ if (type == SftpConstants.SSH_FXP_STATUS) {
+ int substatus = buffer.getInt();
+ String msg = buffer.getString();
+ String lang = buffer.getString();
+ if (log.isTraceEnabled()) {
+ log.trace("checkOneNameResponse({})[id={}] {} status: {} [{}] {}",
+ getClientChannel(), id, SftpConstants.getCommandMessageName(cmd),
+ SftpConstants.getStatusName(substatus), lang, msg);
+ }
+
+ throwStatusException(cmd, id, substatus, msg, lang);
+ }
+
+ return handleUnknownOneNamePacket(cmd, id, type, length, buffer);
+ }
+
+ protected String handleUnknownOneNamePacket(int cmd, int id, int type, int length, Buffer buffer) throws IOException {
+ IOException err = handleUnexpectedPacket(cmd, SftpConstants.SSH_FXP_NAME, id, type, length, buffer);
+ if (err != null) {
+ throw err;
+ }
+
+ return null;
+ }
+
+ protected Attributes readAttributes(int cmd, Buffer buffer) throws IOException {
+ Attributes attrs = new Attributes();
+ int flags = buffer.getInt();
+ int version = getVersion();
+ if (version == SftpConstants.SFTP_V3) {
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_SIZE) != 0) {
+ attrs.setSize(buffer.getLong());
+ }
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_UIDGID) != 0) {
+ attrs.owner(buffer.getInt(), buffer.getInt());
+ }
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_PERMISSIONS) != 0) {
+ int perms = buffer.getInt();
+ attrs.setPermissions(perms);
+ attrs.setType(SftpHelper.permissionsToFileType(perms));
+ }
+
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_ACMODTIME) != 0) {
+ attrs.setAccessTime(SftpHelper.readTime(buffer, version, flags));
+ attrs.setModifyTime(SftpHelper.readTime(buffer, version, flags));
+ }
+ } else if (version >= SftpConstants.SFTP_V4) {
+ attrs.setType(buffer.getUByte());
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_SIZE) != 0) {
+ attrs.setSize(buffer.getLong());
+ }
+
+ if ((version >= SftpConstants.SFTP_V6) && ((flags & SftpConstants.SSH_FILEXFER_ATTR_ALLOCATION_SIZE) != 0)) {
+ @SuppressWarnings("unused")
+ long allocSize = buffer.getLong(); // TODO handle allocation size
+ }
+
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_OWNERGROUP) != 0) {
+ attrs.setOwner(buffer.getString());
+ attrs.setGroup(buffer.getString());
+ }
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_PERMISSIONS) != 0) {
+ attrs.setPermissions(buffer.getInt());
+ }
+
+ // update the permissions according to the type
+ int perms = attrs.getPermissions();
+ perms |= SftpHelper.fileTypeToPermission(attrs.getType());
+ attrs.setPermissions(perms);
+
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_ACCESSTIME) != 0) {
+ attrs.setAccessTime(SftpHelper.readTime(buffer, version, flags));
+ }
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_CREATETIME) != 0) {
+ attrs.setCreateTime(SftpHelper.readTime(buffer, version, flags));
+ }
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_MODIFYTIME) != 0) {
+ attrs.setModifyTime(SftpHelper.readTime(buffer, version, flags));
+ }
+ if ((version >= SftpConstants.SFTP_V6) && (flags & SftpConstants.SSH_FILEXFER_ATTR_CTIME) != 0) {
+ @SuppressWarnings("unused")
+ FileTime attrsChangedTime = SftpHelper.readTime(buffer, version, flags); // TODO the last time the file attributes were changed
+ }
+
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_ACL) != 0) {
+ attrs.setAcl(SftpHelper.readACLs(buffer, version));
+ }
+
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_BITS) != 0) {
+ @SuppressWarnings("unused")
+ int bits = buffer.getInt();
+ @SuppressWarnings("unused")
+ int valid = 0xffffffff;
+ if (version >= SftpConstants.SFTP_V6) {
+ valid = buffer.getInt();
+ }
+ // TODO: handle attrib bits
+ }
+
+ if (version >= SftpConstants.SFTP_V6) {
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_TEXT_HINT) != 0) {
+ @SuppressWarnings("unused")
+ boolean text = buffer.getBoolean(); // TODO: handle text
+ }
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_MIME_TYPE) != 0) {
+ @SuppressWarnings("unused")
+ String mimeType = buffer.getString(); // TODO: handle mime-type
+ }
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_LINK_COUNT) != 0) {
+ @SuppressWarnings("unused")
+ int nlink = buffer.getInt(); // TODO: handle link-count
+ }
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_UNTRANSLATED_NAME) != 0) {
+ @SuppressWarnings("unused")
+ String untranslated = getReferencedName(cmd, buffer); // TODO: handle untranslated-name
+ }
+ }
+ } else {
+ throw new IllegalStateException("readAttributes - unsupported version: " + version);
+ }
+
+ if ((flags & SftpConstants.SSH_FILEXFER_ATTR_EXTENDED) != 0) {
+ attrs.setExtensions(SftpHelper.readExtensions(buffer));
+ }
+
+ return attrs;
+ }
+
+ protected void writeAttributes(Buffer buffer, Attributes attributes) throws IOException {
+ int version = getVersion();
+ int flagsMask = 0;
+ Collection<Attribute> flags = Objects.requireNonNull(attributes, "No attributes").getFlags();
+ if (version == SftpConstants.SFTP_V3) {
+ for (Attribute a : flags) {
+ switch (a) {
+ case Size:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_SIZE;
+ break;
+ case UidGid:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_UIDGID;
+ break;
+ case Perms:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_PERMISSIONS;
+ break;
+ case AccessTime:
+ if (flags.contains(Attribute.ModifyTime)) {
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_ACMODTIME;
+ }
+ break;
+ case ModifyTime:
+ if (flags.contains(Attribute.AccessTime)) {
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_ACMODTIME;
+ }
+ break;
+ case Extensions:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_EXTENDED;
+ break;
+ default: // do nothing
+ }
+ }
+ buffer.putInt(flagsMask);
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_SIZE) != 0) {
+ buffer.putLong(attributes.getSize());
+ }
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_UIDGID) != 0) {
+ buffer.putInt(attributes.getUserId());
+ buffer.putInt(attributes.getGroupId());
+ }
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_PERMISSIONS) != 0) {
+ buffer.putInt(attributes.getPermissions());
+ }
+
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_ACMODTIME) != 0) {
+ SftpHelper.writeTime(buffer, version, flagsMask, attributes.getAccessTime());
+ SftpHelper.writeTime(buffer, version, flagsMask, attributes.getModifyTime());
+ }
+ } else if (version >= SftpConstants.SFTP_V4) {
+ for (Attribute a : flags) {
+ switch (a) {
+ case Size:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_SIZE;
+ break;
+ case OwnerGroup:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_OWNERGROUP;
+ break;
+ case Perms:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_PERMISSIONS;
+ break;
+ case AccessTime:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_ACCESSTIME;
+ break;
+ case ModifyTime:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_MODIFYTIME;
+ break;
+ case CreateTime:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_CREATETIME;
+ break;
+ case Acl:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_ACL;
+ break;
+ case Extensions:
+ flagsMask |= SftpConstants.SSH_FILEXFER_ATTR_EXTENDED;
+ break;
+ default: // do nothing
+ }
+ }
+ buffer.putInt(flagsMask);
+ buffer.putByte((byte) attributes.getType());
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_SIZE) != 0) {
+ buffer.putLong(attributes.getSize());
+ }
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_OWNERGROUP) != 0) {
+ String owner = attributes.getOwner();
+ buffer.putString(GenericUtils.isEmpty(owner) ? SftpUniversalOwnerAndGroup.Owner.getName() : owner);
+
+ String group = attributes.getGroup();
+ buffer.putString(GenericUtils.isEmpty(group) ? SftpUniversalOwnerAndGroup.Group.getName() : group);
+ }
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_PERMISSIONS) != 0) {
+ buffer.putInt(attributes.getPermissions());
+ }
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_ACCESSTIME) != 0) {
+ SftpHelper.writeTime(buffer, version, flagsMask, attributes.getAccessTime());
+ }
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_CREATETIME) != 0) {
+ SftpHelper.writeTime(buffer, version, flagsMask, attributes.getCreateTime());
+ }
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_MODIFYTIME) != 0) {
+ SftpHelper.writeTime(buffer, version, flagsMask, attributes.getModifyTime());
+ }
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_ACL) != 0) {
+ SftpHelper.writeACLs(buffer, version, attributes.getAcl());
+ }
+
+ // TODO: for v6+ add CTIME (see https://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#page-21)
+ } else {
+ throw new UnsupportedOperationException("writeAttributes(" + attributes + ") unsupported version: " + version);
+ }
+
+ if ((flagsMask & SftpConstants.SSH_FILEXFER_ATTR_EXTENDED) != 0) {
+ SftpHelper.writeExtensions(buffer, attributes.getExtensions());
+ }
+ }
+
+ @Override
+ public CloseableHandle open(String path, Collection<OpenMode> options) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("open(" + path + ")[" + options + "] client is closed");
+ }
+
+ /*
+ * Be consistent with FileChannel#open - if no mode specified then READ is assumed
+ */
+ if (GenericUtils.isEmpty(options)) {
+ options = EnumSet.of(OpenMode.Read);
+ }
+
+ Buffer buffer = new ByteArrayBuffer(path.length() + Long.SIZE /* some extra fields */, false);
+ buffer.putString(path);
+ int version = getVersion();
+ int mode = 0;
+ if (version < SftpConstants.SFTP_V5) {
+ for (OpenMode m : options) {
+ switch (m) {
+ case Read:
+ mode |= SftpConstants.SSH_FXF_READ;
+ break;
+ case Write:
+ mode |= SftpConstants.SSH_FXF_WRITE;
+ break;
+ case Append:
+ mode |= SftpConstants.SSH_FXF_APPEND;
+ break;
+ case Create:
+ mode |= SftpConstants.SSH_FXF_CREAT;
+ break;
+ case Truncate:
+ mode |= SftpConstants.SSH_FXF_TRUNC;
+ break;
+ case Exclusive:
+ mode |= SftpConstants.SSH_FXF_EXCL;
+ break;
+ default: // do nothing
+ }
+ }
+ } else {
+ int access = 0;
+ if (options.contains(OpenMode.Read)) {
+ access |= SftpConstants.ACE4_READ_DATA | SftpConstants.ACE4_READ_ATTRIBUTES;
+ }
+ if (options.contains(OpenMode.Write)) {
+ access |= SftpConstants.ACE4_WRITE_DATA | SftpConstants.ACE4_WRITE_ATTRIBUTES;
+ }
+ if (options.contains(OpenMode.Append)) {
+ access |= SftpConstants.ACE4_APPEND_DATA;
+ }
+ buffer.putInt(access);
+
+ if (options.contains(OpenMode.Create) && options.contains(OpenMode.Exclusive)) {
+ mode |= SftpConstants.SSH_FXF_CREATE_NEW;
+ } else if (options.contains(OpenMode.Create) && options.contains(OpenMode.Truncate)) {
+ mode |= SftpConstants.SSH_FXF_CREATE_TRUNCATE;
+ } else if (options.contains(OpenMode.Create)) {
+ mode |= SftpConstants.SSH_FXF_OPEN_OR_CREATE;
+ } else if (options.contains(OpenMode.Truncate)) {
+ mode |= SftpConstants.SSH_FXF_TRUNCATE_EXISTING;
+ } else {
+ mode |= SftpConstants.SSH_FXF_OPEN_EXISTING;
+ }
+ }
+ buffer.putInt(mode);
+ writeAttributes(buffer, fileOpenAttributes);
+
+ CloseableHandle handle = new DefaultCloseableHandle(this, path, checkHandle(SftpConstants.SSH_FXP_OPEN, buffer));
+ if (log.isTraceEnabled()) {
+ log.trace("open({})[{}] options={}: {}", getClientSession(), path, options, handle);
+ }
+ return handle;
+ }
+
+ @Override
+ public void close(Handle handle) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("close(" + handle + ") client is closed");
+ }
+
+ if (log.isTraceEnabled()) {
+ log.trace("close({}) {}", getClientSession(), handle);
+ }
+
+ byte[] id = Objects.requireNonNull(handle, "No handle").getIdentifier();
+ Buffer buffer = new ByteArrayBuffer(id.length + Long.SIZE /* some extra fields */, false);
+ buffer.putBytes(id);
+ checkCommandStatus(SftpConstants.SSH_FXP_CLOSE, buffer);
+ }
+
+ @Override
+ public void remove(String path) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("remove(" + path + ") client is closed");
+ }
+
+ if (log.isDebugEnabled()) {
+ log.debug("remove({}) {}", getClientSession(), path);
+ }
+
+ Buffer buffer = new ByteArrayBuffer(path.length() + Long.SIZE /* some extra fields */, false);
+ buffer.putString(path);
+ checkCommandStatus(SftpConstants.SSH_FXP_REMOVE, buffer);
+ }
+
+ @Override
+ public void rename(String oldPath, String newPath, Collection<CopyMode> options) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("rename(" + oldPath + " => " + newPath + ")[" + options + "] client is closed");
+ }
+
+ if (log.isDebugEnabled()) {
+ log.debug("rename({}) {} => {}", getClientSession(), oldPath, newPath);
+ }
+
+ Buffer buffer = new ByteArrayBuffer(oldPath.length() + newPath.length() + Long.SIZE /* some extra fields */, false);
+ buffer.putString(oldPath);
+ buffer.putString(newPath);
+
+ int numOptions = GenericUtils.size(options);
+ int version = getVersion();
+ if (version >= SftpConstants.SFTP_V5) {
+ int opts = 0;
+ if (numOptions > 0) {
+ for (CopyMode opt : options) {
+ switch (opt) {
+ case Atomic:
+ opts |= SftpConstants.SSH_FXP_RENAME_ATOMIC;
+ break;
+ case Overwrite:
+ opts |= SftpConstants.SSH_FXP_RENAME_OVERWRITE;
+ break;
+ default: // do nothing
+ }
+ }
+ }
+ buffer.putInt(opts);
+ } else if (numOptions > 0) {
+ throw new UnsupportedOperationException("rename(" + oldPath + " => " + newPath + ")"
+ + " - copy options can not be used with this SFTP version: " + options);
+ }
+ checkCommandStatus(SftpConstants.SSH_FXP_RENAME, buffer);
+ }
+
+ @Override
+ public int read(Handle handle, long fileOffset, byte[] dst, int dstOffset, int len, AtomicReference<Boolean> eofSignalled) throws IOException {
+ if (eofSignalled != null) {
+ eofSignalled.set(null);
+ }
+
+ if (!isOpen()) {
+ throw new IOException("read(" + handle + "/" + fileOffset + ")[" + dstOffset + "/" + len + "] client is closed");
+ }
+
+ byte[] id = Objects.requireNonNull(handle, "No handle").getIdentifier();
+ Buffer buffer = new ByteArrayBuffer(id.length + Long.SIZE /* some extra fields */, false);
+ buffer.putBytes(id);
+ buffer.putLong(fileOffset);
+ buffer.putInt(len);
+ return checkData(SftpConstants.SSH_FXP_READ, buffer, dstOffset, dst, eofSignalled);
+ }
+
+ protected int checkData(int cmd, Buffer request, int dstOffset, byte[] dst, AtomicReference<Boolean> eofSignalled) throws IOException {
+ if (eofSignalled != null) {
+ eofSignalled.set(null);
+ }
+ int reqId = send(cmd, request);
+ Buffer response = receive(reqId);
+ return checkDataResponse(cmd, response, dstOffset, dst, eofSignalled);
+ }
+
+ protected int checkDataResponse(int cmd, Buffer buffer, int dstoff, byte[] dst, AtomicReference<Boolean> eofSignalled) throws IOException {
+ if (eofSignalled != null) {
+ eofSignalled.set(null);
+ }
+
+ int length = buffer.getInt();
+ int type = buffer.getUByte();
+ int id = buffer.getInt();
+ if (type == SftpConstants.SSH_FXP_DATA) {
+ int len = buffer.getInt();
+ buffer.getRawBytes(dst, dstoff, len);
+ Boolean indicator = SftpHelper.getEndOfFileIndicatorValue(buffer, getVersion());
+ if (log.isTraceEnabled()) {
+ log.trace("checkDataResponse({}][id={}] {} offset={}, len={}, EOF={}",
+ getClientChannel(), SftpConstants.getCommandMessageName(cmd),
+ id, dstoff, len, indicator);
+ }
+ if (eofSignalled != null) {
+ eofSignalled.set(indicator);
+ }
+
+ return len;
+ }
+
+ if (type == SftpConstants.SSH_FXP_STATUS) {
+ int substatus = buffer.getInt();
+ String msg = buffer.getString();
+ String lang = buffer.getString();
+ if (log.isTraceEnabled()) {
+ log.trace("checkDataResponse({})[id={}] {} status: {} [{}] {}",
+ getClientChannel(), id, SftpConstants.getCommandMessageName(cmd),
+ SftpConstants.getStatusName(substatus), lang, msg);
+ }
+
+ if (substatus == SftpConstants.SSH_FX_EOF) {
+ return -1;
+ }
+
+ throwStatusException(cmd, id, substatus, msg, lang);
+ }
+
+ return handleUnknownDataPacket(cmd, id, type, length, buffer);
+ }
+
+ protected int handleUnknownDataPacket(int cmd, int id, int type, int length, Buffer buffer) throws IOException {
+ IOException err = handleUnexpectedPacket(cmd, SftpConstants.SSH_FXP_DATA, id, type, length, buffer);
+ if (err != null) {
+ throw err;
+ }
+
+ return 0;
+ }
+
+ @Override
+ public void write(Handle handle, long fileOffset, byte[] src, int srcOffset, int len) throws IOException {
+ // do some bounds checking first
+ if ((fileOffset < 0) || (srcOffset < 0) || (len < 0)) {
+ throw new IllegalArgumentException("write(" + handle + ") please ensure all parameters "
+ + " are non-negative values: file-offset=" + fileOffset
+ + ", src-offset=" + srcOffset + ", len=" + len);
+ }
+ if ((srcOffset + len) > src.length) {
+ throw new IllegalArgumentException("write(" + handle + ")"
+ + " cannot read bytes " + srcOffset + " to " + (srcOffset + len)
+ + " when array is only of length " + src.length);
+ }
+ if (!isOpen()) {
+ throw new IOException("write(" + handle + "/" + fileOffset + ")[" + srcOffset + "/" + len + "] client is closed");
+ }
+
+ if (log.isTraceEnabled()) {
+ log.trace("write({}) handle={}, file-offset={}, buf-offset={}, len={}",
+ getClientChannel(), handle, fileOffset, srcOffset, len);
+ }
+
+ byte[] id = Objects.requireNonNull(handle, "No handle").getIdentifier();
+ Buffer buffer = new ByteArrayBuffer(id.length + len + Long.SIZE /* some extra fields */, false);
+ buffer.putBytes(id);
+ buffer.putLong(fileOffset);
+ buffer.putBytes(src, srcOffset, len);
+ checkCommandStatus(SftpConstants.SSH_FXP_WRITE, buffer);
+ }
+
+ @Override
+ public void mkdir(String path) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("mkdir(" + path + ") client is closed");
+ }
+
+ if (log.isDebugEnabled()) {
+ log.debug("mkdir({}) {}", getClientSession(), path);
+ }
+
+ Buffer buffer = new ByteArrayBuffer(path.length() + Long.SIZE /* some extra fields */, false);
+ buffer.putString(path);
+ buffer.putInt(0);
+
+ int version = getVersion();
+ if (version != SftpConstants.SFTP_V3) {
+ buffer.putByte((byte) 0);
+ }
+
+ checkCommandStatus(SftpConstants.SSH_FXP_MKDIR, buffer);
+ }
+
+ @Override
+ public void rmdir(String path) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("rmdir(" + path + ") client is closed");
+ }
+
+ if (log.isDebugEnabled()) {
+ log.debug("rmdir({}) {}", getClientSession(), path);
+ }
+
+ Buffer buffer = new ByteArrayBuffer(path.length() + Long.SIZE /* some extra fields */, false);
+ buffer.putString(path);
+ checkCommandStatus(SftpConstants.SSH_FXP_RMDIR, buffer);
+ }
+
+ @Override
+ public CloseableHandle openDir(String path) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("openDir(" + path + ") client is closed");
+ }
+
+ Buffer buffer = new ByteArrayBuffer(path.length() + Long.SIZE /* some extra fields */, false);
+ buffer.putString(path);
+
+ CloseableHandle handle = new DefaultCloseableHandle(this, path, checkHandle(SftpConstants.SSH_FXP_OPENDIR, buffer));
+ if (log.isTraceEnabled()) {
+ log.trace("openDir({})[{}}: {}", getClientSession(), path, handle);
+ }
+
+ return handle;
+ }
+
+ @Override
+ public List<DirEntry> readDir(Handle handle, AtomicReference<Boolean> eolIndicator) throws IOException {
+ if (eolIndicator != null) {
+ eolIndicator.set(null); // assume unknown information
+ }
+ if (!isOpen()) {
+ throw new IOException("readDir(" + handle + ") client is closed");
+ }
+
+ byte[] id = Objects.requireNonNull(handle, "No handle").getIdentifier();
+ Buffer buffer = new ByteArrayBuffer(id.length + Byte.SIZE /* some extra fields */, false);
+ buffer.putBytes(id);
+
+ int cmdId = send(SftpConstants.SSH_FXP_READDIR, buffer);
+ Buffer response = receive(cmdId);
+ return checkDirResponse(SftpConstants.SSH_FXP_READDIR, response, eolIndicator);
+ }
+
+ protected List<DirEntry> checkDirResponse(int cmd, Buffer buffer, AtomicReference<Boolean> eolIndicator) throws IOException {
+ if (eolIndicator != null) {
+ eolIndicator.set(null); // assume unknown
+ }
+
+ int length = buffer.getInt();
+ int type = buffer.getUByte();
+ int id = buffer.getInt();
+ if (type == SftpConstants.SSH_FXP_NAME) {
+ int len = buffer.getInt();
+ int version = getVersion();
+ ClientChannel channel = getClientChannel();
+ if (log.isDebugEnabled()) {
+ log.debug("checkDirResponse({}}[id={}] reading {} entries", channel, id, len);
+ }
+
+ List<DirEntry> entries = new ArrayList<>(len);
+ for (int i = 0; i < len; i++) {
+ String name = getReferencedName(cmd, buffer);
+ String longName = (version == SftpConstants.SFTP_V3) ? getReferencedName(cmd, buffer) : null;
+ Attributes attrs = readAttributes(cmd, buffer);
+ if (log.isTraceEnabled()) {
+ log.trace("checkDirResponse({})[id={}][{}] ({})[{}]: {}",
+ channel, id, i, name, longName, attrs);
+ }
+
+ entries.add(new DirEntry(name, longName, attrs));
+ }
+
+ Boolean indicator = SftpHelper.getEndOfListIndicatorValue(buffer, version);
+ if (eolIndicator != null) {
+ eolIndicator.set(indicator);
+ }
+
+ if (log.isDebugEnabled()) {
+ log.debug("checkDirResponse({}}[id={}] read count={}, eol={}", channel, entries.size(), indicator);
+ }
+ return entries;
+ }
+
+ if (type == SftpConstants.SSH_FXP_STATUS) {
+ int substatus = buffer.getInt();
+ String msg = buffer.getString();
+ String lang = buffer.getString();
+ if (log.isTraceEnabled()) {
+ log.trace("checkDirResponse({})[id={}] - status: {} [{}] {}",
+ getClientChannel(), id, SftpConstants.getStatusName(substatus), lang, msg);
+ }
+
+ if (substatus == SftpConstants.SSH_FX_EOF) {
+ return null;
+ }
+
+ throwStatusException(cmd, id, substatus, msg, lang);
+ }
+
+ return handleUnknownDirListingPacket(cmd, id, type, length, buffer);
+ }
+
+ protected List<DirEntry> handleUnknownDirListingPacket(int cmd, int id, int type, int length, Buffer buffer) throws IOException {
+ IOException err = handleUnexpectedPacket(cmd, SftpConstants.SSH_FXP_NAME, id, type, length, buffer);
+ if (err != null) {
+ throw err;
+ }
+ return Collections.emptyList();
+ }
+
+ protected IOException handleUnexpectedPacket(int cmd, int expected, int id, int type, int length, Buffer buffer) throws IOException {
+ throw new SshException("Unexpected SFTP packet received while awaiting " + SftpConstants.getCommandMessageName(expected)
+ + " response to " + SftpConstants.getCommandMessageName(cmd)
+ + ": type=" + SftpConstants.getCommandMessageName(type) + ", id=" + id + ", length=" + length);
+ }
+
+ @Override
+ public String canonicalPath(String path) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("canonicalPath(" + path + ") client is closed");
+ }
+
+ Buffer buffer = new ByteArrayBuffer(path.length() + Long.SIZE, false);
+ buffer.putString(path);
+ return checkOneName(SftpConstants.SSH_FXP_REALPATH, buffer);
+ }
+
+ @Override
+ public Attributes stat(String path) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("stat(" + path + ") client is closed");
+ }
+
+ Buffer buffer = new ByteArrayBuffer(path.length() + Long.SIZE, false);
+ buffer.putString(path);
+
+ int version = getVersion();
+ if (version >= SftpConstants.SFTP_V4) {
+ buffer.putInt(SftpConstants.SSH_FILEXFER_ATTR_ALL);
+ }
+
+ return checkAttributes(SftpConstants.SSH_FXP_STAT, buffer);
+ }
+
+ @Override
+ public Attributes lstat(String path) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("lstat(" + path + ") client is closed");
+ }
+
+ Buffer buffer = new ByteArrayBuffer(path.length() + Long.SIZE, false);
+ buffer.putString(path);
+
+ int version = getVersion();
+ if (version >= SftpConstants.SFTP_V4) {
+ buffer.putInt(SftpConstants.SSH_FILEXFER_ATTR_ALL);
+ }
+
+ return checkAttributes(SftpConstants.SSH_FXP_LSTAT, buffer);
+ }
+
+ @Override
+ public Attributes stat(Handle handle) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("stat(" + handle + ") client is closed");
+ }
+
+ byte[] id = Objects.requireNonNull(handle, "No handle").getIdentifier();
+ Buffer buffer = new ByteArrayBuffer(id.length + Byte.SIZE /* a bit extra */, false);
+ buffer.putBytes(id);
+
+ int version = getVersion();
+ if (version >= SftpConstants.SFTP_V4) {
+ buffer.putInt(SftpConstants.SSH_FILEXFER_ATTR_ALL);
+ }
+
+ return checkAttributes(SftpConstants.SSH_FXP_FSTAT, buffer);
+ }
+
+ @Override
+ public void setStat(String path, Attributes attributes) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("setStat(" + path + ")[" + attributes + "] client is closed");
+ }
+
+ if (log.isDebugEnabled()) {
+ log.debug("setStat({})[{}]: {}", getClientSession(), path, attributes);
+ }
+
+ Buffer buffer = new ByteArrayBuffer();
+ buffer.putString(path);
+ writeAttributes(buffer, attributes);
+ checkCommandStatus(SftpConstants.SSH_FXP_SETSTAT, buffer);
+ }
+
+ @Override
+ public void setStat(Handle handle, Attributes attributes) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("setStat(" + handle + ")[" + attributes + "] client is closed");
+ }
+
+ if (log.isDebugEnabled()) {
+ log.debug("setStat({})[{}]: {}", getClientSession(), handle, attributes);
+ }
+ byte[] id = Objects.requireNonNull(handle, "No handle").getIdentifier();
+ Buffer buffer = new ByteArrayBuffer(id.length + (2 * Long.SIZE) /* some extras */, false);
+ buffer.putBytes(id);
+ writeAttributes(buffer, attributes);
+ checkCommandStatus(SftpConstants.SSH_FXP_FSETSTAT, buffer);
+ }
+
+ @Override
+ public String readLink(String path) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("readLink(" + path + ") client is closed");
+ }
+
+ Buffer buffer = new ByteArrayBuffer(path.length() + Long.SIZE /* some extra fields */, false);
+ buffer.putString(path);
+ return checkOneName(SftpConstants.SSH_FXP_READLINK, buffer);
+ }
+
+ @Override
+ public void link(String linkPath, String targetPath, boolean symbolic) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("link(" + linkPath + " => " + targetPath + ")[symbolic=" + symbolic + "] client is closed");
+ }
+
+ if (log.isDebugEnabled()) {
+ log.debug("link({})[symbolic={}] {} => {}", getClientSession(), symbolic, linkPath, targetPath);
+ }
+
+ Buffer buffer = new ByteArrayBuffer(linkPath.length() + targetPath.length() + Long.SIZE /* some extra fields */, false);
+ int version = getVersion();
+ if (version < SftpConstants.SFTP_V6) {
+ if (!symbolic) {
+ throw new UnsupportedOperationException("Hard links are not supported in sftp v" + version);
+ }
+ buffer.putString(targetPath);
+ buffer.putString(linkPath);
+ checkCommandStatus(SftpConstants.SSH_FXP_SYMLINK, buffer);
+ } else {
+ buffer.putString(targetPath);
+ buffer.putString(linkPath);
+ buffer.putBoolean(symbolic);
+ checkCommandStatus(SftpConstants.SSH_FXP_LINK, buffer);
+ }
+ }
+
+ @Override
+ public void lock(Handle handle, long offset, long length, int mask) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("lock(" + handle + ")[offset=" + offset + ", length=" + length + ", mask=0x" + Integer.toHexString(mask) + "] client is closed");
+ }
+
+ if (log.isDebugEnabled()) {
+ log.debug("lock({})[{}] offset={}, length={}, mask=0x{}",
+ getClientSession(), handle, offset, length, Integer.toHexString(mask));
+ }
+
+ byte[] id = Objects.requireNonNull(handle, "No handle").getIdentifier();
+ Buffer buffer = new ByteArrayBuffer(id.length + Long.SIZE /* a bit extra */, false);
+ buffer.putBytes(id);
+ buffer.putLong(offset);
+ buffer.putLong(length);
+ buffer.putInt(mask);
+ checkCommandStatus(SftpConstants.SSH_FXP_BLOCK, buffer);
+ }
+
+ @Override
+ public void unlock(Handle handle, long offset, long length) throws IOException {
+ if (!isOpen()) {
+ throw new IOException("unlock" + handle + ")[offset=" + offset + ", length=" + length + "] client is closed");
+ }
+
+ if (log.isDebugEnabled()) {
+ log.debug("unlock({})[{}] offset={}, length={}", getClientSession(), handle, offset, length);
+ }
+
+ byte[] id = Objects.requireNonNull(handle, "No handle").getIdentifier();
+ Buffer buffer = new ByteArrayBuffer(id.length + Long.SIZE /* a bit extra */, false);
+ buffer.putBytes(id);
+ buffer.putLong(offset);
+ buffer.putLong(length);
+ checkCommandStatus(SftpConstants.SSH_FXP_UNBLOCK, buffer);
+ }
+}
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/AbstractSftpFileAttributeView.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/AbstractSftpFileAttributeView.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/AbstractSftpFileAttributeView.java
new file mode 100644
index 0000000..0fce423
--- /dev/null
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/AbstractSftpFileAttributeView.java
@@ -0,0 +1,92 @@
+/*
+ * 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.client.subsystem.sftp.impl;
+
+import java.io.IOException;
+import java.nio.file.LinkOption;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Path;
+import java.nio.file.attribute.FileAttributeView;
+import java.util.Objects;
+
+import org.apache.sshd.client.subsystem.sftp.SftpClient;
+import org.apache.sshd.client.subsystem.sftp.SftpFileSystem;
+import org.apache.sshd.client.subsystem.sftp.SftpFileSystemProvider;
+import org.apache.sshd.client.subsystem.sftp.SftpPath;
+import org.apache.sshd.common.subsystem.sftp.SftpConstants;
+import org.apache.sshd.common.subsystem.sftp.SftpException;
+import org.apache.sshd.common.util.logging.AbstractLoggingBean;
+
+/**
+ * @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
+ */
+public abstract class AbstractSftpFileAttributeView extends AbstractLoggingBean implements FileAttributeView {
+ protected final SftpFileSystemProvider provider;
+ protected final Path path;
+ protected final LinkOption[] options;
+
+ protected AbstractSftpFileAttributeView(SftpFileSystemProvider provider, Path path, LinkOption... options) {
+ this.provider = Objects.requireNonNull(provider, "No file system provider instance");
+ this.path = Objects.requireNonNull(path, "No path");
+ this.options = options;
+ }
+
+ @Override
+ public String name() {
+ return "view";
+ }
+
+ /**
+ * @return The underlying {@link SftpFileSystemProvider} used to
+ * provide the view functionality
+ */
+ public final SftpFileSystemProvider provider() {
+ return provider;
+ }
+
+ /**
+ * @return The referenced view {@link Path}
+ */
+ public final Path getPath() {
+ return path;
+ }
+
+ protected SftpClient.Attributes readRemoteAttributes() throws IOException {
+ return provider.readRemoteAttributes(provider.toSftpPath(path), options);
+ }
+
+ protected void writeRemoteAttributes(SftpClient.Attributes attrs) throws IOException {
+ SftpPath p = provider.toSftpPath(path);
+ SftpFileSystem fs = p.getFileSystem();
+ try (SftpClient client = fs.getClient()) {
+ try {
+ if (log.isDebugEnabled()) {
+ log.debug("writeRemoteAttributes({})[{}]: {}", fs, p, attrs);
+ }
+ client.setStat(p.toString(), attrs);
+ } catch (SftpException e) {
+ if (e.getStatus() == SftpConstants.SSH_FX_NO_SUCH_FILE) {
+ throw new NoSuchFileException(p.toString());
+ }
+ throw e;
+ }
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/mina-sshd/blob/15428746/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/DefaultCloseableHandle.java
----------------------------------------------------------------------
diff --git a/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/DefaultCloseableHandle.java b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/DefaultCloseableHandle.java
new file mode 100644
index 0000000..f6597f3
--- /dev/null
+++ b/sshd-core/src/main/java/org/apache/sshd/client/subsystem/sftp/impl/DefaultCloseableHandle.java
@@ -0,0 +1,66 @@
+/*
+ * 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.client.subsystem.sftp.impl;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.sshd.client.subsystem.sftp.SftpClient;
+import org.apache.sshd.client.subsystem.sftp.SftpClient.CloseableHandle;
+import org.apache.sshd.common.util.ValidateUtils;
+
+/**
+ * @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
+ */
+public class DefaultCloseableHandle extends CloseableHandle {
+ private final AtomicBoolean open = new AtomicBoolean(true);
+ private final SftpClient client;
+
+ public DefaultCloseableHandle(SftpClient client, String path, byte[] id) {
+ super(path, id);
+ this.client = ValidateUtils.checkNotNull(client, "No client for path=%s", path);
+ }
+
+ public final SftpClient getSftpClient() {
+ return client;
+ }
+
+ @Override
+ public boolean isOpen() {
+ return open.get();
+ }
+
+ @Override
+ public void close() throws IOException {
+ if (open.getAndSet(false)) {
+ client.close(this);
+ }
+ }
+
+ @Override // to avoid Findbugs[EQ_DOESNT_OVERRIDE_EQUALS]
+ public int hashCode() {
+ return super.hashCode();
+ }
+
+ @Override // to avoid Findbugs[EQ_DOESNT_OVERRIDE_EQUALS]
+ public boolean equals(Object obj) {
+ return super.equals(obj);
+ }
+}