acl.c

   1 /*
   2     posix1e - a python module exposing the posix acl functions
   3
   4     Copyright (C) 2002-2009, 2012, 2014, 2015 Iustin Pop <iustin@k1024.org>
   5
   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.
  10
  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.
  15
  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
  19     02110-1301  USA
  20
  21 */
  22
  23 #define PY_SSIZE_T_CLEAN
  24 #include <Python.h>
  25
  26 #include <sys/types.h>
  27 #include <sys/acl.h>
  28
  29 #ifdef HAVE_LINUX
  30 #include <acl/libacl.h>
  31 #define get_perm acl_get_perm
  32 #elif HAVE_FREEBSD
  33 #define get_perm acl_get_perm_np
  34 #endif
  35
  36 /* Used for cpychecker: */
  37 /* The checker automatically defines this preprocessor name when creating
  38    the custom attribute: */
  39 #if defined(WITH_CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF_ATTRIBUTE)
  40 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(typename) \
  41   __attribute__((cpychecker_type_object_for_typedef(typename)))
  42 #else
  43 /* This handles the case where we're compiling with a "vanilla"
  44    compiler that doesn't supply this attribute: */
  45 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(typename)
  46 #endif
  47
  48 /* The checker automatically defines this preprocessor name when creating
  49    the custom attribute: */
  50 #if defined(WITH_CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION_ATTRIBUTE)
  51    #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION \
  52 __attribute__((cpychecker_negative_result_sets_exception))
  53    #else
  54    #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
  55 #endif
  56
  57 static PyTypeObject ACL_Type
  58   CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("ACL_Object");
  59 static PyObject* ACL_applyto(PyObject* obj, PyObject* args);
  60 static PyObject* ACL_valid(PyObject* obj, PyObject* args);
  61
  62 #ifdef HAVE_ACL_COPY_EXT
  63 static PyObject* ACL_get_state(PyObject *obj, PyObject* args);
  64 static PyObject* ACL_set_state(PyObject *obj, PyObject* args);
  65 #endif
  66
  67 #ifdef HAVE_LEVEL2
  68 static PyTypeObject Entry_Type
  69   CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("Entry_Object");
  70 static PyTypeObject Permset_Type
  71   CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("Permset_Object");
  72 static PyObject* Permset_new(PyTypeObject* type, PyObject* args,
  73                              PyObject *keywds);
  74 #endif
  75
  76 static acl_perm_t holder_ACL_EXECUTE = ACL_EXECUTE;
  77 static acl_perm_t holder_ACL_READ = ACL_READ;
  78 static acl_perm_t holder_ACL_WRITE = ACL_WRITE;
  79
  80 typedef struct {
  81     PyObject_HEAD
  82     acl_t acl;
  83 #ifdef HAVE_LEVEL2
  84     int entry_id;
  85 #endif
  86 } ACL_Object;
  87
  88 #ifdef HAVE_LEVEL2
  89
  90 typedef struct {
  91     PyObject_HEAD
  92     PyObject *parent_acl; /* The parent acl, so it won't run out on us */
  93     acl_entry_t entry;
  94 } Entry_Object;
  95
  96 typedef struct {
  97     PyObject_HEAD
  98     PyObject *parent_entry; /* The parent entry, so it won't run out on us */
  99     acl_permset_t permset;
 100 } Permset_Object;
 101
 102 #endif
 103
 104 /* Creation of a new ACL instance */
 105 static PyObject* ACL_new(PyTypeObject* type, PyObject* args,
 106                          PyObject *keywds) {
 107     PyObject* newacl;
 108     ACL_Object *acl;
 109
 110     newacl = type->tp_alloc(type, 0);
 111
 112     if(newacl == NULL) {
 113         return NULL;
 114     }
 115     acl = (ACL_Object*) newacl;
 116
 117     acl->acl = acl_init(0);
 118     if (acl->acl == NULL) {
 119         /* LCOV_EXCL_START */
 120         PyErr_SetFromErrno(PyExc_IOError);
 121         Py_DECREF(newacl);
 122         return NULL;
 123         /* LCOV_EXCL_STOP */
 124     }
 125 #ifdef HAVE_LEVEL2
 126     acl->entry_id = ACL_FIRST_ENTRY;
 127 #endif
 128
 129     return newacl;
 130 }
 131
 132 /* Initialization of a new ACL instance */
 133 static int ACL_init(PyObject* obj, PyObject* args, PyObject *keywds) {
 134     ACL_Object* self = (ACL_Object*) obj;
 135     static char *kwlist[] = { "file", "fd", "text", "acl", "filedef",
 136 #ifdef HAVE_LINUX
 137                               "mode",
 138 #endif
 139 #ifdef HAVE_ACL_COPY_EXT
 140                               "data",
 141 #endif
 142                               NULL };
 143     char *format = "|O&OsO!O&"
 144 #ifdef HAVE_LINUX
 145       "i"
 146 #endif
 147 #ifdef HAVE_ACL_COPY_EXT
 148       "y#"
 149 #endif
 150       ;
 151     acl_t new = NULL;
 152 #ifdef HAVE_LINUX
 153     int mode = -1;
 154 #endif
 155     PyObject *file = NULL;
 156     PyObject *filedef = NULL;
 157     char *text = NULL;
 158     PyObject *fd = NULL;
 159     ACL_Object* thesrc = NULL;
 160 #ifdef HAVE_ACL_COPY_EXT
 161     const void *buf = NULL;
 162     Py_ssize_t bufsize;
 163 #endif
 164     int set_err = 0;
 165
 166     if(!PyTuple_Check(args) || PyTuple_Size(args) != 0 ||
 167        (keywds != NULL && PyDict_Check(keywds) && PyDict_Size(keywds) > 1)) {
 168         PyErr_SetString(PyExc_ValueError, "a max of one keyword argument"
 169                         " must be passed");
 170         return -1;
 171     }
 172     if(!PyArg_ParseTupleAndKeywords(args, keywds, format, kwlist,
 173                                     PyUnicode_FSConverter, &file,
 174                                     &fd, &text, &ACL_Type, &thesrc,
 175                                     PyUnicode_FSConverter, &filedef
 176 #ifdef HAVE_LINUX
 177                                     , &mode
 178 #endif
 179 #ifdef HAVE_ACL_COPY_EXT
 180                                     , &buf, &bufsize
 181 #endif
 182                                     ))
 183         return -1;
 184
 185     if(file != NULL) {
 186         char *path = PyBytes_AS_STRING(file);
 187         new = acl_get_file(path, ACL_TYPE_ACCESS);
 188         // Set custom exception on this failure path which includes
 189         // the filename.
 190         if (new == NULL) {
 191           PyErr_SetFromErrnoWithFilename(PyExc_IOError, path);
 192           set_err = 1;
 193         }
 194         Py_DECREF(file);
 195     } else if(text != NULL)
 196         new = acl_from_text(text);
 197     else if(fd != NULL) {
 198         int fdval;
 199         if ((fdval = PyObject_AsFileDescriptor(fd)) != -1) {
 200             new = acl_get_fd(fdval);
 201         }
 202     } else if(thesrc != NULL)
 203         new = acl_dup(thesrc->acl);
 204     else if(filedef != NULL) {
 205         char *path = PyBytes_AS_STRING(filedef);
 206         new = acl_get_file(path, ACL_TYPE_DEFAULT);
 207         // Set custom exception on this failure path which includes
 208         // the filename.
 209         if (new == NULL) {
 210           PyErr_SetFromErrnoWithFilename(PyExc_IOError, path);
 211           set_err = 1;
 212         }
 213         Py_DECREF(filedef);
 214     }
 215 #ifdef HAVE_LINUX
 216     else if(mode != -1)
 217         new = acl_from_mode(mode);
 218 #endif
 219 #ifdef HAVE_ACL_COPY_EXT
 220     else if(buf != NULL) {
 221       new = acl_copy_int(buf);
 222     }
 223 #endif
 224     else
 225         new = acl_init(0);
 226
 227     if(new == NULL) {
 228         if (!set_err) {
 229             PyErr_SetFromErrno(PyExc_IOError);
 230         }
 231         return -1;
 232     }
 233
 234     /* Free the old acl_t without checking for error, we don't
 235      * care right now */
 236     if(self->acl != NULL)
 237         acl_free(self->acl);
 238
 239     self->acl = new;
 240
 241     return 0;
 242 }
 243
 244 /* Standard type functions */
 245 static void ACL_dealloc(PyObject* obj) {
 246     ACL_Object *self = (ACL_Object*) obj;
 247     PyObject *err_type, *err_value, *err_traceback;
 248     int have_error = PyErr_Occurred() ? 1 : 0;
 249
 250     if (have_error)
 251         PyErr_Fetch(&err_type, &err_value, &err_traceback);
 252     if(self->acl != NULL && acl_free(self->acl) != 0)
 253         PyErr_WriteUnraisable(obj);  /* LCOV_EXCL_LINE */
 254     if (have_error)
 255         PyErr_Restore(err_type, err_value, err_traceback);
 256     PyObject_DEL(self);
 257 }
 258
 259 /* Converts the acl to a text format */
 260 static PyObject* ACL_str(PyObject *obj) {
 261     char *text;
 262     ACL_Object *self = (ACL_Object*) obj;
 263     PyObject *ret;
 264
 265     text = acl_to_text(self->acl, NULL);
 266     if(text == NULL) {
 267         /* LCOV_EXCL_START */
 268         return PyErr_SetFromErrno(PyExc_IOError);
 269         /* LCOV_EXCL_STOP */
 270     }
 271     ret = PyUnicode_FromString(text);
 272     if(acl_free(text) != 0) {
 273         /* LCOV_EXCL_START */
 274         Py_XDECREF(ret);
 275         return PyErr_SetFromErrno(PyExc_IOError);
 276         /* LCOV_EXCL_STOP */
 277     }
 278     return ret;
 279 }
 280
 281 #ifdef HAVE_LINUX
 282 static char __to_any_text_doc__[] =
 283   "to_any_text([prefix='', separator='n', options=0])\n"
 284   "Convert the ACL to a custom text format.\n"
 285   "\n"
 286   "This method encapsulates the ``acl_to_any_text()`` function.\n"
 287   "It allows a customized text format to be generated for the ACL. See\n"
 288   ":manpage:`acl_to_any_text(3)` for more details.\n"
 289   "\n"
 290   ":param string prefix: if given, this string will be pre-pended to\n"
 291   "   all lines\n"
 292   ":param string separator: a single character (defaults to '\\n'); this will"
 293     " be used to separate the entries in the ACL\n"
 294   ":param options: a bitwise combination of:\n\n"
 295   "    - :py:data:`TEXT_ABBREVIATE`: use 'u' instead of 'user', 'g' \n"
 296   "      instead of 'group', etc.\n"
 297   "    - :py:data:`TEXT_NUMERIC_IDS`: User and group IDs are included as\n"
 298   "      decimal numbers instead of names\n"
 299   "    - :py:data:`TEXT_SOME_EFFECTIVE`: Include comments denoting the\n"
 300   "      effective permissions when some are masked\n"
 301   "    - :py:data:`TEXT_ALL_EFFECTIVE`: Include comments after all ACL\n"
 302   "      entries affected by an ACL_MASK entry\n"
 303   "    - :py:data:`TEXT_SMART_INDENT`: Used in combination with the\n"
 304   "      _EFFECTIVE options, this will ensure that comments are aligned\n"
 305   "      to the fourth tab position (assuming one tab equals eight spaces)\n"
 306   ":rtype: string\n"
 307   ;
 308
 309 /* Converts the acl to a custom text format */
 310 static PyObject* ACL_to_any_text(PyObject *obj, PyObject *args,
 311                                  PyObject *kwds) {
 312     char *text;
 313     ACL_Object *self = (ACL_Object*) obj;
 314     PyObject *ret;
 315     const char *arg_prefix = NULL;
 316     char arg_separator = '\n';
 317     int arg_options = 0;
 318     static char *kwlist[] = {"prefix", "separator", "options", NULL};
 319
 320     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|sci", kwlist, &arg_prefix,
 321                                      &arg_separator, &arg_options))
 322       return NULL;
 323
 324     text = acl_to_any_text(self->acl, arg_prefix, arg_separator, arg_options);
 325     if(text == NULL) {
 326         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
 327     }
 328     ret = PyBytes_FromString(text);
 329     if(acl_free(text) != 0) {
 330         /* LCOV_EXCL_START */
 331         Py_XDECREF(ret);
 332         return PyErr_SetFromErrno(PyExc_IOError);
 333         /* LCOV_EXCL_STOP */
 334     }
 335     return ret;
 336 }
 337
 338 static char __check_doc__[] =
 339     "Check the ACL validity.\n"
 340     "\n"
 341     "This is a non-portable, Linux specific extension that allow more\n"
 342     "information to be retrieved in case an ACL is not valid than via the\n"
 343     ":py:func:`valid` method.\n"
 344     "\n"
 345     "This method will return either False (the ACL is valid), or a tuple\n"
 346     "with two elements. The first element is one of the following\n"
 347     "constants:\n\n"
 348     "  - :py:data:`ACL_MULTI_ERROR`: The ACL contains multiple entries that\n"
 349     "    have a tag type that may occur at most once\n"
 350     "  - :py:data:`ACL_DUPLICATE_ERROR`: The ACL contains multiple \n"
 351     "    :py:data:`ACL_USER` or :py:data:`ACL_GROUP` entries with the\n"
 352     "    same ID\n"
 353     "  - :py:data:`ACL_MISS_ERROR`: A required entry is missing\n"
 354     "  - :py:data:`ACL_ENTRY_ERROR`: The ACL contains an invalid entry\n"
 355     "    tag type\n"
 356     "\n"
 357     "The second element of the tuple is the index of the entry that is\n"
 358     "invalid (in the same order as by iterating over the ACL entry)\n"
 359     ;
 360
 361 /* The acl_check method */
 362 static PyObject* ACL_check(PyObject* obj, PyObject* args) {
 363     ACL_Object *self = (ACL_Object*) obj;
 364     int result;
 365     int eindex;
 366
 367     if((result = acl_check(self->acl, &eindex)) == -1)
 368         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
 369     if(result == 0) {
 370         Py_RETURN_FALSE;
 371     }
 372     return Py_BuildValue("(ii)", result, eindex);
 373 }
 374
 375 /* Implementation of the rich compare for ACLs */
 376 static PyObject* ACL_richcompare(PyObject* o1, PyObject* o2, int op) {
 377     ACL_Object *acl1, *acl2;
 378     int n;
 379     PyObject *ret;
 380
 381     if(!PyObject_IsInstance(o2, (PyObject*)&ACL_Type)) {
 382         if(op == Py_EQ)
 383             Py_RETURN_FALSE;
 384         if(op == Py_NE)
 385             Py_RETURN_TRUE;
 386         PyErr_SetString(PyExc_TypeError, "can only compare to an ACL");
 387         return NULL;
 388     }
 389
 390     acl1 = (ACL_Object*)o1;
 391     acl2 = (ACL_Object*)o2;
 392     if((n=acl_cmp(acl1->acl, acl2->acl))==-1)
 393         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
 394     switch(op) {
 395     case Py_EQ:
 396         ret = n == 0 ? Py_True : Py_False;
 397         break;
 398     case Py_NE:
 399         ret = n == 1 ? Py_True : Py_False;
 400         break;
 401     default:
 402         PyErr_SetString(PyExc_TypeError, "ACLs are not orderable");
 403         return NULL;
 404     }
 405     Py_INCREF(ret);
 406     return ret;
 407 }
 408
 409 static char __equiv_mode_doc__[] =
 410     "Return the octal mode the ACL is equivalent to.\n"
 411     "\n"
 412     "This is a non-portable, Linux specific extension that checks\n"
 413     "if the ACL is a basic ACL and returns the corresponding mode.\n"
 414     "\n"
 415     ":rtype: integer\n"
 416     ":raise IOError: An IOerror exception will be raised if the ACL is\n"
 417     "    an extended ACL.\n"
 418     ;
 419
 420 /* The acl_equiv_mode method */
 421 static PyObject* ACL_equiv_mode(PyObject* obj, PyObject* args) {
 422     ACL_Object *self = (ACL_Object*) obj;
 423     mode_t mode;
 424
 425     if(acl_equiv_mode(self->acl, &mode) == -1)
 426         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
 427     return PyLong_FromLong(mode);
 428 }
 429 #endif
 430
 431 /* Custom methods */
 432 static char __applyto_doc__[] =
 433     "applyto(item[, flag=ACL_TYPE_ACCESS])\n"
 434     "Apply the ACL to a file or filehandle.\n"
 435     "\n"
 436     ":param item: either a filename or a file-like object or an integer;\n"
 437     "    this represents the filesystem object on which to act\n"
 438     ":param flag: optional flag representing the type of ACL to set, either\n"
 439     "    :py:data:`ACL_TYPE_ACCESS` (default) or :py:data:`ACL_TYPE_DEFAULT`\n"
 440     ;
 441
 442 /* Applies the ACL to a file */
 443 static PyObject* ACL_applyto(PyObject* obj, PyObject* args) {
 444     ACL_Object *self = (ACL_Object*) obj;
 445     PyObject *target, *tmp;
 446     acl_type_t type = ACL_TYPE_ACCESS;
 447     int nret;
 448     int fd;
 449
 450     if (!PyArg_ParseTuple(args, "O|I", &target, &type))
 451         return NULL;
 452     if ((fd = PyObject_AsFileDescriptor(target)) != -1) {
 453         if((nret = acl_set_fd(fd, self->acl)) == -1) {
 454           PyErr_SetFromErrno(PyExc_IOError);
 455         }
 456     } else {
 457       // PyObject_AsFileDescriptor sets an error when failing, so clear
 458       // it such that further code works; some method lookups fail if an
 459       // error already occured when called, which breaks at least
 460       // PyOS_FSPath (called by FSConverter).
 461       PyErr_Clear();
 462       if(PyUnicode_FSConverter(target, &tmp)) {
 463         char *filename = PyBytes_AS_STRING(tmp);
 464         if ((nret = acl_set_file(filename, type, self->acl)) == -1) {
 465             PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
 466         }
 467         Py_DECREF(tmp);
 468       } else {
 469         nret = -1;
 470       }
 471     }
 472     if (nret < 0) {
 473         return NULL;
 474     } else {
 475         Py_RETURN_NONE;
 476     }
 477 }
 478
 479 static char __valid_doc__[] =
 480     "Test the ACL for validity.\n"
 481     "\n"
 482     "This method tests the ACL to see if it is a valid ACL\n"
 483     "in terms of the file-system. More precisely, it checks that:\n"
 484     "\n"
 485     "The ACL contains exactly one entry with each of the\n"
 486     ":py:data:`ACL_USER_OBJ`, :py:data:`ACL_GROUP_OBJ`, and \n"
 487     ":py:data:`ACL_OTHER` tag types. Entries\n"
 488     "with :py:data:`ACL_USER` and :py:data:`ACL_GROUP` tag types may\n"
 489     "appear zero or more\n"
 490     "times in an ACL. An ACL that contains entries of :py:data:`ACL_USER` or\n"
 491     ":py:data:`ACL_GROUP` tag types must contain exactly one entry of the \n"
 492     ":py:data:`ACL_MASK` tag type. If an ACL contains no entries of\n"
 493     ":py:data:`ACL_USER` or :py:data:`ACL_GROUP` tag types, the\n"
 494     ":py:data:`ACL_MASK` entry is optional.\n"
 495     "\n"
 496     "All user ID qualifiers must be unique among all entries of\n"
 497     "the :py:data:`ACL_USER` tag type, and all group IDs must be unique\n"
 498     "among all entries of :py:data:`ACL_GROUP` tag type.\n"
 499     "\n"
 500     "The method will return 1 for a valid ACL and 0 for an invalid one.\n"
 501     "This has been chosen because the specification for\n"
 502     ":manpage:`acl_valid(3)`\n"
 503     "in the POSIX.1e standard documents only one possible value for errno\n"
 504     "in case of an invalid ACL, so we can't differentiate between\n"
 505     "classes of errors. Other suggestions are welcome.\n"
 506     "\n"
 507     ":return: 0 or 1\n"
 508     ":rtype: integer\n"
 509     ;
 510
 511 /* Checks the ACL for validity */
 512 static PyObject* ACL_valid(PyObject* obj, PyObject* args) {
 513     ACL_Object *self = (ACL_Object*) obj;
 514
 515     if(acl_valid(self->acl) == -1) {
 516         Py_RETURN_FALSE;
 517     } else {
 518         Py_RETURN_TRUE;
 519     }
 520 }
 521
 522 #ifdef HAVE_ACL_COPY_EXT
 523 static PyObject* ACL_get_state(PyObject *obj, PyObject* args) {
 524     ACL_Object *self = (ACL_Object*) obj;
 525     PyObject *ret;
 526     ssize_t size, nsize;
 527     char *buf;
 528
 529     size = acl_size(self->acl);
 530     if(size == -1)
 531         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
 532
 533     if((ret = PyBytes_FromStringAndSize(NULL, size)) == NULL)
 534         return NULL;
 535     buf = PyBytes_AsString(ret);
 536
 537     if((nsize = acl_copy_ext(buf, self->acl, size)) == -1) {
 538         /* LCOV_EXCL_START */
 539         Py_DECREF(ret);
 540         return PyErr_SetFromErrno(PyExc_IOError);
 541         /* LCOV_EXCL_STOP */
 542     }
 543
 544     return ret;
 545 }
 546
 547 static PyObject* ACL_set_state(PyObject *obj, PyObject* args) {
 548     ACL_Object *self = (ACL_Object*) obj;
 549     const void *buf;
 550     Py_ssize_t bufsize;
 551     acl_t ptr;
 552
 553     /* Parse the argument */
 554     if (!PyArg_ParseTuple(args, "y#", &buf, &bufsize))
 555         return NULL;
 556
 557     /* Try to import the external representation */
 558     if((ptr = acl_copy_int(buf)) == NULL)
 559         return PyErr_SetFromErrno(PyExc_IOError);
 560
 561     if(self->acl != NULL) {
 562         /* Ignore errors in freeing the previous acl. We already
 563            allocated the new acl, and the state of the previous one is
 564            suspect if freeing failed (in Linux's libacl, deallocating
 565            a valid ACL can't actually happen, so this path is
 566            unlikely. */
 567         acl_free(self->acl); /* LCOV_EXCL_LINE */
 568     }
 569
 570     self->acl = ptr;
 571
 572     Py_RETURN_NONE;
 573 }
 574 #endif
 575
 576 #ifdef HAVE_LEVEL2
 577
 578 /* tp_iter for the ACL type; since it can be iterated only
 579  * destructively, the type is its iterator
 580  */
 581 static PyObject* ACL_iter(PyObject *obj) {
 582     ACL_Object *self = (ACL_Object*)obj;
 583     self->entry_id = ACL_FIRST_ENTRY;
 584     Py_INCREF(obj);
 585     return obj;
 586 }
 587
 588 /* the tp_iternext function for the ACL type */
 589 static PyObject* ACL_iternext(PyObject *obj) {
 590     ACL_Object *self = (ACL_Object*)obj;
 591     acl_entry_t the_entry_t;
 592     Entry_Object *the_entry_obj;
 593     int nerr;
 594
 595     nerr = acl_get_entry(self->acl, self->entry_id, &the_entry_t);
 596     self->entry_id = ACL_NEXT_ENTRY;
 597     if(nerr == -1)
 598         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
 599     else if(nerr == 0) {
 600         /* Docs says this is not needed */
 601         /*PyErr_SetObject(PyExc_StopIteration, Py_None);*/
 602         return NULL;
 603     }
 604
 605     the_entry_obj = (Entry_Object*) PyType_GenericNew(&Entry_Type, NULL, NULL);
 606     if(the_entry_obj == NULL)
 607         return NULL;
 608
 609     the_entry_obj->entry = the_entry_t;
 610
 611     the_entry_obj->parent_acl = obj;
 612     Py_INCREF(obj); /* For the reference we have in entry->parent */
 613
 614     return (PyObject*)the_entry_obj;
 615 }
 616
 617 static char __ACL_delete_entry_doc__[] =
 618     "delete_entry(entry)\n"
 619     "Deletes an entry from the ACL.\n"
 620     "\n"
 621     ".. note:: Only available with level 2.\n"
 622     "\n"
 623     ":param entry: the Entry object which should be deleted; note that after\n"
 624     "    this function is called, that object is unusable any longer\n"
 625     "    and should be deleted\n"
 626     ;
 627
 628 /* Deletes an entry from the ACL */
 629 static PyObject* ACL_delete_entry(PyObject *obj, PyObject *args) {
 630     ACL_Object *self = (ACL_Object*)obj;
 631     Entry_Object *e;
 632
 633     if (!PyArg_ParseTuple(args, "O!", &Entry_Type, &e))
 634         return NULL;
 635
 636     if (e->parent_acl != obj) {
 637         PyErr_SetString(PyExc_ValueError,
 638                         "Can't remove un-owned entry");
 639         return NULL;
 640     }
 641     if(acl_delete_entry(self->acl, e->entry) == -1)
 642         return PyErr_SetFromErrno(PyExc_IOError);
 643
 644     Py_RETURN_NONE;
 645 }
 646
 647 static char __ACL_calc_mask_doc__[] =
 648     "Compute the file group class mask.\n"
 649     "\n"
 650     "The calc_mask() method calculates and sets the permissions \n"
 651     "associated with the :py:data:`ACL_MASK` Entry of the ACL.\n"
 652     "The value of the new permissions is the union of the permissions \n"
 653     "granted by all entries of tag type :py:data:`ACL_GROUP`, \n"
 654     ":py:data:`ACL_GROUP_OBJ`, or \n"
 655     ":py:data:`ACL_USER`. If the ACL already contains an :py:data:`ACL_MASK`\n"
 656     "entry, its \n"
 657     "permissions are overwritten; if it does not contain an \n"
 658     ":py:data:`ACL_MASK` Entry, one is added.\n"
 659     "\n"
 660     "The order of existing entries in the ACL is undefined after this \n"
 661     "function.\n"
 662     ;
 663
 664 /* Updates the mask entry in the ACL */
 665 static PyObject* ACL_calc_mask(PyObject *obj, PyObject *args) {
 666     ACL_Object *self = (ACL_Object*)obj;
 667
 668     if(acl_calc_mask(&self->acl) == -1)
 669         return PyErr_SetFromErrno(PyExc_IOError);
 670
 671     Py_RETURN_NONE;
 672 }
 673
 674 static char __ACL_append_doc__[] =
 675     "append([entry])\n"
 676     "Append a new Entry to the ACL and return it.\n"
 677     "\n"
 678     "This is a convenience function to create a new Entry \n"
 679     "and append it to the ACL.\n"
 680     "If a parameter of type Entry instance is given, the \n"
 681     "entry will be a copy of that one (as if copied with \n"
 682     ":py:func:`Entry.copy`), otherwise, the new entry will be empty.\n"
 683     "\n"
 684     ":rtype: :py:class:`Entry`\n"
 685     ":returns: the newly created entry\n"
 686     ;
 687
 688 /* Convenience method to create a new Entry */
 689 static PyObject* ACL_append(PyObject *obj, PyObject *args) {
 690     Entry_Object* newentry;
 691     Entry_Object* oldentry = NULL;
 692     int nret;
 693
 694     if (!PyArg_ParseTuple(args, "|O!", &Entry_Type, &oldentry)) {
 695         return NULL;
 696     }
 697
 698     PyObject *new_arglist = Py_BuildValue("(O)", obj);
 699     if (new_arglist == NULL) {
 700         return NULL;
 701     }
 702     newentry = (Entry_Object*) PyObject_CallObject((PyObject*)&Entry_Type, new_arglist);
 703     Py_DECREF(new_arglist);
 704     if(newentry == NULL) {
 705         return NULL;
 706     }
 707
 708     if(oldentry != NULL) {
 709         nret = acl_copy_entry(newentry->entry, oldentry->entry);
 710         if(nret == -1) {
 711             /* LCOV_EXCL_START */
 712             Py_DECREF(newentry);
 713             return PyErr_SetFromErrno(PyExc_IOError);
 714            /* LCOV_EXCL_STOP */
 715         }
 716     }
 717
 718     return (PyObject*)newentry;
 719 }
 720
 721 /***** Entry type *****/
 722
 723 typedef struct {
 724     acl_tag_t tag;
 725     union {
 726         uid_t uid;
 727         gid_t gid;
 728     };
 729 } tag_qual;
 730
 731 /* Pre-declaring the function is more friendly to cpychecker, sigh. */
 732 static int get_tag_qualifier(acl_entry_t entry, tag_qual *tq)
 733   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 734
 735 /* Helper function to get the tag and qualifier of an Entry at the
 736    same time. This is "needed" because the acl_get_qualifier function
 737    returns a pointer to different types, based on the tag value, and
 738    thus it's not straightforward to get the right type.
 739
 740    It sets a Python exception if an error occurs, and returns -1 in
 741    this case. If successful, the tag is set to the tag type, the
 742    qualifier (if any) to either the uid or the gid entry in the
 743    tag_qual structure, and the return value is 0.
 744 */
 745 static int get_tag_qualifier(acl_entry_t entry, tag_qual *tq) {
 746     void *p;
 747
 748     if(acl_get_tag_type(entry, &tq->tag) == -1) {
 749         /* LCOV_EXCL_START */
 750         PyErr_SetFromErrno(PyExc_IOError);
 751         return -1;
 752         /* LCOV_EXCL_STOP */
 753     }
 754     if (tq->tag == ACL_USER || tq->tag == ACL_GROUP) {
 755         if((p = acl_get_qualifier(entry)) == NULL) {
 756             /* LCOV_EXCL_START */
 757             PyErr_SetFromErrno(PyExc_IOError);
 758             return -1;
 759             /* LCOV_EXCL_STOP */
 760         }
 761         if (tq->tag == ACL_USER) {
 762             tq->uid = *(uid_t*)p;
 763         } else {
 764             tq->gid = *(gid_t*)p;
 765         }
 766         acl_free(p);
 767     }
 768     return 0;
 769 }
 770
 771 #define ENTRY_SET_CHECK(self, attr, value)         \
 772     if (value == NULL) { \
 773         PyErr_SetString(PyExc_TypeError, \
 774                         attr " deletion is not supported"); \
 775         return -1; \
 776     }
 777
 778 /* Creation of a new Entry instance */
 779 static PyObject* Entry_new(PyTypeObject* type, PyObject* args,
 780                            PyObject *keywds) {
 781     PyObject* newentry;
 782     Entry_Object* entry;
 783     ACL_Object* parent = NULL;
 784
 785     if (!PyArg_ParseTuple(args, "O!", &ACL_Type, &parent))
 786         return NULL;
 787
 788     newentry = PyType_GenericNew(type, args, keywds);
 789
 790     if(newentry == NULL) {
 791         return NULL;
 792     }
 793
 794     entry = (Entry_Object*)newentry;
 795
 796     if(acl_create_entry(&parent->acl, &entry->entry) == -1) {
 797         /* LCOV_EXCL_START */
 798         PyErr_SetFromErrno(PyExc_IOError);
 799         Py_DECREF(newentry);
 800         return NULL;
 801         /* LCOV_EXCL_STOP */
 802     }
 803     Py_INCREF(parent);
 804     entry->parent_acl = (PyObject*)parent;
 805     return newentry;
 806 }
 807
 808 /* Initialization of a new Entry instance */
 809 static int Entry_init(PyObject* obj, PyObject* args, PyObject *keywds) {
 810     Entry_Object* self = (Entry_Object*) obj;
 811     ACL_Object* parent = NULL;
 812
 813     if (!PyArg_ParseTuple(args, "O!", &ACL_Type, &parent))
 814         return -1;
 815
 816     if ((PyObject*)parent != self->parent_acl) {
 817         PyErr_SetString(PyExc_ValueError,
 818                         "Can't reinitialize with a different parent");
 819         return -1;
 820     }
 821     return 0;
 822 }
 823
 824 /* Free the Entry instance */
 825 static void Entry_dealloc(PyObject* obj) {
 826     Entry_Object *self = (Entry_Object*) obj;
 827     PyObject *err_type, *err_value, *err_traceback;
 828     int have_error = PyErr_Occurred() ? 1 : 0;
 829
 830     if (have_error)
 831         PyErr_Fetch(&err_type, &err_value, &err_traceback);
 832     if(self->parent_acl != NULL) {
 833         Py_DECREF(self->parent_acl);
 834         self->parent_acl = NULL;
 835     }
 836     if (have_error)
 837         PyErr_Restore(err_type, err_value, err_traceback);
 838     PyObject_DEL(self);
 839 }
 840
 841 /* Converts the entry to a text format */
 842 static PyObject* Entry_str(PyObject *obj) {
 843     PyObject *format, *kind;
 844     Entry_Object *self = (Entry_Object*) obj;
 845     tag_qual tq;
 846
 847     if(get_tag_qualifier(self->entry, &tq) < 0) {
 848         return NULL;
 849     }
 850
 851     format = PyUnicode_FromString("ACL entry for ");
 852     if(format == NULL)
 853         return NULL;
 854     switch(tq.tag) {
 855     case ACL_UNDEFINED_TAG:
 856         kind = PyUnicode_FromString("undefined type");
 857         break;
 858     case ACL_USER_OBJ:
 859         kind = PyUnicode_FromString("the owner");
 860         break;
 861     case ACL_GROUP_OBJ:
 862         kind = PyUnicode_FromString("the group");
 863         break;
 864     case ACL_OTHER:
 865         kind = PyUnicode_FromString("the others");
 866         break;
 867     case ACL_USER:
 868         /* FIXME: here and in the group case, we're formatting with
 869            unsigned, because there's no way to automatically determine
 870            the signed-ness of the types; on Linux(glibc) they're
 871            unsigned, so we'll go along with that */
 872         kind = PyUnicode_FromFormat("user with uid %u", tq.uid);
 873         break;
 874     case ACL_GROUP:
 875         kind = PyUnicode_FromFormat("group with gid %u", tq.gid);
 876         break;
 877     case ACL_MASK:
 878         kind = PyUnicode_FromString("the mask");
 879         break;
 880     default: /* LCOV_EXCL_START */
 881         kind = PyUnicode_FromString("UNKNOWN_TAG_TYPE!");
 882         break;
 883         /* LCOV_EXCL_STOP */
 884     }
 885     if (kind == NULL) {
 886         /* LCOV_EXCL_START */
 887         Py_DECREF(format);
 888         return NULL;
 889         /* LCOV_EXCL_STOP */
 890     }
 891     PyObject *ret = PyUnicode_Concat(format, kind);
 892     Py_DECREF(format);
 893     Py_DECREF(kind);
 894     return ret;
 895 }
 896
 897 /* Sets the tag type of the entry */
 898 static int Entry_set_tag_type(PyObject* obj, PyObject* value, void* arg) {
 899     Entry_Object *self = (Entry_Object*) obj;
 900
 901     ENTRY_SET_CHECK(self, "tag type", value);
 902
 903     if(!PyLong_Check(value)) {
 904         PyErr_SetString(PyExc_TypeError,
 905                         "tag type must be integer");
 906         return -1;
 907     }
 908     if(acl_set_tag_type(self->entry, (acl_tag_t)PyLong_AsLong(value)) == -1) {
 909         PyErr_SetFromErrno(PyExc_IOError);
 910         return -1;
 911     }
 912
 913     return 0;
 914 }
 915
 916 /* Returns the tag type of the entry */
 917 static PyObject* Entry_get_tag_type(PyObject *obj, void* arg) {
 918     Entry_Object *self = (Entry_Object*) obj;
 919     acl_tag_t value;
 920
 921     if(acl_get_tag_type(self->entry, &value) == -1) {
 922         /* LCOV_EXCL_START */
 923         PyErr_SetFromErrno(PyExc_IOError);
 924         return NULL;
 925         /* LCOV_EXCL_STOP */
 926     }
 927
 928     return PyLong_FromLong(value);
 929 }
 930
 931 /* Sets the qualifier (either uid_t or gid_t) for the entry,
 932  * usable only if the tag type if ACL_USER or ACL_GROUP
 933  */
 934 static int Entry_set_qualifier(PyObject* obj, PyObject* value, void* arg) {
 935     Entry_Object *self = (Entry_Object*) obj;
 936     unsigned long uidgid;
 937     uid_t uid;
 938     gid_t gid;
 939     void *p;
 940     acl_tag_t tag;
 941
 942     ENTRY_SET_CHECK(self, "qualifier", value);
 943
 944     if(!PyLong_Check(value)) {
 945         PyErr_SetString(PyExc_TypeError,
 946                         "qualifier must be integer");
 947         return -1;
 948     }
 949     /* This is the negative value check, and larger than long
 950        check. If uid_t/gid_t are long-sized, this is enough to check
 951        for both over and underflow. */
 952     if((uidgid = PyLong_AsUnsignedLong(value)) == (unsigned long) -1) {
 953         if(PyErr_Occurred() != NULL) {
 954             return -1;
 955         }
 956     }
 957     /* Due to how acl_set_qualifier takes its argument, we have to do
 958        this ugly dance with two variables and a pointer that will
 959        point to one of them. */
 960     if(acl_get_tag_type(self->entry, &tag) == -1) {
 961         /* LCOV_EXCL_START */
 962         PyErr_SetFromErrno(PyExc_IOError);
 963         return -1;
 964         /* LCOV_EXCL_STOP */
 965     }
 966     uid = uidgid;
 967     gid = uidgid;
 968     /* This is an extra overflow check, in case uid_t/gid_t are
 969        int-sized (and int size smaller than long size). */
 970     switch(tag) {
 971     case ACL_USER:
 972       if((unsigned long)uid != uidgid) {
 973         PyErr_SetString(PyExc_OverflowError, "Can't assign given qualifier");
 974         return -1;
 975       } else {
 976         p = &uid;
 977       }
 978       break;
 979     case ACL_GROUP:
 980       if((unsigned long)gid != uidgid) {
 981         PyErr_SetString(PyExc_OverflowError, "Can't assign given qualifier");
 982         return -1;
 983       } else {
 984         p = &gid;
 985       }
 986       break;
 987     default:
 988       PyErr_SetString(PyExc_TypeError,
 989                       "Can only set qualifiers on ACL_USER or ACL_GROUP entries");
 990       return -1;
 991     }
 992     if(acl_set_qualifier(self->entry, p) == -1) {
 993         /* LCOV_EXCL_START */
 994         PyErr_SetFromErrno(PyExc_IOError);
 995         return -1;
 996         /* LCOV_EXCL_STOP */
 997     }
 998
 999     return 0;
1000 }
1001
1002 /* Returns the qualifier of the entry */
1003 static PyObject* Entry_get_qualifier(PyObject *obj, void* arg) {
1004     Entry_Object *self = (Entry_Object*) obj;
1005     unsigned long value;
1006     tag_qual tq;
1007
1008     if(get_tag_qualifier(self->entry, &tq) < 0) {
1009         return NULL;
1010     }
1011     if (tq.tag == ACL_USER) {
1012         value = tq.uid;
1013     } else if (tq.tag == ACL_GROUP) {
1014         value = tq.gid;
1015     } else {
1016         PyErr_SetString(PyExc_TypeError,
1017                         "Given entry doesn't have an user or"
1018                         " group tag");
1019         return NULL;
1020     }
1021     return PyLong_FromUnsignedLong(value);
1022 }
1023
1024 /* Returns the parent ACL of the entry */
1025 static PyObject* Entry_get_parent(PyObject *obj, void* arg) {
1026     Entry_Object *self = (Entry_Object*) obj;
1027
1028     Py_INCREF(self->parent_acl);
1029     return self->parent_acl;
1030 }
1031
1032 /* Returns the a new Permset representing the permset of the entry
1033  * FIXME: Should return a new reference to the same object, which
1034  * should be created at init time!
1035  */
1036 static PyObject* Entry_get_permset(PyObject *obj, void* arg) {
1037     PyObject *p;
1038
1039     PyObject *perm_arglist = Py_BuildValue("(O)", obj);
1040     if (perm_arglist == NULL) {
1041         return NULL;
1042     }
1043     p = PyObject_CallObject((PyObject*)&Permset_Type, perm_arglist);
1044     Py_DECREF(perm_arglist);
1045     return p;
1046 }
1047
1048 /* Sets the permset of the entry to the passed Permset */
1049 static int Entry_set_permset(PyObject* obj, PyObject* value, void* arg) {
1050     Entry_Object *self = (Entry_Object*)obj;
1051     Permset_Object *p;
1052
1053     ENTRY_SET_CHECK(self, "permset", value);
1054
1055     if(!PyObject_IsInstance(value, (PyObject*)&Permset_Type)) {
1056         PyErr_SetString(PyExc_TypeError, "argument 1 must be posix1e.Permset");
1057         return -1;
1058     }
1059     p = (Permset_Object*)value;
1060     if(acl_set_permset(self->entry, p->permset) == -1) {
1061         /* LCOV_EXCL_START */
1062         PyErr_SetFromErrno(PyExc_IOError);
1063         return -1;
1064         /* LCOV_EXCL_STOP */
1065     }
1066     return 0;
1067 }
1068
1069 static char __Entry_copy_doc__[] =
1070     "copy(src)\n"
1071     "Copies an ACL entry.\n"
1072     "\n"
1073     "This method sets all the parameters to those of another\n"
1074     "entry (either of the same ACL or belonging to another ACL).\n"
1075     "\n"
1076     ":param Entry src: instance of type Entry\n"
1077     ;
1078
1079 /* Sets all the entry parameters to another entry */
1080 static PyObject* Entry_copy(PyObject *obj, PyObject *args) {
1081     Entry_Object *self = (Entry_Object*)obj;
1082     Entry_Object *other;
1083
1084     if(!PyArg_ParseTuple(args, "O!", &Entry_Type, &other))
1085         return NULL;
1086
1087     if(acl_copy_entry(self->entry, other->entry) == -1)
1088         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
1089
1090     Py_RETURN_NONE;
1091 }
1092
1093 /**** Permset type *****/
1094
1095 /* Creation of a new Permset instance */
1096 static PyObject* Permset_new(PyTypeObject* type, PyObject* args,
1097                              PyObject *keywds) {
1098     PyObject* newpermset;
1099     Permset_Object* permset;
1100     Entry_Object* parent = NULL;
1101
1102     if (!PyArg_ParseTuple(args, "O!", &Entry_Type, &parent)) {
1103         return NULL;
1104     }
1105
1106     newpermset = PyType_GenericNew(type, args, keywds);
1107
1108     if(newpermset == NULL) {
1109         return NULL;
1110     }
1111
1112     permset = (Permset_Object*)newpermset;
1113
1114     if(acl_get_permset(parent->entry, &permset->permset) == -1) {
1115         PyErr_SetFromErrno(PyExc_IOError);
1116         Py_DECREF(newpermset);
1117         return NULL;
1118     }
1119
1120     permset->parent_entry = (PyObject*)parent;
1121     Py_INCREF(parent);
1122
1123     return newpermset;
1124 }
1125
1126 /* Initialization of a new Permset instance */
1127 static int Permset_init(PyObject* obj, PyObject* args, PyObject *keywds) {
1128     Permset_Object* self = (Permset_Object*) obj;
1129     Entry_Object* parent = NULL;
1130
1131     if (!PyArg_ParseTuple(args, "O!", &Entry_Type, &parent))
1132         return -1;
1133
1134     if ((PyObject*)parent != self->parent_entry) {
1135         PyErr_SetString(PyExc_ValueError,
1136                         "Can't reinitialize with a different parent");
1137         return -1;
1138     }
1139
1140     return 0;
1141 }
1142
1143 /* Free the Permset instance */
1144 static void Permset_dealloc(PyObject* obj) {
1145     Permset_Object *self = (Permset_Object*) obj;
1146     PyObject *err_type, *err_value, *err_traceback;
1147     int have_error = PyErr_Occurred() ? 1 : 0;
1148
1149     if (have_error)
1150         PyErr_Fetch(&err_type, &err_value, &err_traceback);
1151     if(self->parent_entry != NULL) {
1152         Py_DECREF(self->parent_entry);
1153         self->parent_entry = NULL;
1154     }
1155     if (have_error)
1156         PyErr_Restore(err_type, err_value, err_traceback);
1157     PyObject_DEL(self);
1158 }
1159
1160 /* Permset string representation */
1161 static PyObject* Permset_str(PyObject *obj) {
1162     Permset_Object *self = (Permset_Object*) obj;
1163     char pstr[3];
1164
1165     pstr[0] = get_perm(self->permset, ACL_READ) ? 'r' : '-';
1166     pstr[1] = get_perm(self->permset, ACL_WRITE) ? 'w' : '-';
1167     pstr[2] = get_perm(self->permset, ACL_EXECUTE) ? 'x' : '-';
1168     return PyUnicode_FromStringAndSize(pstr, 3);
1169 }
1170
1171 static char __Permset_clear_doc__[] =
1172     "Clears all permissions from the permission set.\n"
1173     ;
1174
1175 /* Clears all permissions from the permset */
1176 static PyObject* Permset_clear(PyObject* obj, PyObject* args) {
1177     Permset_Object *self = (Permset_Object*) obj;
1178
1179     if(acl_clear_perms(self->permset) == -1)
1180         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
1181
1182     Py_RETURN_NONE;
1183 }
1184
1185 static PyObject* Permset_get_right(PyObject *obj, void* arg) {
1186     Permset_Object *self = (Permset_Object*) obj;
1187
1188     if(get_perm(self->permset, *(acl_perm_t*)arg)) {
1189         Py_RETURN_TRUE;
1190     } else {
1191         Py_RETURN_FALSE;
1192     }
1193 }
1194
1195 static int Permset_set_right(PyObject* obj, PyObject* value, void* arg) {
1196     Permset_Object *self = (Permset_Object*) obj;
1197     int on;
1198     int nerr;
1199
1200     if(!PyLong_Check(value)) {
1201         PyErr_SetString(PyExc_ValueError, "invalid argument, an integer"
1202                         " is expected");
1203         return -1;
1204     }
1205     on = PyLong_AsLong(value);
1206     if(on)
1207         nerr = acl_add_perm(self->permset, *(acl_perm_t*)arg);
1208     else
1209         nerr = acl_delete_perm(self->permset, *(acl_perm_t*)arg);
1210     if(nerr == -1) {
1211         /* LCOV_EXCL_START */
1212         PyErr_SetFromErrno(PyExc_IOError);
1213         return -1;
1214         /* LCOV_EXCL_STOP */
1215     }
1216     return 0;
1217 }
1218
1219 static char __Permset_add_doc__[] =
1220     "add(perm)\n"
1221     "Add a permission to the permission set.\n"
1222     "\n"
1223     "This function adds the permission contained in \n"
1224     "the argument perm to the permission set.  An attempt \n"
1225     "to add a permission that is already contained in the \n"
1226     "permission set is not considered an error.\n"
1227     "\n"
1228     ":param perm: a permission (:py:data:`ACL_WRITE`, :py:data:`ACL_READ`,\n"
1229     "   :py:data:`ACL_EXECUTE`, ...)\n"
1230     ":raises IOError: in case the argument is not a valid descriptor\n"
1231     ;
1232
1233 static PyObject* Permset_add(PyObject* obj, PyObject* args) {
1234     Permset_Object *self = (Permset_Object*) obj;
1235     int right;
1236
1237     if (!PyArg_ParseTuple(args, "i", &right))
1238         return NULL;
1239
1240     if(acl_add_perm(self->permset, (acl_perm_t) right) == -1)
1241         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
1242
1243     Py_RETURN_NONE;
1244 }
1245
1246 static char __Permset_delete_doc__[] =
1247     "delete(perm)\n"
1248     "Delete a permission from the permission set.\n"
1249     "\n"
1250     "This function deletes the permission contained in \n"
1251     "the argument perm from the permission set. An attempt \n"
1252     "to delete a permission that is not contained in the \n"
1253     "permission set is not considered an error.\n"
1254     "\n"
1255     ":param perm: a permission (:py:data:`ACL_WRITE`, :py:data:`ACL_READ`,\n"
1256     "   :py:data:`ACL_EXECUTE`, ...)\n"
1257     ":raises IOError: in case the argument is not a valid descriptor\n"
1258     ;
1259
1260 static PyObject* Permset_delete(PyObject* obj, PyObject* args) {
1261     Permset_Object *self = (Permset_Object*) obj;
1262     int right;
1263
1264     if (!PyArg_ParseTuple(args, "i", &right))
1265         return NULL;
1266
1267     if(acl_delete_perm(self->permset, (acl_perm_t) right) == -1)
1268         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
1269
1270     Py_RETURN_NONE;
1271 }
1272
1273 static char __Permset_test_doc__[] =
1274     "test(perm)\n"
1275     "Test if a permission exists in the permission set.\n"
1276     "\n"
1277     "The test() function tests if the permission represented by\n"
1278     "the argument perm exists in the permission set.\n"
1279     "\n"
1280     ":param perm: a permission (:py:data:`ACL_WRITE`, :py:data:`ACL_READ`,\n"
1281     "   :py:data:`ACL_EXECUTE`, ...)\n"
1282     ":rtype: Boolean\n"
1283     ":raises IOError: in case the argument is not a valid descriptor\n"
1284     ;
1285
1286 static PyObject* Permset_test(PyObject* obj, PyObject* args) {
1287     Permset_Object *self = (Permset_Object*) obj;
1288     int right;
1289     int ret;
1290
1291     if (!PyArg_ParseTuple(args, "i", &right))
1292         return NULL;
1293
1294     ret = get_perm(self->permset, (acl_perm_t) right);
1295     if(ret == -1)
1296         return PyErr_SetFromErrno(PyExc_IOError);  /* LCOV_EXCL_LINE */
1297
1298     if(ret) {
1299         Py_RETURN_TRUE;
1300     } else {
1301         Py_RETURN_FALSE;
1302     }
1303 }
1304
1305 #endif
1306
1307 static char __ACL_Type_doc__[] =
1308     "Type which represents a POSIX ACL\n"
1309     "\n"
1310     ".. note:: only one keyword parameter should be provided\n"
1311     "\n"
1312     ":param string/bytes/path-like file: creates an ACL representing\n"
1313     "    the access ACL of the specified file or directory.\n"
1314     ":param string/bytes/path-like filedef: creates an ACL representing\n"
1315     "    the default ACL of the given directory.\n"
1316     ":param int/iostream fd: creates an ACL representing\n"
1317     "    the access ACL of the given file descriptor.\n"
1318     ":param string text: creates an ACL from a \n"
1319     "    textual description; note the ACL must be valid, which\n"
1320     "    means including a mask for extended ACLs, similar to\n"
1321     "    ``setfacl --no-mask``\n"
1322     ":param ACL acl: creates a copy of an existing ACL instance.\n"
1323     ":param int mode: creates an ACL from a numeric mode\n"
1324     "    (e.g. ``mode=0644``); this is valid only when the C library\n"
1325     "    provides the ``acl_from_mode call``, and\n"
1326     "    note that no validation is done on the given value.\n"
1327     ":param bytes data: creates an ACL from a serialised form,\n"
1328     "    as provided by calling ``__getstate__()`` on an existing ACL\n"
1329     "\n"
1330     "If no parameters are passed, an empty ACL will be created; this\n"
1331     "makes sense only when your OS supports ACL modification\n"
1332     "(i.e. it implements full POSIX.1e support), otherwise the ACL won't\n"
1333     "be useful.\n"
1334     ;
1335
1336 /* ACL type methods */
1337 static PyMethodDef ACL_methods[] = {
1338     {"applyto", ACL_applyto, METH_VARARGS, __applyto_doc__},
1339     {"valid", ACL_valid, METH_NOARGS, __valid_doc__},
1340 #ifdef HAVE_LINUX
1341     {"to_any_text", (PyCFunction)ACL_to_any_text, METH_VARARGS | METH_KEYWORDS,
1342      __to_any_text_doc__},
1343     {"check", ACL_check, METH_NOARGS, __check_doc__},
1344     {"equiv_mode", ACL_equiv_mode, METH_NOARGS, __equiv_mode_doc__},
1345 #endif
1346 #ifdef HAVE_ACL_COPY_EXT
1347     {"__getstate__", ACL_get_state, METH_NOARGS,
1348      "Dumps the ACL to an external format."},
1349     {"__setstate__", ACL_set_state, METH_VARARGS,
1350      "Loads the ACL from an external format."},
1351 #endif
1352 #ifdef HAVE_LEVEL2
1353     {"delete_entry", ACL_delete_entry, METH_VARARGS, __ACL_delete_entry_doc__},
1354     {"calc_mask", ACL_calc_mask, METH_NOARGS, __ACL_calc_mask_doc__},
1355     {"append", ACL_append, METH_VARARGS, __ACL_append_doc__},
1356 #endif
1357     {NULL, NULL, 0, NULL}
1358 };
1359
1360
1361 /* The definition of the ACL Type */
1362 static PyTypeObject ACL_Type = {
1363     PyVarObject_HEAD_INIT(NULL, 0)
1364     "posix1e.ACL",
1365     sizeof(ACL_Object),
1366     0,
1367     ACL_dealloc,        /* tp_dealloc */
1368     0,                  /* tp_print */
1369     0,                  /* tp_getattr */
1370     0,                  /* tp_setattr */
1371     0,                  /* formerly tp_compare, in 3.0 deprecated, in
1372                            3.5 tp_as_async */
1373     0,                  /* tp_repr */
1374     0,                  /* tp_as_number */
1375     0,                  /* tp_as_sequence */
1376     0,                  /* tp_as_mapping */
1377     0,                  /* tp_hash */
1378     0,                  /* tp_call */
1379     ACL_str,            /* tp_str */
1380     0,                  /* tp_getattro */
1381     0,                  /* tp_setattro */
1382     0,                  /* tp_as_buffer */
1383     Py_TPFLAGS_DEFAULT, /* tp_flags */
1384     __ACL_Type_doc__,   /* tp_doc */
1385     0,                  /* tp_traverse */
1386     0,                  /* tp_clear */
1387 #ifdef HAVE_LINUX
1388     ACL_richcompare,    /* tp_richcompare */
1389 #else
1390     0,                  /* tp_richcompare */
1391 #endif
1392     0,                  /* tp_weaklistoffset */
1393 #ifdef HAVE_LEVEL2
1394     ACL_iter,
1395     ACL_iternext,
1396 #else
1397     0,                  /* tp_iter */
1398     0,                  /* tp_iternext */
1399 #endif
1400     ACL_methods,        /* tp_methods */
1401     0,                  /* tp_members */
1402     0,                  /* tp_getset */
1403     0,                  /* tp_base */
1404     0,                  /* tp_dict */
1405     0,                  /* tp_descr_get */
1406     0,                  /* tp_descr_set */
1407     0,                  /* tp_dictoffset */
1408     ACL_init,           /* tp_init */
1409     0,                  /* tp_alloc */
1410     ACL_new,            /* tp_new */
1411 };
1412
1413 #ifdef HAVE_LEVEL2
1414
1415 /* Entry type methods */
1416 static PyMethodDef Entry_methods[] = {
1417     {"copy", Entry_copy, METH_VARARGS, __Entry_copy_doc__},
1418     {NULL, NULL, 0, NULL}
1419 };
1420
1421 static char __Entry_tagtype_doc__[] =
1422     "The tag type of the current entry\n"
1423     "\n"
1424     "This is one of:\n"
1425     " - :py:data:`ACL_UNDEFINED_TAG`\n"
1426     " - :py:data:`ACL_USER_OBJ`\n"
1427     " - :py:data:`ACL_USER`\n"
1428     " - :py:data:`ACL_GROUP_OBJ`\n"
1429     " - :py:data:`ACL_GROUP`\n"
1430     " - :py:data:`ACL_MASK`\n"
1431     " - :py:data:`ACL_OTHER`\n"
1432     ;
1433
1434 static char __Entry_qualifier_doc__[] =
1435     "The qualifier of the current entry\n"
1436     "\n"
1437     "If the tag type is :py:data:`ACL_USER`, this should be a user id.\n"
1438     "If the tag type if :py:data:`ACL_GROUP`, this should be a group id.\n"
1439     "Else it doesn't matter.\n"
1440     ;
1441
1442 static char __Entry_parent_doc__[] =
1443     "The parent ACL of this entry\n"
1444     ;
1445
1446 static char __Entry_permset_doc__[] =
1447     "The permission set of this ACL entry\n"
1448     ;
1449
1450 /* Entry getset */
1451 static PyGetSetDef Entry_getsets[] = {
1452     {"tag_type", Entry_get_tag_type, Entry_set_tag_type,
1453      __Entry_tagtype_doc__},
1454     {"qualifier", Entry_get_qualifier, Entry_set_qualifier,
1455      __Entry_qualifier_doc__},
1456     {"parent", Entry_get_parent, NULL, __Entry_parent_doc__},
1457     {"permset", Entry_get_permset, Entry_set_permset, __Entry_permset_doc__},
1458     {NULL}
1459 };
1460
1461 static char __Entry_Type_doc__[] =
1462     "Type which represents an entry in an ACL.\n"
1463     "\n"
1464     "The type exists only if the OS has full support for POSIX.1e\n"
1465     "Can be created either by:\n"
1466     "\n"
1467     "  >>> e = posix1e.Entry(myACL) # this creates a new entry in the ACL\n"
1468     "  >>> e = myACL.append() # another way for doing the same thing\n"
1469     "\n"
1470     "or by:\n"
1471     "\n"
1472     "  >>> for entry in myACL:\n"
1473     "  ...     print entry\n"
1474     "\n"
1475     "Note that the Entry keeps a reference to its ACL, so even if \n"
1476     "you delete the ACL, it won't be cleaned up and will continue to \n"
1477     "exist until its Entry(ies) will be deleted.\n"
1478     ;
1479 /* The definition of the Entry Type */
1480 static PyTypeObject Entry_Type = {
1481     PyVarObject_HEAD_INIT(NULL, 0)
1482     "posix1e.Entry",
1483     sizeof(Entry_Object),
1484     0,
1485     Entry_dealloc,      /* tp_dealloc */
1486     0,                  /* tp_print */
1487     0,                  /* tp_getattr */
1488     0,                  /* tp_setattr */
1489     0,                  /* tp_compare */
1490     0,                  /* tp_repr */
1491     0,                  /* tp_as_number */
1492     0,                  /* tp_as_sequence */
1493     0,                  /* tp_as_mapping */
1494     0,                  /* tp_hash */
1495     0,                  /* tp_call */
1496     Entry_str,          /* tp_str */
1497     0,                  /* tp_getattro */
1498     0,                  /* tp_setattro */
1499     0,                  /* tp_as_buffer */
1500     Py_TPFLAGS_DEFAULT, /* tp_flags */
1501     __Entry_Type_doc__, /* tp_doc */
1502     0,                  /* tp_traverse */
1503     0,                  /* tp_clear */
1504     0,                  /* tp_richcompare */
1505     0,                  /* tp_weaklistoffset */
1506     0,                  /* tp_iter */
1507     0,                  /* tp_iternext */
1508     Entry_methods,      /* tp_methods */
1509     0,                  /* tp_members */
1510     Entry_getsets,      /* tp_getset */
1511     0,                  /* tp_base */
1512     0,                  /* tp_dict */
1513     0,                  /* tp_descr_get */
1514     0,                  /* tp_descr_set */
1515     0,                  /* tp_dictoffset */
1516     Entry_init,         /* tp_init */
1517     0,                  /* tp_alloc */
1518     Entry_new,          /* tp_new */
1519 };
1520
1521 /* Permset type methods */
1522 static PyMethodDef Permset_methods[] = {
1523     {"clear", Permset_clear, METH_NOARGS, __Permset_clear_doc__, },
1524     {"add", Permset_add, METH_VARARGS, __Permset_add_doc__, },
1525     {"delete", Permset_delete, METH_VARARGS, __Permset_delete_doc__, },
1526     {"test", Permset_test, METH_VARARGS, __Permset_test_doc__, },
1527     {NULL, NULL, 0, NULL}
1528 };
1529
1530 static char __Permset_execute_doc__[] =
1531     "Execute permission property\n"
1532     "\n"
1533     "This is a convenience method of retrieving and setting the execute\n"
1534     "permission in the permission set; the \n"
1535     "same effect can be achieved using the functions\n"
1536     "add(), test(), delete(), and those can take any \n"
1537     "permission defined by your platform.\n"
1538     ;
1539
1540 static char __Permset_read_doc__[] =
1541     "Read permission property\n"
1542     "\n"
1543     "This is a convenience method of retrieving and setting the read\n"
1544     "permission in the permission set; the \n"
1545     "same effect can be achieved using the functions\n"
1546     "add(), test(), delete(), and those can take any \n"
1547     "permission defined by your platform.\n"
1548     ;
1549
1550 static char __Permset_write_doc__[] =
1551     "Write permission property\n"
1552     "\n"
1553     "This is a convenience method of retrieving and setting the write\n"
1554     "permission in the permission set; the \n"
1555     "same effect can be achieved using the functions\n"
1556     "add(), test(), delete(), and those can take any \n"
1557     "permission defined by your platform.\n"
1558     ;
1559
1560 /* Permset getset */
1561 static PyGetSetDef Permset_getsets[] = {
1562     {"execute", Permset_get_right, Permset_set_right,
1563      __Permset_execute_doc__, &holder_ACL_EXECUTE},
1564     {"read", Permset_get_right, Permset_set_right,
1565      __Permset_read_doc__, &holder_ACL_READ},
1566     {"write", Permset_get_right, Permset_set_right,
1567      __Permset_write_doc__, &holder_ACL_WRITE},
1568     {NULL}
1569 };
1570
1571 static char __Permset_Type_doc__[] =
1572     "Type which represents the permission set in an ACL entry\n"
1573     "\n"
1574     "The type exists only if the OS has full support for POSIX.1e\n"
1575     "Can be retrieved either by:\n\n"
1576     ">>> perms = myEntry.permset\n"
1577     "\n"
1578     "or by:\n\n"
1579     ">>> perms = posix1e.Permset(myEntry)\n"
1580     "\n"
1581     "Note that the Permset keeps a reference to its Entry, so even if \n"
1582     "you delete the entry, it won't be cleaned up and will continue to \n"
1583     "exist until its Permset will be deleted.\n"
1584     ;
1585
1586 /* The definition of the Permset Type */
1587 static PyTypeObject Permset_Type = {
1588     PyVarObject_HEAD_INIT(NULL, 0)
1589     "posix1e.Permset",
1590     sizeof(Permset_Object),
1591     0,
1592     Permset_dealloc,    /* tp_dealloc */
1593     0,                  /* tp_print */
1594     0,                  /* tp_getattr */
1595     0,                  /* tp_setattr */
1596     0,                  /* tp_compare */
1597     0,                  /* tp_repr */
1598     0,                  /* tp_as_number */
1599     0,                  /* tp_as_sequence */
1600     0,                  /* tp_as_mapping */
1601     0,                  /* tp_hash */
1602     0,                  /* tp_call */
1603     Permset_str,        /* tp_str */
1604     0,                  /* tp_getattro */
1605     0,                  /* tp_setattro */
1606     0,                  /* tp_as_buffer */
1607     Py_TPFLAGS_DEFAULT, /* tp_flags */
1608     __Permset_Type_doc__,/* tp_doc */
1609     0,                  /* tp_traverse */
1610     0,                  /* tp_clear */
1611     0,                  /* tp_richcompare */
1612     0,                  /* tp_weaklistoffset */
1613     0,                  /* tp_iter */
1614     0,                  /* tp_iternext */
1615     Permset_methods,    /* tp_methods */
1616     0,                  /* tp_members */
1617     Permset_getsets,    /* tp_getset */
1618     0,                  /* tp_base */
1619     0,                  /* tp_dict */
1620     0,                  /* tp_descr_get */
1621     0,                  /* tp_descr_set */
1622     0,                  /* tp_dictoffset */
1623     Permset_init,       /* tp_init */
1624     0,                  /* tp_alloc */
1625     Permset_new,        /* tp_new */
1626 };
1627
1628 #endif
1629
1630 /* Module methods */
1631
1632 static char __deletedef_doc__[] =
1633     "delete_default(path)\n"
1634     "Delete the default ACL from a directory.\n"
1635     "\n"
1636     "This function deletes the default ACL associated with\n"
1637     "a directory (the ACL which will be ANDed with the mode\n"
1638     "parameter to the open, creat functions).\n"
1639     "\n"
1640     ":param string path: the directory whose default ACL should be deleted\n"
1641     ;
1642
1643 /* Deletes the default ACL from a directory */
1644 static PyObject* aclmodule_delete_default(PyObject* obj, PyObject* args) {
1645     char *filename;
1646
1647     /* Parse the arguments */
1648     if (!PyArg_ParseTuple(args, "et", NULL, &filename))
1649         return NULL;
1650
1651     if(acl_delete_def_file(filename) == -1) {
1652         return PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
1653     }
1654
1655     Py_RETURN_NONE;
1656 }
1657
1658 #ifdef HAVE_LINUX
1659 static char __has_extended_doc__[] =
1660     "has_extended(item)\n"
1661     "Check if a file or file handle has an extended ACL.\n"
1662     "\n"
1663     ":param item: either a file name or a file-like object or an integer;\n"
1664     "  it represents the file-system object on which to act\n"
1665     ;
1666
1667 /* Check for extended ACL a file or fd */
1668 static PyObject* aclmodule_has_extended(PyObject* obj, PyObject* args) {
1669     PyObject *item, *tmp;
1670     int nret;
1671     int fd;
1672
1673     if (!PyArg_ParseTuple(args, "O", &item))
1674         return NULL;
1675
1676     if((fd = PyObject_AsFileDescriptor(item)) != -1) {
1677         if((nret = acl_extended_fd(fd)) == -1) {
1678             PyErr_SetFromErrno(PyExc_IOError);
1679         }
1680     } else {
1681       // PyObject_AsFileDescriptor sets an error when failing, so clear
1682       // it such that further code works; some method lookups fail if an
1683       // error already occured when called, which breaks at least
1684       // PyOS_FSPath (called by FSConverter).
1685       PyErr_Clear();
1686       if(PyUnicode_FSConverter(item, &tmp)) {
1687         char *filename = PyBytes_AS_STRING(tmp);
1688         if ((nret = acl_extended_file(filename)) == -1) {
1689             PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
1690         }
1691         Py_DECREF(tmp);
1692       } else {
1693           nret = -1;
1694       }
1695     }
1696
1697     if (nret < 0) {
1698         return NULL;
1699     } else {
1700         return PyBool_FromLong(nret);
1701     }
1702 }
1703 #endif
1704
1705 /* The module methods */
1706 static PyMethodDef aclmodule_methods[] = {
1707     {"delete_default", aclmodule_delete_default, METH_VARARGS,
1708      __deletedef_doc__},
1709 #ifdef HAVE_LINUX
1710     {"has_extended", aclmodule_has_extended, METH_VARARGS,
1711      __has_extended_doc__},
1712 #endif
1713     {NULL, NULL, 0, NULL}
1714 };
1715
1716 static char __posix1e_doc__[] =
1717     "POSIX.1e ACLs manipulation\n"
1718     "==========================\n"
1719     "\n"
1720     "This module provides support for manipulating POSIX.1e ACLS\n"
1721     "\n"
1722     "Depending on the operating system support for POSIX.1e, \n"
1723     "the ACL type will have more or less capabilities:\n\n"
1724     "  - level 1, only basic support, you can create\n"
1725     "    ACLs from files and text descriptions;\n"
1726     "    once created, the type is immutable\n"
1727     "  - level 2, complete support, you can alter\n"
1728     "    the ACL once it is created\n"
1729     "\n"
1730     "Also, in level 2, more types are available, corresponding\n"
1731     "to acl_entry_t (the Entry type), acl_permset_t (the Permset type).\n"
1732     "\n"
1733     "The existence of level 2 support and other extensions can be\n"
1734     "checked by the constants:\n\n"
1735     "  - :py:data:`HAS_ACL_ENTRY` for level 2 and the Entry/Permset classes\n"
1736     "  - :py:data:`HAS_ACL_FROM_MODE` for ``ACL(mode=...)`` usage\n"
1737     "  - :py:data:`HAS_ACL_CHECK` for the :py:func:`ACL.check` function\n"
1738     "  - :py:data:`HAS_EXTENDED_CHECK` for the module-level\n"
1739     "    :py:func:`has_extended` function\n"
1740     "  - :py:data:`HAS_EQUIV_MODE` for the :py:func:`ACL.equiv_mode` method\n"
1741     "  - :py:data:`HAS_COPY_EXT` for the :py:func:`ACL.__getstate__` and\n"
1742     "    :py:func:`ACL.__setstate__` functions (pickle protocol)\n"
1743     "\n"
1744     "Example:\n"
1745     "\n"
1746     ">>> import posix1e\n"
1747     ">>> acl1 = posix1e.ACL(file=\"file.txt\") \n"
1748     ">>> print acl1\n"
1749     "user::rw-\n"
1750     "group::rw-\n"
1751     "other::r--\n"
1752     ">>>\n"
1753     ">>> b = posix1e.ACL(text=\"u::rx,g::-,o::-\")\n"
1754     ">>> print b\n"
1755     "user::r-x\n"
1756     "group::---\n"
1757     "other::---\n"
1758     ">>>\n"
1759     ">>> b.applyto(\"file.txt\")\n"
1760     ">>> print posix1e.ACL(file=\"file.txt\")\n"
1761     "user::r-x\n"
1762     "group::---\n"
1763     "other::---\n"
1764     ">>>\n"
1765     "\n"
1766     ".. py:data:: ACL_USER\n\n"
1767     "   Denotes a specific user entry in an ACL.\n"
1768     "\n"
1769     ".. py:data:: ACL_USER_OBJ\n\n"
1770     "   Denotes the user owner entry in an ACL.\n"
1771     "\n"
1772     ".. py:data:: ACL_GROUP\n\n"
1773     "   Denotes the a group entry in an ACL.\n"
1774     "\n"
1775     ".. py:data:: ACL_GROUP_OBJ\n\n"
1776     "   Denotes the group owner entry in an ACL.\n"
1777     "\n"
1778     ".. py:data:: ACL_OTHER\n\n"
1779     "   Denotes the 'others' entry in an ACL.\n"
1780     "\n"
1781     ".. py:data:: ACL_MASK\n\n"
1782     "   Denotes the mask entry in an ACL, representing the maximum\n"
1783     "   access granted other users, the owner group and other groups.\n"
1784     "\n"
1785     ".. py:data:: ACL_UNDEFINED_TAG\n\n"
1786     "   An undefined tag in an ACL.\n"
1787     "\n"
1788     ".. py:data:: ACL_READ\n\n"
1789     "   Read permission in a permission set.\n"
1790     "\n"
1791     ".. py:data:: ACL_WRITE\n\n"
1792     "   Write permission in a permission set.\n"
1793     "\n"
1794     ".. py:data:: ACL_EXECUTE\n\n"
1795     "   Execute permission in a permission set.\n"
1796     "\n"
1797     ".. py:data:: HAS_ACL_ENTRY\n\n"
1798     "   denotes support for level 2 and the Entry/Permset classes\n"
1799     "\n"
1800     ".. py:data:: HAS_ACL_FROM_MODE\n\n"
1801     "   denotes support for building an ACL from an octal mode\n"
1802     "\n"
1803     ".. py:data:: HAS_ACL_CHECK\n\n"
1804     "   denotes support for extended checks of an ACL's validity\n"
1805     "\n"
1806     ".. py:data:: HAS_EXTENDED_CHECK\n\n"
1807     "   denotes support for checking whether an ACL is basic or extended\n"
1808     "\n"
1809     ".. py:data:: HAS_EQUIV_MODE\n\n"
1810     "   denotes support for the equiv_mode function\n"
1811     "\n"
1812     ".. py:data:: HAS_COPY_EXT\n\n"
1813     "   denotes support for __getstate__()/__setstate__() on an ACL\n"
1814     "\n"
1815     ;
1816
1817 static struct PyModuleDef posix1emodule = {
1818     PyModuleDef_HEAD_INIT,
1819     "posix1e",
1820     __posix1e_doc__,
1821     0,
1822     aclmodule_methods,
1823 };
1824
1825 PyMODINIT_FUNC
1826 PyInit_posix1e(void)
1827 {
1828     PyObject *m, *d;
1829
1830     if(PyType_Ready(&ACL_Type) < 0)
1831         return NULL;
1832
1833 #ifdef HAVE_LEVEL2
1834     if(PyType_Ready(&Entry_Type) < 0)
1835         return NULL;
1836
1837     if(PyType_Ready(&Permset_Type) < 0)
1838         return NULL;
1839 #endif
1840
1841     m = PyModule_Create(&posix1emodule);
1842     if (m==NULL)
1843         return NULL;
1844
1845     d = PyModule_GetDict(m);
1846     if (d == NULL)
1847         return NULL;
1848
1849     Py_INCREF(&ACL_Type);
1850     if (PyDict_SetItemString(d, "ACL",
1851                              (PyObject *) &ACL_Type) < 0)
1852         return NULL;
1853
1854     /* 23.3.6 acl_type_t values */
1855     PyModule_AddIntConstant(m, "ACL_TYPE_ACCESS", ACL_TYPE_ACCESS);
1856     PyModule_AddIntConstant(m, "ACL_TYPE_DEFAULT", ACL_TYPE_DEFAULT);
1857
1858
1859 #ifdef HAVE_LEVEL2
1860     Py_INCREF(&Entry_Type);
1861     if (PyDict_SetItemString(d, "Entry",
1862                              (PyObject *) &Entry_Type) < 0)
1863         return NULL;
1864
1865     Py_INCREF(&Permset_Type);
1866     if (PyDict_SetItemString(d, "Permset",
1867                              (PyObject *) &Permset_Type) < 0)
1868         return NULL;
1869
1870     /* 23.2.2 acl_perm_t values */
1871     PyModule_AddIntConstant(m, "ACL_READ", ACL_READ);
1872     PyModule_AddIntConstant(m, "ACL_WRITE", ACL_WRITE);
1873     PyModule_AddIntConstant(m, "ACL_EXECUTE", ACL_EXECUTE);
1874
1875     /* 23.2.5 acl_tag_t values */
1876     PyModule_AddIntConstant(m, "ACL_UNDEFINED_TAG", ACL_UNDEFINED_TAG);
1877     PyModule_AddIntConstant(m, "ACL_USER_OBJ", ACL_USER_OBJ);
1878     PyModule_AddIntConstant(m, "ACL_USER", ACL_USER);
1879     PyModule_AddIntConstant(m, "ACL_GROUP_OBJ", ACL_GROUP_OBJ);
1880     PyModule_AddIntConstant(m, "ACL_GROUP", ACL_GROUP);
1881     PyModule_AddIntConstant(m, "ACL_MASK", ACL_MASK);
1882     PyModule_AddIntConstant(m, "ACL_OTHER", ACL_OTHER);
1883
1884     /* Document extended functionality via easy-to-use constants */
1885     PyModule_AddIntConstant(m, "HAS_ACL_ENTRY", 1);
1886 #else
1887     PyModule_AddIntConstant(m, "HAS_ACL_ENTRY", 0);
1888 #endif
1889
1890 #ifdef HAVE_LINUX
1891     /* Linux libacl specific acl_to_any_text constants */
1892     PyModule_AddIntConstant(m, "TEXT_ABBREVIATE", TEXT_ABBREVIATE);
1893     PyModule_AddIntConstant(m, "TEXT_NUMERIC_IDS", TEXT_NUMERIC_IDS);
1894     PyModule_AddIntConstant(m, "TEXT_SOME_EFFECTIVE", TEXT_SOME_EFFECTIVE);
1895     PyModule_AddIntConstant(m, "TEXT_ALL_EFFECTIVE", TEXT_ALL_EFFECTIVE);
1896     PyModule_AddIntConstant(m, "TEXT_SMART_INDENT", TEXT_SMART_INDENT);
1897
1898     /* Linux libacl specific acl_check constants */
1899     PyModule_AddIntConstant(m, "ACL_MULTI_ERROR", ACL_MULTI_ERROR);
1900     PyModule_AddIntConstant(m, "ACL_DUPLICATE_ERROR", ACL_DUPLICATE_ERROR);
1901     PyModule_AddIntConstant(m, "ACL_MISS_ERROR", ACL_MISS_ERROR);
1902     PyModule_AddIntConstant(m, "ACL_ENTRY_ERROR", ACL_ENTRY_ERROR);
1903
1904 #define LINUX_EXT_VAL 1
1905 #else
1906 #define LINUX_EXT_VAL 0
1907 #endif
1908     /* declare the Linux extensions */
1909     PyModule_AddIntConstant(m, "HAS_ACL_FROM_MODE", LINUX_EXT_VAL);
1910     PyModule_AddIntConstant(m, "HAS_ACL_CHECK", LINUX_EXT_VAL);
1911     PyModule_AddIntConstant(m, "HAS_EXTENDED_CHECK", LINUX_EXT_VAL);
1912     PyModule_AddIntConstant(m, "HAS_EQUIV_MODE", LINUX_EXT_VAL);
1913
1914     PyModule_AddIntConstant(m, "HAS_COPY_EXT",
1915 #ifdef HAVE_ACL_COPY_EXT
1916                             1
1917 #else
1918                             0
1919 #endif
1920                             );
1921     return m;
1922 }