static int _lgetxattr (Xattr x, const char *path) { ssize_t len; if (x->name) len = lgetxattr (path, x->name, NULL, 0); else len = llistxattr (path, NULL, 0); if (len < 0) { np_uerror (errno); return -1; } assert (x->buf == NULL); x->buf = malloc (len); if (!x->buf) { np_uerror (ENOMEM); return -1; } if (x->name) x->len = lgetxattr (path, x->name, x->buf, len); else x->len = llistxattr (path, x->buf, len); if (x->len < 0) { np_uerror (errno); return -1; } return 0; }
static int setup_xattrs(struct archive_read_disk *a, struct archive_entry *entry, int fd) { char *list, *p; const char *path; ssize_t list_size; path = archive_entry_sourcepath(entry); if (path == NULL) path = archive_entry_pathname(entry); if (!a->follow_symlinks) list_size = llistxattr(path, NULL, 0); else list_size = listxattr(path, NULL, 0); if (list_size == -1) { if (errno == ENOTSUP) return (ARCHIVE_OK); archive_set_error(&a->archive, errno, "Couldn't list extended attributes"); return (ARCHIVE_WARN); } if (list_size == 0) return (ARCHIVE_OK); if ((list = malloc(list_size)) == NULL) { archive_set_error(&a->archive, errno, "Out of memory"); return (ARCHIVE_FATAL); } if (!a->follow_symlinks) list_size = llistxattr(path, list, list_size); else list_size = listxattr(path, list, list_size); if (list_size == -1) { archive_set_error(&a->archive, errno, "Couldn't retrieve extended attributes"); free(list); return (ARCHIVE_WARN); } for (p = list; (p - list) < list_size; p += strlen(p) + 1) { if (strncmp(p, "system.", 7) == 0 || strncmp(p, "xfsroot.", 8) == 0) continue; setup_xattr(a, entry, p, fd); } free(list); return (ARCHIVE_OK); }
/* * Get the list and pass to each layer to find out whether * to send the data or not */ ssize_t v9fs_list_xattr(FsContext *ctx, const char *path, void *value, size_t vsize) { ssize_t size = 0; char *buffer; void *ovalue = value; XattrOperations *xops; char *orig_value, *orig_value_start; ssize_t xattr_len, parsed_len = 0, attr_len; /* Get the actual len */ buffer = rpath(ctx, path); xattr_len = llistxattr(buffer, value, 0); if (xattr_len <= 0) { g_free(buffer); return xattr_len; } /* Now fetch the xattr and find the actual size */ orig_value = g_malloc(xattr_len); xattr_len = llistxattr(buffer, orig_value, xattr_len); g_free(buffer); /* store the orig pointer */ orig_value_start = orig_value; while (xattr_len > parsed_len) { xops = get_xattr_operations(ctx->xops, orig_value); if (!xops) { goto next_entry; } if (!value) { size += xops->listxattr(ctx, path, orig_value, value, vsize); } else { size = xops->listxattr(ctx, path, orig_value, value, vsize); if (size < 0) { goto err_out; } value += size; vsize -= size; } next_entry: /* Got the next entry */ attr_len = strlen(orig_value) + 1; parsed_len += attr_len; orig_value += attr_len; } if (value) { size = value - ovalue; } err_out: g_free(orig_value_start); return size; }
gboolean ostree_get_xattrs_for_file (GFile *f, GVariant **out_xattrs, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; const char *path; ssize_t bytes_read; ot_lvariant GVariant *ret_xattrs = NULL; ot_lfree char *xattr_names = NULL; ot_lfree char *xattr_names_canonical = NULL; GVariantBuilder builder; gboolean builder_initialized = FALSE; path = ot_gfile_get_path_cached (f); g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(ayay)")); builder_initialized = TRUE; bytes_read = llistxattr (path, NULL, 0); if (bytes_read < 0) { if (errno != ENOTSUP) { ot_util_set_error_from_errno (error, errno); goto out; } } else if (bytes_read > 0) { xattr_names = g_malloc (bytes_read); if (llistxattr (path, xattr_names, bytes_read) < 0) { ot_util_set_error_from_errno (error, errno); goto out; } xattr_names_canonical = canonicalize_xattrs (xattr_names, bytes_read); if (!read_xattr_name_array (path, xattr_names_canonical, bytes_read, &builder, error)) goto out; } ret_xattrs = g_variant_builder_end (&builder); g_variant_ref_sink (ret_xattrs); ret = TRUE; ot_transfer_out_value (out_xattrs, &ret_xattrs); out: if (!builder_initialized) g_variant_builder_clear (&builder); return ret; }
int get_xattr(struct asfd *asfd, const char *path, char **xattrtext, size_t *xlen, struct cntr *cntr) { int ret=0; ssize_t len; int have_acl=0; char *toappend=NULL; char *xattrlist=NULL; ssize_t totallen=0; if((len=llistxattr(path, NULL, 0))<0) { logw(asfd, cntr, "could not llistxattr '%s': %zd %s\n", path, len, strerror(errno)); goto end; // Carry on. } if(!(xattrlist=(char *)calloc_w(1, len, __func__))) { ret=-1; goto end; } if((len=llistxattr(path, xattrlist, len))<0) { logw(asfd, cntr, "could not llistxattr '%s': %zd %s\n", path, len, strerror(errno)); goto end; // Carry on. } if(xattrtext && *xattrtext) { // Already have some meta text, which means that some // ACLs were set. have_acl++; } if(get_toappend(asfd, path, &toappend, xattrlist, len, &totallen, have_acl, cntr)) { ret=-1; goto end; } if(toappend) ret=append_to_extrameta(toappend, META_XATTR, xattrtext, xlen, totallen); end: free_w(&toappend); free_w(&xattrlist); return ret; }
/* * List the supported extended attributes. */ int callback_listxattr(const char *path, char *list, size_t size) { char *rpath; int res; /* If we list our own attributes here, some programs will try to copy * them when copying files. That won't work: * - rcs.metadata_dump can't be copied, it is read-only * - rcs.purge can't be copied, it ist write-only * - rcs.locked_version CAN be copied, but this leads to unwantet results * So we just pass the attributes of the underlying filesystem. * * Maybe this isn't the best solution, but it's better than letting some * programs fiddle around with file versions without knowing what they * are doing.*/ rpath = rcs_translate_path(path, rcs_version_path); if (!rpath) return -ENOENT; /* Get the EAs of the real file */ res = llistxattr(rpath, list, size); if (res == -1) res = -errno; free (rpath); return res; }
static int xmp_listxattr(const char *path, char *list, size_t size) { int res = llistxattr(path, list, size); if (res == -1) return -errno; return res; }
ssize_t sys_llistxattr (const char *path, char *list, size_t size) { #if defined(HAVE_LLISTXATTR) ssize_t ret; ret = llistxattr(path, list, size); return remove_user(ret, list, size); #elif defined(HAVE_LISTXATTR) && defined(XATTR_ADD_OPT) ssize_t ret; int options = XATTR_NOFOLLOW; ret = listxattr(path, list, size, options); return remove_user(ret, list, size); #elif defined(HAVE_LLISTEA) return llistea(path, list, size); #elif defined(HAVE_EXTATTR_LIST_LINK) extattr_arg arg; arg.path = path; return bsd_attr_list(1, arg, list, size); #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H) return irix_attr_list(path, 0, list, size, ATTR_DONTFOLLOW); #elif defined(HAVE_ATTROPEN) ssize_t ret = -1; int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0); if (attrdirfd >= 0) { ret = solaris_list_xattr(attrdirfd, list, size); close(attrdirfd); } return ret; #else errno = ENOSYS; return -1; #endif }
static int xmp_listxattr(const char *path, char *list, size_t size) { char buf[BUFSIZE]; int res = llistxattr(_xmp_fullpath(buf, path, BUFSIZE), list, size); if (res == -1) return -errno; return res; }
static INT64_T chirp_fs_local_llistxattr(const char *path, char *list, size_t size) { #ifdef CCTOOLS_OPSYS_DARWIN return listxattr(path, list, size, XATTR_NOFOLLOW); #else return llistxattr(path, list, size); #endif }
static int xmp_listxattr(const char *path, char *list, size_t size) { char fpath[PATH_MAX]; xmp_fullpath(fpath, path); int res = llistxattr(fpath, list, size); if (res == -1) return -errno; return res; }
static int encfs_listxattr(const char *path, char *list, size_t size) { char fpath[PATH_MAX]; // Full buffer to pass to static function dj_fullpath(fpath, path); int res = llistxattr(fpath, list, size); if (res == -1) return -errno; return res; }
static int check_suitable_buf(const char *name, long size) { int n; char buf[size]; n = llistxattr(name, buf, sizeof(buf)); return n != -1; }
static int xmp_listxattr(const char *path, char *list, size_t size) { const char* new_path = rewritepath(path); int res = llistxattr(new_path, list, size); free((void*)new_path); if (res == -1) return -errno; return res; }
static PyObject * llistxattr_wrapper(PyObject *self, PyObject *args) { const char *filename; size_t bufsize; PyObject *o; char* buf; ssize_t n; if (!PyArg_ParseTuple(args, "s", &filename)) return NULL; #ifdef __FreeBSD__ bufsize = extattr_list_link(filename, EXTATTR_NAMESPACE_USER, NULL, 0); buf = malloc(bufsize); if (buf == NULL) { Py_INCREF(Py_None); return Py_None; } n = extattr_list_link(filename, EXTATTR_NAMESPACE_USER, buf, bufsize); if (n >= 0) { /* Convert from length-prefixed BSD style to '\0'-suffixed Linux style. */ size_t i = 0; while (i < n) { unsigned char length = (unsigned char) buf[i]; memmove(buf + i, buf + i + 1, length); buf[i + length] = '\0'; i += length + 1; } o = Py_BuildValue("s#", buf, (int) n); } else { o = Py_BuildValue("i", errno); } free(buf); #else bufsize = 0; o = NULL; do { bufsize += 1024; buf = malloc(bufsize); if (buf == NULL) { Py_INCREF(Py_None); return Py_None; } n = llistxattr(filename, buf, bufsize); if (n >= 0) o = Py_BuildValue("s#", buf, (int) n); else if (n == -1 && errno != ERANGE) o = Py_BuildValue("i", errno); free(buf); } while (o == NULL); #endif return o; }
static int enc_listxattr(const char *path, char *list, size_t size) { /* change path to specific mirror directory instead of root */ char fpath[PATH_MAX]; enc_fullpath(fpath, path); int res = llistxattr(fpath, list, size); if (res == -1) return -errno; return res; }
static ssize_t xattr_listxattr(const char *path, char *namebuf, size_t size, int options) { if (!(options == 0 || options == XATTR_XATTR_NOFOLLOW)) { return -1; } if (options & XATTR_XATTR_NOFOLLOW) { return llistxattr(path, namebuf, size); } else { return listxattr(path, namebuf, size); } }
static int bru_listxattr(const char *path, char *list, size_t size) { SET_CALLER_UID(); REDIR_PATH(path, new_path); int ret = llistxattr(new_path, list, size); SET_RET_ERRNO(); return ret; }
static int do_getxattr(int type, struct iovec *iovec, struct iovec *out_iovec) { int size = 0, offset, retval; V9fsString path, name, xattr; v9fs_string_init(&xattr); v9fs_string_init(&path); retval = proxy_unmarshal(iovec, PROXY_HDR_SZ, "ds", &size, &path); if (retval < 0) { return retval; } offset = PROXY_HDR_SZ + retval; if (size) { xattr.data = g_malloc(size); xattr.size = size; } switch (type) { case T_LGETXATTR: v9fs_string_init(&name); retval = proxy_unmarshal(iovec, offset, "s", &name); if (retval > 0) { retval = lgetxattr(path.data, name.data, xattr.data, size); if (retval < 0) { retval = -errno; } else { xattr.size = retval; } } v9fs_string_free(&name); break; case T_LLISTXATTR: retval = llistxattr(path.data, xattr.data, size); if (retval < 0) { retval = -errno; } else { xattr.size = retval; } break; } if (retval < 0) { goto err_out; } if (!size) { proxy_marshal(out_iovec, PROXY_HDR_SZ, "d", retval); retval = sizeof(retval); } else { retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, "s", &xattr); } err_out: v9fs_string_free(&xattr); v9fs_string_free(&path); return retval; }
ssize_t sys_llistxattr (const char *path, char *list, size_t size) { #if defined(HAVE_LLISTXATTR) return llistxattr(path, list, size); #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H) return irix_attr_list(path, 0, list, size, ATTR_DONTFOLLOW); #else errno = ENOSYS; return -1; #endif }
static int xmp_listxattr(const char *path, char *list, size_t size) { fprintf(f, "listxattr: %s\n", path); int res = llistxattr(path, list, size); if (res == -1){ fprintf(f, "operation failed\n"); return -errno; } fprintf(f, "operation succeeded\n"); return res; }
/** List extended attributes */ int bb_listxattr(const char *path, char *list, size_t size) { int retstat = 0; char fpath[PATH_MAX]; char *ptr; bb_fullpath(fpath, path); retstat = llistxattr(fpath, list, size); return retstat; }
static INT64_T chirp_fs_local_llistxattr(const char *path, char *list, size_t size) { PREAMBLE("llistxattr(`%s', %p, %zu)", path, list, size); RESOLVE(path) #ifdef CCTOOLS_OPSYS_DARWIN rc = listxattr(path, list, size, XATTR_NOFOLLOW); #else rc = llistxattr(path, list, size); #endif PROLOGUE }
/** List extended attributes */ int sfs_listxattr(const char *path, char *list, size_t size) { int retstat = 0; char fpath[PATH_MAX]; sfs_fullpath(fpath, path); retstat = llistxattr(fpath, list, size); if (retstat < 0) retstat = sfs_error("sfs_listxattr llistxattr"); return retstat; }
int thesmurFS_listxattr(const char* path, char* list, size_t size) { char* physical_path; int r; //emergency_output("listxattr"); if(get_physical_path(path, &physical_path) == -1) { //emergency_output("ENOMEM"); return -errno; } r = llistxattr(physical_path, list, size); if(r<0) return -errno; return r; }
static int ciopfs_listxattr(const char *path, char *list, size_t size) { char *p = map_path(path); if (unlikely(p == NULL)) return -ENOMEM; enter_user_context_effective(); int res = llistxattr(p, list, size); if (res == -1) res = -errno; leave_user_context_effective(); free(p); return res; }
static ssize_t xlistxattr(const char *path, char *list, size_t size, int symlink) { #ifdef XATTR_EXTRA_ARGS return listxattr(path, list, size, symlink ? XATTR_NOFOLLOW : 0); #else switch (symlink) { case 0: return listxattr(path, list, size); default: return llistxattr(path, list, size); } #endif }
/* * List the supported extended attributes. */ static int callback_listxattr(const char *path, char *list, size_t size) { int res; char *ipath; ipath=translate_path(path); res = llistxattr(ipath, list, size); free(ipath); if(res == -1) { return -errno; } return res; }
static int xmp_listxattr (const char *path, char *list, size_t size) { int res; char path2[PATH_MAX]; convert_path (path, path2); openrfs_fuse_drop_privs (); res = llistxattr (path, list, size); openrfs_fuse_restore_privs (); if (res == -1) return -errno; return res; }
static int add_xattr_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, u64 objectid, const char *file_name) { int ret; int cur_name_len; char xattr_list[XATTR_LIST_MAX]; char *cur_name; char cur_value[XATTR_SIZE_MAX]; char delimiter = '\0'; char *next_location = xattr_list; ret = llistxattr(file_name, xattr_list, XATTR_LIST_MAX); if (ret < 0) { if(errno == ENOTSUP) return 0; fprintf(stderr, "get a list of xattr failed for %s\n", file_name); return ret; } if (ret == 0) return ret; cur_name = strtok(xattr_list, &delimiter); while (cur_name != NULL) { cur_name_len = strlen(cur_name); next_location += cur_name_len + 1; ret = getxattr(file_name, cur_name, cur_value, XATTR_SIZE_MAX); if (ret < 0) { if(errno == ENOTSUP) return 0; fprintf(stderr, "get a xattr value failed for %s attr %s\n", file_name, cur_name); return ret; } ret = btrfs_insert_xattr_item(trans, root, cur_name, cur_name_len, cur_value, ret, objectid); if (ret) { fprintf(stderr, "insert a xattr item failed for %s\n", file_name); } cur_name = strtok(next_location, &delimiter); } return ret; }