sys-filesystem 1.1.6 → 1.4.3

data/lib/sys/filesystem.rb

@@ -1,12 +1,83 @@
 module Sys
   class Filesystem
     # The version of the sys-filesystem library
-    VERSION = '1.1.6'.freeze
+    VERSION = '1.4.3'.freeze
   end
 end
 
+require 'rbconfig'
+
 if File::ALT_SEPARATOR
   require_relative 'windows/sys/filesystem'
 else
   require_relative 'unix/sys/filesystem'
 end
+
+# Methods universal to all platforms
+
+module Sys
+  class Filesystem
+    class Stat
+      # Returns true if the filesystem is case sensitive for the current path.
+      # Typically this will be any path on MS Windows or Macs using HFS.
+      #
+      # For a root path (really any path without actual a-z characters) we
+      # take a best guess based on the host operating system. However, as a
+      # general rule, I do not recommend using this method for a root path.
+      #
+      def case_insensitive?
+        if path !~ /\w+/
+          if RbConfig::CONFIG['host_os'] =~ /darwin|mac|windows|mswin|mingw/i
+            true # Assumes HFS
+          else
+            false
+          end
+        else
+          File.identical?(path, path.swapcase)
+        end
+      end
+
+      # Opposite of case_insensitive?
+      #
+      def case_sensitive?
+        !case_insensitive?
+      end
+    end
+  end
+end
+
+# Some convenient methods for converting bytes to kb, mb, and gb.
+#
+class Numeric
+  # call-seq:
+  #  <tt>num</tt>.to_kb
+  #
+  # Returns +num+ in terms of kilobytes.
+  def to_kb
+    self / 1024
+  end
+
+  # call-seq:
+  #  <tt>num</tt>.to_mb
+  #
+  # Returns +num+ in terms of megabytes.
+  def to_mb
+    self / 1048576
+  end
+
+  # call-seq:
+  #  <tt>num</tt>.to_gb
+  #
+  # Returns +num+ in terms of gigabytes.
+  def to_gb
+    self / 1073741824
+  end
+
+  # call-seq:
+  #  <tt>num</tt>.to_gb
+  #
+  # Returns +num+ in terms of terabytes.
+  def to_tb
+    self / 1099511627776
+  end
+end

data/lib/sys/unix/sys/filesystem/constants.rb

@@ -1,8 +1,6 @@
 module Sys
   class Filesystem
     module Constants
-      private
-
       MNT_RDONLY      = 0x00000001 # read only filesystem
       MNT_SYNCHRONOUS = 0x00000002 # file system written synchronously
       MNT_NOEXEC      = 0x00000004 # can't exec from filesystem
@@ -33,9 +31,40 @@ module Sys
         MNT_LOCAL  | MNT_QUOTA |
         MNT_ROOTFS | MNT_DOVOLFS | MNT_DONTBROWSE |
         MNT_IGNORE_OWNERSHIP | MNT_AUTOMOUNTED | MNT_JOURNALED |
-        MNT_NOUSERXATTR | MNT_DEFWRITE  | MNT_MULTILABEL |
+        MNT_NOUSERXATTR | MNT_DEFWRITE | MNT_MULTILABEL |
         MNT_NOATIME | MNT_CPROTECT
       )
+
+      MS_RDONLY = 1
+      MS_NOSUID = 2
+      MS_NODEV = 4
+      MS_NOEXEC = 8
+      MS_SYNCHRONOUS = 16
+      MS_REMOUNT = 32
+      MS_MANDLOCK = 64
+      MS_DIRSYNC = 128
+      MS_NOATIME = 1024
+      MS_NODIRATIME = 2048
+      MS_BIND = 4096
+      MS_MOVE = 8192
+      MS_REC = 16384
+      MS_SILENT = 32768
+      MS_POSIXACL = 1 << 16
+      MS_UNBINDABLE = 1 << 17
+      MS_PRIVATE = 1 << 18
+      MS_SLAVE = 1 << 19
+      MS_SHARED = 1 << 20
+      MS_RELATIME = 1 << 21
+      MS_KERNMOUNT = 1 << 22
+      MS_I_VERSION = 1 << 23
+      MS_STRICTATIME = 1 << 24
+      MS_ACTIVE = 1 << 30
+      MS_NOUSER = 1 << 31
+
+      MNT_FORCE = 1
+      MNT_DETACH = 2
+      MNT_EXPIRE = 4
+      UMOUNT_NOFOLLOW = 8
     end
   end
 end

data/lib/sys/unix/sys/filesystem/functions.rb

@@ -7,33 +7,60 @@ module Sys
 
       ffi_lib FFI::Library::LIBC
 
+      def self.linux64?
+        if RUBY_PLATFORM == 'java'
+          ENV_JAVA['sun.arch.data.model'].to_i == 64
+        else
+          RbConfig::CONFIG['host_os'] =~ /linux/i &&
+            (RbConfig::CONFIG['arch'] =~ /64/ || RbConfig::CONFIG['DEFS'] =~ /64/)
+        end
+      end
+
+      private_class_method :linux64?
+
       if RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
-        attach_function(:statvfs, :statvfs64, [:string, :pointer], :int)
+        attach_function(:statvfs, :statvfs64, %i[string pointer], :int)
+      elsif linux64?
+        attach_function(:statvfs, :statvfs64, %i[string pointer], :int)
       else
-        attach_function(:statvfs, [:string, :pointer], :int)
+        attach_function(:statvfs, %i[string pointer], :int)
       end
 
       attach_function(:strerror, [:int], :string)
+      attach_function(:mount_c, :mount, %i[string string string ulong string], :int)
+
+      begin
+        attach_function(:umount_c, :umount, [:string], :int)
+      rescue FFI::NotFoundError
+        if RbConfig::CONFIG['host_os'] =~ /darwin|osx|mach|bsd/i
+          attach_function(:umount_c, :unmount, [:string], :int)
+        end
+      end
 
-      private_class_method :statvfs, :strerror
+      private_class_method :statvfs, :strerror, :mount_c, :umount_c
 
       begin
         if RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
-          attach_function(:fopen, [:string, :string], :pointer)
+          attach_function(:fopen, %i[string string], :pointer)
           attach_function(:fclose, [:pointer], :int)
-          attach_function(:getmntent, [:pointer, :pointer], :int)
+          attach_function(:getmntent, %i[pointer pointer], :int)
           private_class_method :fopen, :fclose, :getmntent
         else
           attach_function(:getmntent, [:pointer], :pointer)
-          attach_function(:setmntent, [:string, :string], :pointer)
+          attach_function(:setmntent, %i[string string], :pointer)
           attach_function(:endmntent, [:pointer], :int)
-          private_class_method :getmntent, :setmntent, :endmntent
+          attach_function(:umount2, %i[string int], :int)
+          private_class_method :getmntent, :setmntent, :endmntent, :umount2
         end
       rescue FFI::NotFoundError
         if RbConfig::CONFIG['host_os'] =~ /darwin|osx|mach/i
-          attach_function(:getmntinfo, :getmntinfo64, [:pointer, :int], :int)
+          begin
+            attach_function(:getmntinfo, :getmntinfo64, %i[pointer int], :int)
+          rescue FFI::NotFoundError
+            attach_function(:getmntinfo, %i[pointer int], :int) # Big Sur and later
+          end
         else
-          attach_function(:getmntinfo, [:pointer, :int], :int)
+          attach_function(:getmntinfo, %i[pointer int], :int)
         end
         private_class_method :getmntinfo
       end

data/lib/sys/unix/sys/filesystem/structs.rb

@@ -5,6 +5,26 @@ module Sys
   class Filesystem
     module Structs
       class Statfs < FFI::Struct
+
+        def self.linux64?
+          if RUBY_PLATFORM == 'java'
+            ENV_JAVA['sun.arch.data.model'].to_i == 64
+          else
+            RbConfig::CONFIG['host_os'] =~ /linux/i &&
+              (RbConfig::CONFIG['arch'] =~ /64/ || RbConfig::CONFIG['DEFS'] =~ /64/)
+          end
+        end
+
+        private_class_method :linux64?
+
+        # FreeBSD 12.0 MNAMELEN from 88 => 1024.
+        MNAMELEN =
+          if RbConfig::CONFIG['host_os'] =~ /freebsd(.*)/i
+            $1.to_f < 12.0 ? 88 : 1024
+          else
+            88
+          end
+
         if RbConfig::CONFIG['host_os'] =~ /bsd/i
           layout(
             :f_version, :uint32,
@@ -27,9 +47,41 @@ module Sys
             :f_fsid,  [:int32, 2],
             :f_charspare, [:char, 80],
             :f_fstypename, [:char, 16],
-            :f_mntfromname, [:char, 88],
-            :f_mntonname, [:char, 88]
+            :f_mntfromname, [:char, MNAMELEN],
+            :f_mntonname, [:char, MNAMELEN]
           )
+        elsif RbConfig::CONFIG['host_os'] =~ /linux/i
+          if linux64?
+            layout(
+              :f_type, :ulong,
+              :f_bsize, :ulong,
+              :f_blocks, :uint64,
+              :f_bfree, :uint64,
+              :f_bavail, :uint64,
+              :f_files, :uint64,
+              :f_ffree, :uint64,
+              :f_fsid, [:int, 2],
+              :f_namelen, :ulong,
+              :f_frsize, :ulong,
+              :f_flags, :ulong,
+              :f_spare, [:ulong, 4]
+            )
+          else
+            layout(
+              :f_type, :ulong,
+              :f_bsize, :ulong,
+              :f_blocks, :uint32,
+              :f_bfree, :uint32,
+              :f_bavail, :uint32,
+              :f_files, :uint32,
+              :f_ffree, :uint32,
+              :f_fsid, [:int, 2],
+              :f_namelen, :ulong,
+              :f_frsize, :ulong,
+              :f_flags, :ulong,
+              :f_spare, [:ulong, 4]
+            )
+          end
         else
           layout(
             :f_bsize, :uint32,
@@ -99,22 +151,36 @@ module Sys
             :f_fstr, [:char, 32],
             :f_filler, [:ulong, 16]
           )
+        elsif RbConfig::CONFIG['host'] =~ /i686/i
+          layout(
+            :f_bsize, :ulong,
+            :f_frsize, :ulong,
+            :f_blocks, :uint,
+            :f_bfree, :uint,
+            :f_bavail, :uint,
+            :f_files, :uint,
+            :f_ffree, :uint,
+            :f_favail, :uint,
+            :f_fsid, :ulong,
+            :f_unused, :int,
+            :f_flag, :ulong,
+            :f_namemax, :ulong,
+            :f_spare, [:int, 6]
+          )
         else
           layout(
             :f_bsize, :ulong,
             :f_frsize, :ulong,
-            :f_blocks, :ulong,
-            :f_bfree, :ulong,
-            :f_bavail, :ulong,
-            :f_files, :ulong,
-            :f_ffree, :ulong,
-            :f_favail, :ulong,
+            :f_blocks, :uint64,
+            :f_bfree, :uint64,
+            :f_bavail, :uint64,
+            :f_files, :uint64,
+            :f_ffree, :uint64,
+            :f_favail, :uint64,
             :f_fsid, :ulong,
             :f_flag, :ulong,
             :f_namemax, :ulong,
-            :f_ftype, :ulong,
-            :f_basetype, [:char, 16],
-            :f_str, [:char, 16]
+            :f_spare, [:int, 6]
           )
         end
       end

data/lib/sys/unix/sys/filesystem.rb

@@ -11,42 +11,46 @@ module Sys
     include Sys::Filesystem::Structs
     extend Sys::Filesystem::Functions
 
-    private
+    private_class_method :new
 
     # Readable versions of constant names
-    @@opt_names = {
-      MNT_RDONLY           => 'read-only',
-      MNT_SYNCHRONOUS      => 'synchronous',
-      MNT_NOEXEC           => 'noexec',
-      MNT_NOSUID           => 'nosuid',
-      MNT_NODEV            => 'nodev',
-      MNT_UNION            => 'union',
-      MNT_ASYNC            => 'asynchronous',
-      MNT_CPROTECT         => 'content-protection',
-      MNT_EXPORTED         => 'exported',
-      MNT_QUARANTINE       => 'quarantined',
-      MNT_LOCAL            => 'local',
-      MNT_QUOTA            => 'quotas',
-      MNT_ROOTFS           => 'rootfs',
-      MNT_DONTBROWSE       => 'nobrowse',
+    OPT_NAMES = {
+      MNT_RDONLY => 'read-only',
+      MNT_SYNCHRONOUS => 'synchronous',
+      MNT_NOEXEC => 'noexec',
+      MNT_NOSUID => 'nosuid',
+      MNT_NODEV => 'nodev',
+      MNT_UNION => 'union',
+      MNT_ASYNC => 'asynchronous',
+      MNT_CPROTECT => 'content-protection',
+      MNT_EXPORTED => 'exported',
+      MNT_QUARANTINE => 'quarantined',
+      MNT_LOCAL => 'local',
+      MNT_QUOTA => 'quotas',
+      MNT_ROOTFS => 'rootfs',
+      MNT_DONTBROWSE => 'nobrowse',
       MNT_IGNORE_OWNERSHIP => 'noowners',
-      MNT_AUTOMOUNTED      => 'automounted',
-      MNT_JOURNALED        => 'journaled',
-      MNT_NOUSERXATTR      => 'nouserxattr',
-      MNT_DEFWRITE         => 'defwrite',
-      MNT_NOATIME          => 'noatime'
-    }
+      MNT_AUTOMOUNTED => 'automounted',
+      MNT_JOURNALED => 'journaled',
+      MNT_NOUSERXATTR => 'nouserxattr',
+      MNT_DEFWRITE => 'defwrite',
+      MNT_NOATIME => 'noatime'
+    }.freeze
+
+    private_constant :OPT_NAMES
 
     # File used to read mount informtion from.
     if File.exist?('/etc/mtab')
-      MOUNT_FILE = '/etc/mtab'
+      MOUNT_FILE = '/etc/mtab'.freeze
     elsif File.exist?('/etc/mnttab')
-      MOUNT_FILE = '/etc/mnttab'
+      MOUNT_FILE = '/etc/mnttab'.freeze
+    elsif File.exist?('/proc/mounts')
+      MOUNT_FILE = '/proc/mounts'.freeze
     else
-      MOUNT_FILE = 'getmntinfo'
+      MOUNT_FILE = 'getmntinfo'.freeze
     end
 
-    public
+    private_constant :MOUNT_FILE
 
     # The error raised if any of the Filesystem methods fail.
     class Error < StandardError; end
@@ -126,12 +130,17 @@ module Sys
 
       # Returns the total space on the partition.
       def bytes_total
-        blocks * block_size
+        blocks * fragment_size
       end
 
       # Returns the total amount of free space on the partition.
       def bytes_free
-        blocks_available * block_size
+        blocks_free * fragment_size
+      end
+
+      # Returns the amount of free space available to unprivileged processes.
+      def bytes_available
+        blocks_available * fragment_size
       end
 
       # Returns the total amount of used space on the partition.
@@ -191,7 +200,27 @@ module Sys
     # Returns a Sys::Filesystem::Stat object containing information about the
     # +path+ on the filesystem.
     #
+    # Examples:
+    #
+    #    # path
+    #    Sys::Filesystem.stat("path")
+    #
+    #    # Pathname
+    #    pathname = Pathname.new("path")
+    #    Sys::Filesystem.stat(pathname)
+    #
+    #    # File
+    #    file = File.open("file", "r")
+    #    Sys::Filesystem.stat(file)
+    #
+    #    # Dir
+    #    dir = Dir.open("/")
+    #    Sys::Filesystem.stat(dir)
+    #
     def self.stat(path)
+      path = path.path if path.respond_to?(:path) # File, Dir
+      path = path.to_s if path.respond_to?(:to_s) # Pathname
+
       fs = Statvfs.new
 
       if statvfs(path, fs) < 0
@@ -217,11 +246,6 @@ module Sys
         obj.block_size /= 256
       end
 
-      # FreeBSD 10 does things a little differently too
-      if RbConfig::CONFIG['host_os'] =~ /freebsd10/i
-        obj.block_size = obj.fragment_size
-      end
-
       if fs.members.include?(:f_basetype)
         obj.base_type = fs[:f_basetype].to_s
       end
@@ -256,17 +280,17 @@ module Sys
 
         ptr = buf.get_pointer(0)
 
-        num.times{ |i|
+        num.times do
           mnt = Statfs.new(ptr)
           obj = Sys::Filesystem::Mount.new
           obj.name = mnt[:f_mntfromname].to_s
           obj.mount_point = mnt[:f_mntonname].to_s
           obj.mount_type = mnt[:f_fstypename].to_s
 
-          string = ""
+          string = ''
           flags = mnt[:f_flags] & MNT_VISFLAGMASK
 
-          @@opt_names.each{ |key,val|
+          OPT_NAMES.each do |key, val|
             if flags & key > 0
               if string.empty?
                 string << val
@@ -275,7 +299,7 @@ module Sys
               end
             end
             flags &= ~key
-          }
+          end
 
           obj.options = string
 
@@ -286,7 +310,7 @@ module Sys
           end
 
           ptr += Statfs.size
-        }
+        end
       else
         begin
           if respond_to?(:setmntent, true)
@@ -363,7 +387,7 @@ module Sys
       dev = File.stat(file).dev
       val = file
 
-      self.mounts.each{ |mnt|
+      mounts.each do |mnt|
         mp = mnt.mount_point
         begin
           if File.stat(mp).dev == dev
@@ -373,31 +397,54 @@ module Sys
         rescue Errno::EACCES
           next
         end
-      }
+      end
 
       val
     end
-  end
-end
 
-class Numeric
-  # Converts a number to kilobytes.
-  def to_kb
-    self / 1024
-  end
+    # Attach the filesystem specified by +source+ to the location (a directory
+    # or file) specified by the pathname in +target+.
+    #
+    # Note that the +source+ is often a pathname referring to a device, but
+    # can also be the pathname of a directory or file, or a dummy string.
+    #
+    # By default this method will assume 'ext2' as the filesystem type, but
+    # you should update this as needed.
+    #
+    # Typically requires admin privileges.
+    #
+    # Example:
+    #
+    #   Sys::Filesystem.mount('/dev/loop0', '/home/you/tmp', 'ext4', Sys::Filesystem::MNT_RDONLY)
+    #
+    def self.mount(source, target, fstype = 'ext2', flags = 0, data = nil)
+      if mount_c(source, target, fstype, flags, data) != 0
+        raise Error, 'mount() function failed: ' + strerror(FFI.errno)
+      end
 
-  # Converts a number to megabytes.
-  def to_mb
-    self / 1048576
-  end
+      self
+    end
 
-  # Converts a number to gigabytes.
-  def to_gb
-    self / 1073741824
-  end
+    # Removes the attachment of the (topmost) filesystem mounted on target.
+    # Additional flags may be provided for operating systems that support
+    # the umount2 function. Otherwise this argument is ignored.
+    #
+    # Typically requires admin privileges.
+    #
+    def self.umount(target, flags = nil)
+      if flags && respond_to?(:umount2)
+        function = 'umount2'
+        rv = umount2_c(target, flags)
+      else
+        function = 'umount'
+        rv = umount_c(target)
+      end
+
+      if rv != 0
+        raise Error, "#{function} function failed: " + strerror(FFI.errno)
+      end
 
-  # Converts a number to terabytes.
-  def to_tb
-    self / 1099511627776
+      self
+    end
   end
 end

data/lib/sys/windows/sys/filesystem/functions.rb

@@ -14,19 +14,22 @@ module Sys
         end
       end
 
-      attach_pfunc :GetDiskFreeSpaceW, [:buffer_in, :pointer, :pointer, :pointer, :pointer], :bool
-      attach_pfunc :GetDiskFreeSpaceExW, [:buffer_in, :pointer, :pointer, :pointer], :bool
-      attach_pfunc :GetLogicalDriveStringsA, [:ulong, :pointer], :ulong
+      attach_pfunc :DeleteVolumeMountPointA, [:string], :bool
+      attach_pfunc :GetDiskFreeSpaceW, %i[buffer_in pointer pointer pointer pointer], :bool
+      attach_pfunc :GetDiskFreeSpaceExW, %i[buffer_in pointer pointer pointer], :bool
+      attach_pfunc :GetLogicalDriveStringsA, %i[ulong pointer], :ulong
 
       attach_pfunc :GetVolumeInformationA,
-        [:buffer_in, :pointer, :ulong, :pointer, :pointer, :pointer, :pointer, :ulong],
-        :bool
+                   %i[buffer_in pointer ulong pointer pointer pointer pointer ulong],
+                   :bool
 
       attach_pfunc :GetVolumeInformationW,
-        [:buffer_in, :pointer, :ulong, :pointer, :pointer, :pointer, :pointer, :ulong],
-        :bool
+                   %i[buffer_in pointer ulong pointer pointer pointer pointer ulong],
+                   :bool
 
-      attach_pfunc :QueryDosDeviceA, [:buffer_in, :buffer_out, :ulong], :ulong
+      attach_pfunc :GetVolumeNameForVolumeMountPointW, %i[buffer_in buffer_in ulong], :bool
+      attach_pfunc :QueryDosDeviceA, %i[buffer_in buffer_out ulong], :ulong
+      attach_pfunc :SetVolumeMountPointW, %i[buffer_in buffer_in], :bool
 
       ffi_lib :shlwapi
 

data/lib/sys/windows/sys/filesystem/helper.rb

@@ -2,6 +2,6 @@ class String
   # Convenience method for converting strings to UTF-16LE for wide character
   # functions that require it.
   def wincode
-    (self.tr(File::SEPARATOR, File::ALT_SEPARATOR) + 0.chr).encode('UTF-16LE')
+    (tr(File::SEPARATOR, File::ALT_SEPARATOR) + 0.chr).encode('UTF-16LE')
   end
 end