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;
}
