2 posix1e - a python module exposing the posix acl functions
4 Copyright (C) 2002-2009, 2012, 2014 Iustin Pop <iusty@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 static PyTypeObject ACL_Type;
71 static PyObject* ACL_applyto(PyObject* obj, PyObject* args);
72 static PyObject* ACL_valid(PyObject* obj, PyObject* args);
74 #ifdef HAVE_ACL_COPY_EXT
75 static PyObject* ACL_get_state(PyObject *obj, PyObject* args);
76 static PyObject* ACL_set_state(PyObject *obj, PyObject* args);
80 static PyTypeObject Entry_Type;
81 static PyTypeObject Permset_Type;
82 static PyObject* Permset_new(PyTypeObject* type, PyObject* args,
86 static acl_perm_t holder_ACL_EXECUTE = ACL_EXECUTE;
87 static acl_perm_t holder_ACL_READ = ACL_READ;
88 static acl_perm_t holder_ACL_WRITE = ACL_WRITE;
102 PyObject *parent_acl; /* The parent acl, so it won't run out on us */
108 PyObject *parent_entry; /* The parent entry, so it won't run out on us */
109 acl_permset_t permset;
114 /* Creation of a new ACL instance */
115 static PyObject* ACL_new(PyTypeObject* type, PyObject* args,
119 newacl = type->tp_alloc(type, 0);
122 ((ACL_Object*)newacl)->acl = NULL;
124 ((ACL_Object*)newacl)->entry_id = ACL_FIRST_ENTRY;
131 /* Initialization of a new ACL instance */
132 static int ACL_init(PyObject* obj, PyObject* args, PyObject *keywds) {
133 ACL_Object* self = (ACL_Object*) obj;
135 static char *kwlist[] = { "file", "fd", "text", "acl", "filedef",
137 char *format = "|etisO!sH";
140 static char *kwlist[] = { "file", "fd", "text", "acl", "filedef", NULL };
141 char *format = "|etisO!s";
144 char *filedef = NULL;
147 ACL_Object* thesrc = NULL;
149 if(!PyTuple_Check(args) || PyTuple_Size(args) != 0 ||
150 (keywds != NULL && PyDict_Check(keywds) && PyDict_Size(keywds) > 1)) {
151 PyErr_SetString(PyExc_ValueError, "a max of one keyword argument"
155 if(!PyArg_ParseTupleAndKeywords(args, keywds, format, kwlist,
156 NULL, &file, &fd, &text, &ACL_Type,
164 /* Free the old acl_t without checking for error, we don't
166 if(self->acl != NULL)
170 self->acl = acl_get_file(file, ACL_TYPE_ACCESS);
171 else if(text != NULL)
172 self->acl = acl_from_text(text);
174 self->acl = acl_get_fd(fd);
175 else if(thesrc != NULL)
176 self->acl = acl_dup(thesrc->acl);
177 else if(filedef != NULL)
178 self->acl = acl_get_file(filedef, ACL_TYPE_DEFAULT);
180 else if(PyMapping_HasKeyString(keywds, kwlist[5]))
181 self->acl = acl_from_mode(mode);
184 self->acl = acl_init(0);
186 if(self->acl == NULL) {
187 PyErr_SetFromErrno(PyExc_IOError);
194 /* Standard type functions */
195 static void ACL_dealloc(PyObject* obj) {
196 ACL_Object *self = (ACL_Object*) obj;
197 PyObject *err_type, *err_value, *err_traceback;
198 int have_error = PyErr_Occurred() ? 1 : 0;
201 PyErr_Fetch(&err_type, &err_value, &err_traceback);
202 if(self->acl != NULL && acl_free(self->acl) != 0)
203 PyErr_WriteUnraisable(obj);
205 PyErr_Restore(err_type, err_value, err_traceback);
209 /* Converts the acl to a text format */
210 static PyObject* ACL_str(PyObject *obj) {
212 ACL_Object *self = (ACL_Object*) obj;
215 text = acl_to_text(self->acl, NULL);
217 return PyErr_SetFromErrno(PyExc_IOError);
219 ret = MyString_FromString(text);
220 if(acl_free(text) != 0) {
222 return PyErr_SetFromErrno(PyExc_IOError);
228 static char __to_any_text_doc__[] =
229 "to_any_text([prefix='', separator='n', options=0])\n"
230 "Convert the ACL to a custom text format.\n"
232 "This method encapsulates the ``acl_to_any_text()`` function.\n"
233 "It allows a customized text format to be generated for the ACL. See\n"
234 ":manpage:`acl_to_any_text(3)` for more details.\n"
236 ":param string prefix: if given, this string will be pre-pended to\n"
238 ":param string separator: a single character (defaults to '\\n'); this will"
239 " be used to separate the entries in the ACL\n"
240 ":param options: a bitwise combination of:\n\n"
241 " - :py:data:`TEXT_ABBREVIATE`: use 'u' instead of 'user', 'g' \n"
242 " instead of 'group', etc.\n"
243 " - :py:data:`TEXT_NUMERIC_IDS`: User and group IDs are included as\n"
244 " decimal numbers instead of names\n"
245 " - :py:data:`TEXT_SOME_EFFECTIVE`: Include comments denoting the\n"
246 " effective permissions when some are masked\n"
247 " - :py:data:`TEXT_ALL_EFFECTIVE`: Include comments after all ACL\n"
248 " entries affected by an ACL_MASK entry\n"
249 " - :py:data:`TEXT_SMART_INDENT`: Used in combination with the\n"
250 " _EFFECTIVE options, this will ensure that comments are aligned\n"
251 " to the fourth tab position (assuming one tab equals eight spaces)\n"
255 /* Converts the acl to a custom text format */
256 static PyObject* ACL_to_any_text(PyObject *obj, PyObject *args,
259 ACL_Object *self = (ACL_Object*) obj;
261 const char *arg_prefix = NULL;
262 char arg_separator = '\n';
264 static char *kwlist[] = {"prefix", "separator", "options", NULL};
266 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|sci", kwlist, &arg_prefix,
267 &arg_separator, &arg_options))
270 text = acl_to_any_text(self->acl, arg_prefix, arg_separator, arg_options);
272 return PyErr_SetFromErrno(PyExc_IOError);
274 ret = PyBytes_FromString(text);
275 if(acl_free(text) != 0) {
277 return PyErr_SetFromErrno(PyExc_IOError);
282 static char __check_doc__[] =
283 "Check the ACL validity.\n"
285 "This is a non-portable, Linux specific extension that allow more\n"
286 "information to be retrieved in case an ACL is not valid than via the\n"
287 ":py:func:`valid` method.\n"
289 "This method will return either False (the ACL is valid), or a tuple\n"
290 "with two elements. The first element is one of the following\n"
292 " - :py:data:`ACL_MULTI_ERROR`: The ACL contains multiple entries that\n"
293 " have a tag type that may occur at most once\n"
294 " - :py:data:`ACL_DUPLICATE_ERROR`: The ACL contains multiple \n"
295 " :py:data:`ACL_USER` or :py:data:`ACL_GROUP` entries with the\n"
297 " - :py:data:`ACL_MISS_ERROR`: A required entry is missing\n"
298 " - :py:data:`ACL_ENTRY_ERROR`: The ACL contains an invalid entry\n"
301 "The second element of the tuple is the index of the entry that is\n"
302 "invalid (in the same order as by iterating over the ACL entry)\n"
305 /* The acl_check method */
306 static PyObject* ACL_check(PyObject* obj, PyObject* args) {
307 ACL_Object *self = (ACL_Object*) obj;
311 if((result = acl_check(self->acl, &eindex)) == -1)
312 return PyErr_SetFromErrno(PyExc_IOError);
316 return Py_BuildValue("(ii)", result, eindex);
319 /* Implementation of the rich compare for ACLs */
320 static PyObject* ACL_richcompare(PyObject* o1, PyObject* o2, int op) {
321 ACL_Object *acl1, *acl2;
325 if(!PyObject_IsInstance(o2, (PyObject*)&ACL_Type)) {
330 PyErr_SetString(PyExc_TypeError, "can only compare to an ACL");
334 acl1 = (ACL_Object*)o1;
335 acl2 = (ACL_Object*)o2;
336 if((n=acl_cmp(acl1->acl, acl2->acl))==-1)
337 return PyErr_SetFromErrno(PyExc_IOError);
340 ret = n == 0 ? Py_True : Py_False;
343 ret = n == 1 ? Py_True : Py_False;
346 ret = Py_NotImplemented;
352 static char __equiv_mode_doc__[] =
353 "Return the octal mode the ACL is equivalent to.\n"
355 "This is a non-portable, Linux specific extension that checks\n"
356 "if the ACL is a basic ACL and returns the corresponding mode.\n"
359 ":raise IOError: An IOerror exception will be raised if the ACL is\n"
360 " an extended ACL.\n"
363 /* The acl_equiv_mode method */
364 static PyObject* ACL_equiv_mode(PyObject* obj, PyObject* args) {
365 ACL_Object *self = (ACL_Object*) obj;
368 if(acl_equiv_mode(self->acl, &mode) == -1)
369 return PyErr_SetFromErrno(PyExc_IOError);
370 return PyInt_FromLong(mode);
374 /* Implementation of the compare for ACLs */
375 static int ACL_nocmp(PyObject* o1, PyObject* o2) {
377 PyErr_SetString(PyExc_TypeError, "cannot compare ACLs using cmp()");
382 static char __applyto_doc__[] =
383 "applyto(item[, flag=ACL_TYPE_ACCESS])\n"
384 "Apply the ACL to a file or filehandle.\n"
386 ":param item: either a filename or a file-like object or an integer;\n"
387 " this represents the filesystem object on which to act\n"
388 ":param flag: optional flag representing the type of ACL to set, either\n"
389 " :py:data:`ACL_TYPE_ACCESS` (default) or :py:data:`ACL_TYPE_DEFAULT`\n"
392 /* Applies the ACL to a file */
393 static PyObject* ACL_applyto(PyObject* obj, PyObject* args) {
394 ACL_Object *self = (ACL_Object*) obj;
396 acl_type_t type = ACL_TYPE_ACCESS;
400 if (!PyArg_ParseTuple(args, "O|I", &myarg, &type))
403 if(PyBytes_Check(myarg)) {
404 char *filename = PyBytes_AS_STRING(myarg);
405 nret = acl_set_file(filename, type, self->acl);
406 } else if (PyUnicode_Check(myarg)) {
408 PyUnicode_AsEncodedString(myarg,
409 Py_FileSystemDefaultEncoding, "strict");
412 const char *filename = PyBytes_AS_STRING(o);
413 nret = acl_set_file(filename, type, self->acl);
415 } else if((fd = PyObject_AsFileDescriptor(myarg)) != -1) {
416 nret = acl_set_fd(fd, self->acl);
418 PyErr_SetString(PyExc_TypeError, "argument 1 must be string, int,"
419 " or file-like object");
423 return PyErr_SetFromErrno(PyExc_IOError);
426 /* Return the result */
431 static char __valid_doc__[] =
432 "Test the ACL for validity.\n"
434 "This method tests the ACL to see if it is a valid ACL\n"
435 "in terms of the file-system. More precisely, it checks that:\n"
437 "The ACL contains exactly one entry with each of the\n"
438 ":py:data:`ACL_USER_OBJ`, :py:data:`ACL_GROUP_OBJ`, and \n"
439 ":py:data:`ACL_OTHER` tag types. Entries\n"
440 "with :py:data:`ACL_USER` and :py:data:`ACL_GROUP` tag types may\n"
441 "appear zero or more\n"
442 "times in an ACL. An ACL that contains entries of :py:data:`ACL_USER` or\n"
443 ":py:data:`ACL_GROUP` tag types must contain exactly one entry of the \n"
444 ":py:data:`ACL_MASK` tag type. If an ACL contains no entries of\n"
445 ":py:data:`ACL_USER` or :py:data:`ACL_GROUP` tag types, the\n"
446 ":py:data:`ACL_MASK` entry is optional.\n"
448 "All user ID qualifiers must be unique among all entries of\n"
449 "the :py:data:`ACL_USER` tag type, and all group IDs must be unique\n"
450 "among all entries of :py:data:`ACL_GROUP` tag type.\n"
452 "The method will return 1 for a valid ACL and 0 for an invalid one.\n"
453 "This has been chosen because the specification for\n"
454 ":manpage:`acl_valid(3)`\n"
455 "in the POSIX.1e standard documents only one possible value for errno\n"
456 "in case of an invalid ACL, so we can't differentiate between\n"
457 "classes of errors. Other suggestions are welcome.\n"
463 /* Checks the ACL for validity */
464 static PyObject* ACL_valid(PyObject* obj, PyObject* args) {
465 ACL_Object *self = (ACL_Object*) obj;
467 if(acl_valid(self->acl) == -1) {
474 #ifdef HAVE_ACL_COPY_EXT
475 static PyObject* ACL_get_state(PyObject *obj, PyObject* args) {
476 ACL_Object *self = (ACL_Object*) obj;
481 size = acl_size(self->acl);
483 return PyErr_SetFromErrno(PyExc_IOError);
485 if((ret = PyBytes_FromStringAndSize(NULL, size)) == NULL)
487 buf = PyBytes_AsString(ret);
489 if((nsize = acl_copy_ext(buf, self->acl, size)) == -1) {
491 return PyErr_SetFromErrno(PyExc_IOError);
497 static PyObject* ACL_set_state(PyObject *obj, PyObject* args) {
498 ACL_Object *self = (ACL_Object*) obj;
503 /* Parse the argument */
504 if (!PyArg_ParseTuple(args, "s#", &buf, &bufsize))
507 /* Try to import the external representation */
508 if((ptr = acl_copy_int(buf)) == NULL)
509 return PyErr_SetFromErrno(PyExc_IOError);
511 /* Free the old acl. Should we ignore errors here? */
512 if(self->acl != NULL) {
513 if(acl_free(self->acl) == -1)
514 return PyErr_SetFromErrno(PyExc_IOError);
519 /* Return the result */
527 /* tp_iter for the ACL type; since it can be iterated only
528 * destructively, the type is its iterator
530 static PyObject* ACL_iter(PyObject *obj) {
531 ACL_Object *self = (ACL_Object*)obj;
532 self->entry_id = ACL_FIRST_ENTRY;
537 /* the tp_iternext function for the ACL type */
538 static PyObject* ACL_iternext(PyObject *obj) {
539 ACL_Object *self = (ACL_Object*)obj;
540 acl_entry_t the_entry_t;
541 Entry_Object *the_entry_obj;
544 nerr = acl_get_entry(self->acl, self->entry_id, &the_entry_t);
545 self->entry_id = ACL_NEXT_ENTRY;
547 return PyErr_SetFromErrno(PyExc_IOError);
549 /* Docs says this is not needed */
550 /*PyErr_SetObject(PyExc_StopIteration, Py_None);*/
554 the_entry_obj = (Entry_Object*) PyType_GenericNew(&Entry_Type, NULL, NULL);
555 if(the_entry_obj == NULL)
558 the_entry_obj->entry = the_entry_t;
560 the_entry_obj->parent_acl = obj;
561 Py_INCREF(obj); /* For the reference we have in entry->parent */
563 return (PyObject*)the_entry_obj;
566 static char __ACL_delete_entry_doc__[] =
567 "delete_entry(entry)\n"
568 "Deletes an entry from the ACL.\n"
570 ".. note:: Only available with level 2.\n"
572 ":param entry: the Entry object which should be deleted; note that after\n"
573 " this function is called, that object is unusable any longer\n"
574 " and should be deleted\n"
577 /* Deletes an entry from the ACL */
578 static PyObject* ACL_delete_entry(PyObject *obj, PyObject *args) {
579 ACL_Object *self = (ACL_Object*)obj;
582 if (!PyArg_ParseTuple(args, "O!", &Entry_Type, &e))
585 if(acl_delete_entry(self->acl, e->entry) == -1)
586 return PyErr_SetFromErrno(PyExc_IOError);
588 /* Return the result */
593 static char __ACL_calc_mask_doc__[] =
594 "Compute the file group class mask.\n"
596 "The calc_mask() method calculates and sets the permissions \n"
597 "associated with the :py:data:`ACL_MASK` Entry of the ACL.\n"
598 "The value of the new permissions is the union of the permissions \n"
599 "granted by all entries of tag type :py:data:`ACL_GROUP`, \n"
600 ":py:data:`ACL_GROUP_OBJ`, or \n"
601 ":py:data:`ACL_USER`. If the ACL already contains an :py:data:`ACL_MASK`\n"
603 "permissions are overwritten; if it does not contain an \n"
604 ":py:data:`ACL_MASK` Entry, one is added.\n"
606 "The order of existing entries in the ACL is undefined after this \n"
610 /* Updates the mask entry in the ACL */
611 static PyObject* ACL_calc_mask(PyObject *obj, PyObject *args) {
612 ACL_Object *self = (ACL_Object*)obj;
614 if(acl_calc_mask(&self->acl) == -1)
615 return PyErr_SetFromErrno(PyExc_IOError);
617 /* Return the result */
622 static char __ACL_append_doc__[] =
624 "Append a new Entry to the ACL and return it.\n"
626 "This is a convenience function to create a new Entry \n"
627 "and append it to the ACL.\n"
628 "If a parameter of type Entry instance is given, the \n"
629 "entry will be a copy of that one (as if copied with \n"
630 ":py:func:`Entry.copy`), otherwise, the new entry will be empty.\n"
632 ":rtype: :py:class:`Entry`\n"
633 ":returns: the newly created entry\n"
636 /* Convenience method to create a new Entry */
637 static PyObject* ACL_append(PyObject *obj, PyObject *args) {
638 ACL_Object* self = (ACL_Object*) obj;
639 Entry_Object* newentry;
640 Entry_Object* oldentry = NULL;
643 newentry = (Entry_Object*)PyType_GenericNew(&Entry_Type, NULL, NULL);
644 if(newentry == NULL) {
648 if (!PyArg_ParseTuple(args, "|O!", &Entry_Type, &oldentry)) {
653 nret = acl_create_entry(&self->acl, &newentry->entry);
656 return PyErr_SetFromErrno(PyExc_IOError);
659 if(oldentry != NULL) {
660 nret = acl_copy_entry(newentry->entry, oldentry->entry);
663 return PyErr_SetFromErrno(PyExc_IOError);
667 newentry->parent_acl = obj;
670 return (PyObject*)newentry;
673 /***** Entry type *****/
675 /* Creation of a new Entry instance */
676 static PyObject* Entry_new(PyTypeObject* type, PyObject* args,
680 newentry = PyType_GenericNew(type, args, keywds);
682 if(newentry != NULL) {
683 ((Entry_Object*)newentry)->entry = NULL;
684 ((Entry_Object*)newentry)->parent_acl = NULL;
690 /* Initialization of a new Entry instance */
691 static int Entry_init(PyObject* obj, PyObject* args, PyObject *keywds) {
692 Entry_Object* self = (Entry_Object*) obj;
693 ACL_Object* parent = NULL;
695 if (!PyArg_ParseTuple(args, "O!", &ACL_Type, &parent))
698 if(acl_create_entry(&parent->acl, &self->entry) == -1) {
699 PyErr_SetFromErrno(PyExc_IOError);
703 self->parent_acl = (PyObject*)parent;
709 /* Free the Entry instance */
710 static void Entry_dealloc(PyObject* obj) {
711 Entry_Object *self = (Entry_Object*) obj;
712 PyObject *err_type, *err_value, *err_traceback;
713 int have_error = PyErr_Occurred() ? 1 : 0;
716 PyErr_Fetch(&err_type, &err_value, &err_traceback);
717 if(self->parent_acl != NULL) {
718 Py_DECREF(self->parent_acl);
719 self->parent_acl = NULL;
722 PyErr_Restore(err_type, err_value, err_traceback);
726 /* Converts the entry to a text format */
727 static PyObject* Entry_str(PyObject *obj) {
731 PyObject *format, *kind;
732 Entry_Object *self = (Entry_Object*) obj;
734 if(acl_get_tag_type(self->entry, &tag) == -1) {
735 PyErr_SetFromErrno(PyExc_IOError);
738 if(tag == ACL_USER || tag == ACL_GROUP) {
739 if((p = acl_get_qualifier(self->entry)) == NULL) {
740 PyErr_SetFromErrno(PyExc_IOError);
743 qualifier = *(uid_t*)p;
749 format = MyString_FromString("ACL entry for ");
753 case ACL_UNDEFINED_TAG:
754 kind = MyString_FromString("undefined type");
757 kind = MyString_FromString("the owner");
760 kind = MyString_FromString("the group");
763 kind = MyString_FromString("the others");
766 kind = MyString_FromFormat("user with uid %d", qualifier);
769 kind = MyString_FromFormat("group with gid %d", qualifier);
772 kind = MyString_FromString("the mask");
775 kind = MyString_FromString("UNKNOWN_TAG_TYPE!");
782 MyString_ConcatAndDel(&format, kind);
786 /* Sets the tag type of the entry */
787 static int Entry_set_tag_type(PyObject* obj, PyObject* value, void* arg) {
788 Entry_Object *self = (Entry_Object*) obj;
791 PyErr_SetString(PyExc_TypeError,
792 "tag type deletion is not supported");
796 if(!PyInt_Check(value)) {
797 PyErr_SetString(PyExc_TypeError,
798 "tag type must be integer");
801 if(acl_set_tag_type(self->entry, (acl_tag_t)PyInt_AsLong(value)) == -1) {
802 PyErr_SetFromErrno(PyExc_IOError);
809 /* Returns the tag type of the entry */
810 static PyObject* Entry_get_tag_type(PyObject *obj, void* arg) {
811 Entry_Object *self = (Entry_Object*) obj;
814 if (self->entry == NULL) {
815 PyErr_SetString(PyExc_AttributeError, "entry attribute");
818 if(acl_get_tag_type(self->entry, &value) == -1) {
819 PyErr_SetFromErrno(PyExc_IOError);
823 return PyInt_FromLong(value);
826 /* Sets the qualifier (either uid_t or gid_t) for the entry,
827 * usable only if the tag type if ACL_USER or ACL_GROUP
829 static int Entry_set_qualifier(PyObject* obj, PyObject* value, void* arg) {
830 Entry_Object *self = (Entry_Object*) obj;
834 PyErr_SetString(PyExc_TypeError,
835 "qualifier deletion is not supported");
839 if(!PyInt_Check(value)) {
840 PyErr_SetString(PyExc_TypeError,
841 "qualifier must be integer");
844 if((uidgid = PyInt_AsLong(value)) == -1) {
845 if(PyErr_Occurred() != NULL) {
849 if(acl_set_qualifier(self->entry, (void*)&uidgid) == -1) {
850 PyErr_SetFromErrno(PyExc_IOError);
857 /* Returns the qualifier of the entry */
858 static PyObject* Entry_get_qualifier(PyObject *obj, void* arg) {
859 Entry_Object *self = (Entry_Object*) obj;
863 if (self->entry == NULL) {
864 PyErr_SetString(PyExc_AttributeError, "entry attribute");
867 if((p = acl_get_qualifier(self->entry)) == NULL) {
868 PyErr_SetFromErrno(PyExc_IOError);
874 return PyInt_FromLong(value);
877 /* Returns the parent ACL of the entry */
878 static PyObject* Entry_get_parent(PyObject *obj, void* arg) {
879 Entry_Object *self = (Entry_Object*) obj;
881 Py_INCREF(self->parent_acl);
882 return self->parent_acl;
885 /* Returns the a new Permset representing the permset of the entry
886 * FIXME: Should return a new reference to the same object, which
887 * should be created at init time!
889 static PyObject* Entry_get_permset(PyObject *obj, void* arg) {
890 Entry_Object *self = (Entry_Object*)obj;
894 p = Permset_new(&Permset_Type, NULL, NULL);
897 ps = (Permset_Object*)p;
898 if(acl_get_permset(self->entry, &ps->permset) == -1) {
899 PyErr_SetFromErrno(PyExc_IOError);
903 ps->parent_entry = obj;
909 /* Sets the permset of the entry to the passed Permset */
910 static int Entry_set_permset(PyObject* obj, PyObject* value, void* arg) {
911 Entry_Object *self = (Entry_Object*)obj;
914 if(!PyObject_IsInstance(value, (PyObject*)&Permset_Type)) {
915 PyErr_SetString(PyExc_TypeError, "argument 1 must be posix1e.Permset");
918 p = (Permset_Object*)value;
919 if(acl_set_permset(self->entry, p->permset) == -1) {
920 PyErr_SetFromErrno(PyExc_IOError);
926 static char __Entry_copy_doc__[] =
928 "Copies an ACL entry.\n"
930 "This method sets all the parameters to those of another\n"
931 "entry (either of the same ACL or belonging to another ACL).\n"
933 ":param Entry src: instance of type Entry\n"
936 /* Sets all the entry parameters to another entry */
937 static PyObject* Entry_copy(PyObject *obj, PyObject *args) {
938 Entry_Object *self = (Entry_Object*)obj;
941 if(!PyArg_ParseTuple(args, "O!", &Entry_Type, &other))
944 if(acl_copy_entry(self->entry, other->entry) == -1)
945 return PyErr_SetFromErrno(PyExc_IOError);
951 /**** Permset type *****/
953 /* Creation of a new Permset instance */
954 static PyObject* Permset_new(PyTypeObject* type, PyObject* args,
956 PyObject* newpermset;
958 newpermset = PyType_GenericNew(type, args, keywds);
960 if(newpermset != NULL) {
961 ((Permset_Object*)newpermset)->permset = NULL;
962 ((Permset_Object*)newpermset)->parent_entry = NULL;
968 /* Initialization of a new Permset instance */
969 static int Permset_init(PyObject* obj, PyObject* args, PyObject *keywds) {
970 Permset_Object* self = (Permset_Object*) obj;
971 Entry_Object* parent = NULL;
973 if (!PyArg_ParseTuple(args, "O!", &Entry_Type, &parent))
976 if(acl_get_permset(parent->entry, &self->permset) == -1) {
977 PyErr_SetFromErrno(PyExc_IOError);
981 self->parent_entry = (PyObject*)parent;
987 /* Free the Permset instance */
988 static void Permset_dealloc(PyObject* obj) {
989 Permset_Object *self = (Permset_Object*) obj;
990 PyObject *err_type, *err_value, *err_traceback;
991 int have_error = PyErr_Occurred() ? 1 : 0;
994 PyErr_Fetch(&err_type, &err_value, &err_traceback);
995 if(self->parent_entry != NULL) {
996 Py_DECREF(self->parent_entry);
997 self->parent_entry = NULL;
1000 PyErr_Restore(err_type, err_value, err_traceback);
1004 /* Permset string representation */
1005 static PyObject* Permset_str(PyObject *obj) {
1006 Permset_Object *self = (Permset_Object*) obj;
1009 pstr[0] = get_perm(self->permset, ACL_READ) ? 'r' : '-';
1010 pstr[1] = get_perm(self->permset, ACL_WRITE) ? 'w' : '-';
1011 pstr[2] = get_perm(self->permset, ACL_EXECUTE) ? 'x' : '-';
1012 return MyString_FromStringAndSize(pstr, 3);
1015 static char __Permset_clear_doc__[] =
1016 "Clears all permissions from the permission set.\n"
1019 /* Clears all permissions from the permset */
1020 static PyObject* Permset_clear(PyObject* obj, PyObject* args) {
1021 Permset_Object *self = (Permset_Object*) obj;
1023 if(acl_clear_perms(self->permset) == -1)
1024 return PyErr_SetFromErrno(PyExc_IOError);
1026 /* Return the result */
1031 static PyObject* Permset_get_right(PyObject *obj, void* arg) {
1032 Permset_Object *self = (Permset_Object*) obj;
1034 if(get_perm(self->permset, *(acl_perm_t*)arg)) {
1041 static int Permset_set_right(PyObject* obj, PyObject* value, void* arg) {
1042 Permset_Object *self = (Permset_Object*) obj;
1046 if(!PyInt_Check(value)) {
1047 PyErr_SetString(PyExc_ValueError, "a maximum of one argument must"
1051 on = PyInt_AsLong(value);
1053 nerr = acl_add_perm(self->permset, *(acl_perm_t*)arg);
1055 nerr = acl_delete_perm(self->permset, *(acl_perm_t*)arg);
1057 PyErr_SetFromErrno(PyExc_IOError);
1063 static char __Permset_add_doc__[] =
1065 "Add a permission to the permission set.\n"
1067 "This function adds the permission contained in \n"
1068 "the argument perm to the permission set. An attempt \n"
1069 "to add a permission that is already contained in the \n"
1070 "permission set is not considered an error.\n"
1072 ":param perm: a permission (:py:data:`ACL_WRITE`, :py:data:`ACL_READ`,\n"
1073 " :py:data:`ACL_EXECUTE`, ...)\n"
1074 ":raises IOError: in case the argument is not a valid descriptor\n"
1077 static PyObject* Permset_add(PyObject* obj, PyObject* args) {
1078 Permset_Object *self = (Permset_Object*) obj;
1081 if (!PyArg_ParseTuple(args, "i", &right))
1084 if(acl_add_perm(self->permset, (acl_perm_t) right) == -1)
1085 return PyErr_SetFromErrno(PyExc_IOError);
1087 /* Return the result */
1092 static char __Permset_delete_doc__[] =
1094 "Delete a permission from the permission set.\n"
1096 "This function deletes the permission contained in \n"
1097 "the argument perm from the permission set. An attempt \n"
1098 "to delete a permission that is not contained in the \n"
1099 "permission set is not considered an error.\n"
1101 ":param perm: a permission (:py:data:`ACL_WRITE`, :py:data:`ACL_READ`,\n"
1102 " :py:data:`ACL_EXECUTE`, ...)\n"
1103 ":raises IOError: in case the argument is not a valid descriptor\n"
1106 static PyObject* Permset_delete(PyObject* obj, PyObject* args) {
1107 Permset_Object *self = (Permset_Object*) obj;
1110 if (!PyArg_ParseTuple(args, "i", &right))
1113 if(acl_delete_perm(self->permset, (acl_perm_t) right) == -1)
1114 return PyErr_SetFromErrno(PyExc_IOError);
1116 /* Return the result */
1121 static char __Permset_test_doc__[] =
1123 "Test if a permission exists in the permission set.\n"
1125 "The test() function tests if the permission represented by\n"
1126 "the argument perm exists in the permission set.\n"
1128 ":param perm: a permission (:py:data:`ACL_WRITE`, :py:data:`ACL_READ`,\n"
1129 " :py:data:`ACL_EXECUTE`, ...)\n"
1131 ":raises IOError: in case the argument is not a valid descriptor\n"
1134 static PyObject* Permset_test(PyObject* obj, PyObject* args) {
1135 Permset_Object *self = (Permset_Object*) obj;
1139 if (!PyArg_ParseTuple(args, "i", &right))
1142 ret = get_perm(self->permset, (acl_perm_t) right);
1144 return PyErr_SetFromErrno(PyExc_IOError);
1155 static char __ACL_Type_doc__[] =
1156 "Type which represents a POSIX ACL\n"
1158 ".. note:: only one keyword parameter should be provided\n"
1160 ":param string file: creates an ACL representing\n"
1161 " the access ACL of the specified file\n"
1162 ":param string filedef: creates an ACL representing\n"
1163 " the default ACL of the given directory\n"
1164 ":param int fd: creates an ACL representing\n"
1165 " the access ACL of the given file descriptor\n"
1166 ":param string text: creates an ACL from a \n"
1167 " textual description\n"
1168 ":param ACL acl: creates a copy of an existing ACL instance\n"
1169 ":param int mode: creates an ACL from a numeric mode\n"
1170 " (e.g. mode=0644) (this is valid only when the C library\n"
1171 " provides the acl_from_mode call)\n"
1173 "If no parameters are passed, an empty ACL will be created; this\n"
1174 "makes sense only when your OS supports ACL modification\n"
1175 "(i.e. it implements full POSIX.1e support), otherwise the ACL won't\n"
1179 /* ACL type methods */
1180 static PyMethodDef ACL_methods[] = {
1181 {"applyto", ACL_applyto, METH_VARARGS, __applyto_doc__},
1182 {"valid", ACL_valid, METH_NOARGS, __valid_doc__},
1184 {"to_any_text", (PyCFunction)ACL_to_any_text, METH_VARARGS | METH_KEYWORDS,
1185 __to_any_text_doc__},
1186 {"check", ACL_check, METH_NOARGS, __check_doc__},
1187 {"equiv_mode", ACL_equiv_mode, METH_NOARGS, __equiv_mode_doc__},
1189 #ifdef HAVE_ACL_COPYEXT
1190 {"__getstate__", ACL_get_state, METH_NOARGS,
1191 "Dumps the ACL to an external format."},
1192 {"__setstate__", ACL_set_state, METH_VARARGS,
1193 "Loads the ACL from an external format."},
1196 {"delete_entry", ACL_delete_entry, METH_VARARGS, __ACL_delete_entry_doc__},
1197 {"calc_mask", ACL_calc_mask, METH_NOARGS, __ACL_calc_mask_doc__},
1198 {"append", ACL_append, METH_VARARGS, __ACL_append_doc__},
1200 {NULL, NULL, 0, NULL}
1204 /* The definition of the ACL Type */
1205 static PyTypeObject ACL_Type = {
1207 PyVarObject_HEAD_INIT(NULL, 0)
1209 PyObject_HEAD_INIT(NULL)
1215 ACL_dealloc, /* tp_dealloc */
1219 ACL_nocmp, /* tp_compare */
1221 0, /* tp_as_number */
1222 0, /* tp_as_sequence */
1223 0, /* tp_as_mapping */
1226 ACL_str, /* tp_str */
1227 0, /* tp_getattro */
1228 0, /* tp_setattro */
1229 0, /* tp_as_buffer */
1230 Py_TPFLAGS_DEFAULT, /* tp_flags */
1231 __ACL_Type_doc__, /* tp_doc */
1232 0, /* tp_traverse */
1235 ACL_richcompare, /* tp_richcompare */
1237 0, /* tp_richcompare */
1239 0, /* tp_weaklistoffset */
1245 0, /* tp_iternext */
1247 ACL_methods, /* tp_methods */
1252 0, /* tp_descr_get */
1253 0, /* tp_descr_set */
1254 0, /* tp_dictoffset */
1255 ACL_init, /* tp_init */
1257 ACL_new, /* tp_new */
1262 /* Entry type methods */
1263 static PyMethodDef Entry_methods[] = {
1264 {"copy", Entry_copy, METH_VARARGS, __Entry_copy_doc__},
1265 {NULL, NULL, 0, NULL}
1268 static char __Entry_tagtype_doc__[] =
1269 "The tag type of the current entry\n"
1272 " - :py:data:`ACL_UNDEFINED_TAG`\n"
1273 " - :py:data:`ACL_USER_OBJ`\n"
1274 " - :py:data:`ACL_USER`\n"
1275 " - :py:data:`ACL_GROUP_OBJ`\n"
1276 " - :py:data:`ACL_GROUP`\n"
1277 " - :py:data:`ACL_MASK`\n"
1278 " - :py:data:`ACL_OTHER`\n"
1281 static char __Entry_qualifier_doc__[] =
1282 "The qualifier of the current entry\n"
1284 "If the tag type is :py:data:`ACL_USER`, this should be a user id.\n"
1285 "If the tag type if :py:data:`ACL_GROUP`, this should be a group id.\n"
1286 "Else it doesn't matter.\n"
1289 static char __Entry_parent_doc__[] =
1290 "The parent ACL of this entry\n"
1293 static char __Entry_permset_doc__[] =
1294 "The permission set of this ACL entry\n"
1298 static PyGetSetDef Entry_getsets[] = {
1299 {"tag_type", Entry_get_tag_type, Entry_set_tag_type,
1300 __Entry_tagtype_doc__},
1301 {"qualifier", Entry_get_qualifier, Entry_set_qualifier,
1302 __Entry_qualifier_doc__},
1303 {"parent", Entry_get_parent, NULL, __Entry_parent_doc__},
1304 {"permset", Entry_get_permset, Entry_set_permset, __Entry_permset_doc__},
1308 static char __Entry_Type_doc__[] =
1309 "Type which represents an entry in an ACL.\n"
1311 "The type exists only if the OS has full support for POSIX.1e\n"
1312 "Can be created either by:\n"
1314 " >>> e = posix1e.Entry(myACL) # this creates a new entry in the ACL\n"
1315 " >>> e = myACL.append() # another way for doing the same thing\n"
1319 " >>> for entry in myACL:\n"
1320 " ... print entry\n"
1322 "Note that the Entry keeps a reference to its ACL, so even if \n"
1323 "you delete the ACL, it won't be cleaned up and will continue to \n"
1324 "exist until its Entry(ies) will be deleted.\n"
1326 /* The definition of the Entry Type */
1327 static PyTypeObject Entry_Type = {
1329 PyVarObject_HEAD_INIT(NULL, 0)
1331 PyObject_HEAD_INIT(NULL)
1335 sizeof(Entry_Object),
1337 Entry_dealloc, /* tp_dealloc */
1343 0, /* tp_as_number */
1344 0, /* tp_as_sequence */
1345 0, /* tp_as_mapping */
1348 Entry_str, /* tp_str */
1349 0, /* tp_getattro */
1350 0, /* tp_setattro */
1351 0, /* tp_as_buffer */
1352 Py_TPFLAGS_DEFAULT, /* tp_flags */
1353 __Entry_Type_doc__, /* tp_doc */
1354 0, /* tp_traverse */
1356 0, /* tp_richcompare */
1357 0, /* tp_weaklistoffset */
1359 0, /* tp_iternext */
1360 Entry_methods, /* tp_methods */
1362 Entry_getsets, /* tp_getset */
1365 0, /* tp_descr_get */
1366 0, /* tp_descr_set */
1367 0, /* tp_dictoffset */
1368 Entry_init, /* tp_init */
1370 Entry_new, /* tp_new */
1373 /* Permset type methods */
1374 static PyMethodDef Permset_methods[] = {
1375 {"clear", Permset_clear, METH_NOARGS, __Permset_clear_doc__, },
1376 {"add", Permset_add, METH_VARARGS, __Permset_add_doc__, },
1377 {"delete", Permset_delete, METH_VARARGS, __Permset_delete_doc__, },
1378 {"test", Permset_test, METH_VARARGS, __Permset_test_doc__, },
1379 {NULL, NULL, 0, NULL}
1382 static char __Permset_execute_doc__[] =
1383 "Execute permission property\n"
1385 "This is a convenience method of retrieving and setting the execute\n"
1386 "permission in the permission set; the \n"
1387 "same effect can be achieved using the functions\n"
1388 "add(), test(), delete(), and those can take any \n"
1389 "permission defined by your platform.\n"
1392 static char __Permset_read_doc__[] =
1393 "Read permission property\n"
1395 "This is a convenience method of retrieving and setting the read\n"
1396 "permission in the permission set; the \n"
1397 "same effect can be achieved using the functions\n"
1398 "add(), test(), delete(), and those can take any \n"
1399 "permission defined by your platform.\n"
1402 static char __Permset_write_doc__[] =
1403 "Write permission property\n"
1405 "This is a convenience method of retrieving and setting the write\n"
1406 "permission in the permission set; the \n"
1407 "same effect can be achieved using the functions\n"
1408 "add(), test(), delete(), and those can take any \n"
1409 "permission defined by your platform.\n"
1412 /* Permset getset */
1413 static PyGetSetDef Permset_getsets[] = {
1414 {"execute", Permset_get_right, Permset_set_right,
1415 __Permset_execute_doc__, &holder_ACL_EXECUTE},
1416 {"read", Permset_get_right, Permset_set_right,
1417 __Permset_read_doc__, &holder_ACL_READ},
1418 {"write", Permset_get_right, Permset_set_right,
1419 __Permset_write_doc__, &holder_ACL_WRITE},
1423 static char __Permset_Type_doc__[] =
1424 "Type which represents the permission set in an ACL entry\n"
1426 "The type exists only if the OS has full support for POSIX.1e\n"
1427 "Can be retrieved either by:\n\n"
1428 ">>> perms = myEntry.permset\n"
1431 ">>> perms = posix1e.Permset(myEntry)\n"
1433 "Note that the Permset keeps a reference to its Entry, so even if \n"
1434 "you delete the entry, it won't be cleaned up and will continue to \n"
1435 "exist until its Permset will be deleted.\n"
1438 /* The definition of the Permset Type */
1439 static PyTypeObject Permset_Type = {
1441 PyVarObject_HEAD_INIT(NULL, 0)
1443 PyObject_HEAD_INIT(NULL)
1447 sizeof(Permset_Object),
1449 Permset_dealloc, /* tp_dealloc */
1455 0, /* tp_as_number */
1456 0, /* tp_as_sequence */
1457 0, /* tp_as_mapping */
1460 Permset_str, /* tp_str */
1461 0, /* tp_getattro */
1462 0, /* tp_setattro */
1463 0, /* tp_as_buffer */
1464 Py_TPFLAGS_DEFAULT, /* tp_flags */
1465 __Permset_Type_doc__,/* tp_doc */
1466 0, /* tp_traverse */
1468 0, /* tp_richcompare */
1469 0, /* tp_weaklistoffset */
1471 0, /* tp_iternext */
1472 Permset_methods, /* tp_methods */
1474 Permset_getsets, /* tp_getset */
1477 0, /* tp_descr_get */
1478 0, /* tp_descr_set */
1479 0, /* tp_dictoffset */
1480 Permset_init, /* tp_init */
1482 Permset_new, /* tp_new */
1487 /* Module methods */
1489 static char __deletedef_doc__[] =
1490 "delete_default(path)\n"
1491 "Delete the default ACL from a directory.\n"
1493 "This function deletes the default ACL associated with\n"
1494 "a directory (the ACL which will be ANDed with the mode\n"
1495 "parameter to the open, creat functions).\n"
1497 ":param string path: the directory whose default ACL should be deleted\n"
1500 /* Deletes the default ACL from a directory */
1501 static PyObject* aclmodule_delete_default(PyObject* obj, PyObject* args) {
1504 /* Parse the arguments */
1505 if (!PyArg_ParseTuple(args, "et", NULL, &filename))
1508 if(acl_delete_def_file(filename) == -1) {
1509 return PyErr_SetFromErrno(PyExc_IOError);
1512 /* Return the result */
1518 static char __has_extended_doc__[] =
1519 "has_extended(item)\n"
1520 "Check if a file or file handle has an extended ACL.\n"
1522 ":param item: either a file name or a file-like object or an integer;\n"
1523 " it represents the file-system object on which to act\n"
1526 /* Check for extended ACL a file or fd */
1527 static PyObject* aclmodule_has_extended(PyObject* obj, PyObject* args) {
1532 if (!PyArg_ParseTuple(args, "O", &myarg))
1535 if(PyBytes_Check(myarg)) {
1536 const char *filename = PyBytes_AS_STRING(myarg);
1537 nret = acl_extended_file(filename);
1538 } else if (PyUnicode_Check(myarg)) {
1540 PyUnicode_AsEncodedString(myarg,
1541 Py_FileSystemDefaultEncoding, "strict");
1544 const char *filename = PyBytes_AS_STRING(o);
1545 nret = acl_extended_file(filename);
1547 } else if((fd = PyObject_AsFileDescriptor(myarg)) != -1) {
1548 nret = acl_extended_fd(fd);
1550 PyErr_SetString(PyExc_TypeError, "argument 1 must be string, int,"
1551 " or file-like object");
1555 return PyErr_SetFromErrno(PyExc_IOError);
1558 /* Return the result */
1559 return PyBool_FromLong(nret);
1563 /* The module methods */
1564 static PyMethodDef aclmodule_methods[] = {
1565 {"delete_default", aclmodule_delete_default, METH_VARARGS,
1568 {"has_extended", aclmodule_has_extended, METH_VARARGS,
1569 __has_extended_doc__},
1571 {NULL, NULL, 0, NULL}
1574 static char __posix1e_doc__[] =
1575 "POSIX.1e ACLs manipulation\n"
1576 "==========================\n"
1578 "This module provides support for manipulating POSIX.1e ACLS\n"
1580 "Depending on the operating system support for POSIX.1e, \n"
1581 "the ACL type will have more or less capabilities:\n\n"
1582 " - level 1, only basic support, you can create\n"
1583 " ACLs from files and text descriptions;\n"
1584 " once created, the type is immutable\n"
1585 " - level 2, complete support, you can alter\n"
1586 " the ACL once it is created\n"
1588 "Also, in level 2, more types are available, corresponding\n"
1589 "to acl_entry_t (the Entry type), acl_permset_t (the Permset type).\n"
1591 "The existence of level 2 support and other extensions can be\n"
1592 "checked by the constants:\n\n"
1593 " - :py:data:`HAS_ACL_ENTRY` for level 2 and the Entry/Permset classes\n"
1594 " - :py:data:`HAS_ACL_FROM_MODE` for ``ACL(mode=...)`` usage\n"
1595 " - :py:data:`HAS_ACL_CHECK` for the :py:func:`ACL.check` function\n"
1596 " - :py:data:`HAS_EXTENDED_CHECK` for the module-level\n"
1597 " :py:func:`has_extended` function\n"
1598 " - :py:data:`HAS_EQUIV_MODE` for the :py:func:`ACL.equiv_mode` method\n"
1602 ">>> import posix1e\n"
1603 ">>> acl1 = posix1e.ACL(file=\"file.txt\") \n"
1609 ">>> b = posix1e.ACL(text=\"u::rx,g::-,o::-\")\n"
1615 ">>> b.applyto(\"file.txt\")\n"
1616 ">>> print posix1e.ACL(file=\"file.txt\")\n"
1622 ".. py:data:: ACL_USER\n\n"
1623 " Denotes a specific user entry in an ACL.\n"
1625 ".. py:data:: ACL_USER_OBJ\n\n"
1626 " Denotes the user owner entry in an ACL.\n"
1628 ".. py:data:: ACL_GROUP\n\n"
1629 " Denotes the a group entry in an ACL.\n"
1631 ".. py:data:: ACL_GROUP_OBJ\n\n"
1632 " Denotes the group owner entry in an ACL.\n"
1634 ".. py:data:: ACL_OTHER\n\n"
1635 " Denotes the 'others' entry in an ACL.\n"
1637 ".. py:data:: ACL_MASK\n\n"
1638 " Denotes the mask entry in an ACL, representing the maximum\n"
1639 " access granted other users, the owner group and other groups.\n"
1641 ".. py:data:: ACL_UNDEFINED_TAG\n\n"
1642 " An undefined tag in an ACL.\n"
1644 ".. py:data:: ACL_READ\n\n"
1645 " Read permission in a permission set.\n"
1647 ".. py:data:: ACL_WRITE\n\n"
1648 " Write permission in a permission set.\n"
1650 ".. py:data:: ACL_EXECUTE\n\n"
1651 " Execute permission in a permission set.\n"
1653 ".. py:data:: HAS_ACL_ENTRY\n\n"
1654 " denotes support for level 2 and the Entry/Permset classes\n"
1656 ".. py:data:: HAS_ACL_FROM_MODE\n\n"
1657 " denotes support for building an ACL from an octal mode\n"
1659 ".. py:data:: HAS_ACL_CHECK\n\n"
1660 " denotes support for extended checks of an ACL's validity\n"
1662 ".. py:data:: HAS_EXTENDED_CHECK\n\n"
1663 " denotes support for checking whether an ACL is basic or extended\n"
1665 ".. py:data:: HAS_EQUIV_MODE\n\n"
1666 " denotes support for the equiv_mode function\n"
1672 static struct PyModuleDef posix1emodule = {
1673 PyModuleDef_HEAD_INIT,
1680 #define INITERROR return NULL
1683 PyInit_posix1e(void)
1686 #define INITERROR return
1688 void initposix1e(void)
1693 Py_TYPE(&ACL_Type) = &PyType_Type;
1694 if(PyType_Ready(&ACL_Type) < 0)
1698 Py_TYPE(&Entry_Type) = &PyType_Type;
1699 if(PyType_Ready(&Entry_Type) < 0)
1702 Py_TYPE(&Permset_Type) = &PyType_Type;
1703 if(PyType_Ready(&Permset_Type) < 0)
1708 m = PyModule_Create(&posix1emodule);
1710 m = Py_InitModule3("posix1e", aclmodule_methods, __posix1e_doc__);
1715 d = PyModule_GetDict(m);
1719 Py_INCREF(&ACL_Type);
1720 if (PyDict_SetItemString(d, "ACL",
1721 (PyObject *) &ACL_Type) < 0)
1724 /* 23.3.6 acl_type_t values */
1725 PyModule_AddIntConstant(m, "ACL_TYPE_ACCESS", ACL_TYPE_ACCESS);
1726 PyModule_AddIntConstant(m, "ACL_TYPE_DEFAULT", ACL_TYPE_DEFAULT);
1730 Py_INCREF(&Entry_Type);
1731 if (PyDict_SetItemString(d, "Entry",
1732 (PyObject *) &Entry_Type) < 0)
1735 Py_INCREF(&Permset_Type);
1736 if (PyDict_SetItemString(d, "Permset",
1737 (PyObject *) &Permset_Type) < 0)
1740 /* 23.2.2 acl_perm_t values */
1741 PyModule_AddIntConstant(m, "ACL_READ", ACL_READ);
1742 PyModule_AddIntConstant(m, "ACL_WRITE", ACL_WRITE);
1743 PyModule_AddIntConstant(m, "ACL_EXECUTE", ACL_EXECUTE);
1745 /* 23.2.5 acl_tag_t values */
1746 PyModule_AddIntConstant(m, "ACL_UNDEFINED_TAG", ACL_UNDEFINED_TAG);
1747 PyModule_AddIntConstant(m, "ACL_USER_OBJ", ACL_USER_OBJ);
1748 PyModule_AddIntConstant(m, "ACL_USER", ACL_USER);
1749 PyModule_AddIntConstant(m, "ACL_GROUP_OBJ", ACL_GROUP_OBJ);
1750 PyModule_AddIntConstant(m, "ACL_GROUP", ACL_GROUP);
1751 PyModule_AddIntConstant(m, "ACL_MASK", ACL_MASK);
1752 PyModule_AddIntConstant(m, "ACL_OTHER", ACL_OTHER);
1754 /* Document extended functionality via easy-to-use constants */
1755 PyModule_AddIntConstant(m, "HAS_ACL_ENTRY", 1);
1757 PyModule_AddIntConstant(m, "HAS_ACL_ENTRY", 0);
1761 /* Linux libacl specific acl_to_any_text constants */
1762 PyModule_AddIntConstant(m, "TEXT_ABBREVIATE", TEXT_ABBREVIATE);
1763 PyModule_AddIntConstant(m, "TEXT_NUMERIC_IDS", TEXT_NUMERIC_IDS);
1764 PyModule_AddIntConstant(m, "TEXT_SOME_EFFECTIVE", TEXT_SOME_EFFECTIVE);
1765 PyModule_AddIntConstant(m, "TEXT_ALL_EFFECTIVE", TEXT_ALL_EFFECTIVE);
1766 PyModule_AddIntConstant(m, "TEXT_SMART_INDENT", TEXT_SMART_INDENT);
1768 /* Linux libacl specific acl_check constants */
1769 PyModule_AddIntConstant(m, "ACL_MULTI_ERROR", ACL_MULTI_ERROR);
1770 PyModule_AddIntConstant(m, "ACL_DUPLICATE_ERROR", ACL_DUPLICATE_ERROR);
1771 PyModule_AddIntConstant(m, "ACL_MISS_ERROR", ACL_MISS_ERROR);
1772 PyModule_AddIntConstant(m, "ACL_ENTRY_ERROR", ACL_ENTRY_ERROR);
1774 /* declare the Linux extensions */
1775 PyModule_AddIntConstant(m, "HAS_ACL_FROM_MODE", 1);
1776 PyModule_AddIntConstant(m, "HAS_ACL_CHECK", 1);
1777 PyModule_AddIntConstant(m, "HAS_EXTENDED_CHECK", 1);
1778 PyModule_AddIntConstant(m, "HAS_EQUIV_MODE", 1);
1780 PyModule_AddIntConstant(m, "HAS_ACL_FROM_MODE", 0);
1781 PyModule_AddIntConstant(m, "HAS_ACL_CHECK", 0);
1782 PyModule_AddIntConstant(m, "HAS_EXTENDED_CHECK", 0);
1783 PyModule_AddIntConstant(m, "HAS_EQUIV_MODE", 0);