rbmount 0.0.1

data/lib/rbmount/iterator.rb

@@ -0,0 +1,48 @@
+#--
+# Copyleft shura. [ shura1991@gmail.com ]
+#
+# This file is part of rbmount.
+#
+# rbmount is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# rbmount is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with rbmount. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'rbmount/c'
+
+module Mount
+  class Iterator
+    def initialize (direction)
+      @pointer = Mount::C.mnt_new_iter(direction)
+      raise if @pointer.null?
+
+      ObjectSpace.define_finalizer(self, method(:finalize))
+    end
+
+    def direction
+      Mount::C.mnt_iter_get_direction(@pointer)
+    end
+
+    def reset
+      Mount::C.mnt_reset_iter(@pointer)
+      self
+    end
+
+    def finalize (id=nil)
+      Mount::C.mnt_free_iter(@pointer)
+    end
+
+    def to_c
+      @pointer
+    end
+  end
+end

data/lib/rbmount/lock.rb

@@ -0,0 +1,51 @@
+#--
+# Copyleft shura. [ shura1991@gmail.com ]
+#
+# This file is part of rbmount.
+#
+# rbmount is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# rbmount is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with rbmount. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'rbmount/c'
+
+module Mount
+  class Lock
+    def initialize (datafile, id)
+      @pointer = Mount::C.mnt_new_lock(datafile, id)
+      raise unless @pointer
+
+      ObjectSpace.define_finalizer(self, method(:finalize))
+    end
+
+    def lock_file
+      Mount::C.mnt_lock_file(@pointer)
+    end
+
+    def unlock_file
+      Mount::C.mnt_unlock_file(@pointer)
+    end
+
+    def block_signals
+      Mount::C.mnt_lock_block_signals(@pointer)
+    end
+
+    def finalize
+      Mount::C.mnt_free_lock(@pointer)
+    end
+
+    def to_c
+      @pointer
+    end
+  end
+end

data/lib/rbmount/mount.rb

@@ -0,0 +1,103 @@
+#--
+# Copyleft shura. [ shura1991@gmail.com ]
+#
+# This file is part of rbmount.
+#
+# rbmount is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# rbmount is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with rbmount. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'rbmount/c'
+
+module Mount
+  MNT_MS_COMMENT    = (1 << 8)
+  MNT_MS_GROUP      = (1 << 6)
+  MNT_MS_HELPER     = (1 << 12)
+  MNT_MS_LOOP       = (1 << 9)
+  MNT_MS_NETDEV     = (1 << 7)
+  MNT_MS_NOAUTO     = (1 << 2)
+  MNT_MS_NOFAIL     = (1 << 10)
+  MNT_MS_OFFSET     = (1 << 14)
+  MNT_MS_OWNER      = (1 << 5)
+  MNT_MS_SIZELIMIT  = (1 << 15)
+  MNT_MS_UHELPER    = (1 << 11)
+  MNT_MS_USER       = (1 << 3)
+  MNT_MS_USERS      = (1 << 4)
+  MNT_MS_XCOMMENT   = (1 << 13)
+  MS_BIND           = 0x1000
+  MS_DIRSYNC        = 128
+  MS_I_VERSION      = (1<<23)
+  MS_MANDLOCK       = 64
+  MS_MGC_MSK        = 0xffff0000
+  MS_MGC_VAL        = 0xC0ED0000
+  MS_MOVE           = 0x2000
+  MS_NOATIME        = 0x400
+  MS_NODEV          = 4
+  MS_NODIRATIME     = 0x800
+  MS_NOEXEC         = 8
+  MS_NOSUID         = 2
+  MS_PRIVATE        = (1<<18)
+  MS_SHARED         = (1<<20)
+  MS_RDONLY         = 1
+  MS_REC            = 0x4000
+  MS_RELATIME       = 0x200000
+  MS_REMOUNT        = 32
+  MS_SILENT         = 0x8000
+  MS_SLAVE          = (1<<19)
+  MS_STRICTATIME    = (1<<24)
+  MS_SYNCHRONOUS    = 16
+  MS_UNBINDABLE     = (1<<17)
+  MS_PROPAGATION    = (MS_SHARED|MS_SLAVE|MS_UNBINDABLE|MS_PRIVATE)
+  MS_SECURE         = (MS_NOEXEC|MS_NOSUID|MS_NODEV)
+  MS_OWNERSECURE    = (MS_NOSUID|MS_NODEV)
+
+  MNT_INVERT        = (1 << 1)
+  MNT_NOMTAB        = (1 << 2)
+  MNT_PREFIX        = (1 << 3)
+
+  MNT_ITER_FORWARD  = 0
+  MNT_ITER_BACKWARD = 1
+
+  VERSION           = "2.19.0"
+
+  class OptMap < Struct.new(:name, :id, :mask)
+  end
+
+
+  def self.fs_type (devname, amb=false)
+    ambi = amb ? FFI::MemoryPointer.new(:int) : nil
+    fs = Mount::C.mnt_get_fstype(devname, ambi, nil)
+
+    amb ? [fs, ambi.read_int] : fs
+  end
+
+  def self.pretty_path (devname)
+    Mount::C.mnt_pretty_path(devname, nil)
+  end
+
+  def self.resolve_path (path)
+    Mount::C.mnt_resolve_path(path, nil)
+  end
+
+  def self.resolve_tag (token, value)
+    Mount::C.mnt_resolve_tag(token, value, nil)
+  end
+
+  def self.init_debug (mask)
+    Mount::C.mnt_init_debug(mask)
+  end
+
+  def self.builtin_optmap (id)
+    Mount::C.mnt_get_builtin_optmap(1).read_array_of_libmnt_optmap
+  end
+end

data/lib/rbmount/string.rb

@@ -0,0 +1,166 @@
+#--
+# Copyleft shura. [ shura1991@gmail.com ]
+#
+# This file is part of rbmount.
+#
+# rbmount is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# rbmount is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with rbmount. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'rbmount/c'
+
+module Mount
+  module OptionString
+    class << self
+      def append_option (optstr=nil, name, value)
+        sptr = optstr.is_a?(::String) ? FFI::MemoryPointer.from_string(optstr) : FFI::MemoryPointer.new(:string)
+        ptr = FFI::MemoryPointer.new(:pointer).write_pointer(sptr)
+
+        raise unless Mount::C.mnt_optstr_append_option(ptr, name, value)
+        ptr.read_pointer.read_string
+      end
+
+      def apply_flags (optstr=nil, flags, map)
+        sptr = optstr.is_a?(::String) ? FFI::MemoryPointer.from_string(optstr) : FFI::MemoryPointer.new(:string)
+        ptr = FFI::MemoryPointer.new(:pointer).write_pointer(sptr)
+
+        raise unless Mount::C.mnt_optstr_apply_flags(ptr, flags, FFI::MemoryPointer.from_array_of_libmnt_optmap(map))
+        ptr.read_pointer.read_string
+      end
+
+      def flags (optstr, map)
+        optstr = FFI::MemoryPointer.new(:string).write_string(optstr)
+        ptr = FFI::MemoryPointer.new(:ulong)
+
+        raise unless Mount::C.mnt_optstr_get_flags(optstr, ptr, FFI::MemoryPointer.from_array_of_libmnt_optmap(map))
+        ptr.read_ulong
+      end
+
+      def option (optstr, name)
+        ptr = FFI::MemoryPointer.new(:pointer)
+        ol = FFI::MemoryPointer.new(:ulong)
+
+        raise unless Mount::C.mnt_optstr_get_option(optstr, name, ptr, ol)
+        ptr.read_pointer.read_string[0, ol.read_ulong]
+      end
+
+      def options (optstr, map, ignore=0)
+        ptr = FFI::MemoryPointer.new(:pointer)
+
+        raise unless Mount::C.mnt_optstr_get_options(optstr, ptr, FFI::MemoryPointer.from_array_of_libmnt_optmap(map), ignore)
+        ptr.read_pointer.read_string
+      end
+
+      def each_option (optstr)
+        optstr = FFI::MemoryPointer.new(:pointer).write_pointer(FFI::MemoryPointer.from_string(optstr))
+
+        Enumerator.new {|y|
+          loop {
+            res = Mount::String.next_option(optstr)
+            break unless res
+            y << res
+          }
+        }.each {|args|
+          yield *args if block_given?
+        }
+      end
+
+      def prepend_option (optstr=nil, name, value)
+        sptr = optstr.is_a?(::String) ? FFI::MemoryPointer.from_string(optstr) : FFI::MemoryPointer.new(:string)
+        ptr = FFI::MemoryPointer.new(:pointer).write_pointer(sptr)
+
+        raise unless Mount::C.mnt_optstr_prepend_option(ptr, name, value)
+        ptr.read_pointer.read_string
+      end
+
+      def remove_option (optstr=nil, name)
+        sptr = optstr.is_a?(::String) ? FFI::MemoryPointer.from_string(optstr) : FFI::MemoryPointer.new(:string)
+        ptr = FFI::MemoryPointer.new(:pointer).write_pointer(sptr)
+
+        raise unless Mount::C.mnt_optstr_remove_option(ptr, name)
+        ptr.read_pointer.read_string
+      end
+
+      def set_option (optstr, name, value=nil)
+        sptr = optstr.is_a?(::String) ? FFI::MemoryPointer.from_string(optstr) : FFI::MemoryPointer.new(:string)
+        ptr = FFI::MemoryPointer.new(:pointer).write_pointer(sptr)
+
+        raise unless Mount::C.mnt_optstr_set_option(ptr, name, value)
+        ptr.read_pointer.read_string
+      end
+
+      def split_optstr (optstr, ignore_user=0, ignore_vfs=0)
+        pi = (1..3).map { FFI::MemoryPointer.new(:pointer).write_pointer(FFI::MemoryPointer.new(:string)) }
+        raise unless Mount::C.mnt_split_optstr(optstr, *pi, ignore_user, ignore_vfs)
+        pi.map {|x| x.read_pointer.read_string }
+      end
+
+      protected
+      def next_option (optstr)
+        name = FFI::MemoryPointer.new(:pointer)
+        ns = FFI::MemoryPointer.new(:ulong)
+        value = FFI::MemoryPointer.new(:pointer)
+        vs = FFI::MemoryPointer.new(:ulong)
+
+        case Mount::C.mnt_optstr_next_option(optstr, name, ns, value, vs)
+        when true
+          [[name, ns], [value, vs]].map {|x, i| x.read_pointer.read_string[0, i.read_ulong] }
+        when false
+          raise
+        else
+          nil
+        end
+      end
+    end
+
+    def append_option (name, value)
+      self.replace(Mount::OptionString.append_option(self, name, value))
+    end
+
+    def apply_flags (flags, map)
+      self.replace(Mount::OptionString.apply_flags(self, flags, map))
+    end
+
+    def flags (map)
+      Mount::OptionString.flags(self, map)
+    end
+
+    def option (name)
+      Mount::OptionString.option(self, name)
+    end
+
+    def options (map, ignore=0)
+      Mount::OptionString.options(self, map, ignore)
+    end
+
+    def each_option (&blk)
+      Mount::OptionString.each_option(self, &blk)
+    end
+
+    def prepend_option (name, value)
+      self.replace(Mount::OptionString.prepend_option(self, name, value))
+    end
+
+    def remove_option (name)
+      self.replace(Mount::OptionString.remove_option(self, name))
+    end
+
+    def set_option (name, value=nil)
+      self.replace(Mount::OptionString.set_option(self, name, value))
+    end
+
+    def split_optstr (ignore_user=0, ignore_vfs=0)
+      Mount::OptionString.split_optstr(self, ignore_user, ignore_vfs)
+    end
+  end
+end

data/lib/rbmount/table.rb

@@ -0,0 +1,188 @@
+#--
+# Copyleft shura. [ shura1991@gmail.com ]
+#
+# This file is part of rbmount.
+#
+# rbmount is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# rbmount is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with rbmount. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'rbmount/c'
+require 'rbmount/iterator'
+require 'rbmount/cache'
+require 'rbmount/fs'
+
+module Mount
+  class Table
+    DIRECTION = Hash.new {|*|
+      :forward
+    }.merge({
+      forward:      Mount::MNT_ITER_FORWARD,
+      'forward' =>  Mount::MNT_ITER_FORWARD,
+      backward:     Mount::MNT_ITER_BACKWARD,
+      'backward' => Mount::MNT_ITER_BACKWARD,
+
+      Mount::MNT_ITER_FORWARD   => Mount::MNT_ITER_FORWARD,
+      Mount::MNT_ITER_BACKWARD  => Mount::MNT_ITER_BACKWARD,
+    }).freeze
+
+    def initialize (path=nil)
+      @pointer = Mount::C.mnt_new_table unless path
+      if File.directory?(path)
+        @pointer = Mount::C.mnt_new_table_from_dir(path)
+      elsif File.file?(path)
+        @pointer = Mount::C.mnt_new_table_from_file(path)
+      else
+        raise ArgumentError
+      end
+
+      raise if !@pointer or @pointer.null?
+
+      ObjectSpace.define_finalizer(self, method(:finalize))
+    end
+
+    def add_fs (fs)
+      Mount::C.mnt_table_add_fs(@pointer, fs.to_c)
+    end
+
+    def next_fs (direction=:forward)
+      Mount::FS.new.tap {|fs|
+        ptr = FFI::MemoryPointer.new(:pointer).write_pointer(fs.to_c)
+
+        res = Mount::C.mnt_table_next_fs(@pointer, Mount::Iter.new(DIRECTION[direction]).to_c, ptr)
+        raise unless res
+        break nil if res == 1
+      }
+    end
+
+    def each_fs (direction=:forward, &blk)
+      Enumerator.new {|y|
+        loop {
+          res = next_fs(direction)
+          break unless res
+          y << res
+        }
+      }.each(&blk)
+    end
+
+    def find_pair (source, target, direction=:forward)
+      Mount::FS.new(Mount::C.mnt_table_find_pair(@pointer, source, target, DIRECTION[direction]))
+    end
+
+    def find_source (source, direction=:forward)
+      Mount::FS.new(Mount::C.mnt_table_find_source(@pointer, source, DIRECTION[direction]))
+    end
+
+    def find_srcpath (path, direction=:forward)
+      Mount::FS.new(Mount::C.mnt_table_find_srcpath(@pointer, source, DIRECTION[direction]))
+    end
+
+    def find_tag (tag, val, direction=:forward)
+      Mount::FS.new(Mount::C.mnt_table_find_tag(@pointer, tag, val, DIRECTION[direction]))
+    end
+
+    def find_target (path, direction=:forward)
+      Mount::FS.new(Mount::C.mnt_table_find_target(@pointer, path, DIRECTION[direction]))
+    end
+
+    def cache
+      Mount::Cache.new(Mount::C.mnt_table_get_cache(@pointer))
+    end
+
+    def name
+      Mount::C.mnt_table_get_name(@pointer)
+    end
+
+    def nents
+      Mount::C.mnt_table_get_nents(@pointer)
+    end
+
+    def root_fs
+      Mount::FS.new.tap {|fs|
+        ptr = FFI::MemoryPointer.new(:pointer).write_pointer(fs.to_c)
+        raise unless Mount::C.mnt_table_get_root_fs(@pointer, ptr)
+      }
+    end
+
+    def fs_mounted?(fstab_fs)
+      Mount::C.mnt_table_is_fs_mounted(@pointer, fstab_fs.to_c)
+    end
+
+    def next_child_fs (parent, direction=:forward)
+      Mount::FS.new.tap {|fs|
+        ptr = FFI::MemoryPointer.new(:pointer).write_pointer(fs.to_c)
+
+        res = Mount::C.mnt_table_next_child_fs(@pointer, Mount::Iter.new(DIRECTION[direction]).to_c,
+                                              parent.to_c, ptr)
+        raise unless res
+        break nil if res == 1
+      }
+    end
+
+    def each_child_fs (parent, direction=:forward, &blk)
+      Enumerator.new {|y|
+        loop {
+          res = next_child_fs(parent, direction)
+          break unless res
+          y << res
+        }
+      }.each(&blk)
+    end
+
+    def parse_file (path)
+      Mount::C.mnt_table_parse_file(@pointer, path)
+    end
+
+    def parse_fstab (path=nil)
+      Mount::C.mnt_table_parse_fstab(@pointer, path)
+    end
+
+    def parse_mtab (path=nil)
+      Mount::C.mnt_table_parse_mtab(@pointer, path)
+    end
+
+    def parse_stream (io, filename)
+      Mount::C.mnt_table_parse_stream(@pointer, io, filename)
+    end
+
+    def remove_fs (fs)
+      Mount::C.mnt_table_remove_fs(@pointer, fs.to_c)
+    end
+
+    def cache= (mpc)
+      Mount::C.mnt_table_set_cache(@pointer, mpc.to_c)
+    end
+
+    def set_iter (fs, direction=:forward)
+      Mount::C.mnt_table_set_iter(@pointer, Mount::Iter.new(DIRECTION[direction]).to_c, fs.to_c)
+    end
+
+    def on_error (&blk)
+      if blk.arity == 3
+        Mount::C.mnt_table_set_iter(@pointer, blk)
+        true
+      else
+        false
+      end
+    end
+
+    def reset!
+      raise unless Mount::C.mnt_reset_table(@pointer)
+      self
+    end
+
+    def finalize
+      Mount::C.mnt_free_table(@pointer)
+    end
+  end
+end