sys-admin 1.5.6 → 1.6.0

data/CHANGES

@@ -1,3 +1,11 @@
+== 1.6.0 - 5-Jan-2013
+* Converted code to use FFI. This mostly only affects the unix flavors.
+* The Admin.users and Admin.groups methods no longer accept a block.
+* Some test suite updates.
+* Because all code is now pure Ruby, there is longer any need for two
+  separate gems. There is now a single, unified gem that works on all
+  supported platforms.
+
 == 1.5.6 - 30-Jul-2011
 * Fixed issue for non-gnu platforms where it would use the wrong function
   prototype because the Ruby core team took it upon themselves to explicitly

data/MANIFEST

@@ -5,10 +5,13 @@
 * README
 * examples/groups.rb
 * examples/users.rb
-* ext/admin.c
-* ext/admin.h
-* ext/extconf.rb
 * lib/sys/admin.rb
+* lib/darwin/sys/admin.rb
+* lib/linux/sys/admin.rb
+* lib/bsd/sys/admin.rb
+* lib/sunos/sys/admin.rb
+* lib/sys/admin/common.rb
+* lib/sys/admin/custom.rb
 * test/test_sys_admin.rb
 * test/test_sys_admin_unix.rb
 * test/test_sys_admin_windows.rb

data/README

@@ -8,19 +8,9 @@
   require 'sys/admin'
   include Sys
 
-  # Yields a User object for each user
-  Admin.users{ |user|
-    p user
-  }
-
   # Returns an Array of User objects
   a = Admin.users
 
-  # Yields a Group object for each group
-  Admin.groups{ |group|
-    p group
-  }
-
   # Returns an Array of Group objects
   g = Admin.groups
 
@@ -47,17 +37,13 @@ Admin.get_group(gid, options = {})
   options you provide, e.g. 'domain' or 'localaccount'.
 
 Admin.groups(options = {})
-Admin.groups(options = {}){ |group| ... }
-  In block form, yields a Group object for each user on the system.  In
-  non-block form, returns an Array of Group objects.
+  Returns an Array of Group objects.
 
   The +options+ hash is for MS Windows only, and allows you to restrict the
   search based on the options you provide, e.g. 'domain' or 'localaccount'.
 
 Admin.users(options = {})
-Admin.users(options = {}){ |user| ... }
-  In block form, yields a User object for each user on the system.  In
-  non-block form, returns an Array of User objects.
+  Returns an Array of User objects.
    
   The +options+ hash is for MS Windows only, and allows you to restrict the
   search based on the options you provide, e.g. 'domain' or 'localaccount'.
@@ -149,7 +135,7 @@ Admin::Error < StandardError
   Artistic 2.0
 
 == Copyright
-  (C) 2005-2010, Daniel J. Berger
+  (C) 2005-2013, Daniel J. Berger
   All Rights Reserved
 
 == Author

data/Rakefile

@@ -2,73 +2,44 @@ require 'rake'
 require 'rake/clean'
 require 'rake/testtask'
 require 'rbconfig'
-include Config
 
-WINDOWS = CONFIG['host_os'] =~ /msdos|mswin|win32|mingw|cygwin|windows/i
-
-CLEAN.include(
-  '**/*.gem',               # Gem files
-  '**/*.rbc',               # Rubinius
-  '**/*.o',                 # C object file
-  '**/*.log',               # Ruby extension build log
-  '**/Makefile',            # C Makefile
-  '**/conftest.dSYM',       # OS X build directory
-  "**/*.#{CONFIG['DLEXT']}" # C shared object
-)
-
-desc "Build the sys-admin library on UNIX systems (but don't install it)"
-task :build => [:clean] do
-  unless WINDOWS
-    Dir.chdir('ext') do
-      ruby 'extconf.rb'
-      sh 'make'
-      build_file = 'admin.' + Config::CONFIG['DLEXT']
-      FileUtils.cp(build_file, 'sys')
-    end
-  end
-end
+CLEAN.include("**/*.gem", "**/*.rbx", "**/*.rbc")
 
 namespace :gem do
-  desc "Create a sys-admin gem file."
+  desc "Create the sys-uname gem"
   task :create => [:clean] do
     spec = eval(IO.read('sys-admin.gemspec'))
-
-    if WINDOWS
-      spec.platform = Gem::Platform::CURRENT
-      spec.platform.cpu = 'universal'
-      spec.files = spec.files.reject{ |f| f.include?('ext') }
-      spec.add_dependency('win32-security', '>= 0.1.2')
-    else
-      spec.files = spec.files.reject{ |f| f.include?('lib') }
-      spec.extensions = ['ext/extconf.rb']
-      spec.extra_rdoc_files << 'ext/sys/admin.c'
-    end
-
     Gem::Builder.new(spec).build
   end
 
-  desc "Install the sys-admin gem."
-  task :install => [:create] do
-    gem = Dir['*.gem'].first
-    sh "gem install #{gem}"
+  desc "Install the sys-uname gem"
+  task :install => [:build] do
+    file = Dir["*.gem"].first
+    sh "gem install #{file}"
   end
 end
 
-desc "Run the test suite"
 Rake::TestTask.new('test') do |t|
-  if WINDOWS
-    t.libs << 'lib'
+  case RbConfig::CONFIG['host_os']
+  when /darwin|osx/i
+    t.libs << 'lib/darwin'
+  when /linux/i
+    t.libs << 'lib/linux'
+  when /sunos|solaris/i
+    t.libs << 'lib/sunos'
+  when /bsd/i
+    t.libs << 'lib/bsd'
+  when /windows|win32|mingw|cygwin|dos/i
+    t.libs << 'lib/windows'
   else
-    task :test => :build
-    t.libs << 'ext'
-    t.libs.delete('lib')
+    t.libs << 'lib/unix'
   end
+
+  t.warning = true
+  t.verbose = true
+
   t.libs << 'test'
   t.test_files = FileList['test/test_sys_admin.rb']
 end
 
-task :test do
-  Rake.application[:clean].execute
-end
-
 task :default => :test

data/examples/example_groups.rb

@@ -0,0 +1,27 @@
+###########################################################################
+# groups.rb
+#
+# Sample script to demonstrate some of the various group methods.  Alter
+# as you see fit.
+###########################################################################
+require "pp"
+require "sys/admin"
+include Sys
+
+if File::ALT_SEPARATOR
+  pp Admin.get_group("guests")
+  pp Admin.get_group(513)
+else
+  pp Admin.get_group("admin")
+  pp Admin.get_group(7)
+end
+
+sleep 3
+
+Admin.groups.each{ |g|
+   pp g
+   puts
+}
+
+# This should raise an error
+Admin.get_group("fofofofof")

data/examples/example_users.rb

@@ -0,0 +1,41 @@
+###########################################################################
+# users.rb
+#
+# Sample script to demonstrate some of the various user methods.  Alter
+# as you see fit.
+###########################################################################
+require "pp"
+require "sys/admin"
+include Sys
+
+=begin
+user = User.new do |u|
+  u.name              = "Foo"
+  u.description       = "Test account"
+  u.password          = "changeme"
+  #u.lockout           = false
+  u.disabled          = true
+  #u.password_required = true
+end
+
+Admin.delete_user(u.name) rescue nil
+Admin.add_user(user)
+
+pp Admin.get_user("Foo")
+
+Admin.delete_user("Foo")
+=end
+
+user = Admin.get_login
+
+puts "User: #{user}"
+
+sleep 3
+
+Admin.users.each{ |u|
+  pp u
+  puts
+}
+
+pp Admin.get_user(user)
+pp Admin.get_user(501)

data/lib/bsd/sys/admin.rb

@@ -0,0 +1,239 @@
+require 'sys/admin/custom'
+require 'sys/admin/common'
+
+# The BSD specific code.
+
+module Sys
+  class Admin
+    private
+
+    # I'm making some aliases here to prevent potential conflicts
+    attach_function :open_c, :open, [:string, :int], :int
+    attach_function :pread_c, :pread, [:int, :pointer, :size_t, :off_t], :size_t
+    attach_function :close_c, :close, [:int], :int
+
+    attach_function :getlogin_r, [:pointer, :int], :int
+    attach_function :getpwnam_r, [:string, :pointer, :pointer, :size_t, :pointer], :int
+    attach_function :getpwuid_r, [:long, :pointer, :pointer, :size_t, :pointer], :int
+    attach_function :getgrnam_r, [:string, :pointer, :pointer, :size_t, :pointer], :int
+    attach_function :getgrgid_r, [:long, :pointer, :pointer, :size_t, :pointer], :int
+
+    private_class_method :getlogin_r, :getpwnam_r, :getpwuid_r, :getgrnam_r
+    private_class_method :getgrgid_r
+    private_class_method :open_c, :pread_c, :close_c
+
+    # struct passwd from /usr/include/pwd.h
+    class PasswdStruct < FFI::Struct
+      layout(
+        :pw_name, :string,
+        :pw_passwd, :string,
+        :pw_uid, :uint,
+        :pw_gid, :uint,
+        :pw_change, :ulong,
+        :pw_class, :string,
+        :pw_gecos, :string,
+        :pw_dir, :string,
+        :pw_shell, :string,
+        :pw_expire, :ulong
+      )
+    end
+
+    # struct group from /usr/include/grp.h
+    class GroupStruct < FFI::Struct
+      layout(
+        :gr_name, :string,
+        :gr_passwd, :string,
+        :gr_gid, :uint,
+        :gr_mem, :pointer
+      )
+    end
+
+    # I'm blending the timeval struct in directly here
+    class LastlogStruct < FFI::Struct
+      layout(
+        :ll_time, :int32,
+        :ll_line, [:char, 32],
+        :ll_host, [:char, 256]
+      )
+    end
+
+    public
+
+    # Returns the login for the current process.
+    #
+    def self.get_login
+      buf = FFI::MemoryPointer.new(:char, 256)
+
+      if getlogin_r(buf, buf.size) != 0
+        raise Error, "getlogin_r function failed: " + strerror(FFI.errno)
+      end
+
+      buf.read_string
+    end
+
+    # Returns a User object for the given name or uid. Raises an error
+    # if a user cannot be found.
+    #
+    # Examples:
+    #
+    #    Sys::Admin.get_user('joe')
+    #    Sys::Admin.get_user(501)
+    #
+    def self.get_user(uid)
+      buf  = FFI::MemoryPointer.new(:char, 1024)
+      pbuf = FFI::MemoryPointer.new(PasswdStruct)
+      temp = PasswdStruct.new
+
+      if uid.is_a?(String)
+        if getpwnam_r(uid, temp, buf, buf.size, pbuf) != 0
+          raise Error, "getpwnam_r function failed: " + strerror(FFI.errno)
+        end
+      else
+        if getpwuid_r(uid, temp, buf, buf.size, pbuf) != 0
+          raise Error, "getpwuid_r function failed: " + strerror(FFI.errno)
+        end
+      end
+
+      ptr = pbuf.read_pointer
+
+      if ptr.null?
+        raise Error, "no user found for #{uid}"
+      end
+
+      pwd = PasswdStruct.new(ptr)
+      get_user_from_struct(pwd)
+    end
+
+    # Returns a Group object for the given name or uid. Raises an error
+    # if a group cannot be found.
+    #
+    # Examples:
+    #
+    #    Sys::Admin.get_group('admin')
+    #    Sys::Admin.get_group(101)
+    #
+    def self.get_group(gid)
+      buf  = FFI::MemoryPointer.new(:char, 1024)
+      pbuf = FFI::MemoryPointer.new(PasswdStruct)
+      temp = GroupStruct.new
+
+      if gid.is_a?(String)
+        if getgrnam_r(gid, temp, buf, buf.size, pbuf) != 0
+          raise Error, "getgrnam_r function failed: " + strerror(FFI.errno)
+        end
+      else
+        if getgrgid_r(gid, temp, buf, buf.size, pbuf) != 0
+          raise Error, "getgrgid_r function failed: " + strerror(FFI.errno)
+        end
+      end
+
+      ptr = pbuf.read_pointer
+
+      if ptr.null?
+        raise Error, "no group found for #{gid}"
+      end
+
+      grp = GroupStruct.new(ptr)
+      get_group_from_struct(grp)
+    end
+
+    # Returns an array of User objects for each user on the system.
+    #
+    def self.users
+      users = []
+
+      begin
+        setpwent()
+
+        until (ptr = getpwent()).null?
+          pwd = PasswdStruct.new(ptr)
+          users << get_user_from_struct(pwd)
+        end
+      ensure
+        endpwent()
+      end
+
+      users
+    end
+
+    # Returns an array of Group objects for each user on the system.
+    #
+    def self.groups
+      groups = []
+
+      begin
+        setgrent()
+
+        until (ptr = getgrent()).null?
+          grp = GroupStruct.new(ptr)
+          groups << get_group_from_struct(grp)
+        end
+      ensure
+        endgrent()
+      end
+
+      groups
+    end
+
+    private
+
+    # Takes a GroupStruct and converts it to a Group object.
+    def self.get_group_from_struct(grp)
+      Group.new do |g|
+        g.name    = grp[:gr_name]
+        g.passwd  = grp[:gr_passwd]
+        g.gid     = grp[:gr_gid]
+        g.members = grp[:gr_mem].read_array_of_string
+      end
+    end
+
+    # Takes a UserStruct and converts it to a User object.
+    def self.get_user_from_struct(pwd)
+      user = User.new do |u|
+        u.name         = pwd[:pw_name]
+        u.passwd       = pwd[:pw_passwd]
+        u.uid          = pwd[:pw_uid]
+        u.gid          = pwd[:pw_gid]
+        u.change       = Time.at(pwd[:pw_change])
+        u.access_class = pwd[:pw_class]
+        u.gecos        = pwd[:pw_gecos]
+        u.dir          = pwd[:pw_dir]
+        u.shell        = pwd[:pw_shell]
+        u.expire       = Time.at(pwd[:pw_expire])
+      end
+
+      log = get_lastlog_info(user.uid)
+
+      if log
+        user.login_time = Time.at(log[:ll_time])
+        user.login_device = log[:ll_line].to_s
+        user.login_host = log[:ll_host].to_s
+      end
+
+      user
+    end
+
+    # Get lastlog information for the given user.
+    def self.get_lastlog_info(uid)
+      logfile = '/var/log/lastlog'
+      lastlog = LastlogStruct.new
+
+      begin
+        fd = open_c(logfile, File::RDONLY)
+
+        if fd != -1
+          bytes = pread_c(fd, lastlog, lastlog.size, uid * lastlog.size)
+          if bytes < 0
+            raise Error, "pread function failed: " + strerror(FFI.errno)
+          end
+        else
+          nil # Ignore, improper permissions
+        end
+      ensure
+        close_c(fd) if fd && fd >= 0
+      end
+
+      lastlog
+    end
+  end
+end