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