net-sftp 4.0.2 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e7dc5adb1f352eecedf9c4d5f6150b32e0e26ccdd76cb6cb242c66fbe636fd4
-  data.tar.gz: e9b3ade5165aa0c1dbb61e64acd303794b16a31aa385472c3c513d983322fb3a
+  metadata.gz: 618cad45c3de8f52cf2579f2616d27df2ecd69d35dce35c6b80822dab1a0f8ac
+  data.tar.gz: 7b07b32f66e9109e037582827bc2dc602b19479d93b6be3e526f263cd499062e
 SHA512:
-  metadata.gz: 8534ab3b4109bd1e5333c1e4814e5e01a855c2f84c40f60d58bfb2d6303bdc1fab20bf8102b31ef2a1b8c408e6565a7a0a26ff1dbf1b1c48445dd2f9aa49bee8
-  data.tar.gz: b36ad98cdca42bdf48a29957105f4a104c2965280f983f937bfd64e8958b86a2354dc612e52404bba88374944bdda86016f4e06449e8fb541e26f74a0e0eeacc
+  metadata.gz: 47d88176bf4883648da4339a5d250e69c84921bc96a5424ff9bb5bb65d4c83b97fa2543e2a11f03d3043c6a04bf8bde5026c167ef6ccd9c1d880f7e8dcb08d10
+  data.tar.gz: c7568857412af07782a37dbc7516fb59af76e47bff76e9229a9fa2429076fca96ca06d92b6f9706de20c700917ecb887ea8e793d23d03c969fa698ad79c37280

data/CHANGES.txt

@@ -1,3 +1,21 @@
+=== 4.1.1
+
+* A read error during a single-file download is raised once, after the outstanding reads complete and the handle is closed, instead of once per in-flight read [#212]
+* `abort!` now stops uploads and downloads: no new write or read is sent, the requests in flight finish and the open files are closed, so `wait` returns once their replies arrive. Previously the transfer kept running to the end, and an upload reported `:finish` twice. [#211]
+* Single-file uploads keep up to `:requests` writes in flight (default 64, like OpenSSH's sftp client, previously 2) so large uploads are no longer bound by round-trip time. The file is closed once every write is acknowledged, and a failed write is raised once, after the close. [#210]
+* Package only `lib`, `CHANGES.txt`, `LICENSE.txt` and `README.rdoc` in the gem, about 20% smaller. Thanks @yuri-zubov [#199]
+
+=== 4.1.0
+
+* BREAKING: Require Ruby 2.6 or later. Bundler on older Rubies resolves to 4.0.2. [#207]
+* BREAKING: `upload` and `download` no longer close an IO object passed in as the local side; `download` flushes it instead. Callers that relied on the close must close it themselves. [#202]
+* Security: An `FXP_VERSION` packet after the session is open now raises `Net::SFTP::Exception` instead of switching protocol version mid-session and dropping pending requests. [#193]
+* Security: A server can no longer make the client allocate without bound, or hang, by sending an ACL, extended attribute or directory listing count larger than the packet holds; such packets now raise `Net::SFTP::Exception`. [#192]
+* Single-file downloads keep up to `:requests` reads in flight (default 64) instead of waiting for each 32 KB reply, so large downloads are no longer bound by round-trip time. [#204]
+* `upload!` and `download!` now give new files and directories the source's permissions (masked to 0777, subject to the umask) like OpenSSH's sftp client, so executables stay executable and private files are no longer created world-readable. The new `:preserve` option also copies access and modification times and sets permissions exactly. As with OpenSSH, attributes are best effort: if they can't be read the transfer uses default permissions, and if they can't be set a warning is logged and the transfer still succeeds. [#203]
+* Added `Net::SFTP::Session#extensions`, the extensions the server advertised in its `FXP_VERSION` packet (such as `posix-rename@openssh.com`). [#195]
+* The `:version` option now caps the negotiated SFTP protocol version; servers that always reply with their own version (OpenSSH replies 3) used to be negotiated at that version instead of the one requested. [#194]
+
 === 4.0.2
 
 * Security: Recursive downloads refuse to follow an existing local symlink at a server-named path instead of writing through it. The local path passed by the caller may still be a symlink. Suggested in #162 by srosenhamer [#186]

data/README.rdoc

@@ -35,6 +35,9 @@ In a nutshell:
     # download a file or directory from the remote host
     sftp.download!("/path/to/remote", "/path/to/local")
 
+    # also copy access and modification times (permissions are always copied)
+    sftp.download!("/path/to/remote", "/path/to/local", :preserve => true)
+
     # grab data off the remote host directly to a buffer
     data = sftp.download!("/path/to/remote")
 

data/lib/net/sftp/operations/download.rb

@@ -49,12 +49,26 @@ module Net; module SFTP; module Operations
   # * <tt>:progress</tt> - either a block or an object to act as a progress
   #   callback. See the discussion of "progress monitoring" below.
   # * <tt>:requests</tt> - the number of pending SFTP requests to allow at
-  #   any given time. When downloading an entire directory tree recursively,
-  #   this will default to 16. Setting this higher might improve throughput.
-  #   Reducing it will reduce throughput.
+  #   any given time. When downloading a single file, this is the number of
+  #   reads kept in flight and defaults to 64. When downloading an entire
+  #   directory tree recursively, it is the number of files and directories
+  #   transferred at once and defaults to 16. Setting this higher might
+  #   improve throughput, particularly on high-latency links. Reducing it
+  #   will reduce throughput.
   # * <tt>:read_size</tt> - the maximum number of bytes to read at a time
   #   from the source. Increasing this value might improve throughput. It
   #   defaults to 32,000 bytes.
+  # * <tt>:preserve</tt> - if true, the local files and directories get the
+  #   access and modification times of the remote ones, and their permissions
+  #   are set exactly, even on files that already exist and regardless of the
+  #   umask.
+  #
+  # Like OpenSSH's sftp client, new local files and directories are created
+  # with the permissions of the remote ones, without setuid, setgid and sticky
+  # bits and subject to the umask. Nothing is set when +local+ is an IO object.
+  # If the remote attributes can't be read, the download goes ahead with
+  # default permissions; if they can't be applied locally, a warning is logged
+  # and the download still succeeds.
   #
   # == Progress Monitoring
   #
@@ -155,6 +169,8 @@ module Net; module SFTP; module Operations
       @progress = progress || options[:progress]
       @options = options
       @active = 0
+      @aborted = false
+      @directories = []
       @properties = options[:properties] || {}
       requests
       read_size
@@ -181,9 +197,10 @@ module Net; module SFTP; module Operations
       @active > 0 || stack.any?
     end
 
-    # Forces the transfer to stop.
+    # Forces the transfer to stop. Reads already sent are left to finish,
+    # then each open file is closed, so #wait returns once that is done.
     def abort!
-      @active = 0
+      @aborted = true
       @stack.clear
     end
 
@@ -210,7 +227,8 @@ module Net; module SFTP; module Operations
 
       # A simple struct for encapsulating information about a single remote
       # file or directory that needs to be downloaded.
-      Entry = Struct.new(:remote, :local, :directory, :size, :handle, :offset, :sink)
+      Entry = Struct.new(:remote, :local, :directory, :size, :handle, :offset, :sink,
+                         :next_read, :pending, :window, :chunks, :eof, :attributes, :error)
 
       #--
       # "ruby -w" hates private attributes, so we have to do these longhand
@@ -231,10 +249,19 @@ module Net; module SFTP; module Operations
         @read_size ||= positive_option(:read_size, DEFAULT_READ_SIZE)
       end
 
-      # The number of simultaneou SFTP requests to use to effect the download.
-      # Defaults to 16 for recursive downloads.
+      # The number of simultaneous SFTP requests to use to effect the download.
+      # Defaults to 16 for recursive downloads and 64 for single files.
       def requests
-        @requests ||= positive_option(:requests, recursive? ? 16 : 2)
+        @requests ||= positive_option(:requests, recursive? ? 16 : 64)
+      end
+
+      # The most reads a single file may have outstanding at once.
+      def read_window_limit
+        recursive? ? 1 : requests
+      end
+
+      def preserve?
+        options[:preserve]
       end
 
       def positive_option(name, default)
@@ -254,7 +281,12 @@ module Net; module SFTP; module Operations
           if entry.directory
             update_progress(:mkdir, entry.local)
             refuse_symlink!(entry.local) if server_named?(entry) && ::File.symlink?(entry.local)
-            ::Dir.mkdir(entry.local) unless ::File.directory?(entry.local)
+            created = !::File.directory?(entry.local)
+            ::Dir.mkdir(entry.local, local_permissions(entry, 0777) | 0300) if created
+            if created || preserve?
+              @directories << entry
+              stat_directory(entry) unless entry.attributes
+            end
             request = sftp.opendir(entry.remote, &method(:on_opendir))
             request[:entry] = entry
           else
@@ -262,7 +294,64 @@ module Net; module SFTP; module Operations
           end
         end
 
-        update_progress(:finish) if !active?
+        if !active?
+          set_directory_attributes
+          update_progress(:finish)
+        end
+      end
+
+      # Only entries listed by readdir come with attributes.
+      def stat_directory(entry)
+        @active += 1
+        sftp.stat(entry.remote) do |response|
+          @active -= 1
+          entry.attributes = remote_attributes(response, "stat #{entry.remote}")
+          process_next_entry
+        end
+      end
+
+      # Without the remote attributes the download goes ahead with default
+      # permissions and no times, as it would for a server that never sent any.
+      def remote_attributes(response, operation)
+        return response[:attrs] if response.ok?
+
+        debug { "#{operation} failed, using default attributes: #{response}" }
+        nil
+      end
+
+      # Deepest directories first, after their contents; setting attributes on
+      # a directory doesn't change its parent's modification time.
+      def set_directory_attributes
+        @directories.reverse_each do |entry|
+          next unless entry.attributes
+
+          permissions = local_permissions(entry, 0777)
+          permissions &= ~::File.umask unless preserve?
+          set_local_attributes(entry, permissions)
+        end
+        @directories.clear
+      end
+
+      # setuid, setgid and sticky bits are never applied, matching OpenSSH.
+      def local_permissions(entry, default)
+        permissions = entry.attributes && entry.attributes.permissions
+        permissions ? permissions & 0777 : default
+      end
+
+      # Like OpenSSH's sftp client, failing to set attributes only warns; the
+      # data has already been transferred.
+      def set_local_attributes(entry, permissions)
+        attempt_local("chmod", entry) { ::File.chmod(permissions, entry.local) } if permissions
+
+        attributes = entry.attributes
+        return unless preserve? && attributes && attributes.atime && attributes.mtime
+        attempt_local("utime", entry) { ::File.utime(attributes.atime, attributes.mtime, entry.local) }
+      end
+
+      def attempt_local(operation, entry)
+        yield
+      rescue SystemCallError => e
+        lwarn { "#{operation} #{entry.local} failed: #{e.message}" }
       end
 
       # Called when a remote directory is "opened" for reading, e.g. to
@@ -281,7 +370,7 @@ module Net; module SFTP; module Operations
       # and #process_next_entry is called.
       def on_readdir(response)
         entry = response.request[:parent]
-        if response.eof?
+        if response.eof? || @aborted
           request = sftp.close(entry.handle, &method(:on_closedir))
           request[:parent] = entry
         elsif !response.ok?
@@ -290,7 +379,9 @@ module Net; module SFTP; module Operations
           response[:names].each do |item|
             next if item.name == "." || item.name == ".."
             validate_entry_name!(entry, item.name)
-            stack << Entry.new(::File.join(entry.remote, item.name), ::File.join(entry.local, item.name), item.directory?, item.attributes.size)
+            child = Entry.new(::File.join(entry.remote, item.name), ::File.join(entry.local, item.name), item.directory?, item.attributes.size)
+            child.attributes = item.attributes
+            stack << child
           end
 
           # take this opportunity to enqueue more requests
@@ -316,11 +407,13 @@ module Net; module SFTP; module Operations
         entry.local != local
       end
 
+      # Like OpenSSH, the file is always created writable by its owner.
       def open_local_file(entry)
-        return ::File.open(entry.local, "wb") unless server_named?(entry) && defined?(::File::NOFOLLOW)
+        permissions = local_permissions(entry, 0666) | 0200
+        return ::File.open(entry.local, "wb", permissions) unless server_named?(entry) && defined?(::File::NOFOLLOW)
 
         begin
-          ::File.open(entry.local, "wb", :flags => ::File::NOFOLLOW)
+          ::File.open(entry.local, "wb", permissions, :flags => ::File::NOFOLLOW)
         rescue SystemCallError
           raise unless ::File.symlink?(entry.local)
           refuse_symlink!(entry.local)
@@ -346,55 +439,148 @@ module Net; module SFTP; module Operations
         process_next_entry
       end
 
-      # Called when a file has been opened. This will call #download_next_chunk
+      # Called when a file has been opened. This will call #request_reads
       # to initiate the data transfer.
       def on_open(response)
         entry = response.request[:entry]
         raise StatusException.new(response, "open #{entry.remote}") unless response.ok?
 
         entry.handle = response[:handle]
+        if @aborted || entry.attributes || entry.local.respond_to?(:write)
+          start_download(entry)
+        else
+          request = sftp.fstat(entry.handle, &method(:on_fstat))
+          request[:entry] = entry
+        end
+      end
+
+      # Called when the attributes of a file opened by #open_file arrive.
+      def on_fstat(response)
+        entry = response.request[:entry]
+        entry.attributes = remote_attributes(response, "fstat #{entry.remote}")
+        start_download(entry)
+      end
+
+      def start_download(entry)
+        return close_aborted_file(entry) if @aborted
+
         entry.sink = entry.local.respond_to?(:write) ? entry.local : open_local_file(entry)
         entry.offset = 0
+        entry.next_read = 0
+        entry.pending = 0
+        entry.window = 1
+        entry.chunks = {}
+
+        request_reads(entry)
+      end
 
-        download_next_chunk(entry)
+      # Keeps up to entry.window reads of #read_size bytes outstanding until
+      # the server reports EOF. The window starts at one and grows with each
+      # data reply, so small files don't cost a burst of reads past their end.
+      def request_reads(entry)
+        while !entry.eof && !@aborted && entry.pending < entry.window
+          read_range(entry, entry.next_read, read_size)
+          entry.next_read += read_size
+        end
       end
 
-      # Initiates a read of the next #read_size bytes from the file.
-      def download_next_chunk(entry)
-        request = sftp.read(entry.handle, entry.offset, read_size, &method(:on_read))
+      def read_range(entry, offset, length)
+        entry.pending += 1
+        request = sftp.read(entry.handle, offset, length, &method(:on_read))
         request[:entry] = entry
-        request[:offset] = entry.offset
+        request[:offset] = offset
+        request[:length] = length
       end
 
-      # Called when a read from a file finishes. If the read was successful
-      # and returned data, this will call #download_next_chunk to read the
-      # next bit from the file. Otherwise the file will be closed.
+      # Called when a read from a file finishes. Replies can arrive out of
+      # order, so data is buffered until everything before it has been
+      # written. Once the server has reported EOF or a read has failed, and
+      # no reads are left outstanding, the file is closed.
       def on_read(response)
         entry = response.request[:entry]
+        entry.pending -= 1
 
-        if response.eof?
-          update_progress(:close, entry)
-          entry.sink.close
-          request = sftp.close(entry.handle, &method(:on_close))
-          request[:entry] = entry
+        if entry.error
+          # The rest of the file is no longer wanted.
+        elsif response.eof?
+          entry.eof = true
         elsif !response.ok?
-          raise StatusException.new(response, "read #{entry.remote}")
+          entry.error = StatusException.new(response, "read #{entry.remote}")
+        elsif response[:data].empty? || response[:data].bytesize > response.request[:length]
+          entry.error = Net::SFTP::Exception.new("read #{entry.remote} returned #{response[:data].bytesize} bytes for a #{response.request[:length]} byte request")
         else
-          entry.offset += response[:data].bytesize
-          update_progress(:get, entry, response.request[:offset], response[:data])
-          entry.sink.write(response[:data])
-          download_next_chunk(entry)
+          offset = response.request[:offset]
+          length = response.request[:length]
+          data = response[:data]
+
+          # Servers may return less than asked for without being at EOF, and
+          # the reads after this one have already been sent.
+          read_range(entry, offset + data.bytesize, length - data.bytesize) if data.bytesize < length && !@aborted
+
+          entry.chunks[offset] = data
+          write_buffered_chunks(entry)
+          entry.window += 1 if entry.window < read_window_limit
+        end
+
+        if entry.error
+          close_failed_file(entry) if entry.pending.zero?
+        else
+          request_reads(entry)
+          close_file(entry) if entry.pending.zero?
+        end
+      end
+
+      def write_buffered_chunks(entry)
+        while (data = entry.chunks.delete(entry.offset))
+          update_progress(:get, entry, entry.offset, data)
+          entry.sink.write(data)
+          entry.offset += data.bytesize
         end
       end
 
+      def close_file(entry)
+        if entry.chunks.any? && !@aborted
+          raise Net::SFTP::Exception, "read #{entry.remote} hit EOF at #{entry.offset} but the server returned data beyond it"
+        end
+
+        update_progress(:close, entry)
+        # The caller's IO stays open, but is flushed so its data is written when download! returns.
+        if entry.sink.equal?(local)
+          entry.sink.flush if entry.sink.respond_to?(:flush)
+        else
+          entry.sink.close
+        end
+        unless entry.local.respond_to?(:write)
+          set_local_attributes(entry, preserve? ? local_permissions(entry, nil) : nil)
+        end
+        request = sftp.close(entry.handle, &method(:on_close))
+        request[:entry] = entry
+      end
+
+      # The local file is left untouched: it may hold an earlier copy.
+      def close_aborted_file(entry)
+        update_progress(:close, entry)
+        request = sftp.close(entry.handle, &method(:on_close))
+        request[:entry] = entry
+      end
+
       # Called when a file handle is closed.
       def on_close(response)
         @active -= 1
         entry = response.request[:entry]
+        raise entry.error if entry.error
         raise StatusException.new(response, "close #{entry.remote}") unless response.ok?
         process_next_entry
       end
 
+      # Waiting for every reply before raising keeps the remote handle from
+      # leaking and the error from being raised again by each later reply.
+      def close_failed_file(entry)
+        entry.sink.close unless entry.sink.equal?(local)
+        request = sftp.close(entry.handle, &method(:on_close))
+        request[:entry] = entry
+      end
+
       # If a progress callback or object has been set, this will report
       # the progress to that callback or object.
       def update_progress(hook, *args)

data/lib/net/sftp/operations/upload.rb

@@ -47,8 +47,9 @@ module Net; module SFTP; module Operations
   #   callback. See the discussion of "progress monitoring" below.
   # * <tt>:requests</tt> - the number of pending SFTP requests to allow at
   #   any given time. When uploading an entire directory tree recursively,
-  #   this will default to 16, otherwise it will default to 2. Setting this
-  #   higher might improve throughput. Reducing it will reduce throughput.
+  #   this will default to 16, otherwise it will default to 64, like OpenSSH's
+  #   sftp client. Setting this higher might improve throughput. Reducing it
+  #   will reduce throughput.
   # * <tt>:read_size</tt> - the maximum number of bytes to read at a time
   #   from the source. Increasing this value might improve throughput. It
   #   defaults to 32,000 bytes. Each chunk is sent as one write request, so
@@ -56,6 +57,15 @@ module Net; module SFTP; module Operations
   #   connection on packets over 256 KiB).
   # * <tt>:name</tt> - the filename to report to the progress monitor when
   #   an IO object is given as +local+. This defaults to "<memory>".
+  # * <tt>:preserve</tt> - if true, the remote files and directories get the
+  #   access and modification times of the local ones, and their permissions
+  #   are set even on files that already exist remotely.
+  #
+  # Like OpenSSH's sftp client, new remote files and directories are created
+  # with the permissions of the local ones, without setuid, setgid and sticky
+  # bits and subject to the server's umask. Nothing is set when +local+ is an
+  # IO object. If the server refuses to set the attributes after the data has
+  # been written, a warning is logged and the upload still succeeds.
   #
   # == Progress Monitoring
   #
@@ -154,6 +164,8 @@ module Net; module SFTP; module Operations
       @options = options
       @properties = options[:properties] || {}
       @active = 0
+      @aborted = false
+      @directories = []
 
       self.logger = sftp.logger
 
@@ -169,7 +181,7 @@ module Net; module SFTP; module Operations
 
         @active += 1
         if @options[:mkdir]
-          sftp.mkdir(remote) do |response|
+          sftp.mkdir(remote, directory_attributes(local, remote)) do |response|
             @active -= 1
             raise StatusException.new(response, "mkdir `#{remote}'") unless response.ok?
             requests.times do
@@ -199,11 +211,11 @@ module Net; module SFTP; module Operations
       @active > 0 || @stack.any?
     end
 
-    # Forces the transfer to stop.
+    # Forces the transfer to stop. Writes already sent are left to finish,
+    # then each open file is closed, so #wait returns once that is done.
     def abort!
-      @active = 0
+      @aborted = true
       @stack.clear
-      @uploads.clear
     end
 
     # Blocks until the upload has completed.
@@ -248,15 +260,19 @@ module Net; module SFTP; module Operations
         value
       end
 
+      def preserve?
+        options[:preserve]
+      end
+
       # A simple struct for recording metadata about the file currently being
       # uploaded.
-      LiveFile = Struct.new(:local, :remote, :io, :size, :handle)
+      LiveFile = Struct.new(:local, :remote, :io, :size, :handle, :attributes, :pending, :error)
 
       # The default # of bytes to read from disk at a time.
       DEFAULT_READ_SIZE   = 32_000
 
       # The number of readers to use when uploading a single file.
-      SINGLE_FILE_READERS = 2
+      SINGLE_FILE_READERS = 64
 
       # The number of readers to use when uploading a directory.
       RECURSIVE_READERS   = 16
@@ -268,7 +284,11 @@ module Net; module SFTP; module Operations
           if @uploads.any?
             write_next_chunk(@uploads.first)
           elsif !active?
-            update_progress(:finish)
+            if @directories.any?
+              set_directory_attributes
+            else
+              update_progress(:finish)
+            end
           end
           return false
         elsif @stack.last.empty?
@@ -288,7 +308,7 @@ module Net; module SFTP; module Operations
 
             @active += 1
             update_progress(:mkdir, rpath)
-            request = sftp.mkdir(rpath, &method(:on_mkdir))
+            request = sftp.mkdir(rpath, directory_attributes(lpath, rpath), &method(:on_mkdir))
             request[:dir] = rpath
           else
             open_file(lpath, rpath)
@@ -317,10 +337,11 @@ module Net; module SFTP; module Operations
           size = file.size
         end
 
-        metafile = LiveFile.new(name, remote, file, size)
+        attributes = local.respond_to?(:read) ? {} : attributes_for(file.stat)
+        metafile = LiveFile.new(name, remote, file, size, nil, attributes, 0)
         update_progress(:open, metafile)
 
-        request = sftp.open(remote, "w", &method(:on_open))
+        request = sftp.open(remote, "w", attributes, &method(:on_open))
         request[:file] = metafile
       end
 
@@ -353,14 +374,25 @@ module Net; module SFTP; module Operations
         end
       end
 
-      # Called when a +write+ request finishes. Raises StatusException if the
-      # write failed, otherwise it calls #write_next_chunk to continue the
-      # write.
+      # Called when a +write+ request finishes. The first failed write stops
+      # the file from being read further and is recorded, to be raised once
+      # the file is closed. The file is closed once the whole file has been
+      # sent or a write has failed, and no writes are left outstanding.
       def on_write(response)
         @active -= 1
         file = response.request[:file]
-        raise StatusException.new(response, "write #{file.remote}") unless response.ok?
-        write_next_chunk(file)
+        file.pending -= 1
+
+        if !response.ok? && !file.error
+          file.error = StatusException.new(response, "write #{file.remote}")
+          stop_reading(file)
+        end
+
+        if file.io.nil? && file.pending.zero?
+          close_file(file)
+        elsif !file.error
+          write_next_chunk(file)
+        end
       end
 
       # Called when a +close+ request finishes. Raises a StatusException if the
@@ -369,27 +401,72 @@ module Net; module SFTP; module Operations
       def on_close(response)
         @active -= 1
         file = response.request[:file]
+        raise file.error if file.error
         raise StatusException.new(response, "close #{file.remote}") unless response.ok?
         process_next_entry
       end
 
+      # setuid, setgid and sticky bits are never sent, matching OpenSSH.
+      def attributes_for(stat)
+        attributes = { :permissions => stat.mode & 0777 }
+        attributes.update(:atime => stat.atime.to_i, :mtime => stat.mtime.to_i) if preserve?
+        attributes
+      end
+
+      # The directory is created writable and searchable by its owner so its
+      # contents can be uploaded; its real attributes are set once everything
+      # else is done (see #set_directory_attributes).
+      def directory_attributes(local, remote)
+        stat = ::File.stat(local)
+        @directories << [remote, attributes_for(stat)]
+        { :permissions => (stat.mode & 0777) | 0300 }
+      end
+
+      # Deepest directories first; setting attributes on a directory doesn't
+      # change its parent's modification time.
+      def set_directory_attributes
+        @directories.reverse_each do |path, attributes|
+          @active += 1
+          sftp.setstat(path, attributes) do |response|
+            @active -= 1
+            warn_unless_ok(response, "setstat #{path}")
+            process_next_entry
+          end
+        end
+        @directories.clear
+      end
+
+      # Called when the +fsetstat+ for :preserve finishes.
+      def on_fsetstat(response)
+        @active -= 1
+        file = response.request[:file]
+        warn_unless_ok(response, "fsetstat #{file.remote}")
+      end
+
+      # Like OpenSSH's sftp client, failing to set attributes only warns; the
+      # data has already been transferred.
+      def warn_unless_ok(response, operation)
+        lwarn { "#{operation} failed: #{response}" } unless response.ok?
+      end
+
       # Attempts to send the next chunk from the given file (where +file+ is
       # a LiveFile instance).
       def write_next_chunk(file)
         if file.io.nil?
           process_next_entry
         else
-          @active += 1
           offset = file.io.pos
-          data = file.io.read(read_size)
+          data = file.io.read(read_size) unless @aborted
           if data.nil?
-            update_progress(:close, file)
-            request = sftp.close(file.handle, &method(:on_close))
-            request[:file] = file
-            file.io.close
-            file.io = nil
-            @uploads.delete(file)
+            stop_reading(file)
+            if file.pending.zero?
+              close_file(file)
+            else
+              process_next_entry
+            end
           else
+            @active += 1
+            file.pending += 1
             update_progress(:put, file, offset, data)
             request = sftp.write(file.handle, offset, data, &method(:on_write))
             request[:file] = file
@@ -397,6 +474,30 @@ module Net; module SFTP; module Operations
         end
       end
 
+      def stop_reading(file)
+        # An IO passed in by the caller is theirs to close.
+        file.io.close unless file.io.equal?(local)
+        file.io = nil
+        @uploads.delete(file)
+      end
+
+      # Like OpenSSH's sftp client, CLOSE waits for every write to be
+      # acknowledged, so a failed write is raised once and the remote handle
+      # is not leaked.
+      def close_file(file)
+        @active += 1
+        unless file.error
+          update_progress(:close, file)
+          if preserve? && file.attributes.any?
+            @active += 1
+            request = sftp.fsetstat(file.handle, file.attributes, &method(:on_fsetstat))
+            request[:file] = file
+          end
+        end
+        request = sftp.close(file.handle, &method(:on_close))
+        request[:file] = file
+      end
+
       # Returns all directory entries for the given path, removing the '.'
       # and '..' relative paths.
       def entries_for(local)