vagrant-sshfs 1.1.0 → 1.2.0

data/lib/vagrant-sshfs/cap/host/linux/sshfs_reverse_mount.rb

@@ -0,0 +1,176 @@
+require "log4r"
+require "vagrant/util/retryable"
+require "tempfile"
+
+# This is already done for us in lib/vagrant-sshfs.rb. We needed to
+# do it there before Process.uid is called the first time by Vagrant
+# This provides a new Process.create() that works on Windows.
+if Vagrant::Util::Platform.windows?
+  require 'win32/process'
+end
+
+module VagrantPlugins
+  module HostLinux
+    module Cap
+      class MountSSHFS
+        extend Vagrant::Util::Retryable
+        @@logger = Log4r::Logger.new("vagrant::synced_folders::sshfs_reverse_mount")
+
+        def self.sshfs_reverse_is_folder_mounted(env, opts)
+          mounted = false
+          hostpath = opts[:hostpath].dup
+          hostpath.gsub!("'", "'\\\\''")
+          hostpath = hostpath.chomp('/') # remove trailing / if exists
+          cat_cmd = Vagrant::Util::Which.which('cat')
+          result = Vagrant::Util::Subprocess.execute(cat_cmd, '/proc/mounts')
+          mounts = File.open('/proc/mounts', 'r')
+          mounts.each_line do |line|
+            if line.split()[1] == hostpath
+              mounted = true
+              break
+            end
+          end
+          return mounted
+        end
+
+        def self.sshfs_reverse_mount_folder(env, machine, opts)
+          # opts contains something like:
+          #   { :type=>:sshfs,
+          #     :guestpath=>"/sharedfolder",
+          #     :hostpath=>"/guests/sharedfolder", 
+          #     :disabled=>false
+          #     :ssh_host=>"192.168.1.1"
+          #     :ssh_port=>"22"
+          #     :ssh_username=>"username"
+          #     :ssh_password=>"password"
+          #   }
+          self.sshfs_mount(machine, opts)
+        end
+
+        def self.sshfs_reverse_unmount_folder(env, machine, opts)
+          self.sshfs_unmount(machine, opts)
+        end
+
+        protected
+
+        # Perform a mount by running an sftp-server on the vagrant host 
+        # and piping stdin/stdout to sshfs running inside the guest
+        def self.sshfs_mount(machine, opts)
+
+          sshfs_path = Vagrant::Util::Which.which('sshfs')
+
+          # expand the guest path so we can handle things like "~/vagrant"
+          expanded_guest_path = machine.guest.capability(
+            :shell_expand_guest_path, opts[:guestpath])
+
+          # Mount path information
+          hostpath = opts[:hostpath].dup
+          hostpath.gsub!("'", "'\\\\''")
+
+          # Add in some sshfs/fuse options that are common to both mount methods
+          opts[:sshfs_opts] = ' -o noauto_cache '# disable caching based on mtime
+
+          # Add in some ssh options that are common to both mount methods
+          opts[:ssh_opts] = ' -o StrictHostKeyChecking=no '# prevent yes/no question 
+          opts[:ssh_opts]+= ' -o ServerAliveInterval=30 '  # send keepalives
+
+          # SSH connection options
+          ssh_opts = opts[:ssh_opts]
+          ssh_opts+= ' -o Port=' + machine.ssh_info[:port].to_s
+          ssh_opts+= ' -o IdentityFile=' + machine.ssh_info[:private_key_path][0]
+          ssh_opts+= ' -o UserKnownHostsFile=/dev/null '
+          ssh_opts+= ' -F /dev/null ' # Don't pick up options from user's config
+
+          ssh_opts_append = opts[:ssh_opts_append].to_s # provided by user
+
+          # SSHFS executable options
+          sshfs_opts = opts[:sshfs_opts]
+          sshfs_opts_append = opts[:sshfs_opts_append].to_s # provided by user
+
+          username = machine.ssh_info[:username]
+          host = machine.ssh_info[:host]
+
+
+          # The sshfs command to mount the guest directory on the host
+          sshfs_cmd = "#{sshfs_path} #{ssh_opts} #{ssh_opts_append} "
+          sshfs_cmd+= "#{sshfs_opts} #{sshfs_opts_append} "
+          sshfs_cmd+= "#{username}@#{host}:#{expanded_guest_path} #{hostpath}" 
+
+          # Log some information
+          @@logger.debug("sshfs cmd: #{sshfs_cmd}")
+
+          machine.ui.info(I18n.t("vagrant.sshfs.actions.reverse_mounting_folder", 
+                          hostpath: hostpath, guestpath: expanded_guest_path))
+
+          # Log STDERR to predictable files so that we can inspect them
+          # later in case things go wrong. We'll use the machines data
+          # directory (i.e. .vagrant/machines/default/virtualbox/) for this
+          f1path = machine.data_dir.join('vagrant_sshfs_sshfs_stderr.txt')
+          f1 = File.new(f1path, 'w+')
+
+          # Launch sshfs command to mount guest dir into the host
+          if Vagrant::Util::Platform.windows?
+            # Need to handle Windows differently. Kernel.spawn fails to work, 
+            # if the shell creating the process is closed.
+            # See https://github.com/dustymabe/vagrant-sshfs/issues/31
+            Process.create(:command_line => ssh_cmd,
+                           :creation_flags => Process::DETACHED_PROCESS,
+                           :process_inherit => false,
+                           :thread_inherit => true,
+                           :startup_info => {:stdin => w2, :stdout => r1, :stderr => f1})
+          else
+            p1 = spawn(sshfs_cmd,   :out => f1, :err => f1, :pgroup => true)
+            Process.detach(p1) # Detach so process will keep running
+          end
+
+          # Check that the mount made it
+          mounted = false
+          for i in 0..6
+            machine.ui.info("Checking Mount..")
+            if self.sshfs_reverse_is_folder_mounted(machine, opts)
+              mounted = true
+              break
+            end
+            sleep(2)
+          end
+          if !mounted
+            f1.rewind # Seek to beginning of the file
+            error_class = VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSReverseMountFailed
+            raise error_class, sshfs_output: f1.read
+          end
+          machine.ui.info("Folder Successfully Mounted!")
+        end
+
+        def self.sshfs_unmount(machine, opts)
+          # opts contains something like:
+          #   { :type=>:sshfs,
+          #     :guestpath=>"/sharedfolder",
+          #     :hostpath=>"/guests/sharedfolder",
+          #     :disabled=>false
+          #     :ssh_host=>"192.168.1.1"
+          #     :ssh_port=>"22"
+          #     :ssh_username=>"username"
+          #     :ssh_password=>"password"
+          #   }
+
+          # Mount path information
+          hostpath = opts[:hostpath].dup
+          hostpath.gsub!("'", "'\\\\''")
+
+          # Log some information
+          machine.ui.info(I18n.t("vagrant.sshfs.actions.reverse_unmounting_folder",
+                                 hostpath: hostpath))
+
+          # Build up the command and connect
+          error_class = VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSUnmountFailed
+          fusermount_cmd = Vagrant::Util::Which.which('fusermount')
+          cmd = "#{fusermount_cmd} -u #{hostpath}"
+          result = Vagrant::Util::Subprocess.execute(*cmd.split())
+          if result.exit_code != 0
+            raise error_class, command: cmd, stdout: result.stdout, stderr: result.stderr
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-sshfs/command.rb

@@ -10,11 +10,19 @@ module VagrantPlugins
         end
 
         def execute
+          options = {:unmount => false} # Default to mounting shares
           opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant sshfs"
+            o.banner = "Usage: vagrant sshfs [--mount|--unmount] [vm-name]"
             o.separator ""
-            o.separator "Mount all sshfs synced folders into the vagrant box"
+            o.separator "Mount or unmount sshfs synced folders into the vagrant box"
             o.separator ""
+
+            o.on("--mount", "Mount folders - the default") do
+              options[:unmount] = false
+            end
+            o.on("--unmount", "Unmount folders") do
+              options[:unmount] = true
+            end
           end
 
           # Parse the options and return if we don't have any target.
@@ -36,8 +44,12 @@ module VagrantPlugins
             folders = synced_folders(machine, cached: false)[:sshfs]
             next if !folders || folders.empty?
 
-            # Sync them!
-            SyncedFolder.new.enable(machine, folders, {})
+            # Mount or Unmount depending on the user's request
+            if options[:unmount]
+              SyncedFolder.new.disable(machine, folders, {})
+            else
+              SyncedFolder.new.enable(machine, folders, {})
+            end
           end
           return error ? 1 : 0
         end

data/lib/vagrant-sshfs/errors.rb

@@ -14,6 +14,14 @@ module VagrantPlugins
         error_key(:slave_mount_failed)
       end
 
+      class SSHFSReverseMountFailed < SSHFSError
+        error_key(:reverse_mount_failed)
+      end
+
+      class SSHFSUnmountFailed < SSHFSError
+        error_key(:unmount_failed)
+      end
+
       class SSHFSInstallFailed < SSHFSError
         error_key(:install_failed)
       end

data/lib/vagrant-sshfs/plugin.rb

@@ -15,68 +15,88 @@ module VagrantPlugins
         SyncedFolder
       end
 
-      command("sshfs", primary: false) do
+      command("sshfs", primary: true) do
         require_relative "command"
         Command::SSHFS
       end
 
-      guest_capability("linux", "sshfs_mount_folder") do
-        require_relative "cap/linux/sshfs_mount"
+      host_capability("linux", "sshfs_reverse_mount_folder") do
+        require_relative "cap/host/linux/sshfs_reverse_mount"
+        VagrantPlugins::HostLinux::Cap::MountSSHFS
+      end
+
+      host_capability("linux", "sshfs_reverse_unmount_folder") do
+        require_relative "cap/host/linux/sshfs_reverse_mount"
+        VagrantPlugins::HostLinux::Cap::MountSSHFS
+      end
+
+      host_capability("linux", "sshfs_reverse_is_folder_mounted") do
+        require_relative "cap/host/linux/sshfs_reverse_mount"
+        VagrantPlugins::HostLinux::Cap::MountSSHFS
+      end
+
+      guest_capability("linux", "sshfs_forward_mount_folder") do
+        require_relative "cap/guest/linux/sshfs_forward_mount"
+        VagrantPlugins::GuestLinux::Cap::MountSSHFS
+      end
+
+      guest_capability("linux", "sshfs_forward_unmount_folder") do
+        require_relative "cap/guest/linux/sshfs_forward_mount"
         VagrantPlugins::GuestLinux::Cap::MountSSHFS
       end
 
-      guest_capability("linux", "sshfs_is_folder_mounted") do
-        require_relative "cap/linux/sshfs_mount"
+      guest_capability("linux", "sshfs_forward_is_folder_mounted") do
+        require_relative "cap/guest/linux/sshfs_forward_mount"
         VagrantPlugins::GuestLinux::Cap::MountSSHFS
       end
 
       guest_capability("redhat", "sshfs_installed") do
-        require_relative "cap/redhat/sshfs_client"
+        require_relative "cap/guest/redhat/sshfs_client"
         VagrantPlugins::GuestRedHat::Cap::SSHFSClient
       end
 
       guest_capability("redhat", "sshfs_install") do
-        require_relative "cap/redhat/sshfs_client"
+        require_relative "cap/guest/redhat/sshfs_client"
         VagrantPlugins::GuestRedHat::Cap::SSHFSClient
       end
 
       guest_capability("fedora", "sshfs_installed") do
-        require_relative "cap/fedora/sshfs_client"
+        require_relative "cap/guest/fedora/sshfs_client"
         VagrantPlugins::GuestFedora::Cap::SSHFSClient
       end
 
       guest_capability("fedora", "sshfs_install") do
-        require_relative "cap/fedora/sshfs_client"
+        require_relative "cap/guest/fedora/sshfs_client"
         VagrantPlugins::GuestFedora::Cap::SSHFSClient
       end
 
       guest_capability("debian", "sshfs_installed") do
-        require_relative "cap/debian/sshfs_client"
+        require_relative "cap/guest/debian/sshfs_client"
         VagrantPlugins::GuestDebian::Cap::SSHFSClient
       end
 
       guest_capability("debian", "sshfs_install") do
-        require_relative "cap/debian/sshfs_client"
+        require_relative "cap/guest/debian/sshfs_client"
         VagrantPlugins::GuestDebian::Cap::SSHFSClient
       end
 
       guest_capability("arch", "sshfs_installed") do
-        require_relative "cap/arch/sshfs_client"
+        require_relative "cap/guest/arch/sshfs_client"
         VagrantPlugins::GuestArch::Cap::SSHFSClient
       end
 
       guest_capability("arch", "sshfs_install") do
-        require_relative "cap/arch/sshfs_client"
+        require_relative "cap/guest/arch/sshfs_client"
         VagrantPlugins::GuestArch::Cap::SSHFSClient
       end
 
       guest_capability("suse", "sshfs_installed") do
-        require_relative "cap/suse/sshfs_client"
+        require_relative "cap/guest/suse/sshfs_client"
         VagrantPlugins::GuestSUSE::Cap::SSHFSClient
       end
 
       guest_capability("suse", "sshfs_install") do
-        require_relative "cap/suse/sshfs_client"
+        require_relative "cap/guest/suse/sshfs_client"
         VagrantPlugins::GuestSUSE::Cap::SSHFSClient
       end
 

data/lib/vagrant-sshfs/synced_folder/sshfs_forward_mount.rb

@@ -0,0 +1,116 @@
+require "log4r"
+
+require "vagrant/util/platform"
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module SyncedFolderSSHFS
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+
+      protected
+
+      # Do a forward mount: mounting host folder into the guest
+      def do_forward_mount(machine, opts)
+
+        # Check to see if sshfs software is in the guest
+        if machine.guest.capability?(:sshfs_installed)
+          if !machine.guest.capability(:sshfs_installed)
+            can_install = machine.guest.capability?(:sshfs_install)
+            if !can_install
+              raise VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSNotInstalledInGuest
+            end
+            machine.ui.info(I18n.t("vagrant.sshfs.actions.installing"))
+            machine.guest.capability(:sshfs_install)
+          end
+        end
+
+        # If already mounted then there is nothing to do
+        if machine.guest.capability(:sshfs_forward_is_folder_mounted, opts)
+          machine.ui.info(
+            I18n.t("vagrant.sshfs.info.already_mounted",
+                   location: 'guest', folder: opts[:guestpath]))
+          return
+        end
+
+        # If the synced folder entry has host information in it then
+        # assume we are doing a normal sshfs mount to a host that isn't
+        # the machine running vagrant. Rely on password/ssh keys.
+        #
+        # If not, then we are doing a slave mount and we need to
+        # make sure we can find the sftp-server and ssh execuatable
+        # files on the host.
+        if opts.has_key?(:ssh_host) and opts[:ssh_host]
+            # Check port information and find out auth info
+            check_host_port(machine, opts)
+            get_auth_info(machine, opts)
+        else
+            opts[:ssh_exe_path] = find_executable('ssh')
+            opts[:sftp_server_exe_path] = find_executable('sftp-server')
+        end
+        # Do the mount
+        machine.ui.info(I18n.t("vagrant.sshfs.actions.mounting"))
+        machine.guest.capability(:sshfs_forward_mount_folder, opts)
+      end
+
+      def do_forward_unmount(machine, opts)
+
+        # If not mounted then there is nothing to do
+        if ! machine.guest.capability(:sshfs_forward_is_folder_mounted, opts)
+          machine.ui.info(
+            I18n.t("vagrant.sshfs.info.not_mounted",
+                   location: 'guest', folder: opts[:guestpath]))
+          return
+        end
+
+        # Do the Unmount
+        machine.ui.info(I18n.t("vagrant.sshfs.actions.unmounting"))
+        machine.guest.capability(:sshfs_forward_unmount_folder, opts)
+      end
+
+      # Check if port information was provided in the options. If not,
+      # then default to port 22 for ssh
+      def check_host_port(machine, opts)
+        if not opts.has_key?(:ssh_port) or not opts[:ssh_port]
+            opts[:ssh_port] = '22'
+        end
+      end
+
+      # Function to gather authentication information (username/password)
+      # for doing a normal sshfs mount
+      def get_auth_info(machine, opts)
+        prompt_for_password = false
+        ssh_info = machine.ssh_info
+
+        # Detect the username of the current user
+        username = `whoami`.strip
+
+        # If no username provided then default to the current
+        # user that is executing vagrant
+          if not opts.has_key?(:ssh_username) or not opts[:ssh_username]
+            opts[:ssh_username] = username
+          end
+
+        # Check to see if we need to prompt the user for a password.
+        # We will prompt if:
+        #  - User asked us to via prompt_for_password option
+        #  - User did not provide a password in options and is not fwding ssh agent
+        #
+        if opts.has_key?(:prompt_for_password) and opts[:prompt_for_password]
+            prompt_for_password = opts[:prompt_for_password]
+        end
+          if not opts.has_key?(:ssh_password) or not opts[:ssh_password]
+            if not ssh_info.has_key?(:forward_agent) or not ssh_info[:forward_agent]
+            prompt_for_password = true
+            end 
+          end
+
+        # Now do the prompt
+        if prompt_for_password
+          opts[:ssh_password] = machine.ui.ask(
+              I18n.t("vagrant.sshfs.ask.prompt_for_password", username: opts[:ssh_username]),
+              echo: false)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-sshfs/synced_folder/sshfs_reverse_mount.rb

@@ -0,0 +1,51 @@
+require "log4r"
+
+require "vagrant/util/platform"
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module SyncedFolderSSHFS
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+
+      protected
+
+      # Do a reverse mount: mounting guest folder onto the host
+      def do_reverse_mount(machine, opts)
+
+        # Check to see if sshfs software is in the host
+        if machine.env.host.capability?(:sshfs_installed)
+          if !machine.env.host.capability(:sshfs_installed)
+            raise VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSNotInstalledInHost
+          end
+        end
+
+        # If already mounted then there is nothing to do
+        if machine.env.host.capability(:sshfs_reverse_is_folder_mounted, opts)
+          machine.ui.info(
+            I18n.t("vagrant.sshfs.info.already_mounted",
+                   location: 'host', folder: opts[:hostpath]))
+          return
+        end
+
+        # Do the mount
+        machine.ui.info(I18n.t("vagrant.sshfs.actions.mounting"))
+        machine.env.host.capability(:sshfs_reverse_mount_folder, machine, opts)
+      end
+
+      def do_reverse_unmount(machine, opts)
+
+        # If not mounted then there is nothing to do
+        if ! machine.env.host.capability(:sshfs_reverse_is_folder_mounted, opts)
+          machine.ui.info(
+            I18n.t("vagrant.sshfs.info.not_mounted",
+                   location: 'host', folder: opts[:hostpath]))
+          return
+        end
+
+        # Do the Unmount
+        machine.ui.info(I18n.t("vagrant.sshfs.actions.unmounting"))
+        machine.env.host.capability(:sshfs_reverse_unmount_folder, machine, opts)
+      end
+    end
+  end
+end

data/lib/vagrant-sshfs/synced_folder.rb

@@ -3,6 +3,9 @@ require "log4r"
 require "vagrant/util/platform"
 require "vagrant/util/which"
 
+require_relative "synced_folder/sshfs_forward_mount"
+require_relative "synced_folder/sshfs_reverse_mount"
+
 module VagrantPlugins
   module SyncedFolderSSHFS
     class SyncedFolder < Vagrant.plugin("2", :synced_folder)
@@ -35,47 +38,36 @@ module VagrantPlugins
       # No return value.
       def enable(machine, folders, pluginopts)
 
-        # Check to see if sshfs software is in the guest
-        if machine.guest.capability?(:sshfs_installed)
-          if !machine.guest.capability(:sshfs_installed)
-            can_install = machine.guest.capability?(:sshfs_install)
-            if !can_install
-              raise VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSNotInstalledInGuest
-            end
-            machine.ui.info(I18n.t("vagrant.sshfs.actions.installing"))
-            machine.guest.capability(:sshfs_install)
-          end
-        end
-
         # Iterate through the folders and mount if needed
         folders.each do |id, opts|
 
-          # If already mounted then there is nothing to do
-          if machine.guest.capability(:sshfs_is_folder_mounted, opts)
-            machine.ui.info(
-              I18n.t("vagrant.sshfs.info.already_mounted",
-                     folder: opts[:guestpath]))
-            next
+          if opts.has_key?(:reverse) and opts[:reverse]
+            do_reverse_mount(machine, opts)
+          else
+            do_forward_mount(machine, opts)
           end
+        end
+      end
 
-          # If the synced folder entry has host information in it then
-          # assume we are doing a normal sshfs mount to a host that isn't
-          # the machine running vagrant. Rely on password/ssh keys.
-          #
-          # If not, then we are doing a slave mount and we need to
-          # make sure we can find the sftp-server and ssh execuatable
-          # files on the host.
-          if opts.has_key?(:ssh_host) and opts[:ssh_host]
-              # Check port information and find out auth info
-              check_host_port(machine, opts)
-              get_auth_info(machine, opts)
+      # This is called to remove the synced folders from a running
+      # machine.
+      #
+      # This is not guaranteed to be called, but this should be implemented
+      # by every synced folder implementation.
+      #
+      # @param [Machine] machine The machine to modify.
+      # @param [Hash] folders The folders to remove. This will not contain
+      #   any folders that should remain.
+      # @param [Hash] opts Any options for the synced folders.
+      def disable(machine, folders, opts)
+
+        # Iterate through the folders and mount if needed
+        folders.each do |id, opts|
+          if opts.has_key?(:reverse) and opts[:reverse]
+            do_reverse_unmount(machine, opts)
           else
-              opts[:ssh_exe_path] = find_executable('ssh')
-              opts[:sftp_server_exe_path] = find_executable('sftp-server')
+            do_forward_unmount(machine, opts)
           end
-          # Do the mount
-          machine.ui.info(I18n.t("vagrant.sshfs.actions.mounting"))
-          machine.guest.capability(:sshfs_mount_folder, opts)
         end
       end
 
@@ -92,51 +84,6 @@ module VagrantPlugins
 
       protected
 
-      # Check if port information was provided in the options. If not,
-      # then default to port 22 for ssh
-      def check_host_port(machine, opts)
-        if not opts.has_key?(:ssh_port) or not opts[:ssh_port]
-            opts[:ssh_port] = '22'
-        end
-      end
-
-      # Function to gather authentication information (username/password)
-      # for doing a normal sshfs mount
-      def get_auth_info(machine, opts)
-        prompt_for_password = false
-        ssh_info = machine.ssh_info
-
-        # Detect the username of the current user
-        username = `whoami`.strip
-
-        # If no username provided then default to the current
-        # user that is executing vagrant
-          if not opts.has_key?(:ssh_username) or not opts[:ssh_username]
-            opts[:ssh_username] = username
-          end
-
-        # Check to see if we need to prompt the user for a password.
-        # We will prompt if:
-        #  - User asked us to via prompt_for_password option
-        #  - User did not provide a password in options and is not fwding ssh agent
-        #
-        if opts.has_key?(:prompt_for_password) and opts[:prompt_for_password]
-            prompt_for_password = opts[:prompt_for_password]
-        end
-          if not opts.has_key?(:ssh_password) or not opts[:ssh_password]
-            if not ssh_info.has_key?(:forward_agent) or not ssh_info[:forward_agent]
-            prompt_for_password = true
-            end 
-          end
-
-        # Now do the prompt
-        if prompt_for_password
-          opts[:ssh_password] = machine.ui.ask(
-              I18n.t("vagrant.sshfs.ask.prompt_for_password", username: opts[:ssh_username]),
-              echo: false)
-        end
-      end
-
       # Function to find the path to an executable with name "name"
       def find_executable(name)
         error_class = VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSExeNotAvailable
@@ -146,13 +93,26 @@ module VagrantPlugins
 
         # Try to include paths where sftp-server may live so
         # That we have a good chance of finding it
-        if Vagrant::Util::Platform.windows? and
-             Vagrant::Util::Platform.cygwin?
-          cygwin_root = Vagrant::Util::Platform.cygwin_windows_path('/')
-          ENV['PATH'] += ';' + cygwin_root + '\usr\sbin'
+        if Vagrant::Util::Platform.windows?
+          if Vagrant::Util::Platform.cygwin?
+            # If in a cygwin terminal then we can programmatically
+            # determine where sftp-server would be. ssh should already
+            # be in path.
+            cygwin_root = Vagrant::Util::Platform.cygwin_windows_path('/')
+            ENV['PATH'] += ';' + cygwin_root + '\usr\sbin'
+          else
+            # If not in a cygwin terminal then we'll have to guess
+            # where cygwin is installed and add the /bin/ (for ssh) and
+            # /usr/sbin (for sftp-server) to the PATH.
+            ENV['PATH'] += ';C:\cygwin\bin'
+            ENV['PATH'] += ';C:\cygwin\usr\sbin'
+            ENV['PATH'] += ';C:\cygwin64\bin'
+            ENV['PATH'] += ';C:\cygwin64\usr\sbin'
+          end
         else
           ENV['PATH'] += ':/usr/libexec/openssh' # Linux (Red Hat Family)
           ENV['PATH'] += ':/usr/lib/openssh'     # Linux (Debian Family)
+          ENV['PATH'] += ':/usr/lib/ssh'         # Linux (Arch Linux Family)
           ENV['PATH'] += ':/usr/libexec/'        # Mac OS X
         end
 

data/lib/vagrant-sshfs/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module SyncedFolderSSHFS
-    VERSION = "1.1.0"
+    VERSION = "1.2.0"
   end
 end