acl.c

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