]> git.k1024.org Git - debian-pyxattr.git/blob - xattr.c
Add Homepage field to debian/control
[debian-pyxattr.git] / xattr.c
1 #define PY_SSIZE_T_CLEAN
2 #include <Python.h>
3 #include <attr/xattr.h>
4 #include <stdio.h>
5
6 /* Compatibility with python 2.4 regarding python size type (PEP 353) */
7 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
8 typedef int Py_ssize_t;
9 #define PY_SSIZE_T_MAX INT_MAX
10 #define PY_SSIZE_T_MIN INT_MIN
11 #endif
12
13 /* the estimated (startup) attribute buffer size in
14    multi-operations */
15 #define ESTIMATE_ATTR_SIZE 256
16
17 typedef enum {T_FD, T_PATH, T_LINK} target_e;
18
19 typedef struct {
20     target_e type;
21     union {
22         const char *name;
23         int fd;
24     };
25 } target_t;
26
27 /** Converts from a string, file or int argument to what we need. */
28 static int convertObj(PyObject *myobj, target_t *tgt, int nofollow) {
29     int fd;
30     if(PyString_Check(myobj)) {
31         tgt->type = nofollow ? T_LINK : T_PATH;
32         tgt->name = PyString_AS_STRING(myobj);
33     } else if((fd = PyObject_AsFileDescriptor(myobj)) != -1) {
34         tgt->type = T_FD;
35         tgt->fd = fd;
36     } else {
37         PyErr_SetString(PyExc_TypeError, "argument must be string or int");
38         return 0;
39     }
40     return 1;
41 }
42
43 /* Combine a namespace string and an attribute name into a
44    fully-qualified name */
45 static const char* merge_ns(const char *ns, const char *name, char **buf) {
46     if(ns != NULL) {
47         int cnt;
48         size_t new_size = strlen(ns) + 1 + strlen(name) + 1;
49         if((*buf = PyMem_Malloc(new_size)) == NULL) {
50             PyErr_NoMemory();
51             return NULL;
52         }
53         cnt = snprintf(*buf, new_size, "%s.%s", ns, name);
54         if(cnt > new_size || cnt < 0) {
55             PyErr_SetString(PyExc_ValueError,
56                             "can't format the attribute name");
57             PyMem_Free(*buf);
58             return NULL;
59         }
60         return *buf;
61     } else {
62         *buf = NULL;
63         return name;
64     }
65 }
66
67 static ssize_t _list_obj(target_t *tgt, char *list, size_t size) {
68     if(tgt->type == T_FD)
69         return flistxattr(tgt->fd, list, size);
70     else if (tgt->type == T_LINK)
71         return llistxattr(tgt->name, list, size);
72     else
73         return listxattr(tgt->name, list, size);
74 }
75
76 static ssize_t _get_obj(target_t *tgt, const char *name, void *value,
77                         size_t size) {
78     if(tgt->type == T_FD)
79         return fgetxattr(tgt->fd, name, value, size);
80     else if (tgt->type == T_LINK)
81         return lgetxattr(tgt->name, name, value, size);
82     else
83         return getxattr(tgt->name, name, value, size);
84 }
85
86 static int _set_obj(target_t *tgt, const char *name,
87                     const void *value, size_t size, int flags) {
88     if(tgt->type == T_FD)
89         return fsetxattr(tgt->fd, name, value, size, flags);
90     else if (tgt->type == T_LINK)
91         return lsetxattr(tgt->name, name, value, size, flags);
92     else
93         return setxattr(tgt->name, name, value, size, flags);
94 }
95
96 static int _remove_obj(target_t *tgt, const char *name) {
97     if(tgt->type == T_FD)
98         return fremovexattr(tgt->fd, name);
99     else if (tgt->type == T_LINK)
100         return lremovexattr(tgt->name, name);
101     else
102         return removexattr(tgt->name, name);
103 }
104
105 /*
106    Checks if an attribute name matches an optional namespace.
107
108    If the namespace is NULL, it will return the name itself.  If the
109    namespace is non-NULL and the name matches, it will return a
110    pointer to the offset in the name after the namespace and the
111    separator. If however the name doesn't match the namespace, it will
112    return NULL.
113 */
114 const char *matches_ns(const char *ns, const char *name) {
115     size_t ns_size;
116     if (ns == NULL)
117         return name;
118     ns_size = strlen(ns);
119
120     if (strlen(name) > (ns_size+1) && !strncmp(name, ns, ns_size) &&
121         name[ns_size] == '.')
122         return name + ns_size + 1;
123     return NULL;
124 }
125
126 /* Wrapper for getxattr */
127 static char __pygetxattr_doc__[] =
128     "Get the value of a given extended attribute (deprecated).\n"
129     "\n"
130     "Parameters:\n"
131     "  - a string representing filename, or a file-like object,\n"
132     "    or a file descriptor; this represents the file on \n"
133     "    which to act\n"
134     "  - a string, representing the attribute whose value to retrieve;\n"
135     "    usually in form of system.posix_acl or user.mime_type\n"
136     "  - (optional) a boolean value (defaults to false), which, if\n"
137     "    the file name given is a symbolic link, makes the\n"
138     "    function operate on the symbolic link itself instead\n"
139     "    of its target;\n"
140     "@deprecated: since version 0.4, this function has been deprecated\n"
141     "    by the L{get} function\n"
142     ;
143
144 static PyObject *
145 pygetxattr(PyObject *self, PyObject *args)
146 {
147     PyObject *myarg;
148     target_t tgt;
149     int nofollow=0;
150     char *attrname;
151     char *buf;
152     ssize_t nalloc, nret;
153     PyObject *res;
154
155     /* Parse the arguments */
156     if (!PyArg_ParseTuple(args, "Os|i", &myarg, &attrname, &nofollow))
157         return NULL;
158     if(!convertObj(myarg, &tgt, nofollow))
159         return NULL;
160
161     /* Find out the needed size of the buffer */
162     if((nalloc = _get_obj(&tgt, attrname, NULL, 0)) == -1) {
163         return PyErr_SetFromErrno(PyExc_IOError);
164     }
165
166     /* Try to allocate the memory, using Python's allocator */
167     if((buf = PyMem_Malloc(nalloc)) == NULL) {
168         PyErr_NoMemory();
169         return NULL;
170     }
171
172     /* Now retrieve the attribute value */
173     if((nret = _get_obj(&tgt, attrname, buf, nalloc)) == -1) {
174         PyMem_Free(buf);
175         return PyErr_SetFromErrno(PyExc_IOError);
176     }
177
178     /* Create the string which will hold the result */
179     res = PyString_FromStringAndSize(buf, nret);
180
181     /* Free the buffer, now it is no longer needed */
182     PyMem_Free(buf);
183
184     /* Return the result */
185     return res;
186 }
187
188 /* Wrapper for getxattr */
189 static char __get_doc__[] =
190     "Get the value of a given extended attribute.\n"
191     "\n"
192     "Example:\n"
193     "    >>> xattr.get('/path/to/file', 'user.comment')\n"
194     "    'test'\n"
195     "    >>> xattr.get('/path/to/file', 'comment', namespace=xattr.NS_USER)\n"
196     "    'test'\n"
197     "\n"
198     "@param item: the item to query; either a string representing the\n"
199     "    filename, or a file-like object, or a file descriptor\n"
200     "@param name: the attribute whose value to set; usually in form of\n"
201     "    system.posix_acl or user.mime_type\n"
202     "@type name: string\n"
203     "@param nofollow: if given and True, and the function is passed a\n"
204     "    filename that points to a symlink, the function will act on the\n"
205     "    symlink itself instead of its target\n"
206     "@type nofollow: boolean\n"
207     "@param namespace: if given, the attribute must not contain the\n"
208     "    namespace itself, but instead the namespace will be taken from\n"
209     "    this parameter\n"
210     "@type namespace: string\n"
211     "@return: the value of the extended attribute (can contain NULLs)\n"
212     "@rtype: string\n"
213     "@raise EnvironmentError: caused by any system errors\n"
214     "@since: 0.4\n"
215     ;
216
217 static PyObject *
218 xattr_get(PyObject *self, PyObject *args, PyObject *keywds)
219 {
220     PyObject *myarg;
221     target_t tgt;
222     int nofollow=0;
223     char *attrname, *namebuf;
224     const char *fullname;
225     char *buf;
226     char *ns = NULL;
227     ssize_t nalloc, nret;
228     PyObject *res;
229     static char *kwlist[] = {"item", "name", "nofollow", "namespace", NULL};
230
231     /* Parse the arguments */
232     if (!PyArg_ParseTupleAndKeywords(args, keywds, "Os|iz", kwlist,
233                                      &myarg, &attrname, &nofollow, &ns))
234         return NULL;
235     if(!convertObj(myarg, &tgt, nofollow))
236         return NULL;
237
238     fullname = merge_ns(ns, attrname, &namebuf);
239
240     /* Find out the needed size of the buffer */
241     if((nalloc = _get_obj(&tgt, fullname, NULL, 0)) == -1) {
242         return PyErr_SetFromErrno(PyExc_IOError);
243     }
244
245     /* Try to allocate the memory, using Python's allocator */
246     if((buf = PyMem_Malloc(nalloc)) == NULL) {
247         PyMem_Free(namebuf);
248         PyErr_NoMemory();
249         return NULL;
250     }
251
252     /* Now retrieve the attribute value */
253     if((nret = _get_obj(&tgt, fullname, buf, nalloc)) == -1) {
254         PyMem_Free(buf);
255         PyMem_Free(namebuf);
256         return PyErr_SetFromErrno(PyExc_IOError);
257     }
258
259     /* Create the string which will hold the result */
260     res = PyString_FromStringAndSize(buf, nret);
261
262     /* Free the buffers, they are no longer needed */
263     PyMem_Free(namebuf);
264     PyMem_Free(buf);
265
266     /* Return the result */
267     return res;
268 }
269
270 /* Wrapper for getxattr */
271 static char __get_all_doc__[] =
272     "Get all the extended attributes of an item.\n"
273     "\n"
274     "This function performs a bulk-get of all extended attribute names\n"
275     "and the corresponding value.\n"
276     "Example:\n"
277     "    >>> xattr.get_all('/path/to/file')\n"
278     "    [('user.mime-type', 'plain/text'), ('user.comment', 'test'),\n"
279     "     ('system.posix_acl_access', '\\x02\\x00...')]\n"
280     "    >>> xattr.get_all('/path/to/file', namespace=xattr.NS_USER)\n"
281     "    [('mime-type', 'plain/text'), ('comment', 'test')]\n"
282     "\n"
283     "@param item: the item to query; either a string representing the\n"
284     "    filename, or a file-like object, or a file descriptor\n"
285     "@keyword namespace: an optional namespace for filtering the\n"
286     "    attributes; for example, querying all user attributes can be\n"
287     "    accomplished by passing namespace=L{NS_USER}\n"
288     "@type namespace: string\n"
289     "@keyword nofollow: if passed and true, if the target file is a\n"
290     "    symbolic link, the attributes for the link itself will be\n"
291     "    returned, instead of the attributes of the target\n"
292     "@type nofollow: boolean\n"
293     "@return: list of tuples (name, value); note that if a namespace\n"
294     "    argument was passed, it (and the separator) will be stripped from\n"
295     "    the names returned\n"
296     "@rtype: list\n"
297     "@raise EnvironmentError: caused by any system errors\n"
298     "@note: Since reading the whole attribute list is not an atomic\n"
299     "    operation, it might be possible that attributes are added\n"
300     "    or removed between the initial query and the actual reading\n"
301     "    of the attributes; the returned list will contain only the\n"
302     "    attributes that were present at the initial listing of the\n"
303     "    attribute names and that were still present when the read\n"
304     "    attempt for the value is made.\n"
305     "@since: 0.4\n"
306     ;
307
308 static PyObject *
309 get_all(PyObject *self, PyObject *args, PyObject *keywds)
310 {
311     PyObject *myarg;
312     int dolink=0;
313     char *ns = NULL;
314     char *buf_list, *buf_val;
315     char *s;
316     size_t nalloc, nlist, nval;
317     PyObject *mylist;
318     target_t tgt;
319     static char *kwlist[] = {"item", "nofollow", "namespace", NULL};
320
321     /* Parse the arguments */
322     if (!PyArg_ParseTupleAndKeywords(args, keywds, "O|iz", kwlist,
323                                      &myarg, &dolink, &ns))
324         return NULL;
325     if(!convertObj(myarg, &tgt, dolink))
326         return NULL;
327
328     /* Compute first the list of attributes */
329
330     /* Find out the needed size of the buffer for the attribute list */
331     nalloc = _list_obj(&tgt, NULL, 0);
332
333     if(nalloc == -1) {
334         return PyErr_SetFromErrno(PyExc_IOError);
335     }
336
337     /* Try to allocate the memory, using Python's allocator */
338     if((buf_list = PyMem_Malloc(nalloc)) == NULL) {
339         PyErr_NoMemory();
340         return NULL;
341     }
342
343     /* Now retrieve the list of attributes */
344     nlist = _list_obj(&tgt, buf_list, nalloc);
345
346     if(nlist == -1) {
347         PyErr_SetFromErrno(PyExc_IOError);
348         goto free_buf_list;
349     }
350
351     /* Create the list which will hold the result */
352     mylist = PyList_New(0);
353     nalloc = ESTIMATE_ATTR_SIZE;
354     if((buf_val = PyMem_Malloc(nalloc)) == NULL) {
355         PyErr_NoMemory();
356         goto free_list;
357     }
358
359     /* Create and insert the attributes as strings in the list */
360     for(s = buf_list; s - buf_list < nlist; s += strlen(s) + 1) {
361         PyObject *my_tuple;
362         int missing;
363         const char *name;
364
365         if((name=matches_ns(ns, s))==NULL)
366             continue;
367         /* Now retrieve the attribute value */
368         missing = 0;
369         while(1) {
370             nval = _get_obj(&tgt, s, buf_val, nalloc);
371
372             if(nval == -1) {
373                 if(errno == ERANGE) {
374                     nval = _get_obj(&tgt, s, NULL, 0);
375                     if((buf_val = PyMem_Realloc(buf_val, nval)) == NULL)
376                         goto free_list;
377                     nalloc = nval;
378                     continue;
379                 } else if(errno == ENODATA || errno == ENOATTR) {
380                     /* this attribute has gone away since we queried
381                        the attribute list */
382                     missing = 1;
383                     break;
384                 }
385                 goto exit_errno;
386             }
387             break;
388         }
389         if(missing)
390             continue;
391         my_tuple = Py_BuildValue("ss#", name, buf_val, nval);
392
393         PyList_Append(mylist, my_tuple);
394         Py_DECREF(my_tuple);
395     }
396
397     /* Free the buffers, now they are no longer needed */
398     PyMem_Free(buf_val);
399     PyMem_Free(buf_list);
400
401     /* Return the result */
402     return mylist;
403  exit_errno:
404     PyErr_SetFromErrno(PyExc_IOError);
405     PyMem_Free(buf_val);
406  free_list:
407     Py_DECREF(mylist);
408  free_buf_list:
409     PyMem_Free(buf_list);
410     return NULL;
411 }
412
413
414 static char __pysetxattr_doc__[] =
415     "Set the value of a given extended attribute (deprecated).\n"
416     "\n"
417     "Be carefull in case you want to set attributes on symbolic\n"
418     "links, you have to use all the 5 parameters; use 0 for the \n"
419     "flags value if you want the default behavior (create or "
420     "replace)\n"
421     "\n"
422     "Parameters:\n"
423     "  - a string representing filename, or a file-like object,\n"
424     "    or a file descriptor; this represents the file on \n"
425     "    which to act\n"
426     "  - a string, representing the attribute whose value to set;\n"
427     "    usually in form of system.posix_acl or user.mime_type\n"
428     "  - a string, possibly with embedded NULLs; note that there\n"
429     "    are restrictions regarding the size of the value, for\n"
430     "    example, for ext2/ext3, maximum size is the block size\n"
431     "  - (optional) flags; if 0 or ommited the attribute will be \n"
432     "    created or replaced; if XATTR_CREATE, the attribute \n"
433     "    will be created, giving an error if it already exists;\n"
434     "    of XATTR_REPLACE, the attribute will be replaced,\n"
435     "    giving an error if it doesn't exists;\n"
436     "  - (optional) a boolean value (defaults to false), which, if\n"
437     "    the file name given is a symbolic link, makes the\n"
438     "    function operate on the symbolic link itself instead\n"
439     "    of its target;\n"
440     "@deprecated: since version 0.4, this function has been deprecated\n"
441     "    by the L{set} function\n"
442     ;
443
444 /* Wrapper for setxattr */
445 static PyObject *
446 pysetxattr(PyObject *self, PyObject *args)
447 {
448     PyObject *myarg;
449     int nofollow=0;
450     char *attrname;
451     char *buf;
452     Py_ssize_t bufsize;
453     int nret;
454     int flags = 0;
455     target_t tgt;
456
457     /* Parse the arguments */
458     if (!PyArg_ParseTuple(args, "Oss#|bi", &myarg, &attrname,
459                           &buf, &bufsize, &flags, &nofollow))
460         return NULL;
461     if(!convertObj(myarg, &tgt, nofollow))
462         return NULL;
463
464     /* Set the attribute's value */
465     if((nret = _set_obj(&tgt, attrname, buf, bufsize, flags)) == -1) {
466         return PyErr_SetFromErrno(PyExc_IOError);
467     }
468
469     /* Return the result */
470     Py_RETURN_NONE;
471 }
472
473 static char __set_doc__[] =
474     "Set the value of a given extended attribute.\n"
475     "\n"
476     "Example:\n"
477     "    >>> xattr.set('/path/to/file', 'user.comment', 'test')\n"
478     "    >>> xattr.set('/path/to/file', 'comment', 'test',"
479     " namespace=xattr.NS_USER)\n"
480     "\n"
481     "@param item: the item to query; either a string representing the\n"
482     "    filename, or a file-like object, or a file descriptor\n"
483     "@param name: the attribute whose value to set; usually in form of\n"
484     "    system.posix_acl or user.mime_type\n"
485     "@type name: string\n"
486     "@param value: a string, possibly with embedded NULLs; note that there\n"
487     "    are restrictions regarding the size of the value, for\n"
488     "    example, for ext2/ext3, maximum size is the block size\n"
489     "@type value: string\n"
490     "@param flags: if 0 or ommited the attribute will be\n"
491     "    created or replaced; if L{XATTR_CREATE}, the attribute\n"
492     "    will be created, giving an error if it already exists;\n"
493     "    if L{XATTR_REPLACE}, the attribute will be replaced,\n"
494     "    giving an error if it doesn't exists;\n"
495     "@type flags: integer\n"
496     "@param nofollow: if given and True, and the function is passed a\n"
497     "    filename that points to a symlink, the function will act on the\n"
498     "    symlink itself instead of its target\n"
499     "@type nofollow: boolean\n"
500     "@param namespace: if given, the attribute must not contain the\n"
501     "    namespace itself, but instead the namespace will be taken from\n"
502     "    this parameter\n"
503     "@type namespace: string\n"
504     "@rtype: None\n"
505     "@raise EnvironmentError: caused by any system errors\n"
506     "@since: 0.4\n"
507     ;
508
509 /* Wrapper for setxattr */
510 static PyObject *
511 xattr_set(PyObject *self, PyObject *args, PyObject *keywds)
512 {
513     PyObject *myarg;
514     int nofollow=0;
515     char *attrname;
516     char *buf;
517     Py_ssize_t bufsize;
518     int nret;
519     int flags = 0;
520     target_t tgt;
521     char *ns = NULL;
522     char *newname;
523     const char *full_name;
524     static char *kwlist[] = {"item", "name", "value", "flags",
525                              "nofollow", "namespace", NULL};
526
527     /* Parse the arguments */
528     if (!PyArg_ParseTupleAndKeywords(args, keywds, "Oss#|iiz", kwlist,
529                                      &myarg, &attrname,
530                                      &buf, &bufsize, &flags, &nofollow, &ns))
531         return NULL;
532     if(!convertObj(myarg, &tgt, nofollow))
533         return NULL;
534
535     full_name = merge_ns(ns, attrname, &newname);
536     /* Set the attribute's value */
537     nret = _set_obj(&tgt, full_name, buf, bufsize, flags);
538     if(newname != NULL)
539         PyMem_Free(newname);
540     if(nret == -1) {
541         return PyErr_SetFromErrno(PyExc_IOError);
542     }
543
544     /* Return the result */
545     Py_RETURN_NONE;
546 }
547
548
549 static char __pyremovexattr_doc__[] =
550     "Remove an attribute from a file (deprecated).\n"
551     "\n"
552     "Parameters:\n"
553     "  - a string representing filename, or a file-like object,\n"
554     "    or a file descriptor; this represents the file on \n"
555     "    which to act\n"
556     "  - a string, representing the attribute to be removed;\n"
557     "    usually in form of system.posix_acl or user.mime_type\n"
558     "  - (optional) a boolean value (defaults to false), which, if\n"
559     "    the file name given is a symbolic link, makes the\n"
560     "    function operate on the symbolic link itself instead\n"
561     "    of its target;\n"
562     "@deprecated: since version 0.4, this function has been deprecated\n"
563     "    by the L{remove}"
564     " function\n"
565     ;
566
567 /* Wrapper for removexattr */
568 static PyObject *
569 pyremovexattr(PyObject *self, PyObject *args)
570 {
571     PyObject *myarg;
572     int nofollow=0;
573     char *attrname;
574     int nret;
575     target_t tgt;
576
577     /* Parse the arguments */
578     if (!PyArg_ParseTuple(args, "Os|i", &myarg, &attrname, &nofollow))
579         return NULL;
580
581     if(!convertObj(myarg, &tgt, nofollow))
582         return NULL;
583
584     /* Remove the attribute */
585     if((nret = _remove_obj(&tgt, attrname)) == -1) {
586         return PyErr_SetFromErrno(PyExc_IOError);
587     }
588
589     /* Return the result */
590     Py_RETURN_NONE;
591 }
592
593 static char __remove_doc__[] =
594     "Remove an attribute from a file.\n"
595     "\n"
596     "Example:\n"
597     "    >>> xattr.remove('/path/to/file', 'user.comment')\n"
598     "\n"
599     "@param item: the item to query; either a string representing the\n"
600     "    filename, or a file-like object, or a file descriptor\n"
601     "@param name: the attribute whose value to set; usually in form of\n"
602     "    system.posix_acl or user.mime_type\n"
603     "@type name: string\n"
604     "@param nofollow: if given and True, and the function is passed a\n"
605     "    filename that points to a symlink, the function will act on the\n"
606     "    symlink itself instead of its target\n"
607     "@type nofollow: boolean\n"
608     "@param namespace: if given, the attribute must not contain the\n"
609     "    namespace itself, but instead the namespace will be taken from\n"
610     "    this parameter\n"
611     "@type namespace: string\n"
612     "@since: 0.4\n"
613     "@rtype: None\n"
614     "@raise EnvironmentError: caused by any system errors\n"
615     ;
616
617 /* Wrapper for removexattr */
618 static PyObject *
619 xattr_remove(PyObject *self, PyObject *args, PyObject *keywds)
620 {
621     PyObject *myarg;
622     int nofollow=0;
623     char *attrname, *name_buf;
624     char *ns = NULL;
625     const char *full_name;
626     int nret;
627     target_t tgt;
628     static char *kwlist[] = {"item", "name", "nofollow", "namespace", NULL};
629
630     /* Parse the arguments */
631     if (!PyArg_ParseTupleAndKeywords(args, keywds, "Os|iz", kwlist,
632                                      &myarg, &attrname, &nofollow, &ns))
633         return NULL;
634
635     if(!convertObj(myarg, &tgt, nofollow))
636         return NULL;
637     full_name = merge_ns(ns, attrname, &name_buf);
638     if(full_name == NULL)
639         return NULL;
640
641     /* Remove the attribute */
642     nret = _remove_obj(&tgt, full_name);
643     PyMem_Free(name_buf);
644     if(nret == -1) {
645         return PyErr_SetFromErrno(PyExc_IOError);
646     }
647
648     /* Return the result */
649     Py_RETURN_NONE;
650 }
651
652 static char __pylistxattr_doc__[] =
653     "Return the list of attribute names for a file (deprecated).\n"
654     "\n"
655     "Parameters:\n"
656     "  - a string representing filename, or a file-like object,\n"
657     "    or a file descriptor; this represents the file to \n"
658     "    be queried\n"
659     "  - (optional) a boolean value (defaults to false), which, if\n"
660     "    the file name given is a symbolic link, makes the\n"
661     "    function operate on the symbolic link itself instead\n"
662     "    of its target;\n"
663     "@deprecated: since version 0.4, this function has been deprecated\n"
664     "    by the L{list}"
665     " function\n"
666     ;
667
668 /* Wrapper for listxattr */
669 static PyObject *
670 pylistxattr(PyObject *self, PyObject *args)
671 {
672     char *buf;
673     int nofollow=0;
674     ssize_t nalloc, nret;
675     PyObject *myarg;
676     PyObject *mylist;
677     Py_ssize_t nattrs;
678     char *s;
679     target_t tgt;
680
681     /* Parse the arguments */
682     if (!PyArg_ParseTuple(args, "O|i", &myarg, &nofollow))
683         return NULL;
684     if(!convertObj(myarg, &tgt, nofollow))
685         return NULL;
686
687     /* Find out the needed size of the buffer */
688     if((nalloc = _list_obj(&tgt, NULL, 0)) == -1) {
689         return PyErr_SetFromErrno(PyExc_IOError);
690     }
691
692     /* Try to allocate the memory, using Python's allocator */
693     if((buf = PyMem_Malloc(nalloc)) == NULL) {
694         PyErr_NoMemory();
695         return NULL;
696     }
697
698     /* Now retrieve the list of attributes */
699     if((nret = _list_obj(&tgt, buf, nalloc)) == -1) {
700         PyMem_Free(buf);
701         return PyErr_SetFromErrno(PyExc_IOError);
702     }
703
704     /* Compute the number of attributes in the list */
705     for(s = buf, nattrs = 0; (s - buf) < nret; s += strlen(s) + 1) {
706         nattrs++;
707     }
708
709     /* Create the list which will hold the result */
710     mylist = PyList_New(nattrs);
711
712     /* Create and insert the attributes as strings in the list */
713     for(s = buf, nattrs = 0; s - buf < nret; s += strlen(s) + 1) {
714         PyList_SET_ITEM(mylist, nattrs, PyString_FromString(s));
715         nattrs++;
716     }
717
718     /* Free the buffer, now it is no longer needed */
719     PyMem_Free(buf);
720
721     /* Return the result */
722     return mylist;
723 }
724
725 static char __list_doc__[] =
726     "Return the list of attribute names for a file.\n"
727     "\n"
728     "Example:\n"
729     "    >>> xattr.list('/path/to/file')\n"
730     "    ['user.test', 'user.comment', 'system.posix_acl_access']\n"
731     "    >>> xattr.list('/path/to/file', namespace=xattr.NS_USER)\n"
732     "    ['test', 'comment']\n"
733     "\n"
734     "@param item: the item to query; either a string representing the\n"
735     "    filename, or a file-like object, or a file descriptor\n"
736     "@param nofollow: if given and True, and the function is passed a\n"
737     "    filename that points to a symlink, the function will act on the\n"
738     "    symlink itself instead of its target\n"
739     "@type nofollow: boolean\n"
740     "@param namespace: if given, the attribute must not contain the\n"
741     "    namespace itself, but instead the namespace will be taken from\n"
742     "    this parameter\n"
743     "@type namespace: string\n"
744     "@return: list of strings; note that if a namespace argument was\n"
745     "    passed, it (and the separator) will be stripped from the names\n"
746     "    returned\n"
747     "@rtype: list\n"
748     "@raise EnvironmentError: caused by any system errors\n"
749     "@since: 0.4\n"
750     ;
751
752 /* Wrapper for listxattr */
753 static PyObject *
754 xattr_list(PyObject *self, PyObject *args, PyObject *keywds)
755 {
756     char *buf;
757     int nofollow=0;
758     ssize_t nalloc, nret;
759     PyObject *myarg;
760     PyObject *mylist;
761     char *ns = NULL;
762     Py_ssize_t nattrs;
763     char *s;
764     target_t tgt;
765     static char *kwlist[] = {"item", "nofollow", "namespace", NULL};
766
767     /* Parse the arguments */
768     if (!PyArg_ParseTupleAndKeywords(args, keywds, "O|iz", kwlist,
769                           &myarg, &nofollow, &ns))
770         return NULL;
771     if(!convertObj(myarg, &tgt, nofollow))
772         return NULL;
773
774     /* Find out the needed size of the buffer */
775     if((nalloc = _list_obj(&tgt, NULL, 0)) == -1) {
776         return PyErr_SetFromErrno(PyExc_IOError);
777     }
778
779     /* Try to allocate the memory, using Python's allocator */
780     if((buf = PyMem_Malloc(nalloc)) == NULL) {
781         PyErr_NoMemory();
782         return NULL;
783     }
784
785     /* Now retrieve the list of attributes */
786     if((nret = _list_obj(&tgt, buf, nalloc)) == -1) {
787         PyMem_Free(buf);
788         return PyErr_SetFromErrno(PyExc_IOError);
789     }
790
791     /* Compute the number of attributes in the list */
792     for(s = buf, nattrs = 0; (s - buf) < nret; s += strlen(s) + 1) {
793         if(matches_ns(ns, s)!=NULL)
794             nattrs++;
795     }
796     /* Create the list which will hold the result */
797     mylist = PyList_New(nattrs);
798
799     /* Create and insert the attributes as strings in the list */
800     for(s = buf, nattrs = 0; s - buf < nret; s += strlen(s) + 1) {
801         const char *name = matches_ns(ns, s);
802         if(name!=NULL) {
803             PyList_SET_ITEM(mylist, nattrs, PyString_FromString(name));
804             nattrs++;
805         }
806     }
807
808     /* Free the buffer, now it is no longer needed */
809     PyMem_Free(buf);
810
811     /* Return the result */
812     return mylist;
813 }
814
815 static PyMethodDef xattr_methods[] = {
816     {"getxattr",  pygetxattr, METH_VARARGS, __pygetxattr_doc__ },
817     {"get",  (PyCFunction) xattr_get, METH_VARARGS | METH_KEYWORDS,
818      __get_doc__ },
819     {"get_all", (PyCFunction) get_all, METH_VARARGS | METH_KEYWORDS,
820      __get_all_doc__ },
821     {"setxattr",  pysetxattr, METH_VARARGS, __pysetxattr_doc__ },
822     {"set",  (PyCFunction) xattr_set, METH_VARARGS | METH_KEYWORDS,
823      __set_doc__ },
824     {"removexattr",  pyremovexattr, METH_VARARGS, __pyremovexattr_doc__ },
825     {"remove",  (PyCFunction) xattr_remove, METH_VARARGS | METH_KEYWORDS,
826      __remove_doc__ },
827     {"listxattr",  pylistxattr, METH_VARARGS, __pylistxattr_doc__ },
828     {"list",  (PyCFunction) xattr_list, METH_VARARGS | METH_KEYWORDS,
829      __list_doc__ },
830     {NULL, NULL, 0, NULL}        /* Sentinel */
831 };
832
833 static char __xattr_doc__[] = \
834     "Interface to extended filesystem attributes.\n"
835     "\n"
836     "This module gives access to the extended attributes present\n"
837     "in some operating systems/filesystems. You can list attributes,\n"
838     "get, set and remove them.\n"
839     "\n"
840     "The module exposes two sets of functions:\n"
841     "  - the 'old' L{listxattr}, L{getxattr}, L{setxattr}, L{removexattr}\n"
842     "    functions which are deprecated since version 0.4\n"
843     "  - the new L{list}, L{get}, L{get_all}, L{set}, L{remove} functions\n"
844     "    which expose a namespace-aware API and simplify a bit the calling\n"
845     "    model by using keyword arguments\n"
846     "\n"
847     "Example: \n\n"
848     "  >>> import xattr\n"
849     "  >>> xattr.listxattr(\"file.txt\")\n"
850     "  ['user.mime_type']\n"
851     "  >>> xattr.getxattr(\"file.txt\", \"user.mime_type\")\n"
852     "  'text/plain'\n"
853     "  >>> xattr.setxattr(\"file.txt\", \"user.comment\", "
854     "\"Simple text file\")\n"
855     "  >>> xattr.listxattr(\"file.txt\")\n"
856     "  ['user.mime_type', 'user.comment']\n"
857     "  >>> xattr.removexattr (\"file.txt\", \"user.comment\")\n"
858     "\n"
859     "@note: Most or all errors reported by the system while using the xattr\n"
860     "library will be reported by raising a L{EnvironmentError}; under Linux,\n"
861     "the following C{errno} values are used:\n"
862     "  - C{ENOATTR} and C{ENODATA} mean that the attribute name is invalid\n"
863     "  - C{ENOTSUP} and C{EOPNOTSUPP} mean that the filesystem does not\n"
864     "    support extended attributes, or that the namespace is invalid\n"
865     "  - C{E2BIG} mean that the attribute value is too big\n"
866     "  - C{ERANGE} mean that the attribute name is too big (it might also\n"
867     "    mean an error in the xattr module itself)\n"
868     "  - C{ENOSPC} and C{EDQUOT} are documented as meaning out of disk space\n"
869     "    or out of disk space because of quota limits\n"
870     "\n"
871     "@group Deprecated API: *xattr\n"
872     "@group Namespace constants: NS_*\n"
873     "@group set function flags: XATTR_CREATE, XATTR_REPLACE\n"
874     "@sort: list, get, get_all, set, remove, listxattr, getxattr, setxattr\n"
875     "    removexattr\n"
876     ;
877
878 void
879 initxattr(void)
880 {
881     PyObject *m = Py_InitModule3("xattr", xattr_methods, __xattr_doc__);
882
883     PyModule_AddStringConstant(m, "__author__", _XATTR_AUTHOR);
884     PyModule_AddStringConstant(m, "__contact__", _XATTR_EMAIL);
885     PyModule_AddStringConstant(m, "__version__", _XATTR_VERSION);
886     PyModule_AddStringConstant(m, "__license__",
887                                "GNU Lesser General Public License (LGPL)");
888     PyModule_AddStringConstant(m, "__docformat__", "epytext en");
889
890     PyModule_AddIntConstant(m, "XATTR_CREATE", XATTR_CREATE);
891     PyModule_AddIntConstant(m, "XATTR_REPLACE", XATTR_REPLACE);
892
893     /* namespace constants */
894     PyModule_AddStringConstant(m, "NS_SECURITY", "security");
895     PyModule_AddStringConstant(m, "NS_SYSTEM", "system");
896     PyModule_AddStringConstant(m, "NS_TRUSTED", "trusted");
897     PyModule_AddStringConstant(m, "NS_USER", "user");
898
899 }