acl.c

   1 #include <sys/types.h>
   2 #include <sys/acl.h>
   3
   4 #include <Python.h>
   5
   6 #ifdef HAVE_LINUX
   7 #include "os_linux.c"
   8 #endif
   9
  10 staticforward PyTypeObject ACL_Type;
  11 static PyObject* ACL_applyto(PyObject* obj, PyObject* args);
  12 static PyObject* ACL_valid(PyObject* obj, PyObject* args);
  13
  14 #ifdef HAVE_LEVEL2
  15 static PyObject* ACL_get_state(PyObject *obj, PyObject* args);
  16 static PyObject* ACL_set_state(PyObject *obj, PyObject* args);
  17
  18 staticforward PyTypeObject Entry_Type;
  19 staticforward PyTypeObject Permset_Type;
  20 static PyObject* Permset_new(PyTypeObject* type, PyObject* args, PyObject *keywds);
  21 #endif
  22
  23 typedef struct {
  24     PyObject_HEAD
  25     acl_t acl;
  26     int entry_id;
  27 } ACL_Object;
  28
  29 #ifdef HAVE_LEVEL2
  30
  31 typedef struct {
  32     PyObject_HEAD
  33     PyObject *parent_acl; /* The parent acl, so it won't run out on us */
  34     acl_entry_t entry;
  35 } Entry_Object;
  36
  37 typedef struct {
  38     PyObject_HEAD
  39     PyObject *parent_entry; /* The parent entry, so it won't run out on us */
  40     acl_permset_t permset;
  41 } Permset_Object;
  42
  43 #endif
  44
  45 /* Creation of a new ACL instance */
  46 static PyObject* ACL_new(PyTypeObject* type, PyObject* args, PyObject *keywds) {
  47     PyObject* newacl;
  48
  49     newacl = type->tp_alloc(type, 0);
  50
  51     if(newacl != NULL) {
  52         ((ACL_Object*)newacl)->acl = NULL;
  53         ((ACL_Object*)newacl)->entry_id = ACL_FIRST_ENTRY;
  54     }
  55
  56     return newacl;
  57 }
  58
  59 /* Initialization of a new ACL instance */
  60 static int ACL_init(PyObject* obj, PyObject* args, PyObject *keywds) {
  61     ACL_Object* self = (ACL_Object*) obj;
  62     static char *kwlist[] = { "file", "fd", "text", "acl", "filedef", NULL };
  63     char *file = NULL;
  64     char *filedef = NULL;
  65     char *text = NULL;
  66     int fd = -1;
  67     ACL_Object* thesrc = NULL;
  68
  69     if(!PyTuple_Check(args) || PyTuple_Size(args) != 0 ||
  70        (keywds != NULL && PyDict_Check(keywds) && PyDict_Size(keywds) > 1)) {
  71         PyErr_SetString(PyExc_ValueError, "a max of one keyword argument must be passed");
  72         return -1;
  73     }
  74     if(!PyArg_ParseTupleAndKeywords(args, keywds, "|sisO!s", kwlist,
  75                                      &file, &fd, &text, &ACL_Type, &thesrc, &filedef))
  76         return -1;
  77
  78     /* Free the old acl_t without checking for error, we don't
  79      * care right now */
  80     if(self->acl != NULL)
  81         acl_free(self->acl);
  82
  83     if(file != NULL)
  84         self->acl = acl_get_file(file, ACL_TYPE_ACCESS);
  85     else if(text != NULL)
  86         self->acl = acl_from_text(text);
  87     else if(fd != -1)
  88         self->acl = acl_get_fd(fd);
  89     else if(thesrc != NULL)
  90         self->acl = acl_dup(thesrc->acl);
  91     else if(filedef != NULL)
  92         self->acl = acl_get_file(filedef, ACL_TYPE_DEFAULT);
  93     else
  94         self->acl = acl_init(0);
  95
  96     if(self->acl == NULL) {
  97         PyErr_SetFromErrno(PyExc_IOError);
  98         return -1;
  99     }
 100
 101     return 0;
 102 }
 103
 104 /* Standard type functions */
 105 static void ACL_dealloc(PyObject* obj) {
 106     ACL_Object *self = (ACL_Object*) obj;
 107     PyObject *err_type, *err_value, *err_traceback;
 108     int have_error = PyErr_Occurred() ? 1 : 0;
 109
 110     if (have_error)
 111         PyErr_Fetch(&err_type, &err_value, &err_traceback);
 112     if(self->acl != NULL && acl_free(self->acl) != 0)
 113         PyErr_WriteUnraisable(obj);
 114     if (have_error)
 115         PyErr_Restore(err_type, err_value, err_traceback);
 116     PyObject_DEL(self);
 117 }
 118
 119 /* Converts the acl to a text format */
 120 static PyObject* ACL_str(PyObject *obj) {
 121     char *text;
 122     ACL_Object *self = (ACL_Object*) obj;
 123     PyObject *ret;
 124
 125     text = acl_to_text(self->acl, NULL);
 126     if(text == NULL) {
 127         return PyErr_SetFromErrno(PyExc_IOError);
 128     }
 129     ret = PyString_FromString(text);
 130     if(acl_free(text) != 0) {
 131         Py_DECREF(ret);
 132         return PyErr_SetFromErrno(PyExc_IOError);
 133     }
 134     return ret;
 135 }
 136
 137 /* Custom methods */
 138 static char __applyto_doc__[] = \
 139 "Apply the ACL to a file or filehandle.\n" \
 140 "\n" \
 141 "Parameters:\n" \
 142 "  - either a filename or a file-like object or an integer; this\n" \
 143 "    represents the filesystem object on which to act\n" \
 144 "  - optional flag representing the type of ACL to set, either\n" \
 145 "    ACL_TYPE_ACCESS (default) or ACL_TYPE_DEFAULT\n" \
 146 ;
 147
 148 /* Applyes the ACL to a file */
 149 static PyObject* ACL_applyto(PyObject* obj, PyObject* args) {
 150     ACL_Object *self = (ACL_Object*) obj;
 151     PyObject *myarg;
 152     acl_type_t type = ACL_TYPE_ACCESS;
 153     int nret;
 154     int fd;
 155
 156     if (!PyArg_ParseTuple(args, "O|i", &myarg, &type))
 157         return NULL;
 158
 159     if(PyString_Check(myarg)) {
 160         char *filename = PyString_AS_STRING(myarg);
 161         nret = acl_set_file(filename, type, self->acl);
 162     } else if((fd = PyObject_AsFileDescriptor(myarg)) != -1) {
 163         nret = acl_set_fd(fd, self->acl);
 164     } else {
 165         PyErr_SetString(PyExc_TypeError, "argument 1 must be string, int, or file-like object");
 166         return 0;
 167     }
 168     if(nret == -1) {
 169         return PyErr_SetFromErrno(PyExc_IOError);
 170     }
 171
 172     /* Return the result */
 173     Py_INCREF(Py_None);
 174     return Py_None;
 175 }
 176
 177 static char __valid_doc__[] = \
 178 "Test the ACL for validity.\n" \
 179 "\n" \
 180 "This method tests the ACL to see if it is a valid ACL\n" \
 181 "in terms of the filesystem. More precisely, it checks:\n" \
 182 "A valid ACL contains exactly one entry with each of the ACL_USER_OBJ,\n" \
 183 "ACL_GROUP_OBJ, and ACL_OTHER tag types. Entries with ACL_USER and\n" \
 184 "ACL_GROUP tag types may appear zero or more times in an ACL. An ACL that\n" \
 185 "contains entries of ACL_USER or ACL_GROUP tag types must contain exactly\n" \
 186 "one entry of the ACL_MASK tag type. If an ACL contains no entries of\n" \
 187 "ACL_USER or ACL_GROUP tag types, the ACL_MASK entry is optional.\n" \
 188 "\n" \
 189 "All user ID qualifiers must be unique among all entries of ACL_USER tag\n" \
 190 "type, and all group IDs must be unique among all entries of ACL_GROUP tag\n" \
 191 "type.\n" \
 192 "\n" \
 193 "The method will return 1 for a valid ACL and 0 for an invalid one.\n" \
 194 "This has been chosen because the specification for acl_valid in POSIX.1e\n" \
 195 "documents only one possible value for errno in case of an invalid ACL, \n" \
 196 "so we can't differentiate between classes of errors. Other suggestions \n" \
 197 "are welcome.\n" \
 198 ;
 199
 200 /* Checks the ACL for validity */
 201 static PyObject* ACL_valid(PyObject* obj, PyObject* args) {
 202     ACL_Object *self = (ACL_Object*) obj;
 203
 204     if(acl_valid(self->acl) == -1) {
 205         Py_INCREF(Py_False);
 206         return Py_False;
 207     } else {
 208         Py_INCREF(Py_True);
 209         return Py_True;
 210     }
 211 }
 212
 213 #ifdef HAVE_LEVEL2
 214
 215 static PyObject* ACL_get_state(PyObject *obj, PyObject* args) {
 216     ACL_Object *self = (ACL_Object*) obj;
 217     PyObject *ret;
 218     ssize_t size, nsize;
 219     char *buf;
 220
 221     size = acl_size(self->acl);
 222     if(size == -1)
 223         return PyErr_SetFromErrno(PyExc_IOError);
 224
 225     if((ret = PyString_FromStringAndSize(NULL, size)) == NULL)
 226         return NULL;
 227     buf = PyString_AsString(ret);
 228
 229     if((nsize = acl_copy_ext(buf, self->acl, size)) == -1) {
 230         Py_DECREF(ret);
 231         return PyErr_SetFromErrno(PyExc_IOError);
 232     }
 233
 234     return ret;
 235 }
 236
 237 static PyObject* ACL_set_state(PyObject *obj, PyObject* args) {
 238     ACL_Object *self = (ACL_Object*) obj;
 239     const void *buf;
 240     int bufsize;
 241     acl_t ptr;
 242
 243     /* Parse the argument */
 244     if (!PyArg_ParseTuple(args, "s#", &buf, &bufsize))
 245         return NULL;
 246
 247     /* Try to import the external representation */
 248     if((ptr = acl_copy_int(buf)) == NULL)
 249         return PyErr_SetFromErrno(PyExc_IOError);
 250
 251     /* Free the old acl. Should we ignore errors here? */
 252     if(self->acl != NULL) {
 253         if(acl_free(self->acl) == -1)
 254             return PyErr_SetFromErrno(PyExc_IOError);
 255     }
 256
 257     self->acl = ptr;
 258
 259     /* Return the result */
 260     Py_INCREF(Py_None);
 261     return Py_None;
 262 }
 263
 264 /* tp_iter for the ACL type; since it can be iterated only
 265  * destructively, the type is its iterator
 266  */
 267 static PyObject* ACL_iter(PyObject *obj) {
 268     ACL_Object *self = (ACL_Object*)obj;
 269     self->entry_id = ACL_FIRST_ENTRY;
 270     Py_INCREF(obj);
 271     return obj;
 272 }
 273
 274 /* the tp_iternext function for the ACL type */
 275 static PyObject* ACL_iternext(PyObject *obj) {
 276     ACL_Object *self = (ACL_Object*)obj;
 277     acl_entry_t the_entry_t;
 278     Entry_Object *the_entry_obj;
 279     int nerr;
 280
 281     nerr = acl_get_entry(self->acl, self->entry_id, &the_entry_t);
 282     self->entry_id = ACL_NEXT_ENTRY;
 283     if(nerr == -1)
 284         return PyErr_SetFromErrno(PyExc_IOError);
 285     else if(nerr == 0) {
 286         /* Docs says this is not needed */
 287         /*PyErr_SetObject(PyExc_StopIteration, Py_None);*/
 288         return NULL;
 289     }
 290
 291     the_entry_obj = (Entry_Object*) PyType_GenericNew(&Entry_Type, NULL, NULL);
 292     if(the_entry_obj == NULL)
 293         return NULL;
 294
 295     the_entry_obj->entry = the_entry_t;
 296
 297     the_entry_obj->parent_acl = obj;
 298     Py_INCREF(obj); /* For the reference we have in entry->parent */
 299
 300     return (PyObject*)the_entry_obj;
 301 }
 302
 303 static char __ACL_delentry_doc__[] = \
 304 "Deletes an entry from the ACL.\n" \
 305 "\n" \
 306 "Note: Only with level 2\n" \
 307 "Parameters:\n" \
 308 " - the Entry object which should be deleted; note that after\n" \
 309 "   this function is called, that object is unusable any longer\n" \
 310 "   and should be deleted\n" \
 311 ;
 312
 313 /* Deletes an entry from the ACL */
 314 static PyObject* ACL_delentry(PyObject *obj, PyObject *args) {
 315     ACL_Object *self = (ACL_Object*)obj;
 316     Entry_Object *e;
 317
 318     if (!PyArg_ParseTuple(args, "O!", &Entry_Type, &e))
 319         return NULL;
 320
 321     if(acl_delete_entry(self->acl, e->entry) == -1)
 322         return PyErr_SetFromErrno(PyExc_IOError);
 323
 324     /* Return the result */
 325     Py_INCREF(Py_None);
 326     return Py_None;
 327 }
 328
 329 /* Creation of a new Entry instance */
 330 static PyObject* Entry_new(PyTypeObject* type, PyObject* args, PyObject *keywds) {
 331     PyObject* newentry;
 332
 333     newentry = PyType_GenericNew(type, args, keywds);
 334
 335     if(newentry != NULL) {
 336         ((Entry_Object*)newentry)->entry = NULL;
 337         ((Entry_Object*)newentry)->parent_acl = NULL;
 338     }
 339
 340     return newentry;
 341 }
 342
 343 /* Initialization of a new Entry instance */
 344 static int Entry_init(PyObject* obj, PyObject* args, PyObject *keywds) {
 345     Entry_Object* self = (Entry_Object*) obj;
 346     ACL_Object* parent = NULL;
 347
 348     if (!PyArg_ParseTuple(args, "O!", &ACL_Type, &parent))
 349         return -1;
 350
 351     if(acl_create_entry(&parent->acl, &self->entry) == -1) {
 352         PyErr_SetFromErrno(PyExc_IOError);
 353         return -1;
 354     }
 355
 356     self->parent_acl = (PyObject*)parent;
 357     Py_INCREF(parent);
 358
 359     return 0;
 360 }
 361
 362 /* Free the Entry instance */
 363 static void Entry_dealloc(PyObject* obj) {
 364     Entry_Object *self = (Entry_Object*) obj;
 365     PyObject *err_type, *err_value, *err_traceback;
 366     int have_error = PyErr_Occurred() ? 1 : 0;
 367
 368     if (have_error)
 369         PyErr_Fetch(&err_type, &err_value, &err_traceback);
 370     if(self->parent_acl != NULL) {
 371         Py_DECREF(self->parent_acl);
 372         self->parent_acl = NULL;
 373     }
 374     if (have_error)
 375         PyErr_Restore(err_type, err_value, err_traceback);
 376     PyObject_DEL(self);
 377 }
 378
 379 /* Converts the entry to a text format */
 380 static PyObject* Entry_str(PyObject *obj) {
 381     acl_tag_t tag;
 382     uid_t qualifier;
 383     void *p;
 384     PyObject *ret;
 385     PyObject *format, *list;
 386     Entry_Object *self = (Entry_Object*) obj;
 387
 388     if(acl_get_tag_type(self->entry, &tag) == -1) {
 389         PyErr_SetFromErrno(PyExc_IOError);
 390         return NULL;
 391     }
 392     if(tag == ACL_USER || tag == ACL_GROUP) {
 393         if((p = acl_get_qualifier(self->entry)) == NULL) {
 394             PyErr_SetFromErrno(PyExc_IOError);
 395             return NULL;
 396         }
 397         qualifier = *(uid_t*)p;
 398         acl_free(p);
 399     } else {
 400         qualifier = 0;
 401     }
 402
 403     format = PyString_FromString("ACL entry for %s");
 404     if(format == NULL)
 405         return NULL;
 406     list = PyTuple_New(1);
 407     if(tag == ACL_UNDEFINED_TAG) {
 408         PyTuple_SetItem(list, 0, PyString_FromString("undefined type"));
 409     } else if(tag == ACL_USER_OBJ) {
 410         PyTuple_SetItem(list, 0, PyString_FromString("the owner"));
 411     } else if(tag == ACL_GROUP_OBJ) {
 412         PyTuple_SetItem(list, 0, PyString_FromString("the group"));
 413     } else if(tag == ACL_OTHER) {
 414         PyTuple_SetItem(list, 0, PyString_FromString("the others"));
 415     } else if(tag == ACL_USER) {
 416         PyTuple_SetItem(list, 0, PyString_FromFormat("user with uid %d", qualifier));
 417     } else if(tag == ACL_GROUP) {
 418         PyTuple_SetItem(list, 0, PyString_FromFormat("group with gid %d", qualifier));
 419     } else if(tag == ACL_MASK) {
 420         PyTuple_SetItem(list, 0, PyString_FromString("the mask"));
 421     } else {
 422         PyTuple_SetItem(list, 0, PyString_FromString("UNKNOWN_TAG_TYPE!"));
 423     }
 424     ret = PyString_Format(format, list);
 425     Py_DECREF(format);
 426     Py_DECREF(list);
 427     return ret;
 428 }
 429
 430 /* Sets the tag type of the entry */
 431 static int Entry_set_tag_type(PyObject* obj, PyObject* value, void* arg) {
 432     Entry_Object *self = (Entry_Object*) obj;
 433
 434     if(value == NULL) {
 435         PyErr_SetString(PyExc_TypeError,
 436                         "tag type deletion is not supported");
 437         return -1;
 438     }
 439
 440     if(!PyInt_Check(value)) {
 441         PyErr_SetString(PyExc_TypeError,
 442                         "tag type must be integer");
 443         return -1;
 444     }
 445     if(acl_set_tag_type(self->entry, (acl_tag_t)PyInt_AsLong(value)) == -1) {
 446         PyErr_SetFromErrno(PyExc_IOError);
 447         return -1;
 448     }
 449
 450     return 0;
 451 }
 452
 453 /* Returns the tag type of the entry */
 454 static PyObject* Entry_get_tag_type(PyObject *obj, void* arg) {
 455     Entry_Object *self = (Entry_Object*) obj;
 456     acl_tag_t value;
 457
 458     if (self->entry == NULL) {
 459         PyErr_SetString(PyExc_AttributeError, "entry attribute");
 460         return NULL;
 461     }
 462     if(acl_get_tag_type(self->entry, &value) == -1) {
 463         PyErr_SetFromErrno(PyExc_IOError);
 464         return NULL;
 465     }
 466
 467     return PyInt_FromLong(value);
 468 }
 469
 470 /* Sets the qualifier (either uid_t or gid_t) for the entry,
 471  * usable only if the tag type if ACL_USER or ACL_GROUP
 472  */
 473 static int Entry_set_qualifier(PyObject* obj, PyObject* value, void* arg) {
 474     Entry_Object *self = (Entry_Object*) obj;
 475     int uidgid;
 476
 477     if(value == NULL) {
 478         PyErr_SetString(PyExc_TypeError,
 479                         "qualifier deletion is not supported");
 480         return -1;
 481     }
 482
 483     if(!PyInt_Check(value)) {
 484         PyErr_SetString(PyExc_TypeError,
 485                         "tag type must be integer");
 486         return -1;
 487     }
 488     uidgid = PyInt_AsLong(value);
 489     if(acl_set_qualifier(self->entry, (void*)&uidgid) == -1) {
 490         PyErr_SetFromErrno(PyExc_IOError);
 491         return -1;
 492     }
 493
 494     return 0;
 495 }
 496
 497 /* Returns the qualifier of the entry */
 498 static PyObject* Entry_get_qualifier(PyObject *obj, void* arg) {
 499     Entry_Object *self = (Entry_Object*) obj;
 500     void *p;
 501     int value;
 502
 503     if (self->entry == NULL) {
 504         PyErr_SetString(PyExc_AttributeError, "entry attribute");
 505         return NULL;
 506     }
 507     if((p = acl_get_qualifier(self->entry)) == NULL) {
 508         PyErr_SetFromErrno(PyExc_IOError);
 509         return NULL;
 510     }
 511     value = *(uid_t*)p;
 512     acl_free(p);
 513
 514     return PyInt_FromLong(value);
 515 }
 516
 517 /* Returns the parent ACL of the entry */
 518 static PyObject* Entry_get_parent(PyObject *obj, void* arg) {
 519     Entry_Object *self = (Entry_Object*) obj;
 520
 521     Py_INCREF(self->parent_acl);
 522     return self->parent_acl;
 523 }
 524
 525 /* Returns the a new Permset representing the permset of the entry
 526  * FIXME: Should return a new reference to the same object, which
 527  * should be created at init time!
 528 */
 529 static PyObject* Entry_get_permset(PyObject *obj, void* arg) {
 530     Entry_Object *self = (Entry_Object*)obj;
 531     PyObject *p;
 532     Permset_Object *ps;
 533
 534     p = Permset_new(&Permset_Type, NULL, NULL);
 535     if(p == NULL)
 536         return NULL;
 537     ps = (Permset_Object*)p;
 538     if(acl_get_permset(self->entry, &ps->permset) == -1) {
 539         PyErr_SetFromErrno(PyExc_IOError);
 540         return NULL;
 541     }
 542     ps->parent_entry = obj;
 543     Py_INCREF(obj);
 544
 545     return (PyObject*)p;
 546 }
 547
 548 /* Sets the permset of the entry to the passed Permset */
 549 static int Entry_set_permset(PyObject* obj, PyObject* value, void* arg) {
 550     Entry_Object *self = (Entry_Object*)obj;
 551     Permset_Object *p;
 552
 553     if(!PyObject_IsInstance(value, (PyObject*)&Permset_Type)) {
 554         PyErr_SetString(PyExc_TypeError, "argument 1 must be posix1e.Permset");
 555         return -1;
 556     }
 557     p = (Permset_Object*)value;
 558     if(acl_set_permset(self->entry, p->permset) == -1) {
 559         PyErr_SetFromErrno(PyExc_IOError);
 560         return -1;
 561     }
 562     return 0;
 563 }
 564
 565 static char __Entry_copy_doc__[] = \
 566 "Copy an ACL entry.\n" \
 567 "\n" \
 568 "This method sets all the parameters to those of another\n" \
 569 "entry, even one of another's ACL\n" \
 570 "Parameters:\n" \
 571 " - src, instance of type Entry\n" \
 572 ;
 573
 574 /* Sets all the entry parameters to another's entry */
 575 static PyObject* Entry_copy(PyObject *obj, PyObject *args) {
 576     Entry_Object *self = (Entry_Object*)obj;
 577     Entry_Object *other;
 578
 579     if(!PyArg_ParseTuple(args, "O!", &Entry_Type, &other))
 580         return NULL;
 581
 582     if(acl_copy_entry(self->entry, other->entry) == -1)
 583         return PyErr_SetFromErrno(PyExc_IOError);
 584
 585     Py_INCREF(Py_None);
 586     return Py_None;
 587 }
 588
 589 /**** Permset type *****/
 590
 591 /* Creation of a new Permset instance */
 592 static PyObject* Permset_new(PyTypeObject* type, PyObject* args, PyObject *keywds) {
 593     PyObject* newpermset;
 594
 595     newpermset = PyType_GenericNew(type, args, keywds);
 596
 597     if(newpermset != NULL) {
 598         ((Permset_Object*)newpermset)->permset = NULL;
 599         ((Permset_Object*)newpermset)->parent_entry = NULL;
 600     }
 601
 602     return newpermset;
 603 }
 604
 605 /* Initialization of a new Permset instance */
 606 static int Permset_init(PyObject* obj, PyObject* args, PyObject *keywds) {
 607     Permset_Object* self = (Permset_Object*) obj;
 608     Entry_Object* parent = NULL;
 609
 610     if (!PyArg_ParseTuple(args, "O!", &Entry_Type, &parent))
 611         return -1;
 612
 613     if(acl_get_permset(parent->entry, &self->permset) == -1) {
 614         PyErr_SetFromErrno(PyExc_IOError);
 615         return -1;
 616     }
 617
 618     self->parent_entry = (PyObject*)parent;
 619     Py_INCREF(parent);
 620
 621     return 0;
 622 }
 623
 624 /* Free the Permset instance */
 625 static void Permset_dealloc(PyObject* obj) {
 626     Permset_Object *self = (Permset_Object*) obj;
 627     PyObject *err_type, *err_value, *err_traceback;
 628     int have_error = PyErr_Occurred() ? 1 : 0;
 629
 630     if (have_error)
 631         PyErr_Fetch(&err_type, &err_value, &err_traceback);
 632     if(self->parent_entry != NULL) {
 633         Py_DECREF(self->parent_entry);
 634         self->parent_entry = NULL;
 635     }
 636     if (have_error)
 637         PyErr_Restore(err_type, err_value, err_traceback);
 638     PyObject_DEL(self);
 639 }
 640
 641 /* Permset string representation */
 642 static PyObject* Permset_str(PyObject *obj) {
 643     Permset_Object *self = (Permset_Object*) obj;
 644     char pstr[3];
 645
 646     pstr[0] = get_perm(self->permset, ACL_READ) ? 'r' : '-';
 647     pstr[1] = get_perm(self->permset, ACL_WRITE) ? 'w' : '-';
 648     pstr[2] = get_perm(self->permset, ACL_EXECUTE) ? 'x' : '-';
 649     return PyString_FromStringAndSize(pstr, 3);
 650 }
 651
 652 static char __Permset_clear_doc__[] = \
 653 "Clear all permissions from the permission set.\n" \
 654 ;
 655
 656 /* Clears all permissions from the permset */
 657 static PyObject* Permset_clear(PyObject* obj, PyObject* args) {
 658     Permset_Object *self = (Permset_Object*) obj;
 659
 660     if(acl_clear_perms(self->permset) == -1)
 661         return PyErr_SetFromErrno(PyExc_IOError);
 662
 663     /* Return the result */
 664     Py_INCREF(Py_None);
 665     return Py_None;
 666 }
 667
 668 static PyObject* Permset_get_right(PyObject *obj, void* arg) {
 669     Permset_Object *self = (Permset_Object*) obj;
 670
 671     if(get_perm(self->permset, (int)arg)) {
 672         Py_INCREF(Py_True);
 673         return Py_True;
 674     } else {
 675         Py_INCREF(Py_False);
 676         return Py_False;
 677     }
 678 }
 679
 680 static int Permset_set_right(PyObject* obj, PyObject* value, void* arg) {
 681     Permset_Object *self = (Permset_Object*) obj;
 682     int on;
 683     int nerr;
 684
 685     if(!PyInt_Check(value)) {
 686         PyErr_SetString(PyExc_ValueError, "a maximum of one argument must be passed");
 687         return -1;
 688     }
 689     on = PyInt_AsLong(value);
 690     if(on)
 691         nerr = acl_add_perm(self->permset, (int)arg);
 692     else
 693         nerr = acl_delete_perm(self->permset, (int)arg);
 694     if(nerr == -1) {
 695         PyErr_SetFromErrno(PyExc_IOError);
 696         return -1;
 697     }
 698     return 0;
 699 }
 700
 701 #endif
 702
 703 static char __ACL_Type_doc__[] = \
 704 "Type which represents a POSIX ACL\n" \
 705 "\n" \
 706 "Parameters:\n" \
 707 "  Only one keword parameter should be provided:\n"
 708 "  - file=\"...\", meaning create ACL representing\n"
 709 "    the access ACL of that file\n" \
 710 "  - filedef=\"...\", meaning create ACL representing\n"
 711 "    the default ACL of that directory\n" \
 712 "  - fd=<int>, meaning create ACL representing\n" \
 713 "    the access ACL of that file descriptor\n" \
 714 "  - text=\"...\", meaning create ACL from a \n" \
 715 "    textual description\n" \
 716 "  - acl=<ACL instance>, meaning create a copy\n" \
 717 "    of an existing ACL instance\n" \
 718 "If no parameters are passed, create an empty ACL; this\n" \
 719 "makes sense only when your OS supports ACL modification\n" \
 720 " (i.e. it implements full POSIX.1e support)\n" \
 721 ;
 722
 723 /* ACL type methods */
 724 static PyMethodDef ACL_methods[] = {
 725     {"applyto", ACL_applyto, METH_VARARGS, __applyto_doc__},
 726     {"valid", ACL_valid, METH_NOARGS, __valid_doc__},
 727 #ifdef HAVE_LEVEL2
 728     {"__getstate__", ACL_get_state, METH_NOARGS, "Dumps the ACL to an external format."},
 729     {"__setstate__", ACL_set_state, METH_VARARGS, "Loads the ACL from an external format."},
 730     {"delentry", ACL_delentry, METH_VARARGS, __ACL_delentry_doc__},
 731 #endif
 732     {NULL, NULL, 0, NULL}
 733 };
 734
 735
 736 /* The definition of the ACL Type */
 737 static PyTypeObject ACL_Type = {
 738     PyObject_HEAD_INIT(NULL)
 739     0,
 740     "posix1e.ACL",
 741     sizeof(ACL_Object),
 742     0,
 743     ACL_dealloc,        /* tp_dealloc */
 744     0,                  /* tp_print */
 745     0,                  /* tp_getattr */
 746     0,                  /* tp_setattr */
 747     0,                  /* tp_compare */
 748     0,                  /* tp_repr */
 749     0,                  /* tp_as_number */
 750     0,                  /* tp_as_sequence */
 751     0,                  /* tp_as_mapping */
 752     0,                  /* tp_hash */
 753     0,                  /* tp_call */
 754     ACL_str,            /* tp_str */
 755     0,                  /* tp_getattro */
 756     0,                  /* tp_setattro */
 757     0,                  /* tp_as_buffer */
 758     Py_TPFLAGS_DEFAULT, /* tp_flags */
 759     __ACL_Type_doc__,   /* tp_doc */
 760     0,                  /* tp_traverse */
 761     0,                  /* tp_clear */
 762     0,                  /* tp_richcompare */
 763     0,                  /* tp_weaklistoffset */
 764 #ifdef HAVE_LEVEL2
 765     ACL_iter,
 766     ACL_iternext,
 767 #else
 768     0,                  /* tp_iter */
 769     0,                  /* tp_iternext */
 770 #endif
 771     ACL_methods,        /* tp_methods */
 772     0,                  /* tp_members */
 773     0,                  /* tp_getset */
 774     0,                  /* tp_base */
 775     0,                  /* tp_dict */
 776     0,                  /* tp_descr_get */
 777     0,                  /* tp_descr_set */
 778     0,                  /* tp_dictoffset */
 779     ACL_init,           /* tp_init */
 780     0,                  /* tp_alloc */
 781     ACL_new,            /* tp_new */
 782 };
 783
 784 #ifdef HAVE_LEVEL2
 785
 786 /* Entry type methods */
 787 static PyMethodDef Entry_methods[] = {
 788     {"copy", Entry_copy, METH_VARARGS, __Entry_copy_doc__},
 789     {NULL, NULL, 0, NULL}
 790 };
 791
 792 static char __Entry_tagtype_doc__[] = \
 793 "The tag type of the current entry\n" \
 794 "\n" \
 795 "This is one of:\n" \
 796 " - ACL_UNDEFINED_TAG\n" \
 797 " - ACL_USER_OBJ\n" \
 798 " - ACL_USER\n" \
 799 " - ACL_GROUP_OBJ\n" \
 800 " - ACL_GROUP\n" \
 801 " - ACL_MASK\n" \
 802 " - ACL_OTHER\n" \
 803 ;
 804
 805 static char __Entry_qualifier_doc__[] = \
 806 "The qualifier of the current entry\n" \
 807 "\n" \
 808 "If the tag type is ACL_USER, this should be a user id.\n" \
 809 "If the tag type if ACL_GROUP, this should be a group id.\n" \
 810 "Else, it doesn't matter.\n" \
 811 ;
 812
 813 static char __Entry_parent_doc__[] = \
 814 "The parent ACL of this entry\n" \
 815 ;
 816
 817 static char __Entry_permset_doc__[] = \
 818 "The permission set of this ACL entry\n" \
 819 ;
 820
 821 /* Entry getset */
 822 static PyGetSetDef Entry_getsets[] = {
 823     {"tag_type", Entry_get_tag_type, Entry_set_tag_type, __Entry_tagtype_doc__},
 824     {"qualifier", Entry_get_qualifier, Entry_set_qualifier, __Entry_qualifier_doc__},
 825     {"parent", Entry_get_parent, NULL, __Entry_parent_doc__},
 826     {"permset", Entry_get_permset, Entry_set_permset, __Entry_permset_doc__},
 827     {NULL}
 828 };
 829
 830 static char __Entry_Type_doc__[] = \
 831 "Type which represents an entry in an ACL.\n" \
 832 "\n" \
 833 "The type exists only if the OS has full support for POSIX.1e\n" \
 834 "Can be created either by:\n" \
 835 "  e = posix1e.Entry(myACL) # this creates a new entry in the ACL\n" \
 836 "or by:\n" \
 837 "  for entry in myACL:\n" \
 838 "      print entry\n" \
 839 ;
 840 /* The definition of the Entry Type */
 841 static PyTypeObject Entry_Type = {
 842     PyObject_HEAD_INIT(NULL)
 843     0,
 844     "posix1e.Entry",
 845     sizeof(Entry_Object),
 846     0,
 847     Entry_dealloc,      /* tp_dealloc */
 848     0,                  /* tp_print */
 849     0,                  /* tp_getattr */
 850     0,                  /* tp_setattr */
 851     0,                  /* tp_compare */
 852     0,                  /* tp_repr */
 853     0,                  /* tp_as_number */
 854     0,                  /* tp_as_sequence */
 855     0,                  /* tp_as_mapping */
 856     0,                  /* tp_hash */
 857     0,                  /* tp_call */
 858     Entry_str,          /* tp_str */
 859     0,                  /* tp_getattro */
 860     0,                  /* tp_setattro */
 861     0,                  /* tp_as_buffer */
 862     Py_TPFLAGS_DEFAULT, /* tp_flags */
 863     __Entry_Type_doc__, /* tp_doc */
 864     0,                  /* tp_traverse */
 865     0,                  /* tp_clear */
 866     0,                  /* tp_richcompare */
 867     0,                  /* tp_weaklistoffset */
 868     0,                  /* tp_iter */
 869     0,                  /* tp_iternext */
 870     Entry_methods,      /* tp_methods */
 871     0,                  /* tp_members */
 872     Entry_getsets,      /* tp_getset */
 873     0,                  /* tp_base */
 874     0,                  /* tp_dict */
 875     0,                  /* tp_descr_get */
 876     0,                  /* tp_descr_set */
 877     0,                  /* tp_dictoffset */
 878     Entry_init,         /* tp_init */
 879     0,                  /* tp_alloc */
 880     Entry_new,          /* tp_new */
 881 };
 882
 883 /* Permset type methods */
 884 static PyMethodDef Permset_methods[] = {
 885     {"clear", Permset_clear, METH_NOARGS, __Permset_clear_doc__, },
 886     {NULL, NULL, 0, NULL}
 887 };
 888
 889 static char __Permset_execute_doc__[] = \
 890 "Execute permsission\n" \
 891 ;
 892
 893 static char __Permset_read_doc__[] = \
 894 "Read permsission\n" \
 895 ;
 896
 897 static char __Permset_write_doc__[] = \
 898 "Write permsission\n" \
 899 ;
 900
 901 /* Permset getset */
 902 static PyGetSetDef Permset_getsets[] = {
 903     {"execute", Permset_get_right, Permset_set_right, __Permset_execute_doc__, (void*)ACL_EXECUTE},
 904     {"read", Permset_get_right, Permset_set_right, __Permset_read_doc__, (void*)ACL_READ},
 905     {"write", Permset_get_right, Permset_set_right, __Permset_write_doc__, (void*)ACL_WRITE},
 906     {NULL}
 907 };
 908
 909 static char __Permset_Type_doc__[] = \
 910 "Type which represents the permission set in an ACL entry\n" \
 911 "\n" \
 912 "The type exists only if the OS has full support for POSIX.1e\n" \
 913 "Can be created either by:\n" \
 914 "  perms = myEntry.permset\n" \
 915 "or by:\n" \
 916 "  perms = posix1e.Permset(myEntry)\n" \
 917 ;
 918
 919 /* The definition of the Permset Type */
 920 static PyTypeObject Permset_Type = {
 921     PyObject_HEAD_INIT(NULL)
 922     0,
 923     "posix1e.Permset",
 924     sizeof(Permset_Object),
 925     0,
 926     Permset_dealloc,    /* tp_dealloc */
 927     0,                  /* tp_print */
 928     0,                  /* tp_getattr */
 929     0,                  /* tp_setattr */
 930     0,                  /* tp_compare */
 931     0,                  /* tp_repr */
 932     0,                  /* tp_as_number */
 933     0,                  /* tp_as_sequence */
 934     0,                  /* tp_as_mapping */
 935     0,                  /* tp_hash */
 936     0,                  /* tp_call */
 937     Permset_str,        /* tp_str */
 938     0,                  /* tp_getattro */
 939     0,                  /* tp_setattro */
 940     0,                  /* tp_as_buffer */
 941     Py_TPFLAGS_DEFAULT, /* tp_flags */
 942     __Permset_Type_doc__,/* tp_doc */
 943     0,                  /* tp_traverse */
 944     0,                  /* tp_clear */
 945     0,                  /* tp_richcompare */
 946     0,                  /* tp_weaklistoffset */
 947     0,                  /* tp_iter */
 948     0,                  /* tp_iternext */
 949     Permset_methods,    /* tp_methods */
 950     0,                  /* tp_members */
 951     Permset_getsets,    /* tp_getset */
 952     0,                  /* tp_base */
 953     0,                  /* tp_dict */
 954     0,                  /* tp_descr_get */
 955     0,                  /* tp_descr_set */
 956     0,                  /* tp_dictoffset */
 957     Permset_init,       /* tp_init */
 958     0,                  /* tp_alloc */
 959     Permset_new,        /* tp_new */
 960 };
 961
 962 #endif
 963
 964 /* Module methods */
 965
 966 static char __deletedef_doc__[] = \
 967 "Delete the default ACL from a directory.\n" \
 968 "\n" \
 969 "This function deletes the default ACL associated with \n" \
 970 "a directory (the ACL which will be ANDed with the mode\n" \
 971 "parameter to the open, creat functions).\n" \
 972 "Parameters:\n" \
 973 "  - a string representing the directory whose default ACL\n" \
 974 "    should be deleted\n" \
 975 ;
 976
 977 /* Deletes the default ACL from a directory */
 978 static PyObject* aclmodule_delete_default(PyObject* obj, PyObject* args) {
 979     char *filename;
 980
 981     /* Parse the arguments */
 982     if (!PyArg_ParseTuple(args, "s", &filename))
 983         return NULL;
 984
 985     if(acl_delete_def_file(filename) == -1) {
 986         return PyErr_SetFromErrno(PyExc_IOError);
 987     }
 988
 989     /* Return the result */
 990     Py_INCREF(Py_None);
 991     return Py_None;
 992 }
 993
 994 /* The module methods */
 995 static PyMethodDef aclmodule_methods[] = {
 996     {"delete_default", aclmodule_delete_default, METH_VARARGS, __deletedef_doc__},
 997     {NULL, NULL, 0, NULL}
 998 };
 999
1000 static char __posix1e_doc__[] = \
1001 "POSIX.1e ACLs manipulation\n" \
1002 "\n" \
1003 "This module provides support for manipulating POSIX.1e ACLS\n" \
1004 "\n" \
1005 "Depending on the operating system support for POSIX.1e, \n" \
1006 "the ACL type will have more or less capabilities:\n" \
1007 "  - level 1, only basic support, you can create\n" \
1008 "    ACLs from files and text descriptions;\n" \
1009 "    once created, the type is immutable\n" \
1010 "  - level 2, complete support, you can alter\n"\
1011 "    the ACL once it is created\n" \
1012 "\n" \
1013 "Also, in level 2, more types are available, corresponding\n" \
1014 "to acl_entry_t (Entry type), acl_permset_t (Permset type).\n" \
1015 "\n" \
1016 "Example:\n" \
1017 ">>> import posix1e\n" \
1018 ">>> acl1 = posix1e.ACL(file=\"file.txt\") \n" \
1019 ">>> print acl1\n" \
1020 "user::rw-\n" \
1021 "group::rw-\n" \
1022 "other::r--\n" \
1023 "\n" \
1024 ">>> b = posix1e.ACL(text=\"u::rx,g::-,o::-\")\n" \
1025 ">>> print b\n" \
1026 "user::r-x\n" \
1027 "group::---\n" \
1028 "other::---\n" \
1029 "\n" \
1030 ">>> b.applyto(\"file.txt\")\n" \
1031 ">>> print posix1e.ACL(file=\"file.txt\")\n" \
1032 "user::r-x\n" \
1033 "group::---\n" \
1034 "other::---\n" \
1035 "\n" \
1036 ">>>\n" \
1037 ;
1038
1039 void initposix1e(void) {
1040     PyObject *m, *d;
1041
1042     ACL_Type.ob_type = &PyType_Type;
1043     if(PyType_Ready(&ACL_Type) < 0)
1044         return;
1045
1046 #ifdef HAVE_LEVEL2
1047     Entry_Type.ob_type = &PyType_Type;
1048     if(PyType_Ready(&Entry_Type) < 0)
1049         return;
1050
1051     Permset_Type.ob_type = &PyType_Type;
1052     if(PyType_Ready(&Permset_Type) < 0)
1053         return;
1054 #endif
1055
1056     m = Py_InitModule3("posix1e", aclmodule_methods, __posix1e_doc__);
1057
1058     d = PyModule_GetDict(m);
1059     if (d == NULL)
1060         return;
1061
1062     Py_INCREF(&ACL_Type);
1063     if (PyDict_SetItemString(d, "ACL",
1064                              (PyObject *) &ACL_Type) < 0)
1065         return;
1066
1067     /* 23.3.6 acl_type_t values */
1068     PyModule_AddIntConstant(m, "ACL_TYPE_ACCESS", ACL_TYPE_ACCESS);
1069     PyModule_AddIntConstant(m, "ACL_TYPE_DEFAULT", ACL_TYPE_DEFAULT);
1070
1071
1072 #ifdef HAVE_LEVEL2
1073     Py_INCREF(&Entry_Type);
1074     if (PyDict_SetItemString(d, "Entry",
1075                              (PyObject *) &Entry_Type) < 0)
1076         return;
1077
1078     Py_INCREF(&Permset_Type);
1079     if (PyDict_SetItemString(d, "Permset",
1080                              (PyObject *) &Permset_Type) < 0)
1081         return;
1082
1083     /* 23.2.2 acl_perm_t values */
1084     PyModule_AddIntConstant(m, "ACL_READ", ACL_READ);
1085     PyModule_AddIntConstant(m, "ACL_WRITE", ACL_WRITE);
1086     PyModule_AddIntConstant(m, "ACL_EXECUTE", ACL_EXECUTE);
1087
1088     /* 23.2.5 acl_tag_t values */
1089     PyModule_AddIntConstant(m, "ACL_UNDEFINED_TAG", ACL_UNDEFINED_TAG);
1090     PyModule_AddIntConstant(m, "ACL_USER_OBJ", ACL_USER_OBJ);
1091     PyModule_AddIntConstant(m, "ACL_USER", ACL_USER);
1092     PyModule_AddIntConstant(m, "ACL_GROUP_OBJ", ACL_GROUP_OBJ);
1093     PyModule_AddIntConstant(m, "ACL_GROUP", ACL_GROUP);
1094     PyModule_AddIntConstant(m, "ACL_MASK", ACL_MASK);
1095     PyModule_AddIntConstant(m, "ACL_OTHER", ACL_OTHER);
1096
1097 #endif
1098 }