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