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