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