xattr.c

Bug Summary

File:	xattr.c
Warning:	line 632, column 20 PyObject ownership leak with reference count of 1

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name xattr.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-output=html -analyzer-checker=python -analyzer-disable-checker=deadcode -analyzer-config prune-paths=true,suppress-c++-stdlib=true,suppress-inlined-defensive-checks=false,suppress-null-return-paths=false,crosscheck-with-z3=true,model-path=/opt/pyrefcon/lib/pyrefcon/models/models -analyzer-config experimental-enable-naive-ctu-analysis=true,ctu-dir=/tmp/pyrefcon/pyxattr/csa-scan,ctu-index-name=/tmp/pyrefcon/pyxattr/csa-scan/externalDefMap.txt,ctu-invocation-list=/tmp/pyrefcon/pyxattr/csa-scan/invocations.yaml,display-ctu-progress=false -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -fcoverage-compilation-dir=/tmp/pyrefcon/pyxattr -resource-dir /opt/pyrefcon/lib/clang/13.0.0 -isystem /opt/pyrefcon/lib/pyrefcon/models/python3.8 -D NDEBUG -D _FORTIFY_SOURCE=2 -D _XATTR_VERSION="0.7.2" -D _XATTR_AUTHOR="Iustin Pop" -D _XATTR_EMAIL="iustin@k1024.org" -internal-isystem /opt/pyrefcon/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-result -Wsign-compare -Wformat -Wformat -Wdate-time -Wsign-compare -fdebug-compilation-dir=/tmp/pyrefcon/pyxattr -ferror-limit 19 -fwrapv -pthread -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/pyrefcon/pyxattr/csa-scan/reports -x c xattr.c

xattr.c

→

1/*
  xattr - a python module for manipulating filesystem extended attributes

  Copyright (C) 2002, 2003, 2006, 2008, 2012, 2013, 2015
    Iustin Pop <iustin@k1024.org>

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301  USA

22*/

24#define PY_SSIZE_T_CLEAN
25#include <Python.h>
26#if defined(__APPLE__) || defined(__linux__1)
27#include <sys/xattr.h>
28#endif
29#include <stdio.h>

31#define ITEM_DOC":param item: a string representing a file-name, a file-like\n"
 "    object, a file descriptor, or (in Python 3.6+) a path-like\n"
 "    object; this represents the file on which to act\n" \
  ":param item: a string representing a file-name, a file-like\n" \
  "    object, a file descriptor, or (in Python 3.6+) a path-like\n" \
  "    object; this represents the file on which to act\n"

36#define NOFOLLOW_DOC":param nofollow: if true and if\n" "    the file name given is a symbolic link, the\n"
 "    function will operate on the symbolic link itself instead\n"
 "    of its target; defaults to false\n" ":type nofollow: boolean, optional\n" \
  ":param nofollow: if true and if\n" \
  "    the file name given is a symbolic link, the\n" \
  "    function will operate on the symbolic link itself instead\n" \
  "    of its target; defaults to false\n" \
  ":type nofollow: boolean, optional\n" \

43#define NS_DOC":param namespace: if given, the attribute must not contain the\n"
 "    namespace, but instead it will be taken from this parameter\n"
 ":type namespace: bytes\n" \
  ":param namespace: if given, the attribute must not contain the\n" \
  "    namespace, but instead it will be taken from this parameter\n" \
  ":type namespace: bytes\n"

48#define NAME_GET_DOC":param string name: the attribute whose value to retrieve;\n"
 "    usually in the form of ``system.posix_acl`` or ``user.mime_type``\n" \
  ":param string name: the attribute whose value to retrieve;\n" \
  "    usually in the form of ``system.posix_acl`` or ``user.mime_type``\n"

52#define NAME_SET_DOC":param string name: the attribute whose value to set;\n" "    usually in the form of ``system.posix_acl`` or ``user.mime_type``\n" \
  ":param string name: the attribute whose value to set;\n" \
  "    usually in the form of ``system.posix_acl`` or ``user.mime_type``\n"

56#define NAME_REMOVE_DOC":param string name: the attribute to remove;\n" "    usually in the form of ``system.posix_acl`` or \n"
 "    ``user.mime_type``\n" \
  ":param string name: the attribute to remove;\n" \
  "    usually in the form of ``system.posix_acl`` or \n" \
  "    ``user.mime_type``\n"

61#define VALUE_DOC":param string value: possibly with embedded NULLs; note that there\n"
 "    are restrictions regarding the size of the value, for\n"
 "    example, for ext2/ext3, maximum size is the block size\n" \
  ":param string value: possibly with embedded NULLs; note that there\n" \
  "    are restrictions regarding the size of the value, for\n" \
  "    example, for ext2/ext3, maximum size is the block size\n" \

66#define FLAGS_DOC":param flags: if 0 or omitted the attribute will be\n" "    created or replaced; if :const:`XATTR_CREATE`, the attribute\n"
 "    will be created, giving an error if it already exists;\n"
 "    if :const:`XATTR_REPLACE`, the attribute will be replaced,\n"
 "    giving an error if it doesn't exist;\n" ":type flags: integer\n" \
  ":param flags: if 0 or omitted the attribute will be\n" \
  "    created or replaced; if :const:`XATTR_CREATE`, the attribute\n" \
  "    will be created, giving an error if it already exists;\n" \
  "    if :const:`XATTR_REPLACE`, the attribute will be replaced,\n" \
  "    giving an error if it doesn't exist;\n" \
  ":type flags: integer\n"

74#define NS_CHANGED_DOC".. versionchanged:: 0.5.1\n" "   The namespace argument, if passed, cannot be None anymore; to\n"
 "   explicitly specify an empty namespace, pass an empty\n" "   string (byte string under Python 3)." \
  ".. versionchanged:: 0.5.1\n" \
  "   The namespace argument, if passed, cannot be None anymore; to\n" \
  "   explicitly specify an empty namespace, pass an empty\n" \
  "   string (byte string under Python 3)."


81/* The initial I/O buffer size for list and get operations; if the
* actual values will be smaller than this, we save a syscall out of
* two and allocate more memory upfront than needed, otherwise we
* incur three syscalls (get with ENORANGE, get with 0 to compute
* actual size, final get). The test suite is marginally faster (5%)
* with this, so it seems worth doing.
87*/
88#define ESTIMATE_ATTR_SIZE1024 1024

90typedef enum {T_FD, T_PATH, T_LINK} target_e;

92typedef struct {
  target_e type;
  union {
      const char *name;
      int fd;
  };
  PyObject *tmp;
99} target_t;

101/* Cleans up a tgt structure */
102static void free_tgt(target_t *tgt) {
  if (tgt->tmp != NULL((void*)0)) {
      Py_DECREF(tgt->tmp)_Py_DECREF(((PyObject*)(tgt->tmp)));
  }
106}

108/* Used for cpychecker: */
109/* The checker automatically defines this preprocessor name when creating
 the custom attribute: */
111#if defined(WITH_CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION_ATTRIBUTE)
 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION \
113__attribute__((cpychecker_negative_result_sets_exception))
#else
 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
#endif

118static int convert_obj(PyObject *myobj, target_t *tgt, int nofollow)
CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;

121static int merge_ns(const char *ns, const char *name,
                  const char **result, char **buf)
CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;


126/** Converts from a string, file or int argument to what we need.
*
* Returns -1 on failure, 0 on success.
*/
130static int convert_obj(PyObject *myobj, target_t *tgt, int nofollow) {
  int fd;
  tgt->tmp = NULL((void*)0);
  if((fd = PyObject_AsFileDescriptor(myobj)) != -1) {
      tgt->type = T_FD;
      tgt->fd = fd;
      return 0;
  }
  // PyObject_AsFileDescriptor sets an error when failing, so clear
  // it such that further code works; some method lookups fail if an
  // error already occured when called, which breaks at least
  // PyOS_FSPath (called by FSConverter).
  PyErr_Clear();

  if(PyUnicode_FSConverter(myobj, &(tgt->tmp))) {
      tgt->type = nofollow ? T_LINK : T_PATH;
      tgt->name = PyBytes_AS_STRING(tgt->tmp)(((void) (0)), (((PyBytesObject *)(tgt->tmp))->ob_sval)
);
      return 0;
  } else {
      // Don't set our own exception type, since we'd ignore the
      // FSConverter-generated one.
      tgt->type = T_PATH;
      tgt->name = NULL((void*)0);
      return -1;
  }
155}

157/* Combine a namespace string and an attribute name into a
 fully-qualified name */
159static int merge_ns(const char *ns, const char *name,
                  const char **result, char **buf) {
  if(ns != NULL((void*)0) && *ns != '\0') {
      int cnt;
      /* The value of new_size is related to/must be kept in-sync
         with the format string below */
      size_t new_size = strlen(ns) + 1 + strlen(name) + 1;
      if((*buf = PyMem_Malloc(new_size)) == NULL((void*)0)) {
          PyErr_NoMemory();
          return -1;
      }
      cnt = snprintf(*buf, new_size, "%s.%s", ns, name)__builtin___snprintf_chk (*buf, new_size, 2 - 1, __builtin_object_size
 (*buf, 2 > 1), "%s.%s", ns, name);
      if((size_t) cnt >= new_size || cnt < 0) {
          PyErr_SetString(PyExc_ValueError,
                          "unexpected: can't format the attribute name");
          PyMem_Free(*buf);
          return -1;
      }
      *result = *buf;
  } else {
      *buf = NULL((void*)0);
      *result = name;
  }
  return 0;
183}

185#if defined(__APPLE__)
186static inline ssize_t _listxattr(const char *path, char *namebuf, size_t size)listxattr(const char *path, char *namebuf, size_t size) {
  return listxattr(path, namebuf, size, 0);
188}
189static inline ssize_t _llistxattr(const char *path, char *namebuf, size_t size)llistxattr(const char *path, char *namebuf, size_t size) {
  return listxattr(path, namebuf, size, XATTR_NOFOLLOW);
191}
192static inline ssize_t _flistxattr(int fd, char *namebuf, size_t size)flistxattr(int fd, char *namebuf, size_t size) {
  return flistxattr(fd, namebuf, size, 0);
194}

196static inline ssize_t _getxattr (const char *path, const char *name, void *value, size_t size)getxattr(const char *path, const char *name, void *value, size_t
 size) {
  return getxattr(path, name, value, size, 0, 0);
198}
199static inline ssize_t _lgetxattr (const char *path, const char *name, void *value, size_t size)lgetxattr(const char *path, const char *name, void *value, size_t
 size) {
  return getxattr(path, name, value, size, 0, XATTR_NOFOLLOW);
201}
202static inline ssize_t _fgetxattr (int filedes, const char *name, void *value, size_t size)fgetxattr(int filedes, const char *name, void *value, size_t size
) {
  return fgetxattr(filedes, name, value, size, 0, 0);
204}

206// [fl]setxattr: Both OS X and Linux define XATTR_CREATE and XATTR_REPLACE for the last option.
207static inline int _setxattr(const char *path, const char *name, const void *value, size_t size, int flags)setxattr(const char *path, const char *name, const void *value
, size_t size, int flags) {
  return setxattr(path, name, value, size, 0, flags);
209}
210static inline int _lsetxattr(const char *path, const char *name, const void *value, size_t size, int flags)lsetxattr(const char *path, const char *name, const void *value
, size_t size, int flags) {
  return setxattr(path, name, value, size, 0, flags | XATTR_NOFOLLOW);
212}
213static inline int _fsetxattr(int filedes, const char *name, const void *value, size_t size, int flags)fsetxattr(int filedes, const char *name, const void *value, size_t
 size, int flags) {
  return fsetxattr(filedes, name, value, size, 0, flags);
215}

217static inline int _removexattr(const char *path, const char *name)removexattr(const char *path, const char *name) {
  return removexattr(path, name, 0);
219}
220static inline int _lremovexattr(const char *path, const char *name)lremovexattr(const char *path, const char *name) {
  return removexattr(path, name, XATTR_NOFOLLOW);
222}
223static inline int _fremovexattr(int filedes, const char *name)fremovexattr(int filedes, const char *name) {
  return fremovexattr(filedes, name, 0);
225}

227#elif defined(__linux__1)
228#define _listxattr(path, list, size)listxattr(path, list, size) listxattr(path, list, size)
229#define _llistxattr(path, list, size)llistxattr(path, list, size) llistxattr(path, list, size)
230#define _flistxattr(fd, list, size)flistxattr(fd, list, size) flistxattr(fd, list, size)

232#define _getxattr(path, name, value, size)getxattr(path, name, value, size)  getxattr(path, name, value, size)
233#define _lgetxattr(path, name, value, size)lgetxattr(path, name, value, size) lgetxattr(path, name, value, size)
234#define _fgetxattr(fd, name, value, size)fgetxattr(fd, name, value, size)   fgetxattr(fd, name, value, size)

236#define _setxattr(path, name, value, size, flags)setxattr(path, name, value, size, flags)   setxattr(path, name, value, size, flags)
237#define _lsetxattr(path, name, value, size, flags)lsetxattr(path, name, value, size, flags)  lsetxattr(path, name, value, size, flags)
238#define _fsetxattr(fd, name, value, size, flags)fsetxattr(fd, name, value, size, flags)    fsetxattr(fd, name, value, size, flags)

240#define _removexattr(path, name)removexattr(path, name)    removexattr(path, name)
241#define _lremovexattr(path, name)lremovexattr(path, name)   lremovexattr(path, name)
242#define _fremovexattr(fd, name)fremovexattr(fd, name)     fremovexattr(fd, name)

244#endif

246typedef ssize_t (*buf_getter)(target_t *tgt, const char *name,
                            void *output, size_t size);

249static ssize_t _list_obj(target_t *tgt, const char *unused, void *list,
                       size_t size) {
  ssize_t ret;

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();;
  if(tgt->type == T_FD)
      ret = _flistxattr(tgt->fd, list, size)flistxattr(tgt->fd, list, size);
  else if (tgt->type == T_LINK)
      ret = _llistxattr(tgt->name, list, size)llistxattr(tgt->name, list, size);
  else
      ret = _listxattr(tgt->name, list, size)listxattr(tgt->name, list, size);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); };
  return ret;
262}

264static ssize_t _get_obj(target_t *tgt, const char *name, void *value,
                      size_t size) {
  ssize_t ret;
  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();;
  if(tgt->type == T_FD)
      ret = _fgetxattr(tgt->fd, name, value, size)fgetxattr(tgt->fd, name, value, size);
  else if (tgt->type == T_LINK)
      ret = _lgetxattr(tgt->name, name, value, size)lgetxattr(tgt->name, name, value, size);
  else
      ret = _getxattr(tgt->name, name, value, size)getxattr(tgt->name, name, value, size);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); };
  return ret;
276}

278static int _set_obj(target_t *tgt, const char *name,
                  const void *value, size_t size, int flags) {
  int ret;
  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();;
  if(tgt->type == T_FD)
      ret = _fsetxattr(tgt->fd, name, value, size, flags)fsetxattr(tgt->fd, name, value, size, flags);
  else if (tgt->type == T_LINK)
      ret = _lsetxattr(tgt->name, name, value, size, flags)lsetxattr(tgt->name, name, value, size, flags);
  else
      ret = _setxattr(tgt->name, name, value, size, flags)setxattr(tgt->name, name, value, size, flags);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); };
  return ret;
290}

292static int _remove_obj(target_t *tgt, const char *name) {
  int ret;
  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();;
  if(tgt->type == T_FD)
      ret = _fremovexattr(tgt->fd, name)fremovexattr(tgt->fd, name);
  else if (tgt->type == T_LINK)
      ret = _lremovexattr(tgt->name, name)lremovexattr(tgt->name, name);
  else
      ret = _removexattr(tgt->name, name)removexattr(tgt->name, name);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); };
  return ret;
303}

305/* Perform a get/list operation with appropriate buffer size,
* determined dynamically.
*
* Arguments:
* - getter: the function that actually does the I/O.
* - tgt, name: passed to the getter.
* - buffer: pointer to either an already allocated memory area (in
*   which case size contains its current size), or NULL to
*   allocate. In all cases (success or failure), the caller should
*   deallocate the buffer, using PyMem_Free().
* - size: either size of current buffer (if non-NULL), or size for
*   initial allocation; zero means use a hardcoded initial buffer
*   size (ESTIMATE_ATTR_SIZE). The value will be updated upon return
*   with the current buffer size.
* - io_errno: if non-NULL, the actual errno will be recorded here; if
*   zero, the call was successful and the output/size/nval are valid.
*
* Return value: if positive or zero, buffer will contain the read
* value. Otherwise, io_errno will contain the I/O errno, or zero
* to signify a Python-level error. In all cases, the Python-level
* error is set to the appropriate value.
*/
327static ssize_t _generic_get(buf_getter getter, target_t *tgt,
                          const char *name,
                          char **buffer,
                          size_t *size,
                          int *io_errno)
  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;

334static ssize_t _generic_get(buf_getter getter, target_t *tgt,
                          const char *name,
                          char **buffer,
                          size_t *size,
                          int *io_errno) {
ssize_t res;
/* Clear errno for now, will only set it when it fails in I/O. */
if (io_errno != NULL((void*)0)) {
  *io_errno = 0;
}

345#define EXIT_IOERROR()                 \
{                                    \
  if (io_errno != NULL((void*)0)) {            \
      *io_errno = errno(*__errno_location ());             \
  }                                  \
  PyErr_SetFromErrno(PyExc_IOError); \
  return -1;                         \
}

/* Initialize the buffer, if needed. */
if (*buffer == NULL((void*)0)) {
  if (*size == 0)
    *size = ESTIMATE_ATTR_SIZE1024;
  if((*buffer = PyMem_Malloc(*size)) == NULL((void*)0)) {
    PyErr_NoMemory();
    return -1;
  }
}
// Try to get the value, while increasing the buffer if too small.
while((res = getter(tgt, name, *buffer, *size)) == -1) {
  if(errno(*__errno_location ()) == ERANGE34) {
    ssize_t realloc_size_s = getter(tgt, name, NULL((void*)0), 0);
    /* ERANGE + proper size _should_ not fail, but... */
    if(realloc_size_s == -1) {
      EXIT_IOERROR();
    }
    size_t realloc_size = (size_t) realloc_size_s;
    char *tmp_buf;
    if((tmp_buf = PyMem_Realloc(*buffer, realloc_size)) == NULL((void*)0)) {
      PyErr_NoMemory();
      return -1;
    }
    *buffer = tmp_buf;
    *size = realloc_size;
    continue;
  } else {
    /* else we're dealing with a different error, which we
       don't know how to handle nicely, so we return */
    EXIT_IOERROR();
  }
}
return res;
387#undef EXIT_IOERROR
388}

390/*
 Checks if an attribute name matches an optional namespace.

 If the namespace is NULL or an empty string, it will return the
 name itself.  If the namespace is non-NULL and the name matches, it
 will return a pointer to the offset in the name after the namespace
 and the separator. If however the name doesn't match the namespace,
 it will return NULL.

399*/
400const char *matches_ns(const char *ns, const char *name) {
  size_t ns_size;
  if (ns == NULL((void*)0) || *ns == '\0')
      return name;
  ns_size = strlen(ns);

  if (strlen(name) > (ns_size+1) && !strncmp(name, ns, ns_size) &&
      name[ns_size] == '.')
      return name + ns_size + 1;
  return NULL((void*)0);
410}

412/* Wrapper for getxattr */
413static char __pygetxattr_doc__[] =
  "getxattr(item, attribute[, nofollow=False])\n"
  "Get the value of a given extended attribute (deprecated).\n"
  "\n"
  ITEM_DOC":param item: a string representing a file-name, a file-like\n"
 "    object, a file descriptor, or (in Python 3.6+) a path-like\n"
 "    object; this represents the file on which to act\n"
  NAME_GET_DOC":param string name: the attribute whose value to retrieve;\n"
 "    usually in the form of ``system.posix_acl`` or ``user.mime_type``\n"
  NOFOLLOW_DOC":param nofollow: if true and if\n" "    the file name given is a symbolic link, the\n"
 "    function will operate on the symbolic link itself instead\n"
 "    of its target; defaults to false\n" ":type nofollow: boolean, optional\n"
  "\n"
  ".. deprecated:: 0.4\n"
  "   this function has been deprecated\n"
  "   by the :func:`get` function.\n"
  ;

426static PyObject *
427pygetxattr(PyObject *self, PyObject *args)
428{
  PyObject *myarg;
  target_t tgt;
  int nofollow = 0;
  char *attrname = NULL((void*)0);
  char *buf = NULL((void*)0);
  ssize_t nret;
  size_t nalloc = 0;
  PyObject *res;

  /* Parse the arguments */
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Oet|i", &myarg, NULL((void*)0), &attrname, &nofollow))
      return NULL((void*)0);
  if(convert_obj(myarg, &tgt, nofollow) < 0) {
      res = NULL((void*)0);
      goto free_arg;
  }

  nret = _generic_get(_get_obj, &tgt, attrname, &buf, &nalloc, NULL((void*)0));
  if (nret == -1) {
    res = NULL((void*)0);
    goto free_buf;
  }
  /* Create the string which will hold the result */
  res = PyBytes_FromStringAndSize(buf, nret);

free_buf:
  /* Free the buffer, now it is no longer needed */
  PyMem_Free(buf);
  free_tgt(&tgt);
free_arg:
  PyMem_Free(attrname);

  /* Return the result */
  return res;
463}

465/* Wrapper for getxattr */
466static char __get_doc__[] =
  "get(item, name[, nofollow=False, namespace=None])\n"
  "Get the value of a given extended attribute.\n"
  "\n"
  "Example:\n"
  "    >>> xattr.get('/path/to/file', 'user.comment')\n"
  "    'test'\n"
  "    >>> xattr.get('/path/to/file', 'comment', namespace=xattr.NS_USER)\n"
  "    'test'\n"
  "\n"
  ITEM_DOC":param item: a string representing a file-name, a file-like\n"
 "    object, a file descriptor, or (in Python 3.6+) a path-like\n"
 "    object; this represents the file on which to act\n"
  NAME_GET_DOC":param string name: the attribute whose value to retrieve;\n"
 "    usually in the form of ``system.posix_acl`` or ``user.mime_type``\n"
  NOFOLLOW_DOC":param nofollow: if true and if\n" "    the file name given is a symbolic link, the\n"
 "    function will operate on the symbolic link itself instead\n"
 "    of its target; defaults to false\n" ":type nofollow: boolean, optional\n"
  NS_DOC":param namespace: if given, the attribute must not contain the\n"
 "    namespace, but instead it will be taken from this parameter\n"
 ":type namespace: bytes\n"
  ":return: the value of the extended attribute (can contain NULLs)\n"
  ":rtype: string\n"
  ":raises EnvironmentError: caused by any system errors\n"
  "\n"
  ".. versionadded:: 0.4\n"
  NS_CHANGED_DOC".. versionchanged:: 0.5.1\n" "   The namespace argument, if passed, cannot be None anymore; to\n"
 "   explicitly specify an empty namespace, pass an empty\n" "   string (byte string under Python 3)."
  ;

488static PyObject *
489xattr_get(PyObject *self, PyObject *args, PyObject *keywds)
490{
  PyObject *myarg;
  target_t tgt;
  int nofollow = 0;
  char *attrname = NULL((void*)0), *namebuf;
  const char *fullname;
  char *buf = NULL((void*)0);
  const char *ns = NULL((void*)0);
  ssize_t nret;
  size_t nalloc = 0;
  PyObject *res = NULL((void*)0);
  static char *kwlist[] = {"item", "name", "nofollow", "namespace", NULL((void*)0)};

  /* Parse the arguments */
  if (!PyArg_ParseTupleAndKeywords_PyArg_ParseTupleAndKeywords_SizeT(args, keywds, "Oet|iy", kwlist,
                                   &myarg, NULL((void*)0), &attrname, &nofollow, &ns))
      return NULL((void*)0);
  res = NULL((void*)0);
  if(convert_obj(myarg, &tgt, nofollow) < 0) {
      goto free_arg;
  }

  if(merge_ns(ns, attrname, &fullname, &namebuf) < 0) {
      goto free_tgt;
  }

  nret = _generic_get(_get_obj, &tgt, fullname, &buf, &nalloc, NULL((void*)0));
  if(nret == -1) {
    goto free_buf;
  }

  /* Create the string which will hold the result */
  res = PyBytes_FromStringAndSize(buf, nret);

  /* Free the buffers, they are no longer needed */
free_buf:
  PyMem_Free(buf);
  PyMem_Free(namebuf);
free_tgt:
  free_tgt(&tgt);
free_arg:
  PyMem_Free(attrname);

  /* Return the result */
  return res;
535}

537/* Wrapper for getxattr */
538static char __get_all_doc__[] =
  "get_all(item[, nofollow=False, namespace=None])\n"
  "Get all the extended attributes of an item.\n"
  "\n"
  "This function performs a bulk-get of all extended attribute names\n"
  "and the corresponding value.\n"
  "Example:\n"
  "\n"
  "    >>> xattr.get_all('/path/to/file')\n"
  "    [('user.mime-type', 'plain/text'), ('user.comment', 'test'),\n"
  "     ('system.posix_acl_access', '\\x02\\x00...')]\n"
  "    >>> xattr.get_all('/path/to/file', namespace=xattr.NS_USER)\n"
  "    [('mime-type', 'plain/text'), ('comment', 'test')]\n"
  "\n"
  ITEM_DOC":param item: a string representing a file-name, a file-like\n"
 "    object, a file descriptor, or (in Python 3.6+) a path-like\n"
 "    object; this represents the file on which to act\n"
  ":keyword namespace: an optional namespace for filtering the\n"
  "   attributes; for example, querying all user attributes can be\n"
  "   accomplished by passing namespace=:const:`NS_USER`\n"
  ":type namespace: string\n"
  NOFOLLOW_DOC":param nofollow: if true and if\n" "    the file name given is a symbolic link, the\n"
 "    function will operate on the symbolic link itself instead\n"
 "    of its target; defaults to false\n" ":type nofollow: boolean, optional\n"
  ":return: list of tuples (name, value); note that if a namespace\n"
  "   argument was passed, it (and the separator) will be stripped from\n"
  "   the names returned\n"
  ":rtype: list\n"
  ":raises EnvironmentError: caused by any system errors\n"
  "\n"
  ".. note:: Since reading the whole attribute list is not an atomic\n"
  "   operation, it might be possible that attributes are added\n"
  "   or removed between the initial query and the actual reading\n"
  "   of the attributes; the returned list will contain only the\n"
  "   attributes that were present at the initial listing of the\n"
  "   attribute names and that were still present when the read\n"
  "   attempt for the value is made.\n"
  ".. versionadded:: 0.4\n"
  NS_CHANGED_DOC".. versionchanged:: 0.5.1\n" "   The namespace argument, if passed, cannot be None anymore; to\n"
 "   explicitly specify an empty namespace, pass an empty\n" "   string (byte string under Python 3)."
  ;

575static PyObject *
576get_all(PyObject *self, PyObject *args, PyObject *keywds)
577{
  PyObject *myarg, *res;
  int nofollow=0;
  const char *ns = NULL((void*)0);
  char *buf_list = NULL((void*)0), *buf_val = NULL((void*)0);
  const char *s;
  size_t nalloc = 0;
  ssize_t nlist, nval;
  PyObject *mylist;
  target_t tgt;
  static char *kwlist[] = {"item", "nofollow", "namespace", NULL((void*)0)};
  int io_errno;

  /* Parse the arguments */
  if (!PyArg_ParseTupleAndKeywords_PyArg_ParseTupleAndKeywords_SizeT(args, keywds, "O|iy", kwlist,
1
Assuming the condition is false→
2
←
Taking false branch→
                                   &myarg, &nofollow, &ns))
      return NULL((void*)0);
  if(convert_obj(myarg, &tgt, nofollow) < 0)
3
←
Taking false branch→
      return NULL((void*)0);

  res = NULL((void*)0);
  /* Compute first the list of attributes */
  nlist = _generic_get(_list_obj, &tgt, NULL((void*)0), &buf_list,
                       &nalloc, &io_errno);
  if (nlist == -1) {
4
←
Assuming the condition is false→
5
←
Taking false branch→
    /* We can't handle any errors, and the Python error is already
       set, just bail out. */
    goto free_tgt;
  }

  /* Create the list which will hold the result. */
  mylist = PyList_New(0);
  if(mylist == NULL((void*)0)) {
6
←
Assuming 'mylist' is not equal to NULL→
7
←
Taking false branch→
    goto free_buf_list;
  }

  nalloc = 0;
  /* Create and insert the attributes as strings in the list */
  for(s = buf_list; s - buf_list < nlist; s += strlen(s) + 1) {
8
←
Assuming the condition is true→
9
←
Loop condition is true.  Entering loop body→
      PyObject *my_tuple;
      const char *name;

      if((name = matches_ns(ns, s)) == NULL((void*)0))
10
←
Assuming the condition is false→
11
←
Taking false branch→
          continue;
      /* Now retrieve the attribute value */
      nval = _generic_get(_get_obj, &tgt, s, &buf_val, &nalloc, &io_errno);
      if (nval == -1) {
12
←
Assuming the condition is false→
13
←
Taking false branch→
        if (io_errno == ENODATA61) {
          PyErr_Clear();
          continue;
        } else {
          Py_DECREF(mylist)_Py_DECREF(((PyObject*)(mylist)));
          goto free_buf_val;
        }
      }
      my_tuple = Py_BuildValue_Py_BuildValue_SizeT("yy#", name, buf_val, nval);
14
←
Calling '_Py_BuildValue_SizeT'→
16
←
Returning from '_Py_BuildValue_SizeT'→
21
←
PyObject ownership leak with reference count of 1
      if (my_tuple == NULL((void*)0)) {
17
←
Assuming 'my_tuple' is not equal to NULL→
18
←
Taking false branch→
        Py_DECREF(mylist)_Py_DECREF(((PyObject*)(mylist)));
        goto free_buf_val;
      }
      if(PyList_Append(mylist, my_tuple) < 0) {
19
←
Assuming the condition is true→
20
←
Taking true branch→
          Py_DECREF(mylist)_Py_DECREF(((PyObject*)(mylist)));
          goto free_buf_val;
      }
      Py_DECREF(my_tuple)_Py_DECREF(((PyObject*)(my_tuple)));
  }

  /* Successful exit */
  res = mylist;

free_buf_val:
  PyMem_Free(buf_val);

free_buf_list:
  PyMem_Free(buf_list);

free_tgt:
  free_tgt(&tgt);

  /* Return the result */
  return res;
658}


661static char __pysetxattr_doc__[] =
  "setxattr(item, name, value[, flags=0, nofollow=False])\n"
  "Set the value of a given extended attribute (deprecated).\n"
  "\n"
  "Be careful in case you want to set attributes on symbolic\n"
  "links, you have to use all the 5 parameters; use 0 for the \n"
  "flags value if you want the default behaviour (create or "
  "replace)\n"
  "\n"
  ITEM_DOC":param item: a string representing a file-name, a file-like\n"
 "    object, a file descriptor, or (in Python 3.6+) a path-like\n"
 "    object; this represents the file on which to act\n"
  NAME_SET_DOC":param string name: the attribute whose value to set;\n" "    usually in the form of ``system.posix_acl`` or ``user.mime_type``\n"
  VALUE_DOC":param string value: possibly with embedded NULLs; note that there\n"
 "    are restrictions regarding the size of the value, for\n"
 "    example, for ext2/ext3, maximum size is the block size\n"
  FLAGS_DOC":param flags: if 0 or omitted the attribute will be\n" "    created or replaced; if :const:`XATTR_CREATE`, the attribute\n"
 "    will be created, giving an error if it already exists;\n"
 "    if :const:`XATTR_REPLACE`, the attribute will be replaced,\n"
 "    giving an error if it doesn't exist;\n" ":type flags: integer\n"
  NOFOLLOW_DOC":param nofollow: if true and if\n" "    the file name given is a symbolic link, the\n"
 "    function will operate on the symbolic link itself instead\n"
 "    of its target; defaults to false\n" ":type nofollow: boolean, optional\n"
  "\n"
  ".. deprecated:: 0.4\n"
  "   this function has been deprecated\n"
  "   by the :func:`set` function.\n"
  ;

681/* Wrapper for setxattr */
682static PyObject *
683pysetxattr(PyObject *self, PyObject *args)
684{
  PyObject *myarg, *res;
  int nofollow = 0;
  char *attrname = NULL((void*)0);
  char *buf = NULL((void*)0);
  Py_ssize_t bufsize_s;
  size_t bufsize;
  int nret;
  int flags = 0;
  target_t tgt;

  /* Parse the arguments */
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Oetet#|ii", &myarg, NULL((void*)0), &attrname,
                        NULL((void*)0), &buf, &bufsize_s, &flags, &nofollow))
      return NULL((void*)0);

  if (bufsize_s < 0) {
      PyErr_SetString(PyExc_ValueError,
                      "negative value size?!");
      res = NULL((void*)0);
      goto free_arg;
  }
  bufsize = (size_t) bufsize_s;

  if(convert_obj(myarg, &tgt, nofollow) < 0) {
      res = NULL((void*)0);
      goto free_arg;
  }

  /* Set the attribute's value */
  nret = _set_obj(&tgt, attrname, buf, bufsize, flags);

  free_tgt(&tgt);

  if(nret == -1) {
      res = PyErr_SetFromErrno(PyExc_IOError);
      goto free_arg;
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  res = Py_None(&_Py_NoneStruct);

free_arg:
  PyMem_Free(attrname);
  PyMem_Free(buf);

  /* Return the result */
  return res;
732}

734static char __set_doc__[] =
  "set(item, name, value[, flags=0, namespace=None])\n"
  "Set the value of a given extended attribute.\n"
  "\n"
  "Example:\n"
  "\n"
  "    >>> xattr.set('/path/to/file', 'user.comment', 'test')\n"
  "    >>> xattr.set('/path/to/file', 'comment', 'test',"
  " namespace=xattr.NS_USER)\n"
  "\n"
  ITEM_DOC":param item: a string representing a file-name, a file-like\n"
 "    object, a file descriptor, or (in Python 3.6+) a path-like\n"
 "    object; this represents the file on which to act\n"
  NAME_SET_DOC":param string name: the attribute whose value to set;\n" "    usually in the form of ``system.posix_acl`` or ``user.mime_type``\n"
  VALUE_DOC":param string value: possibly with embedded NULLs; note that there\n"
 "    are restrictions regarding the size of the value, for\n"
 "    example, for ext2/ext3, maximum size is the block size\n"
  FLAGS_DOC":param flags: if 0 or omitted the attribute will be\n" "    created or replaced; if :const:`XATTR_CREATE`, the attribute\n"
 "    will be created, giving an error if it already exists;\n"
 "    if :const:`XATTR_REPLACE`, the attribute will be replaced,\n"
 "    giving an error if it doesn't exist;\n" ":type flags: integer\n"
  NOFOLLOW_DOC":param nofollow: if true and if\n" "    the file name given is a symbolic link, the\n"
 "    function will operate on the symbolic link itself instead\n"
 "    of its target; defaults to false\n" ":type nofollow: boolean, optional\n"
  NS_DOC":param namespace: if given, the attribute must not contain the\n"
 "    namespace, but instead it will be taken from this parameter\n"
 ":type namespace: bytes\n"
  ":returns: None\n"
  ":raises EnvironmentError: caused by any system errors\n"
  "\n"
  ".. versionadded:: 0.4\n"
  NS_CHANGED_DOC".. versionchanged:: 0.5.1\n" "   The namespace argument, if passed, cannot be None anymore; to\n"
 "   explicitly specify an empty namespace, pass an empty\n" "   string (byte string under Python 3)."
  ;

757/* Wrapper for setxattr */
758static PyObject *
759xattr_set(PyObject *self, PyObject *args, PyObject *keywds)
760{
  PyObject *myarg, *res;
  int nofollow = 0;
  char *attrname = NULL((void*)0);
  char *buf = NULL((void*)0);
  Py_ssize_t bufsize_s;
  size_t bufsize;
  int nret;
  int flags = 0;
  target_t tgt;
  const char *ns = NULL((void*)0);
  char *newname;
  const char *full_name;
  static char *kwlist[] = {"item", "name", "value", "flags",
                           "nofollow", "namespace", NULL((void*)0)};

  /* Parse the arguments */
  if (!PyArg_ParseTupleAndKeywords_PyArg_ParseTupleAndKeywords_SizeT(args, keywds, "Oetet#|iiy",
                                   kwlist, &myarg, NULL((void*)0), &attrname, NULL((void*)0),
                                   &buf, &bufsize_s, &flags, &nofollow, &ns))
      return NULL((void*)0);

  if (bufsize_s < 0) {
      PyErr_SetString(PyExc_ValueError,
                      "negative value size?!");
      res = NULL((void*)0);
      goto free_arg;
  }
  bufsize = (size_t) bufsize_s;

  if(convert_obj(myarg, &tgt, nofollow) < 0) {
      res = NULL((void*)0);
      goto free_arg;
  }

  if(merge_ns(ns, attrname, &full_name, &newname) < 0) {
      res = NULL((void*)0);
      goto free_arg;
  }

  /* Set the attribute's value */
  nret = _set_obj(&tgt, full_name, buf, bufsize, flags);

  PyMem_Free(newname);

  free_tgt(&tgt);

  if(nret == -1) {
      res = PyErr_SetFromErrno(PyExc_IOError);
      goto free_arg;
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  res = Py_None(&_Py_NoneStruct);

free_arg:
  PyMem_Free(attrname);
  PyMem_Free(buf);

  /* Return the result */
  return res;
821}


824static char __pyremovexattr_doc__[] =
  "removexattr(item, name[, nofollow])\n"
  "Remove an attribute from a file (deprecated).\n"
  "\n"
  ITEM_DOC":param item: a string representing a file-name, a file-like\n"
 "    object, a file descriptor, or (in Python 3.6+) a path-like\n"
 "    object; this represents the file on which to act\n"
  NAME_REMOVE_DOC":param string name: the attribute to remove;\n" "    usually in the form of ``system.posix_acl`` or \n"
 "    ``user.mime_type``\n"
  NOFOLLOW_DOC":param nofollow: if true and if\n" "    the file name given is a symbolic link, the\n"
 "    function will operate on the symbolic link itself instead\n"
 "    of its target; defaults to false\n" ":type nofollow: boolean, optional\n"
  "\n"
  ".. deprecated:: 0.4\n"
  "   this function has been deprecated by the :func:`remove` function.\n"
  ;

836/* Wrapper for removexattr */
837static PyObject *
838pyremovexattr(PyObject *self, PyObject *args)
839{
  PyObject *myarg, *res;
  int nofollow = 0;
  char *attrname = NULL((void*)0);
  int nret;
  target_t tgt;

  /* Parse the arguments */
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "Oet|i", &myarg, NULL((void*)0), &attrname, &nofollow))
      return NULL((void*)0);

  if(convert_obj(myarg, &tgt, nofollow) < 0) {
      res = NULL((void*)0);
      goto free_arg;
  }

  /* Remove the attribute */
  nret = _remove_obj(&tgt, attrname);

  free_tgt(&tgt);

  if(nret == -1) {
      res = PyErr_SetFromErrno(PyExc_IOError);
      goto free_arg;
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  res = Py_None(&_Py_NoneStruct);

free_arg:
  PyMem_Free(attrname);

  /* Return the result */
  return res;
873}

875static char __remove_doc__[] =
  "remove(item, name[, nofollow=False, namespace=None])\n"
  "Remove an attribute from a file.\n"
  "\n"
  "Example:\n"
  "\n"
  "    >>> xattr.remove('/path/to/file', 'user.comment')\n"
  "\n"
  ITEM_DOC":param item: a string representing a file-name, a file-like\n"
 "    object, a file descriptor, or (in Python 3.6+) a path-like\n"
 "    object; this represents the file on which to act\n"
  NAME_REMOVE_DOC":param string name: the attribute to remove;\n" "    usually in the form of ``system.posix_acl`` or \n"
 "    ``user.mime_type``\n"
  NOFOLLOW_DOC":param nofollow: if true and if\n" "    the file name given is a symbolic link, the\n"
 "    function will operate on the symbolic link itself instead\n"
 "    of its target; defaults to false\n" ":type nofollow: boolean, optional\n"
  NS_DOC":param namespace: if given, the attribute must not contain the\n"
 "    namespace, but instead it will be taken from this parameter\n"
 ":type namespace: bytes\n"
  ":returns: None\n"
  ":raises EnvironmentError: caused by any system errors\n"
  "\n"
  ".. versionadded:: 0.4\n"
  NS_CHANGED_DOC".. versionchanged:: 0.5.1\n" "   The namespace argument, if passed, cannot be None anymore; to\n"
 "   explicitly specify an empty namespace, pass an empty\n" "   string (byte string under Python 3)."
  ;

894/* Wrapper for removexattr */
895static PyObject *
896xattr_remove(PyObject *self, PyObject *args, PyObject *keywds)
897{
  PyObject *myarg, *res;
  int nofollow = 0;
  char *attrname = NULL((void*)0), *name_buf;
  const char *ns = NULL((void*)0);
  const char *full_name;
  int nret;
  target_t tgt;
  static char *kwlist[] = {"item", "name", "nofollow", "namespace", NULL((void*)0)};

  /* Parse the arguments */
  if (!PyArg_ParseTupleAndKeywords_PyArg_ParseTupleAndKeywords_SizeT(args, keywds, "Oet|iy", kwlist,
                                   &myarg, NULL((void*)0), &attrname, &nofollow, &ns))
      return NULL((void*)0);

  if(convert_obj(myarg, &tgt, nofollow) < 0) {
      res = NULL((void*)0);
      goto free_arg;
  }

  if(merge_ns(ns, attrname, &full_name, &name_buf) < 0) {
      res = NULL((void*)0);
      goto free_arg;
  }

  /* Remove the attribute */
  nret = _remove_obj(&tgt, full_name);

  PyMem_Free(name_buf);

  free_tgt(&tgt);

  if(nret == -1) {
      res = PyErr_SetFromErrno(PyExc_IOError);
      goto free_arg;
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  res = Py_None(&_Py_NoneStruct);

free_arg:
  PyMem_Free(attrname);

  /* Return the result */
  return res;
942}

944static char __pylistxattr_doc__[] =
  "listxattr(item[, nofollow=False])\n"
  "Return the list of attribute names for a file (deprecated).\n"
  "\n"
  ITEM_DOC":param item: a string representing a file-name, a file-like\n"
 "    object, a file descriptor, or (in Python 3.6+) a path-like\n"
 "    object; this represents the file on which to act\n"
  NOFOLLOW_DOC":param nofollow: if true and if\n" "    the file name given is a symbolic link, the\n"
 "    function will operate on the symbolic link itself instead\n"
 "    of its target; defaults to false\n" ":type nofollow: boolean, optional\n"
  "\n"
  ".. deprecated:: 0.4\n"
  "   this function has been deprecated by the :func:`list` function.\n"
  ;

955/* Wrapper for listxattr */
956static PyObject *
957pylistxattr(PyObject *self, PyObject *args)
958{
  char *buf = NULL((void*)0);
  int nofollow = 0;
  ssize_t nret;
  size_t nalloc = 0;
  PyObject *myarg;
  PyObject *mylist;
  Py_ssize_t nattrs;
  char *s;
  target_t tgt;

  /* Parse the arguments */
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O|i", &myarg, &nofollow))
      return NULL((void*)0);
  if(convert_obj(myarg, &tgt, nofollow) < 0)
      return NULL((void*)0);

  nret = _generic_get(_list_obj, &tgt, NULL((void*)0), &buf, &nalloc, NULL((void*)0));
  if (nret == -1) {
    mylist = NULL((void*)0);
    goto free_buf;
  }

  /* Compute the number of attributes in the list */
  for(s = buf, nattrs = 0; (s - buf) < nret; s += strlen(s) + 1) {
      nattrs++;
  }

  /* Create the list which will hold the result */
  mylist = PyList_New(nattrs);
  if(mylist == NULL((void*)0)) {
    goto free_buf;
  }

  /* Create and insert the attributes as strings in the list */
  for(s = buf, nattrs = 0; s - buf < nret; s += strlen(s) + 1) {
      PyObject *item = PyBytes_FromString(s);
      if(item == NULL((void*)0)) {
          Py_DECREF(mylist)_Py_DECREF(((PyObject*)(mylist)));
          mylist = NULL((void*)0);
          goto free_buf;
      }
      PyList_SET_ITEM(mylist, nattrs, item)PyList_SetItem(mylist, nattrs, item);
      nattrs++;
  }

free_buf:
  /* Free the buffer, now it is no longer needed */
  PyMem_Free(buf);
  free_tgt(&tgt);

  /* Return the result */
  return mylist;
1011}

1013static char __list_doc__[] =
  "list(item[, nofollow=False, namespace=None])\n"
  "Return the list of attribute names for a file.\n"
  "\n"
  "Example:\n"
  "\n"
  "    >>> xattr.list('/path/to/file')\n"
  "    ['user.test', 'user.comment', 'system.posix_acl_access']\n"
  "    >>> xattr.list('/path/to/file', namespace=xattr.NS_USER)\n"
  "    ['test', 'comment']\n"
  "\n"
  ITEM_DOC":param item: a string representing a file-name, a file-like\n"
 "    object, a file descriptor, or (in Python 3.6+) a path-like\n"
 "    object; this represents the file on which to act\n"
  NOFOLLOW_DOC":param nofollow: if true and if\n" "    the file name given is a symbolic link, the\n"
 "    function will operate on the symbolic link itself instead\n"
 "    of its target; defaults to false\n" ":type nofollow: boolean, optional\n"
  NS_DOC":param namespace: if given, the attribute must not contain the\n"
 "    namespace, but instead it will be taken from this parameter\n"
 ":type namespace: bytes\n"
  ":returns: the list of attributes; note that if a namespace \n"
  "    argument was passed, it (and the separator) will be stripped\n"
  "    from the names\n"
  "    returned\n"
  ":rtype: list\n"
  ":raises EnvironmentError: caused by any system errors\n"
  "\n"
  ".. versionadded:: 0.4\n"
  NS_CHANGED_DOC".. versionchanged:: 0.5.1\n" "   The namespace argument, if passed, cannot be None anymore; to\n"
 "   explicitly specify an empty namespace, pass an empty\n" "   string (byte string under Python 3)."
  ;

1038/* Wrapper for listxattr */
1039static PyObject *
1040xattr_list(PyObject *self, PyObject *args, PyObject *keywds)
1041{
  char *buf = NULL((void*)0);
  int nofollow = 0;
  ssize_t nret;
  size_t nalloc = 0;
  PyObject *myarg;
  PyObject *res;
  const char *ns = NULL((void*)0);
  Py_ssize_t nattrs;
  char *s;
  target_t tgt;
  static char *kwlist[] = {"item", "nofollow", "namespace", NULL((void*)0)};

  /* Parse the arguments */
  if (!PyArg_ParseTupleAndKeywords_PyArg_ParseTupleAndKeywords_SizeT(args, keywds, "O|iy", kwlist,
                                   &myarg, &nofollow, &ns))
      return NULL((void*)0);
  res = NULL((void*)0);
  if(convert_obj(myarg, &tgt, nofollow) < 0) {
      goto free_arg;
  }
  nret = _generic_get(_list_obj, &tgt, NULL((void*)0), &buf, &nalloc, NULL((void*)0));
  if (nret == -1) {
    goto free_tgt;
  }

  /* Compute the number of attributes in the list */
  for(s = buf, nattrs = 0; (s - buf) < nret; s += strlen(s) + 1) {
      if(matches_ns(ns, s) != NULL((void*)0))
          nattrs++;
  }

  /* Create the list which will hold the result */
  if((res = PyList_New(nattrs)) == NULL((void*)0)) {
      goto free_buf;
  }

  /* Create and insert the attributes as strings in the list */
  for(s = buf, nattrs = 0; s - buf < nret; s += strlen(s) + 1) {
      const char *name = matches_ns(ns, s);
      if(name != NULL((void*)0)) {
          PyObject *item = PyBytes_FromString(name);
          if(item == NULL((void*)0)) {
              Py_DECREF(res)_Py_DECREF(((PyObject*)(res)));
              res = NULL((void*)0);
              goto free_buf;
          }
          PyList_SET_ITEM(res, nattrs, item)PyList_SetItem(res, nattrs, item);
          nattrs++;
      }
  }

free_buf:
  /* Free the buffer, now it is no longer needed */
  PyMem_Free(buf);

free_tgt:
  free_tgt(&tgt);
free_arg:

  /* Return the result */
  return res;
1103}

1105static PyMethodDef xattr_methods[] = {
  {"getxattr",  pygetxattr, METH_VARARGS0x0001, __pygetxattr_doc__ },
  {"get",  (PyCFunction) xattr_get, METH_VARARGS0x0001 | METH_KEYWORDS0x0002,
   __get_doc__ },
  {"get_all", (PyCFunction) get_all, METH_VARARGS0x0001 | METH_KEYWORDS0x0002,
   __get_all_doc__ },
  {"setxattr",  pysetxattr, METH_VARARGS0x0001, __pysetxattr_doc__ },
  {"set",  (PyCFunction) xattr_set, METH_VARARGS0x0001 | METH_KEYWORDS0x0002,
   __set_doc__ },
  {"removexattr",  pyremovexattr, METH_VARARGS0x0001, __pyremovexattr_doc__ },
  {"remove",  (PyCFunction) xattr_remove, METH_VARARGS0x0001 | METH_KEYWORDS0x0002,
   __remove_doc__ },
  {"listxattr",  pylistxattr, METH_VARARGS0x0001, __pylistxattr_doc__ },
  {"list",  (PyCFunction) xattr_list, METH_VARARGS0x0001 | METH_KEYWORDS0x0002,
   __list_doc__ },
  {NULL((void*)0), NULL((void*)0), 0, NULL((void*)0)}        /* Sentinel */
1121};

1123static char __xattr_doc__[] = \
  "This module gives access to the extended attributes present\n"
  "in some operating systems/filesystems. You can list attributes,\n"
  "get, set and remove them.\n"
  "\n"
  "The module exposes two sets of functions:\n"
  "  - the 'old' :func:`listxattr`, :func:`getxattr`, :func:`setxattr`,\n"
  "    :func:`removexattr`\n"
  "    functions which are deprecated since version 0.4\n"
  "  - the new :func:`list`, :func:`get`, :func:`get_all`, :func:`set`,\n"
  "    :func:`remove` functions\n"
  "    which expose a namespace-aware API and simplify a bit the calling\n"
  "    model by using keyword arguments\n"
  "\n"
  "Example: \n\n"
  "  >>> import xattr\n"
  "  >>> xattr.listxattr(\"file.txt\")\n"
  "  ['user.mime_type']\n"
  "  >>> xattr.getxattr(\"file.txt\", \"user.mime_type\")\n"
  "  'text/plain'\n"
  "  >>> xattr.setxattr(\"file.txt\", \"user.comment\", "
  "\"Simple text file\")\n"
  "  >>> xattr.listxattr(\"file.txt\")\n"
  "  ['user.mime_type', 'user.comment']\n"
  "  >>> xattr.removexattr (\"file.txt\", \"user.comment\")\n"
  "\n"
  ".. note:: Most or all errors reported by the system while using\n"
  "   the ``xattr`` library will be reported by raising\n"
  "   a :exc:`EnvironmentError`; under\n"
  "   Linux, the following ``errno`` values are used:\n"
  "\n"
  "   - ``ENODATA`` means that the attribute name is invalid\n"
  "   - ``ENOTSUP`` and ``EOPNOTSUPP`` mean that the filesystem does not\n"
  "     support extended attributes, or that the namespace is invalid\n"
  "   - ``E2BIG`` mean that the attribute value is too big\n"
  "   - ``ERANGE`` mean that the attribute name is too big (it might also\n"
  "     mean an error in the xattr module itself)\n"
  "   - ``ENOSPC`` and ``EDQUOT`` are documented as meaning out of disk\n"
  "     space or out of disk space because of quota limits\n"
  ".. note:: Under Python 3, the namespace argument is a byte string,\n"
  "   not a unicode string.\n"
  "\n"
  ;

1167static struct PyModuleDef xattrmodule = {
  PyModuleDef_HEAD_INIT{ { 1, ((void*)0) }, ((void*)0), 0, ((void*)0), },
  "xattr",
  __xattr_doc__,
  0,
  xattr_methods,
1173};

1175#define INITERRORreturn ((void*)0) return NULL((void*)0)

1177PyMODINIT_FUNCPyObject*
1178PyInit_xattr(void)

1180{
  PyObject *ns_security = NULL((void*)0);
  PyObject *ns_system   = NULL((void*)0);
  PyObject *ns_trusted  = NULL((void*)0);
  PyObject *ns_user     = NULL((void*)0);
  PyObject *m = PyModule_Create(&xattrmodule)PyModule_Create2(&xattrmodule, 1013);
  if (m==NULL((void*)0))
      return NULL((void*)0);

  PyModule_AddStringConstant(m, "__author__", _XATTR_AUTHOR"Iustin Pop");
  PyModule_AddStringConstant(m, "__contact__", _XATTR_EMAIL"iustin@k1024.org");
  PyModule_AddStringConstant(m, "__version__", _XATTR_VERSION"0.7.2");
  PyModule_AddStringConstant(m, "__license__",
                             "GNU Lesser General Public License (LGPL)");
  PyModule_AddStringConstant(m, "__docformat__", "restructuredtext en");

  PyModule_AddIntConstant(m, "XATTR_CREATE", XATTR_CREATEXATTR_CREATE);
  PyModule_AddIntConstant(m, "XATTR_REPLACE", XATTR_REPLACEXATTR_REPLACE);

  /* namespace constants */
  if((ns_security = PyBytes_FromString("security")) == NULL((void*)0))
      goto err_out;
  if((ns_system = PyBytes_FromString("system")) == NULL((void*)0))
      goto err_out;
  if((ns_trusted = PyBytes_FromString("trusted")) == NULL((void*)0))
      goto err_out;
  if((ns_user = PyBytes_FromString("user")) == NULL((void*)0))
      goto err_out;
  if(PyModule_AddObject(m, "NS_SECURITY", ns_security) < 0)
      goto err_out;
  ns_security = NULL((void*)0);
  if(PyModule_AddObject(m, "NS_SYSTEM", ns_system) < 0)
      goto err_out;
  ns_system = NULL((void*)0);
  if(PyModule_AddObject(m, "NS_TRUSTED", ns_trusted) < 0)
      goto err_out;
  ns_trusted = NULL((void*)0);
  if(PyModule_AddObject(m, "NS_USER", ns_user) < 0)
      goto err_out;
  ns_user = NULL((void*)0);

  return m;

err_out:
  Py_XDECREF(ns_user)_Py_XDECREF(((PyObject*)(ns_user)));
  Py_XDECREF(ns_trusted)_Py_XDECREF(((PyObject*)(ns_trusted)));
  Py_XDECREF(ns_system)_Py_XDECREF(((PyObject*)(ns_system)));
  Py_XDECREF(ns_security)_Py_XDECREF(((PyObject*)(ns_security)));
  INITERRORreturn ((void*)0);
1229}

←

/opt/pyrefcon/lib/pyrefcon/models/models/_Py_BuildValue_SizeT.model

1#ifndef _Py_BuildValue_SizeT
2struct _object;
3typedef struct _object PyObject;
4PyObject* clang_analyzer_PyObject_New_Reference();
5PyObject* _Py_BuildValue_SizeT(const char *format, ...) {
6  return clang_analyzer_PyObject_New_Reference();
15
←
Setting reference count to 1→
7}
8#else
9#warning "API _Py_BuildValue_SizeT is defined as a macro."
10#endif