sys-admin 1.3.1

data/lib/sys/unix.h

@@ -0,0 +1,411 @@
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <grp.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+
+#define SYS_ADMIN_VERSION "1.3.1"
+
+#ifdef HAVE_LASTLOG_H
+#include <lastlog.h>
+#else
+#include <utmp.h>
+#endif
+
+#ifndef _POSIX_LOGIN_NAME_MAX
+#define _POSIX_LOGIN_NAME_MAX 9
+#endif
+
+#ifdef _SC_GETPW_R_SIZE_MAX
+#define USER_BUF_SIZE (sysconf(_SC_GETPW_R_SIZE_MAX))
+#else
+#define USER_BUF_SIZE 1024
+#endif
+
+#ifdef _SC_GETGR_R_SIZE_MAX
+#define GROUP_BUF_SIZE (sysconf(_SC_GETGR_R_SIZE_MAX))
+#else
+#define GROUP_BUF_SIZE 7296
+#endif
+
+#ifndef _PATH_LASTLOG
+#define _PATH_LASTLOG "/var/adm/lastlog"
+#endif
+
+/* Function prototypes */
+static VALUE get_user(struct passwd* p);
+static VALUE get_group(struct group* g);
+int get_lastlog_info(const char* n, VALUE rbVal);
+
+VALUE cUser, cGroup, cAdminError;
+
+/*
+ * :no-doc:
+ *
+ * Helper function that returns a User object based on user ID.
+ */
+static VALUE get_user_by_num(VALUE rbUID){
+   VALUE rbUser;
+   uid_t uid = NUM2INT(rbUID);
+
+#ifdef HAVE_GETPWUID_R
+   char buf[USER_BUF_SIZE];
+   struct passwd pwd;
+   struct passwd* pwdbuf;
+
+   if(getpwuid_r(uid, &pwd, buf, sizeof(buf), &pwdbuf) != 0)
+      rb_raise(cAdminError, "%s", strerror(errno));
+
+   if(!pwdbuf)
+      rb_raise(cAdminError, "no user found for %i:", uid);
+
+   rbUser = get_user(pwdbuf);
+#elif HAVE_GETPWUID
+   struct passwd* pwd;
+   if( (pwd = getpwuid(uid)) == NULL)
+      rb_raise(cAdminError, "no user found for: %i", uid);
+
+   rbUser = get_user(pwd);
+#else
+   rb_raise(rb_eNotImpError, "getting user by user ID not supported");
+#endif
+
+   return rbUser;
+}
+
+/*
+ * :no-doc:
+ *
+ * Helper function that returns a User object based on name.
+ */
+static VALUE get_user_by_name(VALUE rbName){
+   VALUE rbUser;
+   SafeStringValue(rbName);
+
+#ifdef HAVE_GETPWNAM_R
+   char buf[USER_BUF_SIZE];
+   struct passwd pwd;
+   struct passwd* pwdbuf;
+
+   if(getpwnam_r(RSTRING(rbName)->ptr, &pwd, buf, sizeof(buf), &pwdbuf) != 0)
+      rb_raise(cAdminError, "%s", strerror(errno));
+
+   if(!pwdbuf)
+      rb_raise(cAdminError, "no user found for %s", StringValuePtr(rbName));
+
+   rbUser = get_user(pwdbuf);
+#elif HAVE_GETPWNAM
+   struct passwd* pwd;
+   if( (pwd = getpwnam(RSTRING(rbName)->ptr)) == NULL)
+      rb_raise(cAdminError, "no user found for %s", StringValuePtr(rbName));
+
+   rbUser = get_user(pwd);
+#else
+   rb_raise(rb_eNotImpError, "getting user by name not supported"); 
+#endif
+
+   return rbUser;
+}
+
+/*
+ * :no-doc:
+ *
+ * Helper function that returns a Group object based on group ID.
+ */
+static VALUE get_group_by_num(VALUE rbGID){
+   VALUE rbGroup;
+   gid_t gid = NUM2INT(rbGID);
+
+#ifdef HAVE_GETGRGID_R
+   char buf[GROUP_BUF_SIZE];
+   struct group grp;
+   struct group* grpbuf;
+
+   if(getgrgid_r(gid, &grp, buf, sizeof(buf), &grpbuf) != 0)
+      rb_raise(cAdminError, "%s", strerror(errno));
+
+   if(!grpbuf)
+      rb_raise(cAdminError, "no group found for group ID: %i", gid);
+
+   rbGroup = get_group(grpbuf);
+#elif HAVE_GETGRGID
+   struct group* grp;
+   if( (grp = getgrgid(gid)) == NULL)
+      rb_raise(cAdminError, "no group found for group ID: %i", gid);
+      
+   rbGroup = get_group(grp);
+#else
+   rb_raise(rb_eNotImpError, "getting group by group ID not supported");
+#endif
+
+   return rbGroup;
+}
+
+/*
+ * :no-doc:
+ *
+ * Helper function that returns a Group object based on group name.
+ */
+static VALUE get_group_by_name(VALUE rbName){
+   VALUE rbGroup = Qnil;
+   SafeStringValue(rbName);
+#ifdef HAVE_GETGRNAM_R
+   char buf[GROUP_BUF_SIZE];
+   struct group grp;
+   struct group* grpbuf;
+
+   if(getgrnam_r(RSTRING(rbName)->ptr, &grp, buf, sizeof(buf), &grpbuf) != 0)
+      rb_raise(cAdminError, "%s", strerror(errno));
+
+   if(!grpbuf)
+      rb_raise(cAdminError, "no group found for: %s", StringValuePtr(rbName));
+
+   rbGroup = get_group(grpbuf);
+#elif HAVE_GETGRNAM
+   struct group* grp
+   if((grp = getgrnam(RSTRING(rbName)->ptr)) == NULL)
+      rb_raise(cAdminError, "no group found for: %s", StringValuePtr(rbName));
+
+   rbGroup = get_group(grp);
+#else
+   rb_raise(rb_eNotImpError,"get_group is not supported on this platform");
+#endif
+
+   return rbGroup;
+} 
+
+/*
+ * :no-doc:
+ *
+ * Helper function that turns a struct passwd into a User object.
+ */
+static VALUE get_user(struct passwd* p){
+   VALUE rbUser = rb_funcall(cUser,rb_intern("new"),0,0);
+
+   rb_iv_set(rbUser, "@name", rb_str_new2(p->pw_name));
+   rb_iv_set(rbUser, "@uid", INT2FIX(p->pw_uid));
+   rb_iv_set(rbUser, "@gid", INT2FIX(p->pw_gid));
+   rb_iv_set(rbUser, "@dir", rb_str_new2(p->pw_dir));
+   rb_iv_set(rbUser, "@shell", rb_str_new2(p->pw_shell));
+
+#ifdef HAVE_ST_PW_PASSWD
+   rb_iv_set(rbUser, "@passwd", rb_str_new2(p->pw_passwd));
+#endif
+
+#ifdef HAVE_ST_PW_AGE
+   rb_iv_set(rbUser, "@age", INT2FIX(p->pw_age));
+#endif
+
+#ifdef HAVE_ST_PW_COMMENT
+   rb_iv_set(rbUser, "@comment", rb_str_new2(p->pw_comment));
+#endif
+
+#ifdef HAVE_ST_PW_GECOS
+   rb_iv_set(rbUser, "@gecos", rb_str_new2(p->pw_gecos));
+#endif
+
+#ifdef HAVE_ST_PW_QUOTA
+   rb_iv_set(rbUser, "@quota", INT2FIX(p->pw_quota));
+#endif
+
+#ifdef HAVE_ST_PW_CLASS
+   rb_iv_set(rbUser, "@class", rb_str_new2(p->pw_class));
+#endif
+
+#ifdef HAVE_ST_PW_EXPIRE
+   rb_iv_set(rbUser, "@expire", INT2FIX(p->pw_expire));
+#endif
+
+   /* Get the lastlog info for the given user */
+   get_lastlog_info(p->pw_name, rbUser);
+
+   return rbUser;
+}
+
+/*
+ * :no-doc:
+ *
+ * Helper function that turns a User object into a struct passwd.
+ */
+void get_user_from_value(VALUE rbUser, struct passwd* pwd){
+
+   VALUE rbName  = rb_iv_get(rbUser, "@name");
+   VALUE rbUID   = rb_iv_get(rbUser, "@uid");
+   VALUE rbGID   = rb_iv_get(rbUser, "@gid");
+   VALUE rbDir   = rb_iv_get(rbUser, "@dir");
+   VALUE rbShell = rb_iv_get(rbUser, "@shell");
+
+   if(NIL_P(rbName))
+      rb_raise(cAdminError, "user name cannot be nil");
+
+   if(!NIL_P(rbUID))
+      pwd->pw_uid = NUM2INT(rbUID);
+
+   if(!NIL_P(rbGID))
+      pwd->pw_gid = NUM2INT(rbGID);
+
+   if(!NIL_P(rbDir)){
+      SafeStringValue(rbDir);
+      pwd->pw_dir = StringValuePtr(rbDir);
+   }
+
+   if(!NIL_P(rbShell)){
+      SafeStringValue(rbShell);
+      pwd->pw_shell = StringValuePtr(rbShell);
+   }
+
+#ifdef HAVE_ST_PW_PASSWD
+   VALUE rbPasswd = rb_iv_get(rbUser, "@passwd");
+   if(!NIL_P(rbPasswd)){
+      SafeStringValue(rbPasswd);
+      pwd->pw_passwd = StringValuePtr(rbPasswd);
+   }
+#endif
+
+#ifdef HAVE_ST_PW_AGE
+   VALUE rbAge = rb_iv_get(rbUser, "@age");
+   if(!NIL_P(rbAge))
+      pwd->pw_age = (char*)NUM2INT(rbAge);
+#endif
+
+#ifdef HAVE_ST_PW_COMMENT
+   VALUE rbComment = rb_iv_get(rbUser, "@comment");
+   if(!NIL_P(rbComment)){
+      SafeStringValue(rbComment);
+      pwd->pw_comment = StringValuePtr(rbComment);
+   }
+#endif
+
+#ifdef HAVE_ST_PW_GECOS
+   VALUE rbGecos = rb_iv_get(rbUser, "@gecos");
+   if(!NIL_P(rbGecos)){
+      SafeStringValue(rbGecos);
+      pwd->pw_gecos = StringValuePtr(rbGecos); 
+   }
+#endif
+
+#ifdef HAVE_ST_PW_QUOTA
+   VALUE rbQuota = rb_iv_get(rbUser, "@quota");
+   if(!NIL_P(rbQuota))
+      pwd->pw_quota = NUM2INT(rbQuota);
+#endif
+
+#ifdef HAVE_ST_PW_CLASS
+   VALUE rbClass = rb_iv_get(rbUser, "@class");
+   if(!NIL_P(rbClass)){
+      SafeStringValue(rbClass);
+      pwd->pw_class = StringValuePtr(rbClass);
+   }
+#endif
+
+#ifdef HAVE_ST_PW_EXPIRE
+   VALUE rbExpire = rb_iv_get(rbUser, "@expire");
+   if(!NIL_P(rbExpire))
+      pwd->pw_expire = NUM2INT(rbExpire);
+#endif
+
+}
+
+/*
+ * :no-doc:
+ *
+ * Helper function that turns a struct grp into a Group object.
+ */
+static VALUE get_group(struct group* g){
+   VALUE rbGroup = rb_funcall(cGroup,rb_intern("new"),0,0);
+   VALUE rbArray = rb_ary_new();
+
+   /* Return the members as an Array of Strings */
+   while(*g->gr_mem){
+      rb_ary_push(rbArray, rb_str_new2(*g->gr_mem));
+      g->gr_mem++;
+   }
+
+   rb_iv_set(rbGroup, "@name", rb_str_new2(g->gr_name));
+   rb_iv_set(rbGroup, "@gid", INT2FIX(g->gr_gid));
+   rb_iv_set(rbGroup, "@members", rbArray);
+#ifdef HAVE_ST_GR_PASSWD
+   rb_iv_set(rbGroup, "@passwd", rb_str_new2(g->gr_passwd));
+#endif
+
+   return rbGroup;
+}
+
+/*
+ * :no-doc:
+ *
+ * Helper function that turns a Group object into a struct group.
+ */
+void get_group_from_value(VALUE rbGroup, struct group* grp){
+   char** members = malloc(sizeof(char*));
+   VALUE rbName   = rb_iv_get(rbGroup, "@name");
+   VALUE rbGID    = rb_iv_get(rbGroup, "@gid");
+   VALUE rbMem    = rb_iv_get(rbGroup, "@members");
+   VALUE rbPasswd = rb_iv_get(rbGroup, "@passwd");
+   int i = 0;
+
+   if(NIL_P(rbName))
+      rb_raise(cAdminError, "group name must be set");
+
+   SafeStringValue(rbName);
+   grp->gr_name = StringValuePtr(rbName);
+
+   if(!NIL_P(rbGID))
+      grp->gr_gid = NUM2INT(rbGID);
+
+   if(!NIL_P(rbMem)){
+      VALUE rbVal;
+      while((rbVal = rb_ary_shift(rbMem)) != Qnil){
+         members[i] = StringValuePtr(rbVal);
+         i++;
+      }
+      members[i] = '\0';
+      grp->gr_mem = members;
+   }
+
+#ifdef HAVE_ST_GR_PASSWD
+   if(!NIL_P(rbPasswd)){
+      SafeStringValue(rbPasswd);
+      grp->gr_passwd = StringValuePtr(rbPasswd);
+   }
+#endif
+
+   free(members);
+}
+
+/*
+ * :no-doc:
+ *
+ * Helper function that gets lastlog information for the User object.
+ */
+int get_lastlog_info(const char* name, VALUE rbUser){
+   int fd;
+   struct lastlog log;
+   struct passwd* pwd;
+   int ll_size = sizeof(struct lastlog);
+
+   /* The lastlog information is not necessarily readable by all users, so
+    * ignore open() errors if they occur.
+    */
+   if((fd = open(_PATH_LASTLOG, O_RDONLY)) == -1)
+      return -1;
+
+   if((pwd = getpwnam(name)) == NULL)
+      rb_sys_fail(0);
+
+   pread(fd, &log, ll_size, pwd->pw_uid * ll_size);
+   close(fd);
+
+#ifdef HAVE_ST_LL_TIME
+   if(log.ll_time != 0)
+      rb_iv_set(rbUser, "@login_time", rb_time_new(log.ll_time, 0));
+#endif
+   rb_iv_set(rbUser, "@login_device", rb_str_new2(log.ll_line));
+   rb_iv_set(rbUser, "@login_host", rb_str_new2(log.ll_host));
+
+   return 0;
+}

data/lib/sys/win32.orig

@@ -0,0 +1,403 @@
+require "win32ole"
+require "Win32API"
+require "socket"
+
+module Sys
+   class AdminError < StandardError; end
+   
+   class Group
+      attr_accessor :caption, :description, :domain, :install_date
+      attr_accessor :name, :sid, :status, :gid
+      attr_writer :local
+      def initialize
+         yield self if block_given?
+      end
+      
+      def local?
+         @local
+      end
+      
+      def sid_type
+         @sid_type
+      end
+      
+      def sid_type=(stype)
+         case stype
+            when 1
+               @sid_type = "user"
+            when 2
+               @sid_type = "group"
+            when 3
+               @sid_type = "domain"
+            when 4
+               @sid_type = "alias"
+            when 5
+               @sid_type = "well_known_group"
+            when 6
+               @sid_type = "deleted_account"
+            when 7
+               @sid_type = "invalid"
+            when 8
+               @sid_type = "unknown"
+            when 9
+               @sid_type = "computer"
+            else
+               @sid_type = "unknown"
+         end
+         @sid_type
+      end
+   end
+   
+   class User
+   
+      attr_accessor :caption, :description, :domain, :password
+      attr_accessor :full_name, :install_date, :name, :sid, :status
+      attr_writer :disabled, :local, :lockout, :password_changeable
+      attr_writer :password_expires, :password_required
+      attr_reader :account_type
+      
+      def initialize
+         yield self if block_given?
+      end
+      
+      def account_type=(type)
+         case type
+            when 256
+               @account_type = "duplicate"
+            when 512
+               @account_type = "normal"
+            when 2048
+               @account_type = "interdomain_trust"
+            when 4096
+               @account_type = "workstation_trust"
+            when 8192
+               @account_type = "server_trust"
+            else
+               @account_type = "unknown"
+         end
+      end
+     
+      def sid_type
+         @sid_type
+      end
+     
+      def sid_type=(stype)
+         case stype
+            when 1
+               @sid_type = "user"
+            when 2
+               @sid_type = "group"
+            when 3
+               @sid_type = "domain"
+            when 4
+               @sid_type = "alias"
+            when 5
+               @sid_type = "well_known_group"
+            when 6
+               @sid_type = "deleted_account"
+            when 7
+               @sid_type = "invalid"
+            when 8
+               @sid_type = "unknown"
+            when 9
+               @sid_type = "computer"
+            else
+               @sid_type = "unknown"
+         end
+      end
+      
+      def disabled?
+         @disabled
+      end
+      
+      def local?
+         @local
+      end
+      
+      def lockout?
+         @lockout
+      end
+      
+      def password_changeable?
+         @password_changeable
+      end
+      
+      def password_expires?
+         @password_expires
+      end
+      
+      def password_required?
+         @password_required
+      end
+   end
+   
+   class Admin
+      VERSION = "1.3.1"
+      
+      # Deletes +userid+ from the given +host+, or the local host if no host
+      # is specified.
+      #
+      def self.delete_user(userid=nil, host=Socket.gethostname)
+         begin
+            adsi = WIN32OLE.connect("WinNT://#{host},Computer")
+         rescue WIN32OLERuntimeError => err
+            raise AdminError, err
+         end
+         
+         begin
+            adsi.delete("user", userid)
+         rescue WIN32OLERuntimeError => err
+            raise AdminError, err
+         end   
+      end
+      
+      # Returns the user name (only) of the current login.
+      #
+      def self.get_login
+         getlogin = Win32API.new("advapi32","GetUserName",['P','P'],'L')  
+         buffer = "\0" * 256;           
+         nsize = [256].pack("L")
+         getlogin.call(buffer,nsize)
+         len = nsize.unpack("L")[0]
+         username = buffer[0 ... len].chop
+         username
+      end
+      
+      # Returns a User object based on either +name+ or +uid+.
+      #
+      # call-seq:
+      #    get_user(name, host=localhost)
+      #    get_user(uid, host=localhost, local=true)
+      #
+      # You may specify a +host+ from which information is retrieved.  The
+      # default is the local machine.  You may also specify whether to
+      # retrieve a local or global account.  The default is local.
+      #
+      def self.get_user(uid, host=Socket.gethostname, local=true)
+         host = Socket.gethostname if host.nil?
+         cs = "winmgmts:{impersonationLevel=impersonate}!"
+         cs << "//#{host}/root/cimv2"
+         
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise AdminError, e
+         end
+         
+         query = "select * from win32_useraccount"
+         query << " where localaccount = true" if local
+         
+         if uid.kind_of?(Fixnum)
+            if local
+               query << " and sid like '%-#{uid}'"
+            else
+               query << " where sid like '%-#{uid}'"
+            end
+         else
+            if local
+               query << " and name = '#{uid}'"
+            else
+               query << " where name = '#{uid}'"
+            end
+         end
+         
+         wmi.execquery(query).each{ |user|
+            # Because our 'like' query isn't fulproof, let's parse
+            # the SID again to make sure
+            if uid.kind_of?(Fixnum)
+               if user.sid.split("-").last.to_i != uid
+                  next
+               end
+            end
+            usr = User.new do |u|
+               u.account_type = user.accounttype
+               u.caption      = user.caption
+               u.description  = user.description
+               u.disabled     = user.disabled
+               u.domain       = user.domain
+               u.full_name    = user.fullname
+               u.install_date = user.installdate
+               u.local        = user.localaccount
+               u.lockout      = user.lockout
+               u.name         = user.name
+               u.password_changeable = user.passwordchangeable
+               u.password_expires    = user.passwordexpires
+               u.password_required   = user.passwordrequired
+               u.sid      = user.sid
+               u.sid_type = user.sidtype
+               u.status   = user.status
+            end
+            return usr
+         }
+      end
+      
+      # In block form, yields a User object for each user on the system.  In
+      # non-block form, returns an Array of User objects.
+      #
+      # call-seq:
+      #    users(host=localhost, local=true)
+      #    users(host=localhost, local=true){ |user| ... }
+      #
+      # You may specify a host from which information is retrieved.  The
+      # default is the local machine.  You can retrieve either a global or
+      # group, depending on the value of the +local+ argument.
+      #
+      def self.users(host=Socket.gethostname, local=true)
+         host = Socket.gethostname if host.nil?
+         cs = "winmgmts:{impersonationLevel=impersonate}!"
+         cs << "//#{host}/root/cimv2"
+         
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise AdminError, e
+         end
+         
+         query = "select * from win32_useraccount"
+         query << " where localaccount = true" if local
+         array = []
+         
+         wmi.execquery(query).each{ |user|
+            usr = User.new do |u|
+               u.account_type = user.accounttype
+               u.caption      = user.caption
+               u.description  = user.description
+               u.disabled     = user.disabled
+               u.domain       = user.domain
+               u.full_name    = user.fullname
+               u.install_date = user.installdate
+               u.local        = user.localaccount
+               u.lockout      = user.lockout
+               u.name         = user.name
+               u.password_changeable = user.passwordchangeable
+               u.password_expires    = user.passwordexpires
+               u.password_required   = user.passwordrequired
+               u.sid      = user.sid
+               u.sid_type = user.sidtype
+               u.status   = user.status
+            end
+            
+            if block_given?
+               yield usr
+            else
+               array.push(usr)
+            end
+         }
+         return array unless block_given?
+      end
+      
+      # Returns a Group object based on either +name+ or +uid+.
+      #
+      # call-seq:
+      #    get_group(name, host=localhost, local=true) 
+      #    get_group(gid, host=localhost, local=true)
+      #
+      # You may specify a host from which information is retrieved.
+      # The default is the local machine.  You can retrieve either a global or
+      # local group, depending on the value of the +local+ argument.
+      #
+      def self.get_group(grp, host=Socket.gethostname, local=true)
+         host = Socket.gethostname if host.nil?
+         cs = "winmgmts:{impersonationLevel=impersonate}!"
+         cs << "//#{host}/root/cimv2"
+         gid = nil
+         
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise AdminError, e
+         end
+                  
+         query = "select * from win32_group"
+         query << " where localaccount = true" if local
+         
+         if grp.kind_of?(Fixnum)
+            if local
+               query << " and sid like '%-#{grp}'"
+            else
+               query << " where sid like '%-#{grp}'"
+            end
+         else
+            if local
+               query << " and name = '#{grp}'"
+            else
+               query << " where name = '#{grp}'"
+            end
+         end
+         
+         wmi.execquery(query).each{ |group|
+            gid = group.sid.split("-").last.to_i
+            
+            # Because our 'like' query isn't fulproof, let's parse
+            # the SID again to make sure
+            if grp.kind_of?(Fixnum)              
+               next if grp != gid
+            end
+            
+            grp = Group.new do |g|
+               g.caption      = group.caption
+               g.description  = group.description              
+               g.domain       = group.domain
+               g.gid          = gid
+               g.install_date = group.installdate
+               g.local        = group.localaccount
+               g.name         = group.name   
+               g.sid          = group.sid                         
+               g.sid_type     = group.sidtype
+               g.status       = group.status
+            end
+            return grp
+         }
+         # If we're here, it means it wasn't found.
+         raise AdminError, "no group found for '#{grp}'"
+      end
+   
+      # In block form, yields a Group object for each user on the system.  In
+      # non-block form, returns an Array of Group objects.
+      #
+      # call-seq:
+      #    groups(host=localhost, local=true)
+      #    groups(host=localhost, local=true){ |group| ... }
+      #
+      # You may specify a host from which information is retrieved.
+      # The default is the local machine.  You can retrieve either a global or
+      # local group, depending on the value of the +local+ argument.
+      #
+      def self.groups(host=Socket.gethostname, local=true)
+         host = Socket.gethostname if host.nil?
+         cs = "winmgmts:{impersonationLevel=impersonate}!"
+         cs << "//#{host}/root/cimv2"
+         
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise AdminError, e
+         end
+         
+         query = "select * from win32_group"
+         query << " where localaccount = true" if local
+         
+         array = []
+         wmi.execquery(query).each{ |group|
+            grp = Group.new do |g|
+               g.caption      = group.caption
+               g.description  = group.description              
+               g.domain       = group.domain
+               g.gid          = group.sid.split("-").last.to_i
+               g.install_date = group.installdate
+               g.local        = group.localaccount
+               g.name         = group.name   
+               g.sid          = group.sid                         
+               g.sid_type     = group.sidtype
+               g.status       = group.status
+            end
+            if block_given?
+               yield grp
+            else
+               array.push(grp)
+            end
+         }
+         return array unless block_given?
+      end
+   end
+end