2 posix1e - a python module exposing the posix acl functions
4 Copyright (C) 2002-2009, 2012, 2014, 2015 Iustin Pop <iustin@k1024.org>
6 This library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 This library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with this library; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 #include <sys/types.h>
29 #include <acl/libacl.h>
30 #define get_perm acl_get_perm
32 #define get_perm acl_get_perm_np
35 #if PY_MAJOR_VERSION >= 3
37 #define PyInt_Check(op) PyLong_Check(op)
38 #define PyInt_FromString PyLong_FromString
39 #define PyInt_FromUnicode PyLong_FromUnicode
40 #define PyInt_FromLong PyLong_FromLong
41 #define PyInt_FromSize_t PyLong_FromSize_t
42 #define PyInt_FromSsize_t PyLong_FromSsize_t
43 #define PyInt_AsLong PyLong_AsLong
44 #define PyInt_AsSsize_t PyLong_AsSsize_t
45 #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
46 #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
47 #define PyInt_AS_LONG PyLong_AS_LONG
48 #define MyString_ConcatAndDel PyUnicode_AppendAndDel
49 #define MyString_FromFormat PyUnicode_FromFormat
50 #define MyString_FromString PyUnicode_FromString
51 #define MyString_FromStringAndSize PyUnicode_FromStringAndSize
53 #define PyBytes_Check PyString_Check
54 #define PyBytes_AS_STRING PyString_AS_STRING
55 #define PyBytes_FromStringAndSize PyString_FromStringAndSize
56 #define PyBytes_FromString PyString_FromString
57 #define PyBytes_FromFormat PyString_FromFormat
58 #define PyBytes_ConcatAndDel PyString_ConcatAndDel
59 #define MyString_ConcatAndDel PyBytes_ConcatAndDel
60 #define MyString_FromFormat PyBytes_FromFormat
61 #define MyString_FromString PyBytes_FromString
62 #define MyString_FromStringAndSize PyBytes_FromStringAndSize
64 /* Python 2.6 already defines Py_TYPE */
66 #define Py_TYPE(o) (((PyObject*)(o))->ob_type)
70 /* Used for cpychecker: */
71 /* The checker automatically defines this preprocessor name when creating
72 the custom attribute: */
73 #if defined(WITH_CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF_ATTRIBUTE)
74 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(typename) \
75 __attribute__((cpychecker_type_object_for_typedef(typename)))
77 /* This handles the case where we're compiling with a "vanilla"
78 compiler that doesn't supply this attribute: */
79 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(typename)
82 /* The checker automatically defines this preprocessor name when creating
83 the custom attribute: */
84 #if defined(WITH_CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION_ATTRIBUTE)
85 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION \
86 __attribute__((cpychecker_negative_result_sets_exception))
88 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
91 static PyTypeObject ACL_Type
92 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("ACL_Object");
93 static PyObject* ACL_applyto(PyObject* obj, PyObject* args);
94 static PyObject* ACL_valid(PyObject* obj, PyObject* args);
96 #ifdef HAVE_ACL_COPY_EXT
97 static PyObject* ACL_get_state(PyObject *obj, PyObject* args);
98 static PyObject* ACL_set_state(PyObject *obj, PyObject* args);
102 static PyTypeObject Entry_Type
103 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("Entry_Object");
104 static PyTypeObject Permset_Type
105 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("Permset_Object");
106 static PyObject* Permset_new(PyTypeObject* type, PyObject* args,
110 static acl_perm_t holder_ACL_EXECUTE = ACL_EXECUTE;
111 static acl_perm_t holder_ACL_READ = ACL_READ;
112 static acl_perm_t holder_ACL_WRITE = ACL_WRITE;
126 PyObject *parent_acl; /* The parent acl, so it won't run out on us */
132 PyObject *parent_entry; /* The parent entry, so it won't run out on us */
133 acl_permset_t permset;
138 /* Creation of a new ACL instance */
139 static PyObject* ACL_new(PyTypeObject* type, PyObject* args,
143 newacl = type->tp_alloc(type, 0);
146 ((ACL_Object*)newacl)->acl = NULL;
148 ((ACL_Object*)newacl)->entry_id = ACL_FIRST_ENTRY;
155 /* Initialization of a new ACL instance */
156 static int ACL_init(PyObject* obj, PyObject* args, PyObject *keywds) {
157 ACL_Object* self = (ACL_Object*) obj;
159 static char *kwlist[] = { "file", "fd", "text", "acl", "filedef",
161 char *format = "|etisO!sH";
164 static char *kwlist[] = { "file", "fd", "text", "acl", "filedef", NULL };
165 char *format = "|etisO!s";
168 char *filedef = NULL;
171 ACL_Object* thesrc = NULL;
173 if(!PyTuple_Check(args) || PyTuple_Size(args) != 0 ||
174 (keywds != NULL && PyDict_Check(keywds) && PyDict_Size(keywds) > 1)) {
175 PyErr_SetString(PyExc_ValueError, "a max of one keyword argument"
179 if(!PyArg_ParseTupleAndKeywords(args, keywds, format, kwlist,
180 NULL, &file, &fd, &text, &ACL_Type,
188 /* Free the old acl_t without checking for error, we don't
190 if(self->acl != NULL)
194 self->acl = acl_get_file(file, ACL_TYPE_ACCESS);
195 else if(text != NULL)
196 self->acl = acl_from_text(text);
198 self->acl = acl_get_fd(fd);
199 else if(thesrc != NULL)
200 self->acl = acl_dup(thesrc->acl);
201 else if(filedef != NULL)
202 self->acl = acl_get_file(filedef, ACL_TYPE_DEFAULT);
204 else if(PyMapping_HasKeyString(keywds, kwlist[5]))
205 self->acl = acl_from_mode(mode);
208 self->acl = acl_init(0);
210 if(self->acl == NULL) {
211 PyErr_SetFromErrno(PyExc_IOError);
218 /* Standard type functions */
219 static void ACL_dealloc(PyObject* obj) {
220 ACL_Object *self = (ACL_Object*) obj;
221 PyObject *err_type, *err_value, *err_traceback;
222 int have_error = PyErr_Occurred() ? 1 : 0;
225 PyErr_Fetch(&err_type, &err_value, &err_traceback);
226 if(self->acl != NULL && acl_free(self->acl) != 0)
227 PyErr_WriteUnraisable(obj);
229 PyErr_Restore(err_type, err_value, err_traceback);
233 /* Converts the acl to a text format */
234 static PyObject* ACL_str(PyObject *obj) {
236 ACL_Object *self = (ACL_Object*) obj;
239 text = acl_to_text(self->acl, NULL);
241 return PyErr_SetFromErrno(PyExc_IOError);
243 ret = MyString_FromString(text);
244 if(acl_free(text) != 0) {
246 return PyErr_SetFromErrno(PyExc_IOError);
252 static char __to_any_text_doc__[] =
253 "to_any_text([prefix='', separator='n', options=0])\n"
254 "Convert the ACL to a custom text format.\n"
256 "This method encapsulates the ``acl_to_any_text()`` function.\n"
257 "It allows a customized text format to be generated for the ACL. See\n"
258 ":manpage:`acl_to_any_text(3)` for more details.\n"
260 ":param string prefix: if given, this string will be pre-pended to\n"
262 ":param string separator: a single character (defaults to '\\n'); this will"
263 " be used to separate the entries in the ACL\n"
264 ":param options: a bitwise combination of:\n\n"
265 " - :py:data:`TEXT_ABBREVIATE`: use 'u' instead of 'user', 'g' \n"
266 " instead of 'group', etc.\n"
267 " - :py:data:`TEXT_NUMERIC_IDS`: User and group IDs are included as\n"
268 " decimal numbers instead of names\n"
269 " - :py:data:`TEXT_SOME_EFFECTIVE`: Include comments denoting the\n"
270 " effective permissions when some are masked\n"
271 " - :py:data:`TEXT_ALL_EFFECTIVE`: Include comments after all ACL\n"
272 " entries affected by an ACL_MASK entry\n"
273 " - :py:data:`TEXT_SMART_INDENT`: Used in combination with the\n"
274 " _EFFECTIVE options, this will ensure that comments are aligned\n"
275 " to the fourth tab position (assuming one tab equals eight spaces)\n"
279 /* Converts the acl to a custom text format */
280 static PyObject* ACL_to_any_text(PyObject *obj, PyObject *args,
283 ACL_Object *self = (ACL_Object*) obj;
285 const char *arg_prefix = NULL;
286 char arg_separator = '\n';
288 static char *kwlist[] = {"prefix", "separator", "options", NULL};
290 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|sci", kwlist, &arg_prefix,
291 &arg_separator, &arg_options))
294 text = acl_to_any_text(self->acl, arg_prefix, arg_separator, arg_options);
296 return PyErr_SetFromErrno(PyExc_IOError);
298 ret = PyBytes_FromString(text);
299 if(acl_free(text) != 0) {
301 return PyErr_SetFromErrno(PyExc_IOError);
306 static char __check_doc__[] =
307 "Check the ACL validity.\n"
309 "This is a non-portable, Linux specific extension that allow more\n"
310 "information to be retrieved in case an ACL is not valid than via the\n"
311 ":py:func:`valid` method.\n"
313 "This method will return either False (the ACL is valid), or a tuple\n"
314 "with two elements. The first element is one of the following\n"
316 " - :py:data:`ACL_MULTI_ERROR`: The ACL contains multiple entries that\n"
317 " have a tag type that may occur at most once\n"
318 " - :py:data:`ACL_DUPLICATE_ERROR`: The ACL contains multiple \n"
319 " :py:data:`ACL_USER` or :py:data:`ACL_GROUP` entries with the\n"
321 " - :py:data:`ACL_MISS_ERROR`: A required entry is missing\n"
322 " - :py:data:`ACL_ENTRY_ERROR`: The ACL contains an invalid entry\n"
325 "The second element of the tuple is the index of the entry that is\n"
326 "invalid (in the same order as by iterating over the ACL entry)\n"
329 /* The acl_check method */
330 static PyObject* ACL_check(PyObject* obj, PyObject* args) {
331 ACL_Object *self = (ACL_Object*) obj;
335 if((result = acl_check(self->acl, &eindex)) == -1)
336 return PyErr_SetFromErrno(PyExc_IOError);
340 return Py_BuildValue("(ii)", result, eindex);
343 /* Implementation of the rich compare for ACLs */
344 static PyObject* ACL_richcompare(PyObject* o1, PyObject* o2, int op) {
345 ACL_Object *acl1, *acl2;
349 if(!PyObject_IsInstance(o2, (PyObject*)&ACL_Type)) {
354 PyErr_SetString(PyExc_TypeError, "can only compare to an ACL");
358 acl1 = (ACL_Object*)o1;
359 acl2 = (ACL_Object*)o2;
360 if((n=acl_cmp(acl1->acl, acl2->acl))==-1)
361 return PyErr_SetFromErrno(PyExc_IOError);
364 ret = n == 0 ? Py_True : Py_False;
367 ret = n == 1 ? Py_True : Py_False;
370 PyErr_SetString(PyExc_TypeError, "ACLs are not orderable");
377 static char __equiv_mode_doc__[] =
378 "Return the octal mode the ACL is equivalent to.\n"
380 "This is a non-portable, Linux specific extension that checks\n"
381 "if the ACL is a basic ACL and returns the corresponding mode.\n"
384 ":raise IOError: An IOerror exception will be raised if the ACL is\n"
385 " an extended ACL.\n"
388 /* The acl_equiv_mode method */
389 static PyObject* ACL_equiv_mode(PyObject* obj, PyObject* args) {
390 ACL_Object *self = (ACL_Object*) obj;
393 if(acl_equiv_mode(self->acl, &mode) == -1)
394 return PyErr_SetFromErrno(PyExc_IOError);
395 return PyInt_FromLong(mode);
400 /* Implementation of the compare for ACLs */
401 static int ACL_nocmp(PyObject* o1, PyObject* o2) {
403 PyErr_SetString(PyExc_TypeError, "cannot compare ACLs using cmp()");
409 static char __applyto_doc__[] =
410 "applyto(item[, flag=ACL_TYPE_ACCESS])\n"
411 "Apply the ACL to a file or filehandle.\n"
413 ":param item: either a filename or a file-like object or an integer;\n"
414 " this represents the filesystem object on which to act\n"
415 ":param flag: optional flag representing the type of ACL to set, either\n"
416 " :py:data:`ACL_TYPE_ACCESS` (default) or :py:data:`ACL_TYPE_DEFAULT`\n"
419 /* Applies the ACL to a file */
420 static PyObject* ACL_applyto(PyObject* obj, PyObject* args) {
421 ACL_Object *self = (ACL_Object*) obj;
423 acl_type_t type = ACL_TYPE_ACCESS;
427 if (!PyArg_ParseTuple(args, "O|I", &myarg, &type))
430 if(PyBytes_Check(myarg)) {
431 char *filename = PyBytes_AS_STRING(myarg);
432 nret = acl_set_file(filename, type, self->acl);
433 } else if (PyUnicode_Check(myarg)) {
435 PyUnicode_AsEncodedString(myarg,
436 Py_FileSystemDefaultEncoding, "strict");
439 const char *filename = PyBytes_AS_STRING(o);
440 nret = acl_set_file(filename, type, self->acl);
442 } else if((fd = PyObject_AsFileDescriptor(myarg)) != -1) {
443 nret = acl_set_fd(fd, self->acl);
445 PyErr_SetString(PyExc_TypeError, "argument 1 must be string, int,"
446 " or file-like object");
450 return PyErr_SetFromErrno(PyExc_IOError);
453 /* Return the result */
458 static char __valid_doc__[] =
459 "Test the ACL for validity.\n"
461 "This method tests the ACL to see if it is a valid ACL\n"
462 "in terms of the file-system. More precisely, it checks that:\n"
464 "The ACL contains exactly one entry with each of the\n"
465 ":py:data:`ACL_USER_OBJ`, :py:data:`ACL_GROUP_OBJ`, and \n"
466 ":py:data:`ACL_OTHER` tag types. Entries\n"
467 "with :py:data:`ACL_USER` and :py:data:`ACL_GROUP` tag types may\n"
468 "appear zero or more\n"
469 "times in an ACL. An ACL that contains entries of :py:data:`ACL_USER` or\n"
470 ":py:data:`ACL_GROUP` tag types must contain exactly one entry of the \n"
471 ":py:data:`ACL_MASK` tag type. If an ACL contains no entries of\n"
472 ":py:data:`ACL_USER` or :py:data:`ACL_GROUP` tag types, the\n"
473 ":py:data:`ACL_MASK` entry is optional.\n"
475 "All user ID qualifiers must be unique among all entries of\n"
476 "the :py:data:`ACL_USER` tag type, and all group IDs must be unique\n"
477 "among all entries of :py:data:`ACL_GROUP` tag type.\n"
479 "The method will return 1 for a valid ACL and 0 for an invalid one.\n"
480 "This has been chosen because the specification for\n"
481 ":manpage:`acl_valid(3)`\n"
482 "in the POSIX.1e standard documents only one possible value for errno\n"
483 "in case of an invalid ACL, so we can't differentiate between\n"
484 "classes of errors. Other suggestions are welcome.\n"
490 /* Checks the ACL for validity */
491 static PyObject* ACL_valid(PyObject* obj, PyObject* args) {
492 ACL_Object *self = (ACL_Object*) obj;
494 if(acl_valid(self->acl) == -1) {
501 #ifdef HAVE_ACL_COPY_EXT
502 static PyObject* ACL_get_state(PyObject *obj, PyObject* args) {
503 ACL_Object *self = (ACL_Object*) obj;
508 size = acl_size(self->acl);
510 return PyErr_SetFromErrno(PyExc_IOError);
512 if((ret = PyBytes_FromStringAndSize(NULL, size)) == NULL)
514 buf = PyBytes_AsString(ret);
516 if((nsize = acl_copy_ext(buf, self->acl, size)) == -1) {
518 return PyErr_SetFromErrno(PyExc_IOError);
524 static PyObject* ACL_set_state(PyObject *obj, PyObject* args) {
525 ACL_Object *self = (ACL_Object*) obj;
530 /* Parse the argument */
531 if (!PyArg_ParseTuple(args, "s#", &buf, &bufsize))
534 /* Try to import the external representation */
535 if((ptr = acl_copy_int(buf)) == NULL)
536 return PyErr_SetFromErrno(PyExc_IOError);
538 /* Free the old acl. Should we ignore errors here? */
539 if(self->acl != NULL) {
540 if(acl_free(self->acl) == -1)
541 return PyErr_SetFromErrno(PyExc_IOError);
546 /* Return the result */
554 /* tp_iter for the ACL type; since it can be iterated only
555 * destructively, the type is its iterator
557 static PyObject* ACL_iter(PyObject *obj) {
558 ACL_Object *self = (ACL_Object*)obj;
559 self->entry_id = ACL_FIRST_ENTRY;
564 /* the tp_iternext function for the ACL type */
565 static PyObject* ACL_iternext(PyObject *obj) {
566 ACL_Object *self = (ACL_Object*)obj;
567 acl_entry_t the_entry_t;
568 Entry_Object *the_entry_obj;
571 nerr = acl_get_entry(self->acl, self->entry_id, &the_entry_t);
572 self->entry_id = ACL_NEXT_ENTRY;
574 return PyErr_SetFromErrno(PyExc_IOError);
576 /* Docs says this is not needed */
577 /*PyErr_SetObject(PyExc_StopIteration, Py_None);*/
581 the_entry_obj = (Entry_Object*) PyType_GenericNew(&Entry_Type, NULL, NULL);
582 if(the_entry_obj == NULL)
585 the_entry_obj->entry = the_entry_t;
587 the_entry_obj->parent_acl = obj;
588 Py_INCREF(obj); /* For the reference we have in entry->parent */
590 return (PyObject*)the_entry_obj;
593 static char __ACL_delete_entry_doc__[] =
594 "delete_entry(entry)\n"
595 "Deletes an entry from the ACL.\n"
597 ".. note:: Only available with level 2.\n"
599 ":param entry: the Entry object which should be deleted; note that after\n"
600 " this function is called, that object is unusable any longer\n"
601 " and should be deleted\n"
604 /* Deletes an entry from the ACL */
605 static PyObject* ACL_delete_entry(PyObject *obj, PyObject *args) {
606 ACL_Object *self = (ACL_Object*)obj;
609 if (!PyArg_ParseTuple(args, "O!", &Entry_Type, &e))
612 if(acl_delete_entry(self->acl, e->entry) == -1)
613 return PyErr_SetFromErrno(PyExc_IOError);
615 /* Return the result */
620 static char __ACL_calc_mask_doc__[] =
621 "Compute the file group class mask.\n"
623 "The calc_mask() method calculates and sets the permissions \n"
624 "associated with the :py:data:`ACL_MASK` Entry of the ACL.\n"
625 "The value of the new permissions is the union of the permissions \n"
626 "granted by all entries of tag type :py:data:`ACL_GROUP`, \n"
627 ":py:data:`ACL_GROUP_OBJ`, or \n"
628 ":py:data:`ACL_USER`. If the ACL already contains an :py:data:`ACL_MASK`\n"
630 "permissions are overwritten; if it does not contain an \n"
631 ":py:data:`ACL_MASK` Entry, one is added.\n"
633 "The order of existing entries in the ACL is undefined after this \n"
637 /* Updates the mask entry in the ACL */
638 static PyObject* ACL_calc_mask(PyObject *obj, PyObject *args) {
639 ACL_Object *self = (ACL_Object*)obj;
641 if(acl_calc_mask(&self->acl) == -1)
642 return PyErr_SetFromErrno(PyExc_IOError);
644 /* Return the result */
649 static char __ACL_append_doc__[] =
651 "Append a new Entry to the ACL and return it.\n"
653 "This is a convenience function to create a new Entry \n"
654 "and append it to the ACL.\n"
655 "If a parameter of type Entry instance is given, the \n"
656 "entry will be a copy of that one (as if copied with \n"
657 ":py:func:`Entry.copy`), otherwise, the new entry will be empty.\n"
659 ":rtype: :py:class:`Entry`\n"
660 ":returns: the newly created entry\n"
663 /* Convenience method to create a new Entry */
664 static PyObject* ACL_append(PyObject *obj, PyObject *args) {
665 ACL_Object* self = (ACL_Object*) obj;
666 Entry_Object* newentry;
667 Entry_Object* oldentry = NULL;
670 newentry = (Entry_Object*)PyType_GenericNew(&Entry_Type, NULL, NULL);
671 if(newentry == NULL) {
675 if (!PyArg_ParseTuple(args, "|O!", &Entry_Type, &oldentry)) {
680 nret = acl_create_entry(&self->acl, &newentry->entry);
683 return PyErr_SetFromErrno(PyExc_IOError);
686 if(oldentry != NULL) {
687 nret = acl_copy_entry(newentry->entry, oldentry->entry);
690 return PyErr_SetFromErrno(PyExc_IOError);
694 newentry->parent_acl = obj;
697 return (PyObject*)newentry;
700 /***** Entry type *****/
710 /* Pre-declaring the function is more friendly to cpychecker, sigh. */
711 static int get_tag_qualifier(acl_entry_t entry, tag_qual *tq)
712 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
714 /* Helper function to get the tag and qualifier of an Entry at the
715 same time. This is "needed" because the acl_get_qualifier function
716 returns a pointer to different types, based on the tag value, and
717 thus it's not straightforward to get the right type.
719 It sets a Python exception if an error occurs, and returns -1 in
720 this case. If successful, the tag is set to the tag type, the
721 qualifier (if any) to either the uid or the gid entry in the
722 tag_qual structure, and the return value is 0.
724 static int get_tag_qualifier(acl_entry_t entry, tag_qual *tq) {
727 if(acl_get_tag_type(entry, &tq->tag) == -1) {
728 PyErr_SetFromErrno(PyExc_IOError);
731 if (tq->tag == ACL_USER || tq->tag == ACL_GROUP) {
732 if((p = acl_get_qualifier(entry)) == NULL) {
733 PyErr_SetFromErrno(PyExc_IOError);
736 if (tq->tag == ACL_USER) {
737 tq->uid = *(uid_t*)p;
739 tq->gid = *(gid_t*)p;
746 /* Creation of a new Entry instance */
747 static PyObject* Entry_new(PyTypeObject* type, PyObject* args,
751 newentry = PyType_GenericNew(type, args, keywds);
753 if(newentry != NULL) {
754 ((Entry_Object*)newentry)->entry = NULL;
755 ((Entry_Object*)newentry)->parent_acl = NULL;
761 /* Initialization of a new Entry instance */
762 static int Entry_init(PyObject* obj, PyObject* args, PyObject *keywds) {
763 Entry_Object* self = (Entry_Object*) obj;
764 ACL_Object* parent = NULL;
766 if (!PyArg_ParseTuple(args, "O!", &ACL_Type, &parent))
769 if(acl_create_entry(&parent->acl, &self->entry) == -1) {
770 PyErr_SetFromErrno(PyExc_IOError);
774 self->parent_acl = (PyObject*)parent;
780 /* Free the Entry instance */
781 static void Entry_dealloc(PyObject* obj) {
782 Entry_Object *self = (Entry_Object*) obj;
783 PyObject *err_type, *err_value, *err_traceback;
784 int have_error = PyErr_Occurred() ? 1 : 0;
787 PyErr_Fetch(&err_type, &err_value, &err_traceback);
788 if(self->parent_acl != NULL) {
789 Py_DECREF(self->parent_acl);
790 self->parent_acl = NULL;
793 PyErr_Restore(err_type, err_value, err_traceback);
797 /* Converts the entry to a text format */
798 static PyObject* Entry_str(PyObject *obj) {
799 PyObject *format, *kind;
800 Entry_Object *self = (Entry_Object*) obj;
803 if(get_tag_qualifier(self->entry, &tq) < 0) {
807 format = MyString_FromString("ACL entry for ");
811 case ACL_UNDEFINED_TAG:
812 kind = MyString_FromString("undefined type");
815 kind = MyString_FromString("the owner");
818 kind = MyString_FromString("the group");
821 kind = MyString_FromString("the others");
824 /* FIXME: here and in the group case, we're formatting with
825 unsigned, because there's no way to automatically determine
826 the signed-ness of the types; on Linux(glibc) they're
827 unsigned, so we'll go along with that */
828 kind = MyString_FromFormat("user with uid %u", tq.uid);
831 kind = MyString_FromFormat("group with gid %u", tq.gid);
834 kind = MyString_FromString("the mask");
837 kind = MyString_FromString("UNKNOWN_TAG_TYPE!");
844 MyString_ConcatAndDel(&format, kind);
848 /* Sets the tag type of the entry */
849 static int Entry_set_tag_type(PyObject* obj, PyObject* value, void* arg) {
850 Entry_Object *self = (Entry_Object*) obj;
853 PyErr_SetString(PyExc_TypeError,
854 "tag type deletion is not supported");
858 if(!PyInt_Check(value)) {
859 PyErr_SetString(PyExc_TypeError,
860 "tag type must be integer");
863 if(acl_set_tag_type(self->entry, (acl_tag_t)PyInt_AsLong(value)) == -1) {
864 PyErr_SetFromErrno(PyExc_IOError);
871 /* Returns the tag type of the entry */
872 static PyObject* Entry_get_tag_type(PyObject *obj, void* arg) {
873 Entry_Object *self = (Entry_Object*) obj;
876 if (self->entry == NULL) {
877 PyErr_SetString(PyExc_AttributeError, "entry attribute");
880 if(acl_get_tag_type(self->entry, &value) == -1) {
881 PyErr_SetFromErrno(PyExc_IOError);
885 return PyInt_FromLong(value);
888 /* Sets the qualifier (either uid_t or gid_t) for the entry,
889 * usable only if the tag type if ACL_USER or ACL_GROUP
891 static int Entry_set_qualifier(PyObject* obj, PyObject* value, void* arg) {
892 Entry_Object *self = (Entry_Object*) obj;
900 PyErr_SetString(PyExc_TypeError,
901 "qualifier deletion is not supported");
905 if(!PyInt_Check(value)) {
906 PyErr_SetString(PyExc_TypeError,
907 "qualifier must be integer");
910 if((uidgid = PyInt_AsLong(value)) == -1) {
911 if(PyErr_Occurred() != NULL) {
915 /* Due to how acl_set_qualifier takes its argument, we have to do
916 this ugly dance with two variables and a pointer that will
917 point to one of them. */
918 if(acl_get_tag_type(self->entry, &tag) == -1) {
919 PyErr_SetFromErrno(PyExc_IOError);
926 if((long)uid != uidgid) {
927 PyErr_SetString(PyExc_OverflowError, "cannot assign given qualifier");
934 if((long)gid != uidgid) {
935 PyErr_SetString(PyExc_OverflowError, "cannot assign given qualifier");
942 PyErr_SetString(PyExc_TypeError,
943 "can only set qualifiers on ACL_USER or ACL_GROUP entries");
946 if(acl_set_qualifier(self->entry, p) == -1) {
947 PyErr_SetFromErrno(PyExc_IOError);
954 /* Returns the qualifier of the entry */
955 static PyObject* Entry_get_qualifier(PyObject *obj, void* arg) {
956 Entry_Object *self = (Entry_Object*) obj;
960 if (self->entry == NULL) {
961 PyErr_SetString(PyExc_AttributeError, "entry attribute");
964 if(get_tag_qualifier(self->entry, &tq) < 0) {
967 if (tq.tag == ACL_USER) {
969 } else if (tq.tag == ACL_GROUP) {
972 PyErr_SetString(PyExc_TypeError,
973 "given entry doesn't have an user or"
977 return PyInt_FromLong(value);
980 /* Returns the parent ACL of the entry */
981 static PyObject* Entry_get_parent(PyObject *obj, void* arg) {
982 Entry_Object *self = (Entry_Object*) obj;
984 Py_INCREF(self->parent_acl);
985 return self->parent_acl;
988 /* Returns the a new Permset representing the permset of the entry
989 * FIXME: Should return a new reference to the same object, which
990 * should be created at init time!
992 static PyObject* Entry_get_permset(PyObject *obj, void* arg) {
993 Entry_Object *self = (Entry_Object*)obj;
997 p = Permset_new(&Permset_Type, NULL, NULL);
1000 ps = (Permset_Object*)p;
1001 if(acl_get_permset(self->entry, &ps->permset) == -1) {
1002 PyErr_SetFromErrno(PyExc_IOError);
1006 ps->parent_entry = obj;
1009 return (PyObject*)p;
1012 /* Sets the permset of the entry to the passed Permset */
1013 static int Entry_set_permset(PyObject* obj, PyObject* value, void* arg) {
1014 Entry_Object *self = (Entry_Object*)obj;
1017 if(!PyObject_IsInstance(value, (PyObject*)&Permset_Type)) {
1018 PyErr_SetString(PyExc_TypeError, "argument 1 must be posix1e.Permset");
1021 p = (Permset_Object*)value;
1022 if(acl_set_permset(self->entry, p->permset) == -1) {
1023 PyErr_SetFromErrno(PyExc_IOError);
1029 static char __Entry_copy_doc__[] =
1031 "Copies an ACL entry.\n"
1033 "This method sets all the parameters to those of another\n"
1034 "entry (either of the same ACL or belonging to another ACL).\n"
1036 ":param Entry src: instance of type Entry\n"
1039 /* Sets all the entry parameters to another entry */
1040 static PyObject* Entry_copy(PyObject *obj, PyObject *args) {
1041 Entry_Object *self = (Entry_Object*)obj;
1042 Entry_Object *other;
1044 if(!PyArg_ParseTuple(args, "O!", &Entry_Type, &other))
1047 if(acl_copy_entry(self->entry, other->entry) == -1)
1048 return PyErr_SetFromErrno(PyExc_IOError);
1054 /**** Permset type *****/
1056 /* Creation of a new Permset instance */
1057 static PyObject* Permset_new(PyTypeObject* type, PyObject* args,
1059 PyObject* newpermset;
1061 newpermset = PyType_GenericNew(type, args, keywds);
1063 if(newpermset != NULL) {
1064 ((Permset_Object*)newpermset)->permset = NULL;
1065 ((Permset_Object*)newpermset)->parent_entry = NULL;
1071 /* Initialization of a new Permset instance */
1072 static int Permset_init(PyObject* obj, PyObject* args, PyObject *keywds) {
1073 Permset_Object* self = (Permset_Object*) obj;
1074 Entry_Object* parent = NULL;
1076 if (!PyArg_ParseTuple(args, "O!", &Entry_Type, &parent))
1079 if(acl_get_permset(parent->entry, &self->permset) == -1) {
1080 PyErr_SetFromErrno(PyExc_IOError);
1084 self->parent_entry = (PyObject*)parent;
1090 /* Free the Permset instance */
1091 static void Permset_dealloc(PyObject* obj) {
1092 Permset_Object *self = (Permset_Object*) obj;
1093 PyObject *err_type, *err_value, *err_traceback;
1094 int have_error = PyErr_Occurred() ? 1 : 0;
1097 PyErr_Fetch(&err_type, &err_value, &err_traceback);
1098 if(self->parent_entry != NULL) {
1099 Py_DECREF(self->parent_entry);
1100 self->parent_entry = NULL;
1103 PyErr_Restore(err_type, err_value, err_traceback);
1107 /* Permset string representation */
1108 static PyObject* Permset_str(PyObject *obj) {
1109 Permset_Object *self = (Permset_Object*) obj;
1112 pstr[0] = get_perm(self->permset, ACL_READ) ? 'r' : '-';
1113 pstr[1] = get_perm(self->permset, ACL_WRITE) ? 'w' : '-';
1114 pstr[2] = get_perm(self->permset, ACL_EXECUTE) ? 'x' : '-';
1115 return MyString_FromStringAndSize(pstr, 3);
1118 static char __Permset_clear_doc__[] =
1119 "Clears all permissions from the permission set.\n"
1122 /* Clears all permissions from the permset */
1123 static PyObject* Permset_clear(PyObject* obj, PyObject* args) {
1124 Permset_Object *self = (Permset_Object*) obj;
1126 if(acl_clear_perms(self->permset) == -1)
1127 return PyErr_SetFromErrno(PyExc_IOError);
1129 /* Return the result */
1134 static PyObject* Permset_get_right(PyObject *obj, void* arg) {
1135 Permset_Object *self = (Permset_Object*) obj;
1137 if(get_perm(self->permset, *(acl_perm_t*)arg)) {
1144 static int Permset_set_right(PyObject* obj, PyObject* value, void* arg) {
1145 Permset_Object *self = (Permset_Object*) obj;
1149 if(!PyInt_Check(value)) {
1150 PyErr_SetString(PyExc_ValueError, "invalid argument, an integer"
1154 on = PyInt_AsLong(value);
1156 nerr = acl_add_perm(self->permset, *(acl_perm_t*)arg);
1158 nerr = acl_delete_perm(self->permset, *(acl_perm_t*)arg);
1160 PyErr_SetFromErrno(PyExc_IOError);
1166 static char __Permset_add_doc__[] =
1168 "Add a permission to the permission set.\n"
1170 "This function adds the permission contained in \n"
1171 "the argument perm to the permission set. An attempt \n"
1172 "to add a permission that is already contained in the \n"
1173 "permission set is not considered an error.\n"
1175 ":param perm: a permission (:py:data:`ACL_WRITE`, :py:data:`ACL_READ`,\n"
1176 " :py:data:`ACL_EXECUTE`, ...)\n"
1177 ":raises IOError: in case the argument is not a valid descriptor\n"
1180 static PyObject* Permset_add(PyObject* obj, PyObject* args) {
1181 Permset_Object *self = (Permset_Object*) obj;
1184 if (!PyArg_ParseTuple(args, "i", &right))
1187 if(acl_add_perm(self->permset, (acl_perm_t) right) == -1)
1188 return PyErr_SetFromErrno(PyExc_IOError);
1190 /* Return the result */
1195 static char __Permset_delete_doc__[] =
1197 "Delete a permission from the permission set.\n"
1199 "This function deletes the permission contained in \n"
1200 "the argument perm from the permission set. An attempt \n"
1201 "to delete a permission that is not contained in the \n"
1202 "permission set is not considered an error.\n"
1204 ":param perm: a permission (:py:data:`ACL_WRITE`, :py:data:`ACL_READ`,\n"
1205 " :py:data:`ACL_EXECUTE`, ...)\n"
1206 ":raises IOError: in case the argument is not a valid descriptor\n"
1209 static PyObject* Permset_delete(PyObject* obj, PyObject* args) {
1210 Permset_Object *self = (Permset_Object*) obj;
1213 if (!PyArg_ParseTuple(args, "i", &right))
1216 if(acl_delete_perm(self->permset, (acl_perm_t) right) == -1)
1217 return PyErr_SetFromErrno(PyExc_IOError);
1219 /* Return the result */
1224 static char __Permset_test_doc__[] =
1226 "Test if a permission exists in the permission set.\n"
1228 "The test() function tests if the permission represented by\n"
1229 "the argument perm exists in the permission set.\n"
1231 ":param perm: a permission (:py:data:`ACL_WRITE`, :py:data:`ACL_READ`,\n"
1232 " :py:data:`ACL_EXECUTE`, ...)\n"
1234 ":raises IOError: in case the argument is not a valid descriptor\n"
1237 static PyObject* Permset_test(PyObject* obj, PyObject* args) {
1238 Permset_Object *self = (Permset_Object*) obj;
1242 if (!PyArg_ParseTuple(args, "i", &right))
1245 ret = get_perm(self->permset, (acl_perm_t) right);
1247 return PyErr_SetFromErrno(PyExc_IOError);
1258 static char __ACL_Type_doc__[] =
1259 "Type which represents a POSIX ACL\n"
1261 ".. note:: only one keyword parameter should be provided\n"
1263 ":param string file: creates an ACL representing\n"
1264 " the access ACL of the specified file\n"
1265 ":param string filedef: creates an ACL representing\n"
1266 " the default ACL of the given directory\n"
1267 ":param int fd: creates an ACL representing\n"
1268 " the access ACL of the given file descriptor\n"
1269 ":param string text: creates an ACL from a \n"
1270 " textual description\n"
1271 ":param ACL acl: creates a copy of an existing ACL instance\n"
1272 ":param int mode: creates an ACL from a numeric mode\n"
1273 " (e.g. mode=0644) (this is valid only when the C library\n"
1274 " provides the acl_from_mode call)\n"
1276 "If no parameters are passed, an empty ACL will be created; this\n"
1277 "makes sense only when your OS supports ACL modification\n"
1278 "(i.e. it implements full POSIX.1e support), otherwise the ACL won't\n"
1282 /* ACL type methods */
1283 static PyMethodDef ACL_methods[] = {
1284 {"applyto", ACL_applyto, METH_VARARGS, __applyto_doc__},
1285 {"valid", ACL_valid, METH_NOARGS, __valid_doc__},
1287 {"to_any_text", (PyCFunction)ACL_to_any_text, METH_VARARGS | METH_KEYWORDS,
1288 __to_any_text_doc__},
1289 {"check", ACL_check, METH_NOARGS, __check_doc__},
1290 {"equiv_mode", ACL_equiv_mode, METH_NOARGS, __equiv_mode_doc__},
1292 #ifdef HAVE_ACL_COPYEXT
1293 {"__getstate__", ACL_get_state, METH_NOARGS,
1294 "Dumps the ACL to an external format."},
1295 {"__setstate__", ACL_set_state, METH_VARARGS,
1296 "Loads the ACL from an external format."},
1299 {"delete_entry", ACL_delete_entry, METH_VARARGS, __ACL_delete_entry_doc__},
1300 {"calc_mask", ACL_calc_mask, METH_NOARGS, __ACL_calc_mask_doc__},
1301 {"append", ACL_append, METH_VARARGS, __ACL_append_doc__},
1303 {NULL, NULL, 0, NULL}
1307 /* The definition of the ACL Type */
1308 static PyTypeObject ACL_Type = {
1310 PyVarObject_HEAD_INIT(NULL, 0)
1312 PyObject_HEAD_INIT(NULL)
1318 ACL_dealloc, /* tp_dealloc */
1323 0, /* formerly tp_compare, in 3.0 deprecated, in
1326 ACL_nocmp, /* tp_compare */
1329 0, /* tp_as_number */
1330 0, /* tp_as_sequence */
1331 0, /* tp_as_mapping */
1334 ACL_str, /* tp_str */
1335 0, /* tp_getattro */
1336 0, /* tp_setattro */
1337 0, /* tp_as_buffer */
1338 Py_TPFLAGS_DEFAULT, /* tp_flags */
1339 __ACL_Type_doc__, /* tp_doc */
1340 0, /* tp_traverse */
1343 ACL_richcompare, /* tp_richcompare */
1345 0, /* tp_richcompare */
1347 0, /* tp_weaklistoffset */
1353 0, /* tp_iternext */
1355 ACL_methods, /* tp_methods */
1360 0, /* tp_descr_get */
1361 0, /* tp_descr_set */
1362 0, /* tp_dictoffset */
1363 ACL_init, /* tp_init */
1365 ACL_new, /* tp_new */
1370 /* Entry type methods */
1371 static PyMethodDef Entry_methods[] = {
1372 {"copy", Entry_copy, METH_VARARGS, __Entry_copy_doc__},
1373 {NULL, NULL, 0, NULL}
1376 static char __Entry_tagtype_doc__[] =
1377 "The tag type of the current entry\n"
1380 " - :py:data:`ACL_UNDEFINED_TAG`\n"
1381 " - :py:data:`ACL_USER_OBJ`\n"
1382 " - :py:data:`ACL_USER`\n"
1383 " - :py:data:`ACL_GROUP_OBJ`\n"
1384 " - :py:data:`ACL_GROUP`\n"
1385 " - :py:data:`ACL_MASK`\n"
1386 " - :py:data:`ACL_OTHER`\n"
1389 static char __Entry_qualifier_doc__[] =
1390 "The qualifier of the current entry\n"
1392 "If the tag type is :py:data:`ACL_USER`, this should be a user id.\n"
1393 "If the tag type if :py:data:`ACL_GROUP`, this should be a group id.\n"
1394 "Else it doesn't matter.\n"
1397 static char __Entry_parent_doc__[] =
1398 "The parent ACL of this entry\n"
1401 static char __Entry_permset_doc__[] =
1402 "The permission set of this ACL entry\n"
1406 static PyGetSetDef Entry_getsets[] = {
1407 {"tag_type", Entry_get_tag_type, Entry_set_tag_type,
1408 __Entry_tagtype_doc__},
1409 {"qualifier", Entry_get_qualifier, Entry_set_qualifier,
1410 __Entry_qualifier_doc__},
1411 {"parent", Entry_get_parent, NULL, __Entry_parent_doc__},
1412 {"permset", Entry_get_permset, Entry_set_permset, __Entry_permset_doc__},
1416 static char __Entry_Type_doc__[] =
1417 "Type which represents an entry in an ACL.\n"
1419 "The type exists only if the OS has full support for POSIX.1e\n"
1420 "Can be created either by:\n"
1422 " >>> e = posix1e.Entry(myACL) # this creates a new entry in the ACL\n"
1423 " >>> e = myACL.append() # another way for doing the same thing\n"
1427 " >>> for entry in myACL:\n"
1428 " ... print entry\n"
1430 "Note that the Entry keeps a reference to its ACL, so even if \n"
1431 "you delete the ACL, it won't be cleaned up and will continue to \n"
1432 "exist until its Entry(ies) will be deleted.\n"
1434 /* The definition of the Entry Type */
1435 static PyTypeObject Entry_Type = {
1437 PyVarObject_HEAD_INIT(NULL, 0)
1439 PyObject_HEAD_INIT(NULL)
1443 sizeof(Entry_Object),
1445 Entry_dealloc, /* tp_dealloc */
1451 0, /* tp_as_number */
1452 0, /* tp_as_sequence */
1453 0, /* tp_as_mapping */
1456 Entry_str, /* tp_str */
1457 0, /* tp_getattro */
1458 0, /* tp_setattro */
1459 0, /* tp_as_buffer */
1460 Py_TPFLAGS_DEFAULT, /* tp_flags */
1461 __Entry_Type_doc__, /* tp_doc */
1462 0, /* tp_traverse */
1464 0, /* tp_richcompare */
1465 0, /* tp_weaklistoffset */
1467 0, /* tp_iternext */
1468 Entry_methods, /* tp_methods */
1470 Entry_getsets, /* tp_getset */
1473 0, /* tp_descr_get */
1474 0, /* tp_descr_set */
1475 0, /* tp_dictoffset */
1476 Entry_init, /* tp_init */
1478 Entry_new, /* tp_new */
1481 /* Permset type methods */
1482 static PyMethodDef Permset_methods[] = {
1483 {"clear", Permset_clear, METH_NOARGS, __Permset_clear_doc__, },
1484 {"add", Permset_add, METH_VARARGS, __Permset_add_doc__, },
1485 {"delete", Permset_delete, METH_VARARGS, __Permset_delete_doc__, },
1486 {"test", Permset_test, METH_VARARGS, __Permset_test_doc__, },
1487 {NULL, NULL, 0, NULL}
1490 static char __Permset_execute_doc__[] =
1491 "Execute permission property\n"
1493 "This is a convenience method of retrieving and setting the execute\n"
1494 "permission in the permission set; the \n"
1495 "same effect can be achieved using the functions\n"
1496 "add(), test(), delete(), and those can take any \n"
1497 "permission defined by your platform.\n"
1500 static char __Permset_read_doc__[] =
1501 "Read permission property\n"
1503 "This is a convenience method of retrieving and setting the read\n"
1504 "permission in the permission set; the \n"
1505 "same effect can be achieved using the functions\n"
1506 "add(), test(), delete(), and those can take any \n"
1507 "permission defined by your platform.\n"
1510 static char __Permset_write_doc__[] =
1511 "Write permission property\n"
1513 "This is a convenience method of retrieving and setting the write\n"
1514 "permission in the permission set; the \n"
1515 "same effect can be achieved using the functions\n"
1516 "add(), test(), delete(), and those can take any \n"
1517 "permission defined by your platform.\n"
1520 /* Permset getset */
1521 static PyGetSetDef Permset_getsets[] = {
1522 {"execute", Permset_get_right, Permset_set_right,
1523 __Permset_execute_doc__, &holder_ACL_EXECUTE},
1524 {"read", Permset_get_right, Permset_set_right,
1525 __Permset_read_doc__, &holder_ACL_READ},
1526 {"write", Permset_get_right, Permset_set_right,
1527 __Permset_write_doc__, &holder_ACL_WRITE},
1531 static char __Permset_Type_doc__[] =
1532 "Type which represents the permission set in an ACL entry\n"
1534 "The type exists only if the OS has full support for POSIX.1e\n"
1535 "Can be retrieved either by:\n\n"
1536 ">>> perms = myEntry.permset\n"
1539 ">>> perms = posix1e.Permset(myEntry)\n"
1541 "Note that the Permset keeps a reference to its Entry, so even if \n"
1542 "you delete the entry, it won't be cleaned up and will continue to \n"
1543 "exist until its Permset will be deleted.\n"
1546 /* The definition of the Permset Type */
1547 static PyTypeObject Permset_Type = {
1549 PyVarObject_HEAD_INIT(NULL, 0)
1551 PyObject_HEAD_INIT(NULL)
1555 sizeof(Permset_Object),
1557 Permset_dealloc, /* tp_dealloc */
1563 0, /* tp_as_number */
1564 0, /* tp_as_sequence */
1565 0, /* tp_as_mapping */
1568 Permset_str, /* tp_str */
1569 0, /* tp_getattro */
1570 0, /* tp_setattro */
1571 0, /* tp_as_buffer */
1572 Py_TPFLAGS_DEFAULT, /* tp_flags */
1573 __Permset_Type_doc__,/* tp_doc */
1574 0, /* tp_traverse */
1576 0, /* tp_richcompare */
1577 0, /* tp_weaklistoffset */
1579 0, /* tp_iternext */
1580 Permset_methods, /* tp_methods */
1582 Permset_getsets, /* tp_getset */
1585 0, /* tp_descr_get */
1586 0, /* tp_descr_set */
1587 0, /* tp_dictoffset */
1588 Permset_init, /* tp_init */
1590 Permset_new, /* tp_new */
1595 /* Module methods */
1597 static char __deletedef_doc__[] =
1598 "delete_default(path)\n"
1599 "Delete the default ACL from a directory.\n"
1601 "This function deletes the default ACL associated with\n"
1602 "a directory (the ACL which will be ANDed with the mode\n"
1603 "parameter to the open, creat functions).\n"
1605 ":param string path: the directory whose default ACL should be deleted\n"
1608 /* Deletes the default ACL from a directory */
1609 static PyObject* aclmodule_delete_default(PyObject* obj, PyObject* args) {
1612 /* Parse the arguments */
1613 if (!PyArg_ParseTuple(args, "et", NULL, &filename))
1616 if(acl_delete_def_file(filename) == -1) {
1617 return PyErr_SetFromErrno(PyExc_IOError);
1620 /* Return the result */
1626 static char __has_extended_doc__[] =
1627 "has_extended(item)\n"
1628 "Check if a file or file handle has an extended ACL.\n"
1630 ":param item: either a file name or a file-like object or an integer;\n"
1631 " it represents the file-system object on which to act\n"
1634 /* Check for extended ACL a file or fd */
1635 static PyObject* aclmodule_has_extended(PyObject* obj, PyObject* args) {
1640 if (!PyArg_ParseTuple(args, "O", &myarg))
1643 if(PyBytes_Check(myarg)) {
1644 const char *filename = PyBytes_AS_STRING(myarg);
1645 nret = acl_extended_file(filename);
1646 } else if (PyUnicode_Check(myarg)) {
1648 PyUnicode_AsEncodedString(myarg,
1649 Py_FileSystemDefaultEncoding, "strict");
1652 const char *filename = PyBytes_AS_STRING(o);
1653 nret = acl_extended_file(filename);
1655 } else if((fd = PyObject_AsFileDescriptor(myarg)) != -1) {
1656 nret = acl_extended_fd(fd);
1658 PyErr_SetString(PyExc_TypeError, "argument 1 must be string, int,"
1659 " or file-like object");
1663 return PyErr_SetFromErrno(PyExc_IOError);
1666 /* Return the result */
1667 return PyBool_FromLong(nret);
1671 /* The module methods */
1672 static PyMethodDef aclmodule_methods[] = {
1673 {"delete_default", aclmodule_delete_default, METH_VARARGS,
1676 {"has_extended", aclmodule_has_extended, METH_VARARGS,
1677 __has_extended_doc__},
1679 {NULL, NULL, 0, NULL}
1682 static char __posix1e_doc__[] =
1683 "POSIX.1e ACLs manipulation\n"
1684 "==========================\n"
1686 "This module provides support for manipulating POSIX.1e ACLS\n"
1688 "Depending on the operating system support for POSIX.1e, \n"
1689 "the ACL type will have more or less capabilities:\n\n"
1690 " - level 1, only basic support, you can create\n"
1691 " ACLs from files and text descriptions;\n"
1692 " once created, the type is immutable\n"
1693 " - level 2, complete support, you can alter\n"
1694 " the ACL once it is created\n"
1696 "Also, in level 2, more types are available, corresponding\n"
1697 "to acl_entry_t (the Entry type), acl_permset_t (the Permset type).\n"
1699 "The existence of level 2 support and other extensions can be\n"
1700 "checked by the constants:\n\n"
1701 " - :py:data:`HAS_ACL_ENTRY` for level 2 and the Entry/Permset classes\n"
1702 " - :py:data:`HAS_ACL_FROM_MODE` for ``ACL(mode=...)`` usage\n"
1703 " - :py:data:`HAS_ACL_CHECK` for the :py:func:`ACL.check` function\n"
1704 " - :py:data:`HAS_EXTENDED_CHECK` for the module-level\n"
1705 " :py:func:`has_extended` function\n"
1706 " - :py:data:`HAS_EQUIV_MODE` for the :py:func:`ACL.equiv_mode` method\n"
1710 ">>> import posix1e\n"
1711 ">>> acl1 = posix1e.ACL(file=\"file.txt\") \n"
1717 ">>> b = posix1e.ACL(text=\"u::rx,g::-,o::-\")\n"
1723 ">>> b.applyto(\"file.txt\")\n"
1724 ">>> print posix1e.ACL(file=\"file.txt\")\n"
1730 ".. py:data:: ACL_USER\n\n"
1731 " Denotes a specific user entry in an ACL.\n"
1733 ".. py:data:: ACL_USER_OBJ\n\n"
1734 " Denotes the user owner entry in an ACL.\n"
1736 ".. py:data:: ACL_GROUP\n\n"
1737 " Denotes the a group entry in an ACL.\n"
1739 ".. py:data:: ACL_GROUP_OBJ\n\n"
1740 " Denotes the group owner entry in an ACL.\n"
1742 ".. py:data:: ACL_OTHER\n\n"
1743 " Denotes the 'others' entry in an ACL.\n"
1745 ".. py:data:: ACL_MASK\n\n"
1746 " Denotes the mask entry in an ACL, representing the maximum\n"
1747 " access granted other users, the owner group and other groups.\n"
1749 ".. py:data:: ACL_UNDEFINED_TAG\n\n"
1750 " An undefined tag in an ACL.\n"
1752 ".. py:data:: ACL_READ\n\n"
1753 " Read permission in a permission set.\n"
1755 ".. py:data:: ACL_WRITE\n\n"
1756 " Write permission in a permission set.\n"
1758 ".. py:data:: ACL_EXECUTE\n\n"
1759 " Execute permission in a permission set.\n"
1761 ".. py:data:: HAS_ACL_ENTRY\n\n"
1762 " denotes support for level 2 and the Entry/Permset classes\n"
1764 ".. py:data:: HAS_ACL_FROM_MODE\n\n"
1765 " denotes support for building an ACL from an octal mode\n"
1767 ".. py:data:: HAS_ACL_CHECK\n\n"
1768 " denotes support for extended checks of an ACL's validity\n"
1770 ".. py:data:: HAS_EXTENDED_CHECK\n\n"
1771 " denotes support for checking whether an ACL is basic or extended\n"
1773 ".. py:data:: HAS_EQUIV_MODE\n\n"
1774 " denotes support for the equiv_mode function\n"
1780 static struct PyModuleDef posix1emodule = {
1781 PyModuleDef_HEAD_INIT,
1788 #define INITERROR return NULL
1791 PyInit_posix1e(void)
1794 #define INITERROR return
1796 void initposix1e(void)
1801 Py_TYPE(&ACL_Type) = &PyType_Type;
1802 if(PyType_Ready(&ACL_Type) < 0)
1806 Py_TYPE(&Entry_Type) = &PyType_Type;
1807 if(PyType_Ready(&Entry_Type) < 0)
1810 Py_TYPE(&Permset_Type) = &PyType_Type;
1811 if(PyType_Ready(&Permset_Type) < 0)
1816 m = PyModule_Create(&posix1emodule);
1818 m = Py_InitModule3("posix1e", aclmodule_methods, __posix1e_doc__);
1823 d = PyModule_GetDict(m);
1827 Py_INCREF(&ACL_Type);
1828 if (PyDict_SetItemString(d, "ACL",
1829 (PyObject *) &ACL_Type) < 0)
1832 /* 23.3.6 acl_type_t values */
1833 PyModule_AddIntConstant(m, "ACL_TYPE_ACCESS", ACL_TYPE_ACCESS);
1834 PyModule_AddIntConstant(m, "ACL_TYPE_DEFAULT", ACL_TYPE_DEFAULT);
1838 Py_INCREF(&Entry_Type);
1839 if (PyDict_SetItemString(d, "Entry",
1840 (PyObject *) &Entry_Type) < 0)
1843 Py_INCREF(&Permset_Type);
1844 if (PyDict_SetItemString(d, "Permset",
1845 (PyObject *) &Permset_Type) < 0)
1848 /* 23.2.2 acl_perm_t values */
1849 PyModule_AddIntConstant(m, "ACL_READ", ACL_READ);
1850 PyModule_AddIntConstant(m, "ACL_WRITE", ACL_WRITE);
1851 PyModule_AddIntConstant(m, "ACL_EXECUTE", ACL_EXECUTE);
1853 /* 23.2.5 acl_tag_t values */
1854 PyModule_AddIntConstant(m, "ACL_UNDEFINED_TAG", ACL_UNDEFINED_TAG);
1855 PyModule_AddIntConstant(m, "ACL_USER_OBJ", ACL_USER_OBJ);
1856 PyModule_AddIntConstant(m, "ACL_USER", ACL_USER);
1857 PyModule_AddIntConstant(m, "ACL_GROUP_OBJ", ACL_GROUP_OBJ);
1858 PyModule_AddIntConstant(m, "ACL_GROUP", ACL_GROUP);
1859 PyModule_AddIntConstant(m, "ACL_MASK", ACL_MASK);
1860 PyModule_AddIntConstant(m, "ACL_OTHER", ACL_OTHER);
1862 /* Document extended functionality via easy-to-use constants */
1863 PyModule_AddIntConstant(m, "HAS_ACL_ENTRY", 1);
1865 PyModule_AddIntConstant(m, "HAS_ACL_ENTRY", 0);
1869 /* Linux libacl specific acl_to_any_text constants */
1870 PyModule_AddIntConstant(m, "TEXT_ABBREVIATE", TEXT_ABBREVIATE);
1871 PyModule_AddIntConstant(m, "TEXT_NUMERIC_IDS", TEXT_NUMERIC_IDS);
1872 PyModule_AddIntConstant(m, "TEXT_SOME_EFFECTIVE", TEXT_SOME_EFFECTIVE);
1873 PyModule_AddIntConstant(m, "TEXT_ALL_EFFECTIVE", TEXT_ALL_EFFECTIVE);
1874 PyModule_AddIntConstant(m, "TEXT_SMART_INDENT", TEXT_SMART_INDENT);
1876 /* Linux libacl specific acl_check constants */
1877 PyModule_AddIntConstant(m, "ACL_MULTI_ERROR", ACL_MULTI_ERROR);
1878 PyModule_AddIntConstant(m, "ACL_DUPLICATE_ERROR", ACL_DUPLICATE_ERROR);
1879 PyModule_AddIntConstant(m, "ACL_MISS_ERROR", ACL_MISS_ERROR);
1880 PyModule_AddIntConstant(m, "ACL_ENTRY_ERROR", ACL_ENTRY_ERROR);
1882 #define LINUX_EXT_VAL 1
1884 #define LINUX_EXT_VAL 0
1886 /* declare the Linux extensions */
1887 PyModule_AddIntConstant(m, "HAS_ACL_FROM_MODE", LINUX_EXT_VAL);
1888 PyModule_AddIntConstant(m, "HAS_ACL_CHECK", LINUX_EXT_VAL);
1889 PyModule_AddIntConstant(m, "HAS_EXTENDED_CHECK", LINUX_EXT_VAL);
1890 PyModule_AddIntConstant(m, "HAS_EQUIV_MODE", LINUX_EXT_VAL);