Add binary package for Python3
[debian-pyxattr.git] / xattr.c
1 /*
2     xattr - a python module for manipulating filesystem extended attributes
3
4     Copyright (C) 2002, 2003, 2006, 2008, 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 #define PY_SSIZE_T_CLEAN
24 #include <Python.h>
25 #include <attr/xattr.h>
26 #include <stdio.h>
27
28 /* Compatibility with python 2.4 regarding python size type (PEP 353) */
29 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
30 typedef int Py_ssize_t;
31 #define PY_SSIZE_T_MAX INT_MAX
32 #define PY_SSIZE_T_MIN INT_MIN
33 #endif
34
35 #if PY_MAJOR_VERSION >= 3
36 #define IS_PY3K
37 #define BYTES_CHAR "y"
38 #else
39 #define BYTES_CHAR "s"
40 #define PyBytes_Check PyString_Check
41 #define PyBytes_AS_STRING PyString_AS_STRING
42 #define PyBytes_FromStringAndSize PyString_FromStringAndSize
43 #define PyBytes_FromString PyString_FromString
44 #endif
45
46 #define ITEM_DOC \
47     ":param item: a string representing a file-name, or a file-like\n" \
48     "    object, or a file descriptor; this represents the file on \n" \
49     "    which to act\n"
50
51 #define NOFOLLOW_DOC \
52     ":param nofollow: if true and if\n" \
53     "    the file name given is a symbolic link, the\n" \
54     "    function will operate on the symbolic link itself instead\n" \
55     "    of its target; defaults to false\n" \
56     ":type nofollow: boolean, optional\n" \
57
58 #define NS_DOC \
59     ":param namespace: if given, the attribute must not contain the\n" \
60     "    namespace, but instead it will be taken from this parameter\n" \
61     ":type namespace: bytes\n"
62
63 #define NAME_GET_DOC \
64     ":param string name: the attribute whose value to retrieve;\n" \
65     "    usually in the form of ``system.posix_acl`` or ``user.mime_type``\n"
66
67 #define NAME_SET_DOC \
68     ":param string name: the attribute whose value to set;\n" \
69     "    usually in the form of ``system.posix_acl`` or ``user.mime_type``\n"
70
71 #define NAME_REMOVE_DOC \
72     ":param string name: the attribute to remove;\n" \
73     "    usually in the form of ``system.posix_acl`` or \n" \
74     "    ``user.mime_type``\n"
75
76 #define VALUE_DOC \
77     ":param string value: possibly with embedded NULLs; note that there\n" \
78     "    are restrictions regarding the size of the value, for\n" \
79     "    example, for ext2/ext3, maximum size is the block size\n" \
80
81 #define FLAGS_DOC \
82     ":param flags: if 0 or omitted the attribute will be\n" \
83     "    created or replaced; if :const:`XATTR_CREATE`, the attribute\n" \
84     "    will be created, giving an error if it already exists;\n" \
85     "    if :const:`XATTR_REPLACE`, the attribute will be replaced,\n" \
86     "    giving an error if it doesn't exist;\n" \
87     ":type flags: integer\n"
88
89 #define NS_CHANGED_DOC \
90     ".. versionchanged:: 0.5.1\n" \
91     "   The namespace argument, if passed, cannot be None anymore; to\n" \
92     "   explicitly specify an empty namespace, pass an empty\n" \
93     "   string (byte string under Python 3)."
94
95
96 /* the estimated (startup) attribute buffer size in
97    multi-operations */
98 #define ESTIMATE_ATTR_SIZE 256
99
100 typedef enum {T_FD, T_PATH, T_LINK} target_e;
101
102 typedef struct {
103     target_e type;
104     union {
105         const char *name;
106         int fd;
107     };
108     PyObject *tmp;
109 } target_t;
110
111 /* Cleans up a tgt structure */
112 static void free_tgt(target_t *tgt) {
113     if (tgt->tmp != NULL) {
114         Py_DECREF(tgt->tmp);
115     }
116 }
117
118 /* Used for cpychecker: */
119 /* The checker automatically defines this preprocessor name when creating
120    the custom attribute: */
121 #if defined(WITH_CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION_ATTRIBUTE)
122    #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION \
123 __attribute__((cpychecker_negative_result_sets_exception))
124  #else
125    #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
126  #endif
127
128 static int convert_obj(PyObject *myobj, target_t *tgt, int nofollow)
129   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
130
131 static int merge_ns(const char *ns, const char *name,
132                     const char **result, char **buf)
133   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
134
135
136 /** Converts from a string, file or int argument to what we need.
137  *
138  * Returns -1 on failure, 0 on success.
139  */
140 static int convert_obj(PyObject *myobj, target_t *tgt, int nofollow) {
141     int fd;
142     tgt->tmp = NULL;
143     if(PyBytes_Check(myobj)) {
144         tgt->type = nofollow ? T_LINK : T_PATH;
145         tgt->name = PyBytes_AS_STRING(myobj);
146     } else if(PyUnicode_Check(myobj)) {
147         tgt->type = nofollow ? T_LINK : T_PATH;
148         tgt->tmp = \
149             PyUnicode_AsEncodedString(myobj,
150                                       Py_FileSystemDefaultEncoding, "strict");
151         if(tgt->tmp == NULL)
152             return -1;
153         tgt->name = PyBytes_AS_STRING(tgt->tmp);
154     } else if((fd = PyObject_AsFileDescriptor(myobj)) != -1) {
155         tgt->type = T_FD;
156         tgt->fd = fd;
157     } else {
158         PyErr_SetString(PyExc_TypeError, "argument must be string or int");
159         return -1;
160     }
161     return 0;
162 }
163
164 /* Combine a namespace string and an attribute name into a
165    fully-qualified name */
166 static int merge_ns(const char *ns, const char *name,
167                     const char **result, char **buf) {
168     if(ns != NULL && *ns != '\0') {
169         int cnt;
170         size_t new_size = strlen(ns) + 1 + strlen(name) + 1;
171         if((*buf = PyMem_Malloc(new_size)) == NULL) {
172             PyErr_NoMemory();
173             return -1;
174         }
175         cnt = snprintf(*buf, new_size, "%s.%s", ns, name);
176         if(cnt > new_size || cnt < 0) {
177             PyErr_SetString(PyExc_ValueError,
178                             "can't format the attribute name");
179             PyMem_Free(*buf);
180             return -1;
181         }
182         *result = *buf;
183     } else {
184         *buf = NULL;
185         *result = name;
186     }
187     return 0;
188 }
189
190 static ssize_t _list_obj(target_t *tgt, char *list, size_t size) {
191     if(tgt->type == T_FD)
192         return flistxattr(tgt->fd, list, size);
193     else if (tgt->type == T_LINK)
194         return llistxattr(tgt->name, list, size);
195     else
196         return listxattr(tgt->name, list, size);
197 }
198
199 static ssize_t _get_obj(target_t *tgt, const char *name, void *value,
200                         size_t size) {
201     if(tgt->type == T_FD)
202         return fgetxattr(tgt->fd, name, value, size);
203     else if (tgt->type == T_LINK)
204         return lgetxattr(tgt->name, name, value, size);
205     else
206         return getxattr(tgt->name, name, value, size);
207 }
208
209 static int _set_obj(target_t *tgt, const char *name,
210                     const void *value, size_t size, int flags) {
211     if(tgt->type == T_FD)
212         return fsetxattr(tgt->fd, name, value, size, flags);
213     else if (tgt->type == T_LINK)
214         return lsetxattr(tgt->name, name, value, size, flags);
215     else
216         return setxattr(tgt->name, name, value, size, flags);
217 }
218
219 static int _remove_obj(target_t *tgt, const char *name) {
220     if(tgt->type == T_FD)
221         return fremovexattr(tgt->fd, name);
222     else if (tgt->type == T_LINK)
223         return lremovexattr(tgt->name, name);
224     else
225         return removexattr(tgt->name, name);
226 }
227
228 /*
229    Checks if an attribute name matches an optional namespace.
230
231    If the namespace is NULL or an empty string, it will return the
232    name itself.  If the namespace is non-NULL and the name matches, it
233    will return a pointer to the offset in the name after the namespace
234    and the separator. If however the name doesn't match the namespace,
235    it will return NULL.
236
237 */
238 const char *matches_ns(const char *ns, const char *name) {
239     size_t ns_size;
240     if (ns == NULL || *ns == '\0')
241         return name;
242     ns_size = strlen(ns);
243
244     if (strlen(name) > (ns_size+1) && !strncmp(name, ns, ns_size) &&
245         name[ns_size] == '.')
246         return name + ns_size + 1;
247     return NULL;
248 }
249
250 /* Wrapper for getxattr */
251 static char __pygetxattr_doc__[] =
252     "getxattr(item, attribute[, nofollow=False])\n"
253     "Get the value of a given extended attribute (deprecated).\n"
254     "\n"
255     ITEM_DOC
256     NAME_GET_DOC
257     NOFOLLOW_DOC
258     "\n"
259     ".. deprecated:: 0.4\n"
260     "   this function has been deprecated\n"
261     "   by the :func:`get` function.\n"
262     ;
263
264 static PyObject *
265 pygetxattr(PyObject *self, PyObject *args)
266 {
267     PyObject *myarg;
268     target_t tgt;
269     int nofollow = 0;
270     char *attrname = NULL;
271     char *buf;
272     ssize_t nalloc, nret;
273     PyObject *res;
274
275     /* Parse the arguments */
276     if (!PyArg_ParseTuple(args, "Oet|i", &myarg, NULL, &attrname, &nofollow))
277         return NULL;
278     if(convert_obj(myarg, &tgt, nofollow) < 0) {
279         res = NULL;
280         goto freearg;
281     }
282
283     /* Find out the needed size of the buffer */
284     if((nalloc = _get_obj(&tgt, attrname, NULL, 0)) == -1) {
285         res = PyErr_SetFromErrno(PyExc_IOError);
286         goto freetgt;
287     }
288
289     /* Try to allocate the memory, using Python's allocator */
290     if((buf = PyMem_Malloc(nalloc)) == NULL) {
291         res = PyErr_NoMemory();
292         goto freetgt;
293     }
294
295     /* Now retrieve the attribute value */
296     if((nret = _get_obj(&tgt, attrname, buf, nalloc)) == -1) {
297         res = PyErr_SetFromErrno(PyExc_IOError);
298         goto freebuf;
299     }
300
301     /* Create the string which will hold the result */
302     res = PyBytes_FromStringAndSize(buf, nret);
303
304  freebuf:
305     /* Free the buffer, now it is no longer needed */
306     PyMem_Free(buf);
307  freetgt:
308     free_tgt(&tgt);
309  freearg:
310     PyMem_Free(attrname);
311
312     /* Return the result */
313     return res;
314 }
315
316 /* Wrapper for getxattr */
317 static char __get_doc__[] =
318     "get(item, name[, nofollow=False, namespace=None])\n"
319     "Get the value of a given extended attribute.\n"
320     "\n"
321     "Example:\n"
322     "    >>> xattr.get('/path/to/file', 'user.comment')\n"
323     "    'test'\n"
324     "    >>> xattr.get('/path/to/file', 'comment', namespace=xattr.NS_USER)\n"
325     "    'test'\n"
326     "\n"
327     ITEM_DOC
328     NAME_GET_DOC
329     NOFOLLOW_DOC
330     NS_DOC
331     ":return: the value of the extended attribute (can contain NULLs)\n"
332     ":rtype: string\n"
333     ":raises EnvironmentError: caused by any system errors\n"
334     "\n"
335     ".. versionadded:: 0.4\n"
336     NS_CHANGED_DOC
337     ;
338
339 static PyObject *
340 xattr_get(PyObject *self, PyObject *args, PyObject *keywds)
341 {
342     PyObject *myarg;
343     target_t tgt;
344     int nofollow = 0;
345     char *attrname = NULL, *namebuf;
346     const char *fullname;
347     char *buf;
348     const char *ns = NULL;
349     ssize_t nalloc, nret;
350     PyObject *res;
351     static char *kwlist[] = {"item", "name", "nofollow", "namespace", NULL};
352
353     /* Parse the arguments */
354     if (!PyArg_ParseTupleAndKeywords(args, keywds, "Oet|i" BYTES_CHAR, kwlist,
355                                      &myarg, NULL, &attrname, &nofollow, &ns))
356         return NULL;
357     if(convert_obj(myarg, &tgt, nofollow) < 0) {
358         res = NULL;
359         goto freearg;
360     }
361
362     if(merge_ns(ns, attrname, &fullname, &namebuf) < 0) {
363         res = NULL;
364         goto freearg;
365     }
366
367     /* Find out the needed size of the buffer */
368     if((nalloc = _get_obj(&tgt, fullname, NULL, 0)) == -1) {
369         res = PyErr_SetFromErrno(PyExc_IOError);
370         goto freetgt;
371     }
372
373     /* Try to allocate the memory, using Python's allocator */
374     if((buf = PyMem_Malloc(nalloc)) == NULL) {
375         res = PyErr_NoMemory();
376         goto freenamebuf;
377     }
378
379     /* Now retrieve the attribute value */
380     if((nret = _get_obj(&tgt, fullname, buf, nalloc)) == -1) {
381         res = PyErr_SetFromErrno(PyExc_IOError);
382         goto freebuf;
383     }
384
385     /* Create the string which will hold the result */
386     res = PyBytes_FromStringAndSize(buf, nret);
387
388     /* Free the buffers, they are no longer needed */
389  freebuf:
390     PyMem_Free(buf);
391  freenamebuf:
392     PyMem_Free(namebuf);
393  freetgt:
394     free_tgt(&tgt);
395  freearg:
396     PyMem_Free(attrname);
397
398     /* Return the result */
399     return res;
400 }
401
402 /* Wrapper for getxattr */
403 static char __get_all_doc__[] =
404     "get_all(item[, nofollow=False, namespace=None])\n"
405     "Get all the extended attributes of an item.\n"
406     "\n"
407     "This function performs a bulk-get of all extended attribute names\n"
408     "and the corresponding value.\n"
409     "Example:\n"
410     "\n"
411     "    >>> xattr.get_all('/path/to/file')\n"
412     "    [('user.mime-type', 'plain/text'), ('user.comment', 'test'),\n"
413     "     ('system.posix_acl_access', '\\x02\\x00...')]\n"
414     "    >>> xattr.get_all('/path/to/file', namespace=xattr.NS_USER)\n"
415     "    [('mime-type', 'plain/text'), ('comment', 'test')]\n"
416     "\n"
417     ITEM_DOC
418     ":keyword namespace: an optional namespace for filtering the\n"
419     "   attributes; for example, querying all user attributes can be\n"
420     "   accomplished by passing namespace=:const:`NS_USER`\n"
421     ":type namespace: string\n"
422     NOFOLLOW_DOC
423     ":return: list of tuples (name, value); note that if a namespace\n"
424     "   argument was passed, it (and the separator) will be stripped from\n"
425     "   the names returned\n"
426     ":rtype: list\n"
427     ":raises EnvironmentError: caused by any system errors\n"
428     "\n"
429     ".. note:: Since reading the whole attribute list is not an atomic\n"
430     "   operation, it might be possible that attributes are added\n"
431     "   or removed between the initial query and the actual reading\n"
432     "   of the attributes; the returned list will contain only the\n"
433     "   attributes that were present at the initial listing of the\n"
434     "   attribute names and that were still present when the read\n"
435     "   attempt for the value is made.\n"
436     ".. versionadded:: 0.4\n"
437     NS_CHANGED_DOC
438     ;
439
440 static PyObject *
441 get_all(PyObject *self, PyObject *args, PyObject *keywds)
442 {
443     PyObject *myarg, *res;
444     int nofollow=0;
445     const char *ns = NULL;
446     char *buf_list, *buf_val;
447     const char *s;
448     ssize_t nalloc, nlist, nval;
449     PyObject *mylist;
450     target_t tgt;
451     static char *kwlist[] = {"item", "nofollow", "namespace", NULL};
452
453     /* Parse the arguments */
454     if (!PyArg_ParseTupleAndKeywords(args, keywds, "O|i" BYTES_CHAR, kwlist,
455                                      &myarg, &nofollow, &ns))
456         return NULL;
457     if(convert_obj(myarg, &tgt, nofollow) < 0)
458         return NULL;
459
460     /* Compute first the list of attributes */
461
462     /* Find out the needed size of the buffer for the attribute list */
463     nalloc = _list_obj(&tgt, NULL, 0);
464
465     if(nalloc == -1) {
466         res = PyErr_SetFromErrno(PyExc_IOError);
467         goto freetgt;
468     }
469
470     /* Try to allocate the memory, using Python's allocator */
471     if((buf_list = PyMem_Malloc(nalloc)) == NULL) {
472         res = PyErr_NoMemory();
473         goto freetgt;
474     }
475
476     /* Now retrieve the list of attributes */
477     nlist = _list_obj(&tgt, buf_list, nalloc);
478
479     if(nlist == -1) {
480         res = PyErr_SetFromErrno(PyExc_IOError);
481         goto free_buf_list;
482     }
483
484     /* Create the list which will hold the result */
485     mylist = PyList_New(0);
486     if(mylist == NULL) {
487       res = NULL;
488       goto free_buf_list;
489     }
490
491     nalloc = ESTIMATE_ATTR_SIZE;
492     if((buf_val = PyMem_Malloc(nalloc)) == NULL) {
493         Py_DECREF(mylist);
494         res = PyErr_NoMemory();
495         goto free_buf_list;
496     }
497
498     /* Create and insert the attributes as strings in the list */
499     for(s = buf_list; s - buf_list < nlist; s += strlen(s) + 1) {
500         PyObject *my_tuple;
501         int missing;
502         const char *name;
503
504         if((name=matches_ns(ns, s))==NULL)
505             continue;
506         /* Now retrieve the attribute value */
507         missing = 0;
508         while(1) {
509             nval = _get_obj(&tgt, s, buf_val, nalloc);
510
511             if(nval == -1) {
512                 if(errno == ERANGE) {
513                     nval = _get_obj(&tgt, s, NULL, 0);
514                     if((buf_val = PyMem_Realloc(buf_val, nval)) == NULL) {
515                         res = PyErr_NoMemory();
516                         Py_DECREF(mylist);
517                         goto free_buf_list;
518                     }
519                     nalloc = nval;
520                     continue;
521                 } else if(errno == ENODATA || errno == ENOATTR) {
522                     /* this attribute has gone away since we queried
523                        the attribute list */
524                     missing = 1;
525                     break;
526                 }
527                 /* else we're dealing with a different error, which we
528                    don't know how to handle nicely, so we abort */
529                 Py_DECREF(mylist);
530                 res = PyErr_SetFromErrno(PyExc_IOError);
531                 goto freebufval;
532             }
533             break;
534         }
535         if(missing)
536             continue;
537 #ifdef IS_PY3K
538         my_tuple = Py_BuildValue("yy#", name, buf_val, nval);
539 #else
540         my_tuple = Py_BuildValue("ss#", name, buf_val, nval);
541 #endif
542         if (my_tuple == NULL) {
543           Py_DECREF(mylist);
544           res = NULL;
545           goto freebufval;
546         }
547         PyList_Append(mylist, my_tuple);
548         Py_DECREF(my_tuple);
549     }
550
551     /* Successful exit */
552     res = mylist;
553
554  freebufval:
555     PyMem_Free(buf_val);
556
557  free_buf_list:
558     PyMem_Free(buf_list);
559
560  freetgt:
561     free_tgt(&tgt);
562
563     /* Return the result */
564     return res;
565 }
566
567
568 static char __pysetxattr_doc__[] =
569     "setxattr(item, name, value[, flags=0, nofollow=False])\n"
570     "Set the value of a given extended attribute (deprecated).\n"
571     "\n"
572     "Be careful in case you want to set attributes on symbolic\n"
573     "links, you have to use all the 5 parameters; use 0 for the \n"
574     "flags value if you want the default behaviour (create or "
575     "replace)\n"
576     "\n"
577     ITEM_DOC
578     NAME_SET_DOC
579     VALUE_DOC
580     FLAGS_DOC
581     NOFOLLOW_DOC
582     "\n"
583     ".. deprecated:: 0.4\n"
584     "   this function has been deprecated\n"
585     "   by the :func:`set` function.\n"
586     ;
587
588 /* Wrapper for setxattr */
589 static PyObject *
590 pysetxattr(PyObject *self, PyObject *args)
591 {
592     PyObject *myarg, *res;
593     int nofollow = 0;
594     char *attrname = NULL;
595     char *buf = NULL;
596     Py_ssize_t bufsize;
597     int nret;
598     int flags = 0;
599     target_t tgt;
600
601     /* Parse the arguments */
602     if (!PyArg_ParseTuple(args, "Oetet#|ii", &myarg, NULL, &attrname,
603                           NULL, &buf, &bufsize, &flags, &nofollow))
604         return NULL;
605     if(convert_obj(myarg, &tgt, nofollow) < 0) {
606         res = NULL;
607         goto freearg;
608     }
609
610     /* Set the attribute's value */
611     nret = _set_obj(&tgt, attrname, buf, bufsize, flags);
612
613     free_tgt(&tgt);
614
615     if(nret == -1) {
616         res = PyErr_SetFromErrno(PyExc_IOError);
617         goto freearg;
618     }
619
620     Py_INCREF(Py_None);
621     res = Py_None;
622
623  freearg:
624     PyMem_Free(attrname);
625     PyMem_Free(buf);
626
627     /* Return the result */
628     return res;
629 }
630
631 static char __set_doc__[] =
632     "set(item, name, value[, flags=0, namespace=None])\n"
633     "Set the value of a given extended attribute.\n"
634     "\n"
635     "Example:\n"
636     "\n"
637     "    >>> xattr.set('/path/to/file', 'user.comment', 'test')\n"
638     "    >>> xattr.set('/path/to/file', 'comment', 'test',"
639     " namespace=xattr.NS_USER)\n"
640     "\n"
641     ITEM_DOC
642     NAME_SET_DOC
643     VALUE_DOC
644     FLAGS_DOC
645     NOFOLLOW_DOC
646     NS_DOC
647     ":returns: None\n"
648     ":raises EnvironmentError: caused by any system errors\n"
649     "\n"
650     ".. versionadded:: 0.4\n"
651     NS_CHANGED_DOC
652     ;
653
654 /* Wrapper for setxattr */
655 static PyObject *
656 xattr_set(PyObject *self, PyObject *args, PyObject *keywds)
657 {
658     PyObject *myarg, *res;
659     int nofollow = 0;
660     char *attrname = NULL;
661     char *buf = NULL;
662     Py_ssize_t bufsize;
663     int nret;
664     int flags = 0;
665     target_t tgt;
666     const char *ns = NULL;
667     char *newname;
668     const char *full_name;
669     static char *kwlist[] = {"item", "name", "value", "flags",
670                              "nofollow", "namespace", NULL};
671
672     /* Parse the arguments */
673     if (!PyArg_ParseTupleAndKeywords(args, keywds, "Oetet#|ii" BYTES_CHAR,
674                                      kwlist, &myarg, NULL, &attrname, NULL,
675                                      &buf, &bufsize, &flags, &nofollow, &ns))
676         return NULL;
677     if(convert_obj(myarg, &tgt, nofollow) < 0) {
678         res = NULL;
679         goto freearg;
680     }
681
682     if(merge_ns(ns, attrname, &full_name, &newname) < 0) {
683         res = NULL;
684         goto freearg;
685     }
686
687     /* Set the attribute's value */
688     nret = _set_obj(&tgt, full_name, buf, bufsize, flags);
689
690     PyMem_Free(newname);
691
692     free_tgt(&tgt);
693
694     if(nret == -1) {
695         res = PyErr_SetFromErrno(PyExc_IOError);
696         goto freearg;
697     }
698
699     Py_INCREF(Py_None);
700     res = Py_None;
701
702  freearg:
703     PyMem_Free(attrname);
704     PyMem_Free(buf);
705
706     /* Return the result */
707     return res;
708 }
709
710
711 static char __pyremovexattr_doc__[] =
712     "removexattr(item, name[, nofollow])\n"
713     "Remove an attribute from a file (deprecated).\n"
714     "\n"
715     ITEM_DOC
716     NAME_REMOVE_DOC
717     NOFOLLOW_DOC
718     "\n"
719     ".. deprecated:: 0.4\n"
720     "   this function has been deprecated by the :func:`remove` function.\n"
721     ;
722
723 /* Wrapper for removexattr */
724 static PyObject *
725 pyremovexattr(PyObject *self, PyObject *args)
726 {
727     PyObject *myarg, *res;
728     int nofollow = 0;
729     char *attrname = NULL;
730     int nret;
731     target_t tgt;
732
733     /* Parse the arguments */
734     if (!PyArg_ParseTuple(args, "Oet|i", &myarg, NULL, &attrname, &nofollow))
735         return NULL;
736
737     if(convert_obj(myarg, &tgt, nofollow) < 0) {
738         res = NULL;
739         goto freearg;
740     }
741
742     /* Remove the attribute */
743     nret = _remove_obj(&tgt, attrname);
744
745     free_tgt(&tgt);
746
747     if(nret == -1) {
748         res = PyErr_SetFromErrno(PyExc_IOError);
749         goto freearg;
750     }
751
752     Py_INCREF(Py_None);
753     res = Py_None;
754
755  freearg:
756     PyMem_Free(attrname);
757
758     /* Return the result */
759     return res;
760 }
761
762 static char __remove_doc__[] =
763     "remove(item, name[, nofollow=False, namespace=None])\n"
764     "Remove an attribute from a file.\n"
765     "\n"
766     "Example:\n"
767     "\n"
768     "    >>> xattr.remove('/path/to/file', 'user.comment')\n"
769     "\n"
770     ITEM_DOC
771     NAME_REMOVE_DOC
772     NOFOLLOW_DOC
773     NS_DOC
774     ":returns: None\n"
775     ":raises EnvironmentError: caused by any system errors\n"
776     "\n"
777     ".. versionadded:: 0.4\n"
778     NS_CHANGED_DOC
779     ;
780
781 /* Wrapper for removexattr */
782 static PyObject *
783 xattr_remove(PyObject *self, PyObject *args, PyObject *keywds)
784 {
785     PyObject *myarg, *res;
786     int nofollow = 0;
787     char *attrname = NULL, *name_buf;
788     const char *ns = NULL;
789     const char *full_name;
790     int nret;
791     target_t tgt;
792     static char *kwlist[] = {"item", "name", "nofollow", "namespace", NULL};
793
794     /* Parse the arguments */
795     if (!PyArg_ParseTupleAndKeywords(args, keywds, "Oet|i" BYTES_CHAR, kwlist,
796                                      &myarg, NULL, &attrname, &nofollow, &ns))
797         return NULL;
798
799     if(convert_obj(myarg, &tgt, nofollow) < 0) {
800         res = NULL;
801         goto freearg;
802     }
803
804     if(merge_ns(ns, attrname, &full_name, &name_buf) < 0) {
805         res = NULL;
806         goto freearg;
807     }
808
809     /* Remove the attribute */
810     nret = _remove_obj(&tgt, full_name);
811
812     PyMem_Free(name_buf);
813
814     free_tgt(&tgt);
815
816     if(nret == -1) {
817         res = PyErr_SetFromErrno(PyExc_IOError);
818         goto freearg;
819     }
820
821     Py_INCREF(Py_None);
822     res = Py_None;
823
824  freearg:
825     PyMem_Free(attrname);
826
827     /* Return the result */
828     return res;
829 }
830
831 static char __pylistxattr_doc__[] =
832     "listxattr(item[, nofollow=False])\n"
833     "Return the list of attribute names for a file (deprecated).\n"
834     "\n"
835     ITEM_DOC
836     NOFOLLOW_DOC
837     "\n"
838     ".. deprecated:: 0.4\n"
839     "   this function has been deprecated by the :func:`list` function.\n"
840     ;
841
842 /* Wrapper for listxattr */
843 static PyObject *
844 pylistxattr(PyObject *self, PyObject *args)
845 {
846     char *buf;
847     int nofollow=0;
848     ssize_t nalloc, nret;
849     PyObject *myarg;
850     PyObject *mylist;
851     Py_ssize_t nattrs;
852     char *s;
853     target_t tgt;
854
855     /* Parse the arguments */
856     if (!PyArg_ParseTuple(args, "O|i", &myarg, &nofollow))
857         return NULL;
858     if(convert_obj(myarg, &tgt, nofollow) < 0)
859         return NULL;
860
861     /* Find out the needed size of the buffer */
862     if((nalloc = _list_obj(&tgt, NULL, 0)) == -1) {
863         mylist = PyErr_SetFromErrno(PyExc_IOError);
864         goto freetgt;
865     }
866
867     /* Try to allocate the memory, using Python's allocator */
868     if((buf = PyMem_Malloc(nalloc)) == NULL) {
869         mylist = PyErr_NoMemory();
870         goto freetgt;
871     }
872
873     /* Now retrieve the list of attributes */
874     if((nret = _list_obj(&tgt, buf, nalloc)) == -1) {
875         mylist = PyErr_SetFromErrno(PyExc_IOError);
876         goto freebuf;
877     }
878
879     /* Compute the number of attributes in the list */
880     for(s = buf, nattrs = 0; (s - buf) < nret; s += strlen(s) + 1) {
881         nattrs++;
882     }
883
884     /* Create the list which will hold the result */
885     mylist = PyList_New(nattrs);
886     if(mylist == NULL)
887       goto freebuf;
888
889     /* Create and insert the attributes as strings in the list */
890     for(s = buf, nattrs = 0; s - buf < nret; s += strlen(s) + 1) {
891         PyObject *item = PyBytes_FromString(s);
892         if(item == NULL) {
893             Py_DECREF(mylist);
894             mylist = NULL;
895             goto freebuf;
896         }
897         PyList_SET_ITEM(mylist, nattrs, item);
898         nattrs++;
899     }
900
901  freebuf:
902     /* Free the buffer, now it is no longer needed */
903     PyMem_Free(buf);
904
905  freetgt:
906     free_tgt(&tgt);
907
908     /* Return the result */
909     return mylist;
910 }
911
912 static char __list_doc__[] =
913     "list(item[, nofollow=False, namespace=None])\n"
914     "Return the list of attribute names for a file.\n"
915     "\n"
916     "Example:\n"
917     "\n"
918     "    >>> xattr.list('/path/to/file')\n"
919     "    ['user.test', 'user.comment', 'system.posix_acl_access']\n"
920     "    >>> xattr.list('/path/to/file', namespace=xattr.NS_USER)\n"
921     "    ['test', 'comment']\n"
922     "\n"
923     ITEM_DOC
924     NOFOLLOW_DOC
925     NS_DOC
926     ":returns: the list of attributes; note that if a namespace \n"
927     "    argument was passed, it (and the separator) will be stripped\n"
928     "    from the names\n"
929     "    returned\n"
930     ":rtype: list\n"
931     ":raises EnvironmentError: caused by any system errors\n"
932     "\n"
933     ".. versionadded:: 0.4\n"
934     NS_CHANGED_DOC
935     ;
936
937 /* Wrapper for listxattr */
938 static PyObject *
939 xattr_list(PyObject *self, PyObject *args, PyObject *keywds)
940 {
941     char *buf;
942     int nofollow = 0;
943     ssize_t nalloc, nret;
944     PyObject *myarg;
945     PyObject *res;
946     const char *ns = NULL;
947     Py_ssize_t nattrs;
948     char *s;
949     target_t tgt;
950     static char *kwlist[] = {"item", "nofollow", "namespace", NULL};
951
952     /* Parse the arguments */
953     if (!PyArg_ParseTupleAndKeywords(args, keywds, "O|i" BYTES_CHAR, kwlist,
954                                      &myarg, &nofollow, &ns))
955         return NULL;
956     if(convert_obj(myarg, &tgt, nofollow) < 0) {
957         res = NULL;
958         goto freearg;
959     }
960
961     /* Find out the needed size of the buffer */
962     if((nalloc = _list_obj(&tgt, NULL, 0)) == -1) {
963         res = PyErr_SetFromErrno(PyExc_IOError);
964         goto freetgt;
965     }
966
967     /* Try to allocate the memory, using Python's allocator */
968     if((buf = PyMem_Malloc(nalloc)) == NULL) {
969         res = PyErr_NoMemory();
970         goto freetgt;
971     }
972
973     /* Now retrieve the list of attributes */
974     if((nret = _list_obj(&tgt, buf, nalloc)) == -1) {
975         res = PyErr_SetFromErrno(PyExc_IOError);
976         goto freebuf;
977     }
978
979     /* Compute the number of attributes in the list */
980     for(s = buf, nattrs = 0; (s - buf) < nret; s += strlen(s) + 1) {
981         if(matches_ns(ns, s) != NULL)
982             nattrs++;
983     }
984     /* Create the list which will hold the result */
985     res = PyList_New(nattrs);
986     if(res == NULL)
987         goto freebuf;
988
989     /* Create and insert the attributes as strings in the list */
990     for(s = buf, nattrs = 0; s - buf < nret; s += strlen(s) + 1) {
991         const char *name = matches_ns(ns, s);
992         if(name!=NULL) {
993             PyObject *item = PyBytes_FromString(name);
994             if(item == NULL) {
995                 Py_DECREF(res);
996                 res = NULL;
997                 goto freebuf;
998             }
999             PyList_SET_ITEM(res, nattrs, item);
1000             nattrs++;
1001         }
1002     }
1003
1004  freebuf:
1005     /* Free the buffer, now it is no longer needed */
1006     PyMem_Free(buf);
1007
1008  freetgt:
1009     free_tgt(&tgt);
1010  freearg:
1011
1012     /* Return the result */
1013     return res;
1014 }
1015
1016 static PyMethodDef xattr_methods[] = {
1017     {"getxattr",  pygetxattr, METH_VARARGS, __pygetxattr_doc__ },
1018     {"get",  (PyCFunction) xattr_get, METH_VARARGS | METH_KEYWORDS,
1019      __get_doc__ },
1020     {"get_all", (PyCFunction) get_all, METH_VARARGS | METH_KEYWORDS,
1021      __get_all_doc__ },
1022     {"setxattr",  pysetxattr, METH_VARARGS, __pysetxattr_doc__ },
1023     {"set",  (PyCFunction) xattr_set, METH_VARARGS | METH_KEYWORDS,
1024      __set_doc__ },
1025     {"removexattr",  pyremovexattr, METH_VARARGS, __pyremovexattr_doc__ },
1026     {"remove",  (PyCFunction) xattr_remove, METH_VARARGS | METH_KEYWORDS,
1027      __remove_doc__ },
1028     {"listxattr",  pylistxattr, METH_VARARGS, __pylistxattr_doc__ },
1029     {"list",  (PyCFunction) xattr_list, METH_VARARGS | METH_KEYWORDS,
1030      __list_doc__ },
1031     {NULL, NULL, 0, NULL}        /* Sentinel */
1032 };
1033
1034 static char __xattr_doc__[] = \
1035     "This module gives access to the extended attributes present\n"
1036     "in some operating systems/filesystems. You can list attributes,\n"
1037     "get, set and remove them.\n"
1038     "\n"
1039     "The module exposes two sets of functions:\n"
1040     "  - the 'old' :func:`listxattr`, :func:`getxattr`, :func:`setxattr`,\n"
1041     "    :func:`removexattr`\n"
1042     "    functions which are deprecated since version 0.4\n"
1043     "  - the new :func:`list`, :func:`get`, :func:`get_all`, :func:`set`,\n"
1044     "    :func:`remove` functions\n"
1045     "    which expose a namespace-aware API and simplify a bit the calling\n"
1046     "    model by using keyword arguments\n"
1047     "\n"
1048     "Example: \n\n"
1049     "  >>> import xattr\n"
1050     "  >>> xattr.listxattr(\"file.txt\")\n"
1051     "  ['user.mime_type']\n"
1052     "  >>> xattr.getxattr(\"file.txt\", \"user.mime_type\")\n"
1053     "  'text/plain'\n"
1054     "  >>> xattr.setxattr(\"file.txt\", \"user.comment\", "
1055     "\"Simple text file\")\n"
1056     "  >>> xattr.listxattr(\"file.txt\")\n"
1057     "  ['user.mime_type', 'user.comment']\n"
1058     "  >>> xattr.removexattr (\"file.txt\", \"user.comment\")\n"
1059     "\n"
1060     ".. note:: Most or all errors reported by the system while using\n"
1061     "   the ``xattr`` library will be reported by raising\n"
1062     "   a :exc:`EnvironmentError`; under\n"
1063     "   Linux, the following ``errno`` values are used:\n"
1064     "\n"
1065     "   - ``ENOATTR`` and ``ENODATA`` mean that the attribute name is\n"
1066     "     invalid\n"
1067     "   - ``ENOTSUP`` and ``EOPNOTSUPP`` mean that the filesystem does not\n"
1068     "     support extended attributes, or that the namespace is invalid\n"
1069     "   - ``E2BIG`` mean that the attribute value is too big\n"
1070     "   - ``ERANGE`` mean that the attribute name is too big (it might also\n"
1071     "     mean an error in the xattr module itself)\n"
1072     "   - ``ENOSPC`` and ``EDQUOT`` are documented as meaning out of disk\n"
1073     "     space or out of disk space because of quota limits\n"
1074     ".. note:: Under Python 3, the namespace argument is a byte string,\n"
1075     "   not a unicode string.\n"
1076     "\n"
1077     ;
1078
1079 #ifdef IS_PY3K
1080
1081 static struct PyModuleDef xattrmodule = {
1082     PyModuleDef_HEAD_INIT,
1083     "xattr",
1084     __xattr_doc__,
1085     0,
1086     xattr_methods,
1087 };
1088
1089 #define INITERROR return NULL
1090
1091 PyMODINIT_FUNC
1092 PyInit_xattr(void)
1093
1094 #else
1095 #define INITERROR return
1096 void
1097 initxattr(void)
1098 #endif
1099 {
1100     PyObject *ns_security = NULL;
1101     PyObject *ns_system   = NULL;
1102     PyObject *ns_trusted  = NULL;
1103     PyObject *ns_user     = NULL;
1104 #ifdef IS_PY3K
1105     PyObject *m = PyModule_Create(&xattrmodule);
1106 #else
1107     PyObject *m = Py_InitModule3("xattr", xattr_methods, __xattr_doc__);
1108 #endif
1109     if (m==NULL)
1110         INITERROR;
1111
1112     PyModule_AddStringConstant(m, "__author__", _XATTR_AUTHOR);
1113     PyModule_AddStringConstant(m, "__contact__", _XATTR_EMAIL);
1114     PyModule_AddStringConstant(m, "__version__", _XATTR_VERSION);
1115     PyModule_AddStringConstant(m, "__license__",
1116                                "GNU Lesser General Public License (LGPL)");
1117     PyModule_AddStringConstant(m, "__docformat__", "restructuredtext en");
1118
1119     PyModule_AddIntConstant(m, "XATTR_CREATE", XATTR_CREATE);
1120     PyModule_AddIntConstant(m, "XATTR_REPLACE", XATTR_REPLACE);
1121
1122     /* namespace constants */
1123     if((ns_security = PyBytes_FromString("security")) == NULL)
1124         goto err_out;
1125     if((ns_system = PyBytes_FromString("system")) == NULL)
1126         goto err_out;
1127     if((ns_trusted = PyBytes_FromString("trusted")) == NULL)
1128         goto err_out;
1129     if((ns_user = PyBytes_FromString("user")) == NULL)
1130         goto err_out;
1131     if(PyModule_AddObject(m, "NS_SECURITY", ns_security) < 0)
1132         goto err_out;
1133     ns_security = NULL;
1134     if(PyModule_AddObject(m, "NS_SYSTEM", ns_system) < 0)
1135         goto err_out;
1136     ns_system = NULL;
1137     if(PyModule_AddObject(m, "NS_TRUSTED", ns_trusted) < 0)
1138         goto err_out;
1139     ns_trusted = NULL;
1140     if(PyModule_AddObject(m, "NS_USER", ns_user) < 0)
1141         goto err_out;
1142     ns_user = NULL;
1143
1144 #ifdef IS_PY3K
1145     return m;
1146 #else
1147     return;
1148 #endif
1149
1150  err_out:
1151     Py_XDECREF(ns_user);
1152     Py_XDECREF(ns_trusted);
1153     Py_XDECREF(ns_system);
1154     Py_XDECREF(ns_security);
1155     INITERROR;
1156 }