solaris-file 0.3.1

data/CHANGES

@@ -0,0 +1,19 @@
+== 0.3.1 - 11-Jul-2006
+* Fixed a potential 64 bit bug in a struct declaration.
+* Minor RDoc updates, changes and internal cosmetic changes.
+
+== 0.3.0 - 13-Jun-2005
+* Added the File.resolvepath and File.realpath methods.
+* Code cleanup.  Attempting to pass a path greater than PATH_MAX
+  now raises an ArgumentError.
+* More tests added.
+
+== 0.2.0 - 1-Apr-2005
+* The Solaris::FileError class has been changed to File::SolarisError.
+* Added internal taint checking for methods that accept String arguments.
+* Improved error handling and general cleanup.
+* Added README and CHANGES files.  The former replaces the doc/file.txt file.
+* Added a gemspec.
+
+== 0.1.0 - 27-Jan-2005
+* Initial release.

data/MANIFEST

@@ -0,0 +1,14 @@
+extconf.rb
+MANIFEST
+README
+CHANGES
+solaris-file.gemspec
+
+examples/bar.txt
+examples/foo.txt
+examples/test.rb
+
+lib/solaris/sfile.c
+lib/solaris/sfile.h
+
+test/tc_solaris_file.rb

data/README

@@ -0,0 +1,112 @@
+== Description
+   Adds ACL support for the File class on Solaris.
+
+== Prerequisites
+   Ruby 1.8.x
+
+== Installation
+   ruby extconf.rb
+   make
+   ruby test/tc_solaris_file.rb
+   make site-install
+
+== Synopsis
+   require "solaris/file"
+   
+   f = "some_file.txt"
+   acl_text = "user::rw-,user:nobody:r--,"
+   acl_text << "group::r--,group:sys:r--,mask:r--,other:r--"
+   
+   File.trivial?(f) # probably true
+   File.acl_write_text(acl_text)
+   
+   # No longer a trivial file
+   File.trivial?(f) # false
+   File.acl_read(f).each{ |acl| p acl }
+
+== Class Methods
+File.acl_count(file_name)
+   Returns the number of ACL entries for the file.  Returns 0 if it's a
+   trivial file.
+
+File.acl_read(file_name)
+   Returns an Array of ACLStruct's or nil if file_name is a trivial file.
+
+Fiel.acl_read_text(file_name)
+   Returns a String form of the ACL entries for the file.  Returns nil if
+   it's a trivial ACL.
+
+File.acl_write_text(file_name, acl_string)
+   Accepts a formatted ACL string that set the ACL for the file.  If the
+   string is badly formed, a File::SolarisError is raised.
+   
+File.realpath(path)
+   Resolves all symbolic links in +path+.  Resolves to an absolute pathname
+   where possible.
+   
+File.resolvepath(path)
+   Resolves all symbolic links in +path+.  All "." components are removed, as
+   well as all nonleading ".." components and their preceding directory
+   component.  If leading ".." components resolve to the root directory, they
+   are replaced by "/".
+   
+File.trivial?(file_name)
+   Returns true if the file is a trivial ACL file, i.e. has no ACL entries for
+   additional users or groups.
+   
+= Instance Methods
+File#acl_count
+   Returns the number of ACL entries for the file.  Returns 0 if it's a
+   trivial file.
+   
+File#acl_read
+   Returns an Array of ACLStruct's.
+   
+File#acl_read_text
+   Returns a String form of the ACL entries for the file.  Returns nil if
+   it's a trivial ACL.
+
+File#acl_write_text(acl_string)
+   Accepts a formatted ACL string that set the ACL for the file.  If the
+   string is badly formed, a File::SolarisError is raised.
+   
+File#trivial?
+   Returns true if the file is a trivial ACL file, i.e. has no ACL entries for
+   additional users or groups
+
+== Constants
+File::SOLARIS_VERSION
+   Returns the current version number of this package as a String.
+   
+== Error Classes
+File::SolarisError < StandardError
+   Raised if anything goes wrong with any of the above methods.
+   
+== Known Bugs
+   None that I am aware of.  Please report any bugs using the tracker on the
+   project page at http://www.rubyforge.org/projects/solarisutils
+   
+== Future Plans
+   Add File.acl_write and File#acl_write methods that accept an array of
+   ACLStruct's.
+   Add support for extended file attributes.
+   
+== Developer's Notes
+   This is a BETA release.  I have not totally settled on the API.
+   
+== Copyright
+    (C) 2005, 2006 Daniel J. Berger
+    All Rights Reserved
+    
+== Warranty
+	This package is provided "as is" and without any express or
+	implied warranties, including, without limitation, the implied
+	warranties of merchantability and fitness for a particular purpose.
+	
+== License
+   Ruby's
+    
+== Author
+   Daniel J. Berger
+   djberg96 [at gmail dot com]
+   imperator on IRC (irc.freenode.net)

data/examples/test.rb

@@ -0,0 +1,60 @@
+#############################################################
+# test.rb
+#
+# Test script for general futzing.  Modify as you see fit.
+#############################################################
+base = File.basename(Dir.pwd)
+
+if base == "examples" || base =~ /solaris-file.*/
+   require "ftools"
+   Dir.chdir("..") if base == "examples"
+   Dir.mkdir("solaris") unless File.exists?("solaris")
+   File.copy("file.so","solaris")
+   $LOAD_PATH.unshift(Dir.pwd)
+   Dir.chdir("examples")
+end
+
+require "solaris/file"
+require "pp"
+
+puts
+puts "Version: " + File::SOLARIS_VERSION
+puts "-" * 20
+
+file1 = "foo.txt"
+file2 = "bar.txt"
+
+File.open(file1,"w+"){ |fh| fh.puts "foo" }
+File.open(file2,"w+"){ |fh| fh.puts "bar" }
+
+acl_text = "user::rw-,user:nobody:r--,group::r--,group:sys:r--,mask:r--,other:r--"
+acl_text2 = "user::rw-,user:nobody:r--,group::r--,group:sys:r--,mask:r--,other:rw-"
+
+pp File.acl_count(file1)     # Should be 0
+pp File.acl_read(file1)      # Should return nil
+pp File.acl_read_text(file1) # Should return nil
+pp File.trivial?(file1)      # Should return true
+
+File.acl_write_text(file1,acl_text)
+
+pp File.acl_count(file1)     # Should now be 6
+pp File.acl_read(file1)      # Should return 6 ACL Struct's
+pp File.acl_read_text(file1) # Should return an string like 'acl_text' above
+pp File.trivial?(file1)      # Should return false
+
+pp File.acl_count(file2)
+pp File.acl_read(file2)
+pp File.acl_read_text(file2)
+pp File.trivial?(file2)
+
+# Use instance methods instead this time
+File.open(file2){ |fh|
+   fh.acl_write_text(acl_text2)
+   pp fh.acl_count
+   pp fh.acl_read
+   pp fh.acl_read_text
+   pp fh.trivial?
+}
+
+File.delete(file1) if File.exists?(file1)
+File.delete(file2) if File.exists?(file2)

data/extconf.rb

@@ -0,0 +1,8 @@
+require "mkmf"
+require "ftools"
+
+File.copy("lib/solaris/sfile.c",".")
+File.copy("lib/solaris/sfile.h",".")
+
+have_library("sec")
+create_makefile("solaris/file")

data/lib/solaris/sfile.c

@@ -0,0 +1,423 @@
+#include "ruby.h"
+#include "rubyio.h"
+#include <sys/acl.h>
+#include <sys/param.h>
+#include <unistd.h>
+#include "sfile.h"
+
+/*
+ * call-seq:
+ *    File.acl_count(file_name)
+ *
+ * Returns the number of ACL entries for +file_name+.  Returns 0 if +file_name+
+ * is a trivial file.
+ */
+static VALUE acl_count(VALUE klass, VALUE v_path){
+   int num_acls = 0;
+   char pathp[PATH_MAX];
+
+   SafeStringValue(v_path);
+
+   if(strlcpy(pathp, StringValuePtr(v_path), PATH_MAX) >= PATH_MAX)
+      rb_raise(rb_eArgError, "path length exceeds limit of: %i", PATH_MAX);
+
+   if((num_acls = acl(pathp, GETACLCNT, 0, NULL)) == -1)
+      rb_sys_fail(0);
+
+   if(num_acls == MIN_ACL_ENTRIES)
+      num_acls = 0;
+
+   return INT2FIX(num_acls);
+}
+
+/*
+ * call-seq:
+ *    File#acl_count
+ *
+ * Returns the number of ACL entries for the current handle.  Returns 0 if
+ * the file is a trivial file.
+ */
+static VALUE acl_icount(VALUE self){
+   int num_acls = 0;
+   int fildes = FIX2INT(rb_funcall(self,rb_intern("fileno"), 0, 0));
+
+   if((num_acls = facl(fildes, GETACLCNT, 0, NULL)) == -1)
+      rb_sys_fail(0);
+
+   if(num_acls == MIN_ACL_ENTRIES)
+      num_acls = 0;
+
+   return INT2FIX(num_acls);
+}
+
+/*
+ * call-seq:
+ *    File.acl_read(file_name)
+ *
+ * Returns an array of ACLStruct's that contain three members each:
+ *
+ * - acl_type (String)
+ * - acl_id   (Integer)
+ * - acl_perm (Integer)
+ *
+ * Returns nil if +file_name+ is a trivial file.
+ */
+static VALUE acl_read(VALUE klass, VALUE v_path){
+   int num_acls = 0;
+   char pathp[PATH_MAX];
+   VALUE v_array = Qnil;
+   int i;
+
+   SafeStringValue(v_path);
+
+   if(strlcpy(pathp, StringValuePtr(v_path), PATH_MAX) >= PATH_MAX)
+      rb_raise(rb_eArgError, "path length exceeds limit of: %i", PATH_MAX);
+
+   if((num_acls = acl(pathp, GETACLCNT, 0, NULL)) == -1)
+      rb_sys_fail(0);
+
+   if(num_acls != MIN_ACL_ENTRIES){
+      aclent_t* acl_buf;
+      v_array = rb_ary_new();
+
+      if( (acl_buf = malloc(sizeof(aclent_t) * num_acls) ) == NULL)
+         rb_sys_fail(0);
+
+      if(acl(pathp, GETACL, num_acls, acl_buf) != num_acls)
+         rb_sys_fail(0);
+
+      for(i = 0; i < num_acls; i++){
+         rb_ary_push(v_array,
+            rb_struct_new(sACLStruct,
+               acl_type_string(acl_buf[i].a_type),
+               INT2FIX(acl_buf[i].a_id),
+               INT2FIX(acl_buf[i].a_perm)
+            )
+         );
+      }
+
+      free(acl_buf);
+   }
+
+   return v_array;
+}
+
+/*
+ * call-seq:
+ *    File#acl_read
+ *
+ * Returns an array of ACLStruct's that contain three members each:
+ *
+ * - acl_type (String)
+ * - acl_id   (Integer)
+ * - acl_perm (Integer)
+ *
+ * Returns nil if the file is a trivial file.
+ */
+static VALUE acl_iread(VALUE self){
+   int num_acls = 0;
+   int fildes = FIX2INT(rb_funcall(self,rb_intern("fileno"),0,0));
+   VALUE v_array = Qnil;
+   int i;
+
+   if( (num_acls = facl(fildes, GETACLCNT, 0, NULL)) == -1)
+      rb_sys_fail(0);
+
+   if(num_acls != MIN_ACL_ENTRIES){
+      aclent_t* acl_buf;
+      v_array = rb_ary_new();
+
+      if( (acl_buf = malloc(sizeof(aclent_t) * num_acls) ) == NULL)
+         rb_sys_fail(0);
+
+      if(facl(fildes, GETACL, num_acls, acl_buf) != num_acls)
+         rb_sys_fail(0);
+
+      for(i = 0; i < num_acls; i++){
+         rb_ary_push(v_array,
+            rb_struct_new(sACLStruct,
+               acl_type_string(acl_buf[i].a_type),
+               INT2FIX(acl_buf[i].a_id),
+               INT2FIX(acl_buf[i].a_perm)
+            )
+         );
+      }
+
+      free(acl_buf);
+   }
+   return v_array;
+}
+
+/*
+ * call-seq:
+ *    File.acl_read_text(file_name)
+ * 
+ * Returns a textual representation of the ACL for +file_name+.  If +file_name+
+ * is a trivial file, nil is returned.
+ */
+static VALUE acl_read_text(VALUE klass, VALUE v_path){
+   aclent_t* acl_buf;
+   int num_acls = 0;
+   char* acl_text;
+   char pathp[PATH_MAX];
+   VALUE v_text = Qnil;
+
+   SafeStringValue(v_path);
+
+   if(strlcpy(pathp, StringValuePtr(v_path), PATH_MAX) >= PATH_MAX)
+      rb_raise(rb_eArgError, "path length exceeds limit of: %i", PATH_MAX);
+
+   if( (num_acls = acl(pathp, GETACLCNT, 0, NULL)) == -1)
+      rb_sys_fail(0);
+
+   if(num_acls != MIN_ACL_ENTRIES){
+      if( (acl_buf = malloc(sizeof(aclent_t) * num_acls) ) == NULL)
+         rb_sys_fail(0);
+
+      if(acl(pathp, GETACL, num_acls, acl_buf) != num_acls)
+         rb_sys_fail(0);
+
+      acl_text = acltotext(acl_buf, num_acls);
+      
+      free(acl_buf);
+      v_text = rb_str_new2(acl_text);
+   }
+
+   return v_text;
+}
+
+/*
+ * call-seq:
+ *    File.acl_write_text(file_name, acl_text)
+ *
+ * Sets the ACL for +file_name+ using +acl_text+.  The +acl_text+ argument is a
+ * human readable ACL text String.
+ *
+ * If +acl_text+ is invalid then a Solaris::FileError is raised, and in most
+ * cases the offending entry number will be identified.
+ */
+static VALUE acl_write_text(VALUE klass, VALUE v_path, VALUE v_text){
+   aclent_t* acl_buf;
+   int num_acls, which;
+   char pathp[PATH_MAX];
+   char* acl_text = StringValuePtr(v_text);
+   int rv;
+
+   SafeStringValue(v_path);
+   SafeStringValue(v_text);
+
+   if(strlcpy(pathp, StringValuePtr(v_path), PATH_MAX) >= PATH_MAX)
+      rb_raise(rb_eArgError, "path length exceeds limit of: %i", PATH_MAX);
+
+   if((acl_buf = aclfromtext(acl_text, &num_acls)) == NULL)
+      rb_raise(cSolarisFileError, "invalid ACL text");
+
+   rv = aclcheck(acl_buf, num_acls, &which);
+   do_acl_check(rv, which);
+
+   if(acl(pathp, SETACL, num_acls, acl_buf) == -1){
+      free(acl_text);
+      rb_sys_fail(0);
+   }
+
+   free(acl_text);
+   free(acl_buf);
+
+   return klass;
+}
+
+/*
+ * call-seq:
+ *    File.resolvepath(path)
+ *
+ * Resolves all symbolic links in +path+.  All "." components are removed, as
+ * well as all nonleading ".." components and their preceding directory
+ * component.  If leading ".." components resolve to the root directory, they
+ * are replaced by "/".
+ */
+static VALUE solaris_resolvepath(VALUE klass, VALUE v_path){
+   char pathp[PATH_MAX];
+
+   SafeStringValue(v_path);
+   memset(pathp, 0, PATH_MAX);
+
+   if(resolvepath(StringValuePtr(v_path), pathp, PATH_MAX) == -1)
+      rb_sys_fail(0);
+
+   return rb_str_new2(pathp);
+}
+
+/*
+ * call-seq:
+ *    File.realpath(path)
+ *
+ * Resolves all symbolic links in +path+.  Resolves to an absolute pathname
+ * where possible.
+ *
+ * The difference between this method and File.resolvepath is that this method
+ * will resolve to an absolute pathname where possible.
+ */
+static VALUE solaris_realpath(VALUE klass, VALUE v_path){
+   char pathp[PATH_MAX];
+
+   SafeStringValue(v_path);
+
+   if(realpath(StringValuePtr(v_path), pathp) == NULL)
+      rb_sys_fail(0);
+
+   return rb_str_new2(pathp);
+}
+
+/* Instance Methods */
+
+/*
+ * call-seq:
+ *    File#acl_write_text(acl_text)
+ *
+ * Sets the ACL for the file using +acl_text+.  The +acl_text+ argument is a
+ * human readable ACL text String.
+ *
+ * If +acl_text+ is invalid then a File::SolarisError is raised, and in most
+ * cases the offending entry number will be identified.
+ */
+static VALUE acl_iwrite_text(VALUE self, VALUE v_text){
+   aclent_t* acl_buf;
+   int num_acls, which;
+   char* acl_text = StringValuePtr(v_text);
+   int fildes = FIX2INT(rb_funcall(self, rb_intern("fileno"), 0, 0));
+   int rv;
+
+   SafeStringValue(v_text);
+
+   if((acl_buf = aclfromtext(acl_text, &num_acls)) == NULL)
+      rb_raise(cSolarisFileError, "invalid ACL text");
+
+   rv = aclcheck(acl_buf, num_acls, &which);
+   do_acl_check(rv, which);
+
+   if(facl(fildes, SETACL, num_acls, acl_buf) == -1){
+      free(acl_text);
+      rb_sys_fail(0);
+   }
+
+   free(acl_text);
+   free(acl_buf);
+
+   return self;
+}
+
+
+/*
+ * call-seq:
+ *    File#acl_read_text
+ * 
+ * Returns a textual representation of the ACL for the current handle.  If
+ * the file is a trivial file, nil is returned.
+ */
+static VALUE acl_iread_text(VALUE self){
+   char* acl_text;
+   int num_acls = 0;
+   int fildes = FIX2INT(rb_funcall(self,rb_intern("fileno"),0,0));
+   VALUE v_text = Qnil;
+
+   if( (num_acls = facl(fildes,GETACLCNT,0,NULL)) == -1)
+      rb_sys_fail(0);
+
+   if(num_acls != MIN_ACL_ENTRIES){
+      aclent_t* acl_buf;
+
+      if( (acl_buf = malloc(sizeof(aclent_t) * num_acls) ) == NULL)
+         rb_sys_fail(0);
+
+      if(facl(fildes, GETACL, num_acls, acl_buf) != num_acls)
+         rb_sys_fail(0);
+
+      acl_text = acltotext(acl_buf,num_acls);
+      
+      free(acl_buf);
+      v_text = rb_str_new2(acl_text); 
+   }
+
+   return v_text;
+}
+
+/*
+ * call-seq:
+ *    File.trivial?(file_name)
+ *
+ * Returns true if +file_name+ is a trivial file, i.e. has no additional ACL
+ * entries.  Otherwise, it returns false.
+ */
+static VALUE acl_trivial(VALUE klass, VALUE v_path){
+   char pathp[PATH_MAX];
+   int num_acls = 0;
+   VALUE v_bool = Qfalse;
+
+   SafeStringValue(v_path);
+
+   if(strlcpy(pathp, StringValuePtr(v_path), PATH_MAX) >= PATH_MAX)
+      rb_raise(rb_eArgError, "path length exceeds limit of: %i", PATH_MAX);
+
+   if((num_acls = acl(pathp, GETACLCNT, 0, NULL)) == -1)
+      rb_sys_fail(0);
+
+   if(num_acls == MIN_ACL_ENTRIES)
+      v_bool = Qtrue;
+
+   return v_bool;
+}
+
+/*
+ * call-seq:
+ *    File#trivial?
+ *
+ * Returns true if the current file is a trivial file, i.e. has no additional
+ * ACL entries.  Otherwise, it returns false.
+ */
+static VALUE acl_itrivial(VALUE self){
+   int fildes = FIX2INT(rb_funcall(self,rb_intern("fileno"),0,0));
+   int num_acls = 0;
+   VALUE v_bool = Qfalse;
+
+   if( (num_acls = facl(fildes,GETACLCNT,0,NULL)) == -1)
+      rb_sys_fail(0);
+
+   if(num_acls == MIN_ACL_ENTRIES)
+      v_bool = Qtrue;
+
+   return v_bool;
+}
+
+/*
+ * Adds ACL support for the File class on Solaris
+ */
+void Init_file(){
+   /* Error Classes */
+   cSolarisFileError = rb_define_class_under(rb_cFile, "SolarisError",
+      rb_eStandardError
+   );
+
+   /* Class Methods */
+   rb_define_singleton_method(rb_cFile, "acl_count", acl_count, 1);
+   rb_define_singleton_method(rb_cFile, "acl_read", acl_read, 1);
+   rb_define_singleton_method(rb_cFile, "acl_read_text", acl_read_text, 1);
+   rb_define_singleton_method(rb_cFile, "acl_write_text", acl_write_text, 2);
+   rb_define_singleton_method(rb_cFile, "trivial?", acl_trivial, 1);
+   rb_define_singleton_method(rb_cFile, "realpath", solaris_realpath, 1);
+   rb_define_singleton_method(rb_cFile, "resolvepath", solaris_resolvepath, 1);
+
+   /* Instance Methods */
+   rb_define_method(rb_cFile,"acl_count", acl_icount, 0);
+   rb_define_method(rb_cFile,"acl_read", acl_iread, 0);
+   rb_define_method(rb_cFile,"acl_read_text", acl_iread_text, 0);
+   rb_define_method(rb_cFile,"acl_write_text", acl_iwrite_text, 1);
+   rb_define_method(rb_cFile,"trivial?", acl_itrivial, 0);
+
+   /* Structs */
+   sACLStruct = rb_struct_define("ACLStruct",
+      "acl_type", "acl_id", "acl_perm", NULL
+   );
+
+   /* Constants */
+   rb_define_const(rb_cFile, "SOLARIS_VERSION", rb_str_new2(SOLARIS_VERSION));
+}

data/lib/solaris/sfile.h

@@ -0,0 +1,78 @@
+#define SOLARIS_VERSION "0.3.1"
+#define MAX_STRING 512
+
+VALUE cSolarisFileError;
+VALUE sACLStruct;
+
+/*
+ * Converts a numeric ACL type into a human readable string.
+ */
+static VALUE acl_type_string(int acl_type){
+   VALUE rbACLType;
+
+   switch(acl_type){
+      case USER: case USER_OBJ:
+         rbACLType = rb_str_new2("user");
+         break;
+      case GROUP: case GROUP_OBJ:
+         rbACLType = rb_str_new2("group");
+         break;
+      case OTHER_OBJ:
+         rbACLType = rb_str_new2("other");
+         break;
+      case CLASS_OBJ:
+         rbACLType = rb_str_new2("mask");
+         break;
+      case DEF_USER: case DEF_USER_OBJ:
+         rbACLType = rb_str_new2("defaultuser");
+         break;
+      case DEF_GROUP: case DEF_GROUP_OBJ:
+         rbACLType = rb_str_new2("defaultgroup");
+         break;
+      case DEF_OTHER_OBJ:
+         rbACLType = rb_str_new2("defaultother");
+         break;
+      case DEF_CLASS_OBJ:
+         rbACLType = rb_str_new2("defaultmask");
+         break;
+      default:
+         rbACLType = rb_str_new2("unknown");
+   }
+   return rbACLType;
+}
+
+/*
+ * Helper function used by the acl_write_text class and instance methods.
+ */
+void do_acl_check(int aclcheck_val, int which){
+   char err[MAX_STRING];
+
+   switch(aclcheck_val){
+      case 0:
+         break; /* Nothing wrong */
+      case USER_ERROR:
+         sprintf(err,"Invalid ACL entry: %i; Multiple user entries", which);
+         rb_raise(cSolarisFileError,err);
+      case GRP_ERROR:
+         sprintf(err,"Invalid ACL entry: %i; Multiple group entries", which);
+         rb_raise(cSolarisFileError,err);
+      case OTHER_ERROR:
+         sprintf(err,"Invalid ACL entry: %i; Multiple other entries", which);
+         rb_raise(cSolarisFileError,err);
+      case CLASS_ERROR:
+         sprintf(err,"Invalid ACL entry: %i; Multiple mask entries", which);
+         rb_raise(cSolarisFileError,err);
+      case DUPLICATE_ERROR:
+         sprintf(err,"Invalid ACL entry: %i; Multiple user or group entries", which);
+         rb_raise(cSolarisFileError,err);
+      case ENTRY_ERROR:
+         sprintf(err,"Invalid ACL entry: %i; Invalid entry type", which);
+         rb_raise(cSolarisFileError,err);
+      case MISS_ERROR:
+         rb_raise(cSolarisFileError, "Missing ACL entries");
+      case MEM_ERROR:
+         rb_raise(cSolarisFileError, "Out of memory!");
+      default:
+         rb_raise(cSolarisFileError, "Unknown error");
+   };
+}

data/test/tc_solaris_file.rb

@@ -0,0 +1,156 @@
+###############################################################################
+# tc_solaris_file.rb
+#
+# Test suite for the solaris-file package.
+###############################################################################
+base = File.basename(Dir.pwd)
+
+if base == "test" || base =~ /solaris-file.*/
+   require "ftools"
+   Dir.chdir("..") if base == "test"
+   Dir.mkdir("solaris") unless File.exists?("solaris")
+   File.copy("file.so","solaris")
+   $LOAD_PATH.unshift(Dir.pwd)
+   Dir.chdir("test") rescue nil
+end
+
+require "test/unit"
+require "solaris/file"
+require "open3"
+
+class TC_Solaris_File < Test::Unit::TestCase
+   def setup
+      @dir   = Dir.pwd
+      @file  = "foo.txt" # trivial
+      @file2 = "bar.txt" # non-trivial
+
+      @acl_text = "user::rw-,user:nobody:r--,"
+      @acl_text << "group::r--,group:sys:r--,mask:r--,other:r--"
+
+      File.open(@file,"w+"){ |fh| fh.puts "foo" } unless File.exists?(@file)
+      File.open(@file2,"w+"){ |fh| fh.puts "bar" } unless File.exists?(@file2)
+
+      system("setfacl -m #{@acl_text} #{@file2}") # Make @file2 non-trivial
+
+      @fh = File.open(@file)
+      @fh2 = File.open(@file2)
+   end
+
+   def test_version
+      assert_equal("0.3.1", File::SOLARIS_VERSION)
+   end
+
+   # CLASS METHODS
+
+   # This yields an ACL struct for each entry
+   def test_class_acl_read
+      assert_respond_to(File,:acl_read)
+      assert_nothing_raised{ File.acl_read(@file) }
+      assert_equal(nil,File.acl_read(@file))
+      assert_kind_of(Array,File.acl_read(@file2))
+      assert_raises(Errno::ENOENT){ File.acl_read("bogus") }
+      assert_raises(ArgumentError){ File.acl_read("bogus"*500) }
+   end
+
+   # Tests the acltotext() approach
+   def test_class_acl_read_text
+      assert_respond_to(File,:acl_read_text)
+      assert_nothing_raised{ File.acl_read_text(@file) }
+      assert_kind_of(NilClass,File.acl_read_text(@file))
+      assert_kind_of(String,File.acl_read_text(@file2))
+      assert_raises(Errno::ENOENT){ File.acl_read_text("bogus") }
+   end
+
+   # Tests the aclfromtext() approach
+   def test_class_acl_write_text
+      text = "user::rw-,group::r--,mask:r--,other:---"
+      assert_respond_to(File,:acl_write_text)
+      assert_nothing_raised{ File.acl_write_text(@file,text) }
+      assert_raises(File::SolarisError){ File.acl_write_text(@file,"bogus") }
+   end
+
+   def test_class_acl_trivial
+      assert_respond_to(File,:trivial?)
+      assert_nothing_raised{ File.trivial?(@file) }
+      assert_equal(true,File.trivial?(@file))
+      assert_equal(false,File.trivial?(@file2))
+      assert_raises(Errno::ENOENT){ File.trivial?("bogus") }
+      assert_raises(ArgumentError){ File.trivial?("bogus"*500) }
+   end
+
+   def test_class_acl_count
+      assert_respond_to(File, :acl_count)
+      assert_nothing_raised{ File.acl_count(@file) }
+      assert_kind_of(Fixnum, File.acl_count(@file))
+      assert_raises(Errno::ENOENT){ File.acl_count("bogus") }
+      assert_raises(ArgumentError){ File.acl_count("bogus"*500) }
+   end
+
+   def test_class_realpath
+      dir1 = File.dirname(Dir.pwd) + "/examples"
+      dir2 = Dir.pwd + "/.././examples"
+
+      assert_respond_to(File, :realpath)
+      assert_nothing_raised{ File.realpath(@dir) }
+      assert_equal(@dir, File.realpath(@dir))
+      assert_equal(dir1, File.realpath(dir2))
+      assert_raises(Errno::ENOENT){ File.realpath("bogus") }
+   end
+
+   def test_class_resolvepath
+      assert_respond_to(File, :resolvepath)
+      assert_nothing_raised{ File.resolvepath(@dir) }
+      assert_equal(@dir, File.resolvepath(@dir))
+      assert_equal("../examples", File.resolvepath("../examples"))
+      assert_raises(Errno::ENOENT){ File.resolvepath("bogus") }
+   end
+
+   # INSTANCE METHODS
+
+   def test_instance_acl
+      assert_respond_to(@fh, :acl_read)
+      assert_nothing_raised{ @fh.acl_read }
+      assert_equal(nil, @fh.acl_read)
+      assert_kind_of(Array, @fh2.acl_read)
+      assert_kind_of(Struct::ACLStruct, @fh2.acl_read.first)
+   end
+
+   # Tests the acltotext() approach
+   def test_instance_acl_read_text
+      assert_respond_to(@fh,:acl_read_text)
+      assert_nothing_raised{ @fh.acl_read_text }
+      assert_equal(nil, @fh.acl_read_text)
+      assert_kind_of(String, @fh2.acl_read_text)
+   end
+
+   # Tests the aclfromtext() approach
+   def test_instance_acl_write_text
+      text = "user::rw-,group::r--,mask:r--,other:---"
+      assert_respond_to(@fh2,:acl_write_text)
+      assert_nothing_raised{ @fh2.acl_write_text(text) }
+      assert_raises(File::SolarisError){ @fh2.acl_write_text("bogus") }
+   end
+
+   def test_instance_acl_trivial
+      assert_respond_to(@fh, :trivial?)
+      assert_nothing_raised{ @fh.trivial? }
+      assert_equal(true, @fh.trivial?)
+      assert_equal(false, @fh2.trivial?)
+   end
+
+   def test_instance_acl_count
+      assert_respond_to(@fh,:acl_count)
+      assert_nothing_raised{ @fh.acl_count }
+      assert_kind_of(Fixnum,@fh.acl_count)
+      assert_equal(0,@fh.acl_count)
+      assert_equal(6,@fh2.acl_count)
+   end
+
+   def teardown
+      @dir = nil
+      @file = nil
+      @file2 = nil
+      @fh.close
+      @fh2.close
+   end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: solaris-file
+version: !ruby/object:Gem::Version 
+  version: 0.3.1
+date: 2006-07-11 00:00:00 -06:00
+summary: ACL and other methods for the File class on Solaris
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/sysutils
+rubyforge_project: 
+description: ACL and other methods for the File class on Solaris
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel Berger
+files: 
+- CHANGES
+- MANIFEST
+- README
+- extconf.rb
+- lib/solaris/sfile.c
+- lib/solaris/sfile.h
+- examples/test.rb
+test_files: 
+- test/tc_solaris_file.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+executables: []
+
+extensions: 
+- extconf.rb
+requirements: []
+
+dependencies: []
+