libacl-ruby 0.0.1.dev

data/COPYING.txt

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

data/README.rdoc

@@ -0,0 +1,80 @@
+= libacl-ruby
+
+== Prerequesites
+
+In order to successfully install libacl-ruby, you need the following: 
+
+* Ruby >= 1.9.2
+* A C++ compiler (we use the {GNU project's}[http://www.gnu.org] <tt>g++</tt>)
+* libacl
+
+== How to install?
+
+=== RubyGems
+
+This is the easiest and preferred way. Ensure you have a proper built 
+environment for C++ code, and then do 
+
+  # gem install libacl-ruby
+
+=== Building from source
+
+If you want to be on the bleeding etch, clone the our 
+{git repository at GitHub}[https://github.com/Hanmac/libacl-ruby]: 
+
+  $ git clone https://github.com/Hanmac/libacl-ruby.git
+  $ cd libacl-ruby
+
+Then you can either choose to use the library from that directory by running 
+
+  $ rake compile
+
+or to make a gem and install that one. 
+
+  $ rake gem
+  # gem install --local pkg/libacl-ruby-x.x.x
+
+== How to use?
+
+First, you have to require the library: 
+
+  require "acl" #Note this is NOT "libacl-ruby"
+
+Then you can use the beautiful rubyish API: 
+
+  
+== Further reading
+
+Have a look at the documentation for the ACL and ACL::Entry classes 
+for more information. 
+
+== Contributors
+
+The following people have worked on libacl-ruby beside 
+me: 
+
+* Quintus <sutniuq ÄT gmx DÖT net> contributed to the docs
+
+== License
+
+libacl-ruby is a Ruby binding for the C library libacl. 
+
+Copyright © 2011 Hans Mackowiak
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+=== Contact
+
+You can read me via the email address hanmac ÄT gmx DÖT de. 

data/ext/acl.cpp

@@ -0,0 +1,217 @@
+#include "main.hpp"
+
+VALUE rb_cAcl,rb_cAclEntry;
+
+#define _self wrap<acl_t>(self)
+
+VALUE ACL_alloc(VALUE self)
+{
+	acl_t acl = acl_init(1);
+	return wrap(acl);
+}
+
+VALUE IO_acl(VALUE self)
+{
+	acl_t acl = acl_get_fd(NUM2INT(rb_funcall(self,rb_intern("to_i"),0)));
+	return acl ? wrap(acl) : Qnil;
+}
+
+VALUE IO_set_acl(VALUE self,VALUE acl)
+{
+	acl_set_fd(NUM2INT(rb_funcall(self,rb_intern("to_i"),0)),wrap<acl_t>(acl));
+	return acl;
+}
+VALUE File_single_access_acl(VALUE self,VALUE name)
+{
+	acl_t acl = acl_get_file(rb_string_value_cstr(&name), ACL_TYPE_ACCESS);
+	return acl ? wrap(acl) : Qnil;
+}
+
+VALUE File_single_default_acl(VALUE self,VALUE name)
+{
+	acl_t acl = acl_get_file(rb_string_value_cstr(&name), ACL_TYPE_DEFAULT);
+	return acl ? wrap(acl) : Qnil;
+}
+
+VALUE File_single_set_access_acl(VALUE self,VALUE name,VALUE acl)
+{
+	acl_set_file(rb_string_value_cstr(&name), ACL_TYPE_ACCESS,wrap<acl_t>(acl));
+	return acl;
+}
+
+VALUE File_single_set_default_acl(VALUE self,VALUE name,VALUE acl)
+{
+	acl_set_file(rb_string_value_cstr(&name), ACL_TYPE_DEFAULT,wrap<acl_t>(acl));
+	return acl;
+}
+
+VALUE File_access_acl(VALUE self)
+{
+	VALUE name = rb_get_path(self);
+	acl_t acl = acl_get_file(rb_string_value_cstr(&name), ACL_TYPE_ACCESS);
+	return acl ? wrap(acl) : Qnil;
+}
+
+VALUE File_set_access_acl(VALUE self,VALUE acl)
+{
+	if(rb_obj_is_kind_of(acl,rb_cAcl)){
+		VALUE name = rb_get_path(self);
+		acl_set_file(rb_string_value_cstr(&name), ACL_TYPE_ACCESS,wrap<acl_t>(acl));
+	}else
+		rb_raise(rb_eTypeError,"exepted %s!",rb_class2name(rb_cAcl));
+	return acl;
+}
+
+VALUE File_default_acl(VALUE self)
+{
+	VALUE name = rb_get_path(self);
+	acl_t acl = acl_get_file(rb_string_value_cstr(&name), ACL_TYPE_DEFAULT);
+	return acl ? wrap(acl) : Qnil;
+}
+
+VALUE File_set_default_acl(VALUE self,VALUE acl)
+{
+	if(rb_obj_is_kind_of(acl,rb_cAcl)){
+		VALUE name = rb_get_path(self);
+		acl_set_file(rb_string_value_cstr(&name), ACL_TYPE_DEFAULT,wrap<acl_t>(acl));
+	}else
+		rb_raise(rb_eTypeError,"exepted %s!",rb_class2name(rb_cAcl));
+	return acl;
+}
+
+
+VALUE ACL_size(VALUE self)
+{
+	return INT2NUM(acl_entries(_self));
+}
+
+VALUE ACL_valid(VALUE self)
+{	
+//	int i =	acl_check(_self,NULL);
+//	if(i)
+//		rb_warn("%d:%s",i,acl_error(i));
+	return acl_valid(_self)==0 ? Qtrue : Qfalse;
+}
+
+
+VALUE ACL_inspect(VALUE self)
+{
+	return rb_str_new2(acl_to_text(_self,NULL));
+}
+
+VALUE ACL_entries(VALUE self)
+{
+	RETURN_ENUMERATOR(self,0,NULL);
+	VALUE result = rb_ary_new();
+	acl_entry_t entry;
+	int i = -1;
+	for(int id = ACL_FIRST_ENTRY;i > 0;id=ACL_NEXT_ENTRY){
+		i = acl_get_entry(_self,id, &entry);
+		if(i>0){
+			VALUE temp = wrap(entry);
+			rb_yield(temp);
+			rb_ary_push(result,temp);
+		}
+	}
+	return result;
+}
+
+VALUE ACL_add(VALUE self,VALUE entry)
+{
+	acl_entry_t newentry;
+	acl_t acl = _self;
+	int i = -1;
+	bool found_mask=false;
+	acl_tag_t tag,oldtag;
+	acl_get_tag_type(wrap<acl_entry_t>(entry),&tag);
+	switch(tag){
+	case ACL_USER_OBJ:
+	case ACL_GROUP_OBJ:
+	case ACL_OTHER:
+	case ACL_MASK:
+		for(int id = ACL_FIRST_ENTRY;i>0;id=ACL_NEXT_ENTRY){
+			i = acl_get_entry(_self,id, &newentry);
+			if(i){
+				acl_get_tag_type(newentry,&oldtag);
+				if(tag==oldtag)
+					acl_delete_entry(_self,newentry);
+			}
+		}
+		break;
+	case ACL_USER:
+	case ACL_GROUP:
+	
+		for(int id = ACL_FIRST_ENTRY;i>0;id=ACL_NEXT_ENTRY){
+			i = acl_get_entry(_self,id, &newentry);
+			if(i>0){
+				acl_get_tag_type(newentry,&oldtag);
+				if(oldtag == ACL_MASK)
+					found_mask=true;
+				if((tag==oldtag) && (acl_get_qualifier(newentry)==acl_get_qualifier(wrap<acl_entry_t>(entry))))
+					acl_delete_entry(_self,newentry);
+			}
+		}
+		if(!found_mask)
+			acl_calc_mask(&acl);
+	}
+	acl_create_entry(&acl,&newentry);
+	acl_copy_entry(newentry,wrap<acl_entry_t>(entry));
+	return self;
+}
+
+VALUE ACL_get(VALUE self,VALUE nr)
+{
+	if(acl_entries(_self) <= NUM2INT(nr))
+		return Qnil;
+	acl_entry_t entry;
+	int i = 0;
+	for(int id = ACL_FIRST_ENTRY;i <= NUM2INT(nr) ;i++){
+		acl_get_entry(_self,id, &entry);
+		id=ACL_NEXT_ENTRY;
+	}
+	return wrap(entry);
+}
+
+VALUE ACL_delete_if(VALUE self)
+{
+	RETURN_ENUMERATOR(self,0,NULL);
+	VALUE result = rb_ary_new();
+	acl_entry_t entry;
+	int i = -1;
+	for(int id = ACL_FIRST_ENTRY;i>0;id=ACL_NEXT_ENTRY){
+		i = acl_get_entry(_self,id, &entry);
+		if(i>0){
+			VALUE temp = wrap(entry);
+			if(RTEST(rb_yield(temp))){
+				acl_delete_entry(_self,entry);
+				rb_ary_push(result,temp);
+			}
+		}
+	}
+	return result;
+}
+
+extern "C" void Init_acl(void){
+	rb_cAcl = rb_define_class("ACL",rb_cObject);
+	rb_define_alloc_func(rb_cAcl,ACL_alloc);
+	rb_define_method(rb_cIO,"acl",RUBY_METHOD_FUNC(IO_acl),0);
+	rb_define_method(rb_cIO,"acl=",RUBY_METHOD_FUNC(IO_set_acl),1);
+	rb_define_method(rb_cFile,"access_acl",RUBY_METHOD_FUNC(File_access_acl),0);
+	rb_define_method(rb_cFile,"access_acl=",RUBY_METHOD_FUNC(File_set_access_acl),1);
+	rb_define_method(rb_cFile,"default_acl",RUBY_METHOD_FUNC(File_default_acl),0);
+	rb_define_method(rb_cFile,"default_acl=",RUBY_METHOD_FUNC(File_set_default_acl),1);
+	rb_define_singleton_method(rb_cFile,"get_access_acl",RUBY_METHOD_FUNC(File_single_access_acl),1);
+	rb_define_singleton_method(rb_cFile,"set_access_acl",RUBY_METHOD_FUNC(File_single_set_access_acl),2);
+	rb_define_singleton_method(rb_cFile,"get_default_acl",RUBY_METHOD_FUNC(File_single_default_acl),1);
+	rb_define_singleton_method(rb_cFile,"set_default_acl",RUBY_METHOD_FUNC(File_single_set_default_acl),2);
+	rb_define_method(rb_cAcl,"size",RUBY_METHOD_FUNC(ACL_size),0);
+	rb_define_method(rb_cAcl,"[]",RUBY_METHOD_FUNC(ACL_get),1);
+	
+	rb_define_method(rb_cAcl,"delete_if",RUBY_METHOD_FUNC(ACL_delete_if),0);
+	//rb_define_method(rb_cAcl,"inspect",RUBY_METHOD_FUNC(ACL_inspect),0);
+	rb_define_method(rb_cAcl,"valid?",RUBY_METHOD_FUNC(ACL_valid),0);
+	rb_define_method(rb_cAcl,"each",RUBY_METHOD_FUNC(ACL_entries),0);
+	rb_define_method(rb_cAcl,"<<",RUBY_METHOD_FUNC(ACL_add),1);
+	rb_include_module(rb_cAcl,rb_mEnumerable);
+	Init_aclEntry(rb_cAcl);
+}

data/ext/entry.cpp

@@ -0,0 +1,337 @@
+#include "main.hpp"
+#define _self wrap<acl_entry_t>(self)
+
+VALUE ACLEntry_set_perm(VALUE self,VALUE perm);
+VALUE ACLEntry_set_id(VALUE self,VALUE id);
+
+VALUE ACLEntry_alloc(VALUE self)
+{
+	acl_t acl = acl_init(1);
+	acl_entry_t entry;
+	acl_create_entry(&acl,&entry);
+	acl_free(acl);
+	return wrap(entry);
+}
+
+VALUE ACLEntry_initialize_copy(VALUE self, VALUE other)
+{
+	rb_call_super(1,&other);
+	acl_copy_entry(_self,wrap<acl_entry_t>(other));
+	return self;
+}
+
+VALUE ACLEntry_initialize(int argc, VALUE *argv,VALUE self)
+{
+	VALUE type,perm,id;
+	rb_scan_args(argc, argv, "21", &type,&perm,&id);
+	type = rb_funcall(type,rb_intern("to_sym"),0);
+	if(SYM2ID(type) == rb_intern("user")){
+		if(NIL_P(id))
+			acl_set_tag_type(_self,ACL_USER_OBJ);
+		else
+			acl_set_tag_type(_self,ACL_USER);
+	}else if(SYM2ID(type) == rb_intern("group")){
+		if(NIL_P(id))
+			acl_set_tag_type(_self,ACL_GROUP_OBJ);
+		else
+			acl_set_tag_type(_self,ACL_GROUP);
+	}else if(SYM2ID(type) == rb_intern("other")){
+			acl_set_tag_type(_self,ACL_OTHER);
+	}else if(SYM2ID(type) == rb_intern("mask")){
+			acl_set_tag_type(_self,ACL_MASK);
+	}else
+		rb_raise(rb_eTypeError,"exepted one of :user,:group,:other,:mask!");
+	ACLEntry_set_perm(self,perm);
+	if(!NIL_P(id))
+		ACLEntry_set_id(self,id);
+	return self;
+}
+
+VALUE ACLEntry_id(VALUE self)
+{
+	int* id = (int*) acl_get_qualifier(_self);
+return id==NULL ? Qnil : INT2NUM(*id);
+}
+
+VALUE ACLEntry_id_name(VALUE self)
+{
+	acl_tag_t tag;
+	acl_get_tag_type(_self,&tag);
+	int* id = (int*) acl_get_qualifier(_self);
+	passwd* pwd;
+	group* grp;
+	VALUE result = Qnil;
+	switch(tag){
+	case ACL_USER:
+		pwd = getpwuid(*id);
+		if(pwd)
+			result = rb_str_new2(pwd->pw_name);
+		break;
+	case ACL_GROUP:
+		grp = getgrgid(*id);
+		if(grp)
+			result = rb_str_new2(grp->gr_name);
+		break;
+	}
+	return result;
+}
+
+VALUE ACLEntry_set_id(VALUE self,VALUE id)
+{
+	acl_tag_t tag;
+	acl_get_tag_type(_self,&tag);
+	if(NIL_P(id)){
+		switch(tag){
+		case ACL_USER:
+			acl_set_tag_type(_self,ACL_USER_OBJ);
+			break;
+		case ACL_GROUP:
+			acl_set_tag_type(_self,ACL_GROUP_OBJ);
+			break;
+		}
+		acl_set_qualifier(_self,NULL);
+	}else if(rb_obj_is_kind_of(id,rb_cInteger)){
+		int i;
+		switch(tag){
+		case ACL_USER_OBJ:
+		case ACL_USER:
+		case ACL_GROUP_OBJ:
+		case ACL_GROUP:
+			i = NUM2INT(id);
+			acl_set_qualifier(_self,&i);
+		default:
+			rb_raise(rb_eArgError,"id only supported with user or group.");
+		}
+	}else{
+		passwd* pwd;
+		group* grp;
+		id= rb_funcall(id,rb_intern("to_s"),0);
+		const char* name = rb_string_value_cstr(&id);
+		switch(tag){
+		case ACL_USER_OBJ:
+		case ACL_USER:
+			pwd = getpwnam(name);
+			if(pwd){
+				uid_t u = pwd->pw_uid;
+				acl_set_tag_type(_self,ACL_USER);
+				acl_set_qualifier(_self,&u);
+			}else
+				rb_raise(rb_eArgError,"There is no User with the name:%s!",name);
+			break;
+		case ACL_GROUP_OBJ:
+		case ACL_GROUP:
+			grp = getgrnam(name);
+			if(grp){
+					gid_t g = grp->gr_gid;
+					acl_set_tag_type(_self,ACL_GROUP);
+					acl_set_qualifier(_self,&g);
+			}else
+				rb_raise(rb_eArgError,"There is no Group with the name:%s!",name);
+			break;
+		default:
+			rb_raise(rb_eArgError,"id only supported with user or group.");
+		}
+	}
+	return id;
+}
+VALUE ACLEntry_perm(VALUE self)
+{
+	acl_permset_t set;
+	acl_get_permset(_self,&set);	
+	char perm[3];
+	perm[0] = acl_get_perm(set,ACL_READ) ? 'r' : '-';
+	perm[1] = acl_get_perm(set,ACL_WRITE) ? 'w' : '-';
+	perm[2] = acl_get_perm(set,ACL_EXECUTE) ? 'x' : '-';
+	return rb_str_new(perm,3);
+}
+
+VALUE ACLEntry_set_perm(VALUE self,VALUE perm)
+{
+	acl_permset_t set;
+	acl_get_permset(_self,&set);
+	acl_clear_perms(set);
+	if(rb_obj_is_kind_of(perm,rb_cInteger)){
+		int cperm = NUM2INT(perm);
+		if((cperm & ACL_READ) == ACL_READ)
+			acl_add_perm(set,ACL_READ);
+		if((cperm & ACL_WRITE) == ACL_WRITE)
+			acl_add_perm(set,ACL_WRITE);
+		if((cperm & ACL_EXECUTE) == ACL_EXECUTE)
+			acl_add_perm(set,ACL_EXECUTE);
+	}else{
+		perm= rb_funcall(perm,rb_intern("to_s"),0);
+		const char* cperm = rb_string_value_cstr(&perm);
+		for(unsigned int i = 0;i<strlen(cperm);i++){
+			switch(cperm[i]){
+			case 'r':
+				acl_add_perm(set,ACL_READ);
+				break;
+			case 'w':
+				acl_add_perm(set,ACL_WRITE);
+				break;
+			case 'x':
+				acl_add_perm(set,ACL_EXECUTE);
+				break;
+			}
+		}
+	}
+	return perm;
+}
+
+VALUE ACLEntry_type(VALUE self)
+{
+	acl_tag_t tag;
+	acl_get_tag_type(_self,&tag);
+	return INT2NUM(tag);
+}
+VALUE ACLEntry_readable(VALUE self)
+{
+	acl_permset_t set;
+	acl_get_permset(_self,&set);
+	return acl_get_perm(set,ACL_READ) ? Qtrue : Qfalse;
+}
+VALUE ACLEntry_writeable(VALUE self)
+{
+	acl_permset_t set;
+	acl_get_permset(_self,&set);
+	return acl_get_perm(set,ACL_WRITE) ? Qtrue : Qfalse;
+}
+VALUE ACLEntry_executable(VALUE self)
+{
+	acl_permset_t set;
+	acl_get_permset(_self,&set);
+	return acl_get_perm(set,ACL_EXECUTE) ? Qtrue : Qfalse;
+}
+VALUE ACLEntry_clear(VALUE self)
+{
+	acl_permset_t set;
+	acl_get_permset(_self,&set);
+	acl_clear_perms(set);
+	return self;
+}
+
+VALUE ACLEntry_to_i(VALUE self)
+{
+	acl_permset_t set;
+	acl_get_permset(_self,&set);
+	int i = 0;
+	if(acl_get_perm(set,ACL_READ))
+		i += ACL_READ;
+	if(acl_get_perm(set,ACL_WRITE))
+		i += ACL_WRITE;
+	if(acl_get_perm(set,ACL_EXECUTE))
+		i += ACL_EXECUTE;
+	return INT2NUM(i);
+}
+
+VALUE ACLEntry_inspect(VALUE self)
+{
+	acl_tag_t tag;
+	acl_get_tag_type(_self,&tag);
+	passwd* pwd;
+	group* grp;
+	int* id = (int*) acl_get_qualifier(_self);
+	VALUE array[4], result = Qnil;
+	array[2]=array[3]=ACLEntry_perm(self);
+	switch(tag){
+	case ACL_MASK:
+		array[0]=rb_str_new2("#<%s:Mask:%s>");
+		array[1]=rb_class_of(self);	
+		result = rb_f_sprintf(3,array);
+		break;
+	case ACL_OTHER:
+		array[0]=rb_str_new2("#<%s:Other:%s>");
+		array[1]=rb_class_of(self);	
+		result = rb_f_sprintf(3,array);
+		break;
+	case ACL_USER:		
+		pwd = getpwuid(*id);
+		if(pwd){
+			array[0]=rb_str_new2("#<%s:User(%s):%s>");
+			array[2]=rb_str_new2(pwd->pw_name);
+		}else{
+			array[0]=rb_str_new2("#<%s:User(%d):%s>");
+			array[2]=INT2NUM(*id);
+		}
+		array[1]=rb_class_of(self);
+		result = rb_f_sprintf(4,array);
+		break;
+	case ACL_USER_OBJ:
+		array[0]=rb_str_new2("#<%s:User:%s>");
+		array[1]=rb_class_of(self);	
+		result = rb_f_sprintf(3,array);
+		break;
+	case ACL_GROUP:
+		grp = getgrgid(*id);
+		if(grp){
+			array[0]=rb_str_new2("#<%s:Group(%s):%s>");
+			array[2]=rb_str_new2(grp->gr_name);
+		}else{
+			array[0]=rb_str_new2("#<%s:Group(%d):%s>");
+			array[2]=INT2NUM(*id);
+		}
+		array[1]=rb_class_of(self);
+		result = rb_f_sprintf(4,array);
+		break;
+	case ACL_GROUP_OBJ:
+		array[0]=rb_str_new2("#<%s:Group:%s>");
+		array[1]=rb_class_of(self);	
+		result = rb_f_sprintf(3,array);
+		break;
+	}
+	return result;
+}
+
+VALUE ACLEntry_set_readable(VALUE self,VALUE val){
+	acl_permset_t set;
+	acl_get_permset(_self,&set);
+	RTEST(val) ? acl_add_perm(set,ACL_READ) : acl_delete_perm(set,ACL_READ);
+	return val;
+}
+VALUE ACLEntry_set_writeable(VALUE self,VALUE val){
+	acl_permset_t set;
+	acl_get_permset(_self,&set);
+	RTEST(val) ? acl_add_perm(set,ACL_WRITE) : acl_delete_perm(set,ACL_WRITE);
+	return val;
+}
+VALUE ACLEntry_set_executable(VALUE self,VALUE val){
+	acl_permset_t set;
+	acl_get_permset(_self,&set);
+	RTEST(val) ? acl_add_perm(set,ACL_EXECUTE) : acl_delete_perm(set,ACL_EXECUTE);
+	return val;
+}
+
+VALUE ACLEntry_cmp(VALUE self,VALUE val){
+	return rb_funcall(ACLEntry_to_i(self),rb_intern("<=>"),1,rb_funcall(val,rb_intern("to_i"),0));
+}
+void Init_aclEntry(VALUE m){
+	rb_cAclEntry = rb_define_class_under(m,"Entry",rb_cObject);
+	rb_define_alloc_func(rb_cAclEntry,ACLEntry_alloc);
+	rb_define_private_method(rb_cAclEntry,"initialize_copy",RUBY_METHOD_FUNC(ACLEntry_initialize_copy),1);
+	
+	rb_define_method(rb_cAclEntry,"initialize",RUBY_METHOD_FUNC(ACLEntry_initialize),-1);
+	
+	rb_define_method(rb_cAclEntry,"id",RUBY_METHOD_FUNC(ACLEntry_id),0);
+	rb_define_method(rb_cAclEntry,"id_name",RUBY_METHOD_FUNC(ACLEntry_id_name),0);
+	rb_define_method(rb_cAclEntry,"id_name=",RUBY_METHOD_FUNC(ACLEntry_set_id),1);
+	rb_define_alias(rb_cAclEntry,"id=","id_name=");
+	rb_define_method(rb_cAclEntry,"perm",RUBY_METHOD_FUNC(ACLEntry_perm),0);
+	rb_define_method(rb_cAclEntry,"perm=",RUBY_METHOD_FUNC(ACLEntry_set_perm),1);
+	rb_define_method(rb_cAclEntry,"type",RUBY_METHOD_FUNC(ACLEntry_type),0);
+	
+	rb_define_method(rb_cAclEntry,"readable",RUBY_METHOD_FUNC(ACLEntry_readable),0);
+	rb_define_method(rb_cAclEntry,"writeable",RUBY_METHOD_FUNC(ACLEntry_writeable),0);
+	rb_define_method(rb_cAclEntry,"executable",RUBY_METHOD_FUNC(ACLEntry_executable),0);
+	
+	rb_define_method(rb_cAclEntry,"readable=",RUBY_METHOD_FUNC(ACLEntry_set_readable),1);
+	rb_define_method(rb_cAclEntry,"writeable=",RUBY_METHOD_FUNC(ACLEntry_set_writeable),1);
+	rb_define_method(rb_cAclEntry,"executable=",RUBY_METHOD_FUNC(ACLEntry_set_executable),1);
+	
+	rb_define_method(rb_cAclEntry,"clear",RUBY_METHOD_FUNC(ACLEntry_clear),0);
+	rb_define_method(rb_cAclEntry,"to_i",RUBY_METHOD_FUNC(ACLEntry_to_i),0);
+
+	rb_define_method(rb_cAclEntry,"inspect",RUBY_METHOD_FUNC(ACLEntry_inspect),0);
+	
+	rb_define_method(rb_cAclEntry,"<=>",RUBY_METHOD_FUNC(ACLEntry_cmp),1);
+	rb_include_module(rb_cAclEntry,rb_mComparable);
+}

data/ext/extconf.rb

@@ -0,0 +1,23 @@
+require 'mkmf'
+
+#find_library("acl","acl_get_file")
+#find_library("acl","acl_get_fd")
+
+dir_config("acl")
+
+unless(find_header("sys/acl.h") && 
+	find_header("acl/libacl.h") && 
+	find_library("acl",nil,"/usr/lib"))
+abort("libacl is missing.")
+end
+
+have_header("pwd.h") if find_header("pwd.h")
+have_header("grp.h") if find_header("grp.h")
+
+unless have_func("rb_string_value_cstr","ruby.h")
+	abort("missing VALUE to char convert!")
+end
+
+$CFLAGS += " -Wall"
+
+create_makefile("acl")

data/ext/main.hpp

@@ -0,0 +1,70 @@
+#ifndef __RubyAclMain_H__
+#define __RubyAclMain_H__
+#include <ruby.h>
+#include <sys/acl.h>
+#include <acl/libacl.h>
+
+#include <pwd.h>
+#include <grp.h>
+
+extern VALUE rb_cAcl,rb_cAclEntry;
+
+void Init_aclEntry(VALUE m);
+//template <typename T>
+//VALUE wrap(T *arg){ return Qnil;};
+template <typename T>
+VALUE wrap(T arg){ return Qnil;};
+template <typename T>
+T wrap(const VALUE &arg){};
+
+struct ruby_acl_entry{
+	acl_t acl;
+	acl_entry_t entry;
+};
+inline void ruby_acl_free(ruby_acl_entry* entry){
+	acl_free(entry->acl);
+	free(entry);
+}
+
+template <>
+inline VALUE wrap< acl_entry_t >(acl_entry_t entry )
+{
+	ruby_acl_entry *obj = new ruby_acl_entry;
+	acl_entry_t newentry;
+	acl_t acl = acl_init(0);
+	obj->acl = acl;
+	acl_create_entry(&acl,&newentry);
+	obj->entry =newentry;
+	acl_copy_entry(newentry,entry);
+	return Data_Wrap_Struct(rb_cAclEntry, NULL, ruby_acl_free, obj);
+}
+
+template <>
+inline VALUE wrap< acl_t >(acl_t file )
+{
+	return Data_Wrap_Struct(rb_cAcl, NULL, acl_free, file);
+}
+
+template <>
+inline acl_t wrap< acl_t >(const VALUE &vfile)
+{
+	if ( ! rb_obj_is_kind_of(vfile, rb_cAcl) )
+		return NULL;
+	acl_t file;
+  Data_Get_Struct( vfile, __acl_ext, file);
+	return file;
+}
+
+
+template <>
+inline acl_entry_t wrap< acl_entry_t >(const VALUE &vfile)
+{
+	if ( ! rb_obj_is_kind_of(vfile, rb_cAclEntry) )
+		return NULL;
+	ruby_acl_entry *obj;
+  Data_Get_Struct( vfile, ruby_acl_entry, obj);
+	return obj->entry;
+}
+
+#endif /* __RubyAclMain_H__ */
+

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: libacl-ruby
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 1
+  - dev
+  version: 0.0.1.dev
+platform: ruby
+authors: 
+- Hanmac
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-12 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: |
+  libacl-ruby provides Ruby bindings for the libacl library that 
+  allows you to access the Access Control Lists.
+
+email: hanmac@gmx.de
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- COPYING.txt
+- ext/entry.cpp
+- ext/acl.cpp
+- ext/main.hpp
+- ext/extconf.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- -t
+- libacl-ruby RDocs
+- -m
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      version: "1.9"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: 
+- A C++ compiler
+- libacl library
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby bindings for libacl
+test_files: []
+