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