* Written by Jay Fenlason, vaguely based on the ACLs patch.
*
* Copyright (C) 2004 Red Hat, Inc.
- * Copyright (C) 2006-2009 Wayne Davison
+ * Copyright (C) 2006-2018 Wayne Davison
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
extern int read_only;
extern int list_only;
extern int preserve_xattrs;
+extern int preserve_links;
+extern int preserve_devices;
+extern int preserve_specials;
extern int checksum_seed;
+extern int saw_xattr_filter;
#define RSYNC_XAL_INITIAL 5
#define RSYNC_XAL_LIST_INITIAL 100
int num;
} rsync_xa;
+struct _rsync_xa_list;
+
+typedef struct _rsync_xa_list_ref {
+ struct _rsync_xa_list_ref *next;
+ int ndx;
+} rsync_xa_list_ref;
+
+typedef struct _rsync_xa_list {
+ int ndx;
+ int64 key;
+ item_list xa_items;
+} rsync_xa_list;
+
static size_t namebuf_len = 0;
static char *namebuf = NULL;
-static item_list empty_xattr = EMPTY_ITEM_LIST;
+static const rsync_xa_list empty_xa_list = {
+ .xa_items = EMPTY_ITEM_LIST,
+};
+static const item_list empty_xattr = EMPTY_ITEM_LIST;
static item_list rsync_xal_l = EMPTY_ITEM_LIST;
+static struct hashtable *rsync_xal_h = NULL;
static size_t prior_xattr_count = (size_t)-1;
size_t i;
rsync_xa *rxas = xalp->items;
+ if (!xalp->malloced)
+ return;
+
for (i = 0; i < xalp->count; i++) {
free(rxas[i].datum);
/*free(rxas[i].name);*/
}
- xalp->count = 0;
+ free(xalp->items);
}
void free_xattr(stat_x *sxp)
arg = namebuf_len;
got_error:
rsyserr(FERROR_XFER, errno,
- "get_xattr_names: llistxattr(\"%s\",%s) failed",
- fname, big_num(arg));
+ "get_xattr_names: llistxattr(%s,%s) failed",
+ full_fname(fname), big_num(arg));
return -1;
}
list_len = sys_llistxattr(fname, NULL, 0);
if (errno == ENOTSUP || no_missing_error)
return NULL;
rsyserr(FERROR_XFER, errno,
- "get_xattr_data: lgetxattr(\"%s\",\"%s\",0) failed",
- fname, name);
+ "get_xattr_data: lgetxattr(%s,\"%s\",0) failed",
+ full_fname(fname), name);
return NULL;
}
if (len != datum_len) {
if (len == (size_t)-1) {
rsyserr(FERROR_XFER, errno,
- "get_xattr_data: lgetxattr(\"%s\",\"%s\",%ld)"
- " failed", fname, name, (long)datum_len);
+ "get_xattr_data: lgetxattr(%s,\"%s\",%ld) failed",
+ full_fname(fname), name, (long)datum_len);
} else {
rprintf(FERROR_XFER,
- "get_xattr_data: lgetxattr(\"%s\",\"%s\",%ld)"
- " returned %ld\n", fname, name,
+ "get_xattr_data: lgetxattr(%s,\"%s\",%ld) returned %ld\n",
+ full_fname(fname), name,
(long)datum_len, (long)len);
}
free(ptr);
name_len = strlen(name) + 1;
list_len -= name_len;
+ if (saw_xattr_filter) {
+ if (name_is_excluded(name, NAME_IS_XATTR, ALL_FILTERS))
+ continue;
+ }
#ifdef HAVE_LINUX_XATTRS
- /* We always ignore the system namespace, and non-root
- * ignores everything but the user namespace. */
- if (user_only ? !HAS_PREFIX(name, USER_PREFIX)
- : HAS_PREFIX(name, SYSTEM_PREFIX))
+ /* Choose between ignoring the system namespace or (non-root) ignoring any non-user namespace. */
+ else if (user_only ? !HAS_PREFIX(name, USER_PREFIX) : HAS_PREFIX(name, SYSTEM_PREFIX))
continue;
#endif
/* No rsync.%FOO attributes are copied w/o 2 -X options. */
- if (name_len > RPRE_LEN && name[RPRE_LEN] == '%'
- && HAS_PREFIX(name, RSYNC_PREFIX)) {
+ if (name_len > RPRE_LEN && name[RPRE_LEN] == '%' && HAS_PREFIX(name, RSYNC_PREFIX)) {
if ((am_sender && preserve_xattrs < 2)
|| (am_root < 0
&& (strcmp(name+RPRE_LEN+1, XSTAT_SUFFIX) == 0
if (datum_len > MAX_FULL_DATUM) {
/* For large datums, we store a flag and a checksum. */
name_offset = 1 + MAX_DIGEST_LEN;
- sum_init(checksum_seed);
+ sum_init(-1, checksum_seed);
sum_update(ptr, datum_len);
free(ptr);
sxp->xattr = new(item_list);
*sxp->xattr = empty_xattr;
-#ifdef NO_SPECIAL_XATTRS
- if (IS_SPECIAL(sxp->st.st_mode))
- return 0;
+ if (S_ISREG(sxp->st.st_mode) || S_ISDIR(sxp->st.st_mode)) {
+ /* Everyone supports this. */
+ } else if (S_ISLNK(sxp->st.st_mode)) {
+#ifndef NO_SYMLINK_XATTRS
+ if (!preserve_links)
#endif
-#ifdef NO_DEVICE_XATTRS
- if (IS_DEVICE(sxp->st.st_mode))
- return 0;
+ return 0;
+ } else if (IS_SPECIAL(sxp->st.st_mode)) {
+#ifndef NO_SPECIAL_XATTRS
+ if (!preserve_specials)
#endif
-#ifdef NO_SYMLINK_XATTRS
- if (S_ISLNK(sxp->st.st_mode))
- return 0;
+ return 0;
+ } else if (IS_DEVICE(sxp->st.st_mode)) {
+#ifndef NO_DEVICE_XATTRS
+ if (!preserve_devices)
#endif
+ return 0;
+ } else if (IS_MISSING_FILE(sxp->st))
+ return 0;
if (rsync_xal_get(fname, sxp->xattr) < 0) {
free_xattr(sxp);
name_len = strlen(name) + 1;
list_len -= name_len;
+ if (saw_xattr_filter) {
+ if (name_is_excluded(name, NAME_IS_XATTR, ALL_FILTERS))
+ continue;
+ }
#ifdef HAVE_LINUX_XATTRS
- /* We always ignore the system namespace, and non-root
- * ignores everything but the user namespace. */
- if (user_only ? !HAS_PREFIX(name, USER_PREFIX)
- : HAS_PREFIX(name, SYSTEM_PREFIX))
+ /* Choose between ignoring the system namespace or (non-root) ignoring any non-user namespace. */
+ else if (user_only ? !HAS_PREFIX(name, USER_PREFIX) : HAS_PREFIX(name, SYSTEM_PREFIX))
continue;
#endif
if (sys_lsetxattr(dest, name, ptr, datum_len) < 0) {
int save_errno = errno ? errno : EINVAL;
rsyserr(FERROR_XFER, errno,
- "rsync_xal_set: lsetxattr(\"%s\",\"%s\") failed",
- dest, name);
+ "copy_xattrs: lsetxattr(%s,\"%s\") failed",
+ full_fname(dest), name);
errno = save_errno;
return -1;
}
return 0;
}
-static int find_matching_xattr(item_list *xalp)
+static int64 xattr_lookup_hash(const item_list *xalp)
{
- size_t i, j;
- item_list *lst = rsync_xal_l.items;
+ const rsync_xa *rxas = xalp->items;
+ size_t i;
+ int64 key = hashlittle(&xalp->count, sizeof xalp->count);
- for (i = 0; i < rsync_xal_l.count; i++) {
- rsync_xa *rxas1 = lst[i].items;
- rsync_xa *rxas2 = xalp->items;
+ for (i = 0; i < xalp->count; i++) {
+ key += hashlittle(rxas[i].name, rxas[i].name_len);
+ if (rxas[i].datum_len > MAX_FULL_DATUM)
+ key += hashlittle(rxas[i].datum, MAX_DIGEST_LEN);
+ else
+ key += hashlittle(rxas[i].datum, rxas[i].datum_len);
+ }
+
+ if (key == 0) {
+ /* This is very unlikely, but we should never
+ * return 0 as hashtable_find() doesn't like it. */
+ return 1;
+ }
+
+ return key;
+}
+
+static int find_matching_xattr(const item_list *xalp)
+{
+ const struct ht_int64_node *node;
+ const rsync_xa_list_ref *ref;
+ int64 key;
+
+ if (rsync_xal_h == NULL)
+ return -1;
+
+ key = xattr_lookup_hash(xalp);
+
+ node = hashtable_find(rsync_xal_h, key, 0);
+ if (node == NULL)
+ return -1;
+
+ if (node->data == NULL)
+ return -1;
+
+ for (ref = node->data; ref != NULL; ref = ref->next) {
+ const rsync_xa_list *ptr = rsync_xal_l.items;
+ const rsync_xa *rxas1;
+ const rsync_xa *rxas2 = xalp->items;
+ size_t j;
+
+ ptr += ref->ndx;
+ rxas1 = ptr->xa_items.items;
/* Wrong number of elements? */
- if (lst[i].count != xalp->count)
+ if (ptr->xa_items.count != xalp->count)
continue;
/* any elements different? */
for (j = 0; j < xalp->count; j++) {
}
/* no differences found. This is The One! */
if (j == xalp->count)
- return i;
+ return ref->ndx;
}
return -1;
}
/* Store *xalp on the end of rsync_xal_l */
-static void rsync_xal_store(item_list *xalp)
+static int rsync_xal_store(item_list *xalp)
{
- item_list *new_lst = EXPAND_ITEM_LIST(&rsync_xal_l, item_list, RSYNC_XAL_LIST_INITIAL);
+ struct ht_int64_node *node;
+ int ndx = rsync_xal_l.count; /* pre-incremented count */
+ rsync_xa_list *new_list = EXPAND_ITEM_LIST(&rsync_xal_l, rsync_xa_list, RSYNC_XAL_LIST_INITIAL);
+ rsync_xa_list_ref *new_ref;
/* Since the following call starts a new list, we know it will hold the
* entire initial-count, not just enough space for one new item. */
- *new_lst = empty_xattr;
- (void)EXPAND_ITEM_LIST(new_lst, rsync_xa, xalp->count);
- memcpy(new_lst->items, xalp->items, xalp->count * sizeof (rsync_xa));
- new_lst->count = xalp->count;
+ *new_list = empty_xa_list;
+ (void)EXPAND_ITEM_LIST(&new_list->xa_items, rsync_xa, xalp->count);
+ memcpy(new_list->xa_items.items, xalp->items, xalp->count * sizeof (rsync_xa));
+ new_list->xa_items.count = xalp->count;
xalp->count = 0;
+
+ new_list->ndx = ndx;
+ new_list->key = xattr_lookup_hash(&new_list->xa_items);
+
+ if (rsync_xal_h == NULL)
+ rsync_xal_h = hashtable_create(512, 1);
+ if (rsync_xal_h == NULL)
+ out_of_memory("rsync_xal_h hashtable_create()");
+
+ node = hashtable_find(rsync_xal_h, new_list->key, 1);
+ if (node == NULL)
+ out_of_memory("rsync_xal_h hashtable_find()");
+
+ new_ref = new0(rsync_xa_list_ref);
+ if (new_ref == NULL)
+ out_of_memory("new0(rsync_xa_list_ref)");
+
+ new_ref->ndx = ndx;
+
+ if (node->data != NULL) {
+ rsync_xa_list_ref *ref = node->data;
+
+ while (ref != NULL) {
+ if (ref->next != NULL) {
+ ref = ref->next;
+ continue;
+ }
+
+ ref->next = new_ref;
+ break;
+ }
+ } else
+ node->data = new_ref;
+
+ return ndx;
}
/* Send the make_xattr()-generated xattr list for this flist entry. */
-int send_xattr(stat_x *sxp, int f)
+int send_xattr(int f, stat_x *sxp)
{
int ndx = find_matching_xattr(sxp->xattr);
if (rxa->datum_len > MAX_FULL_DATUM)
write_buf(f, rxa->datum + 1, MAX_DIGEST_LEN);
else
- write_buf(f, rxa->datum, rxa->datum_len);
+ write_bigbuf(f, rxa->datum, rxa->datum_len);
}
- ndx = rsync_xal_l.count; /* pre-incremented count */
- rsync_xal_store(sxp->xattr); /* adds item to rsync_xal_l */
+ ndx = rsync_xal_store(sxp->xattr); /* adds item to rsync_xal_l */
}
return ndx;
* need so that send_xattr_request() can tell the sender about them. */
int xattr_diff(struct file_struct *file, stat_x *sxp, int find_all)
{
- item_list *lst = rsync_xal_l.items;
+ const rsync_xa_list *glst = rsync_xal_l.items;
+ const item_list *lst;
rsync_xa *snd_rxa, *rec_rxa;
int snd_cnt, rec_cnt;
int cmp, same, xattrs_equal = 1;
rec_cnt = 0;
}
- if (F_XATTR(file) >= 0)
- lst += F_XATTR(file);
- else
+ if (F_XATTR(file) >= 0) {
+ glst += F_XATTR(file);
+ lst = &glst->xa_items;
+ } else
lst = &empty_xattr;
snd_rxa = lst->items;
* XSTATE_ABBREV states into XSTATE_DONE. */
void send_xattr_request(const char *fname, struct file_struct *file, int f_out)
{
- item_list *lst = rsync_xal_l.items;
+ const rsync_xa_list *glst = rsync_xal_l.items;
+ const item_list *lst;
int cnt, prior_req = 0;
rsync_xa *rxa;
- lst += F_XATTR(file);
+ glst += F_XATTR(file);
+ lst = &glst->xa_items;
+
for (rxa = lst->items, cnt = lst->count; cnt--; rxa++) {
if (rxa->datum_len <= MAX_FULL_DATUM)
continue;
}
write_varint(f_out, len); /* length might have changed! */
- write_buf(f_out, ptr, len);
+ write_bigbuf(f_out, ptr, len);
free(ptr);
}
}
* stores it in place of its checksum. */
int recv_xattr_request(struct file_struct *file, int f_in)
{
- item_list *lst = rsync_xal_l.items;
+ const rsync_xa_list *glst = rsync_xal_l.items;
+ const item_list *lst;
char *old_datum, *name;
rsync_xa *rxa;
int rel_pos, cnt, num, got_xattr_data = 0;
if (F_XATTR(file) < 0) {
rprintf(FERROR, "recv_xattr_request: internal data error!\n");
- exit_cleanup(RERR_STREAMIO);
+ exit_cleanup(RERR_PROTOCOL);
}
- lst += F_XATTR(file);
+ glst += F_XATTR(file);
+ lst = &glst->xa_items;
cnt = lst->count;
rxa = lst->items;
num = 0;
while ((rel_pos = read_varint(f_in)) != 0) {
num += rel_pos;
- while (cnt && rxa->num < num) {
- rxa++;
- cnt--;
+ if (am_sender) {
+ /* The sender-related num values are only in order on the sender.
+ * We use that order here to scan foward or backward as needed. */
+ if (rel_pos < 0) {
+ while (cnt < (int)lst->count && rxa->num > num) {
+ rxa--;
+ cnt++;
+ }
+ } else {
+ while (cnt > 1 && rxa->num < num) {
+ rxa++;
+ cnt--;
+ }
+ }
+ } else {
+ int j;
+ /* The receiving side has no known num order, so we just scan
+ * forward (w/wrap) and hope that the next value is near by. */
+ for (j = lst->count; j > 1 && rxa->num != num; j--) {
+ if (--cnt)
+ rxa++;
+ else {
+ cnt = lst->count;
+ rxa = lst->items;
+ }
+ }
}
if (!cnt || rxa->num != num) {
rprintf(FERROR, "[%s] could not find xattr #%d for %s\n",
who_am_i(), num, f_name(file, NULL));
- exit_cleanup(RERR_STREAMIO);
+ exit_cleanup(RERR_PROTOCOL);
}
if (!XATTR_ABBREV(*rxa) || rxa->datum[0] != XSTATE_ABBREV) {
rprintf(FERROR, "[%s] internal abbrev error on %s (%s, len=%ld)!\n",
who_am_i(), f_name(file, NULL), rxa->name, (long)rxa->datum_len);
- exit_cleanup(RERR_STREAMIO);
+ exit_cleanup(RERR_PROTOCOL);
}
if (am_sender) {
/* ------------------------------------------------------------------------- */
/* receive and build the rsync_xattr_lists */
-void receive_xattr(struct file_struct *file, int f)
+void receive_xattr(int f, struct file_struct *file)
{
static item_list temp_xattr = EMPTY_ITEM_LIST;
int count, num;
F_XATTR(file) = ndx - 1;
return;
}
-
+
if ((count = read_varint(f)) != 0) {
(void)EXPAND_ITEM_LIST(&temp_xattr, rsync_xa, count);
temp_xattr.count = 0;
size_t dget_len = datum_len > MAX_FULL_DATUM ? 1 + MAX_DIGEST_LEN : datum_len;
size_t extra_len = MIGHT_NEED_RPRE ? RPRE_LEN : 0;
if ((dget_len + extra_len < dget_len)
- || (dget_len + extra_len + name_len < dget_len))
+ || (dget_len + extra_len + name_len < dget_len + extra_len))
overflow_exit("receive_xattr");
ptr = new_array(char, dget_len + extra_len + name_len);
if (!ptr)
out_of_memory("receive_xattr");
name = ptr + dget_len + extra_len;
read_buf(f, name, name_len);
+ if (name_len < 1 || name[name_len-1] != '\0') {
+ rprintf(FERROR, "Invalid xattr name received (missing trailing \\0).\n");
+ exit_cleanup(RERR_FILEIO);
+ }
if (dget_len == datum_len)
read_buf(f, ptr, dget_len);
else {
*ptr = XSTATE_ABBREV;
read_buf(f, ptr + 1, MAX_DIGEST_LEN);
}
+
+ if (saw_xattr_filter) {
+ if (name_is_excluded(name, NAME_IS_XATTR, ALL_FILTERS)) {
+ free(ptr);
+ continue;
+ }
+ }
#ifdef HAVE_LINUX_XATTRS
/* Non-root can only save the user namespace. */
if (am_root <= 0 && !HAS_PREFIX(name, USER_PREFIX)) {
- if (!am_root) {
+ if (!am_root && !saw_xattr_filter) {
free(ptr);
continue;
}
free(ptr);
continue;
}
+
rxa = EXPAND_ITEM_LIST(&temp_xattr, rsync_xa, 1);
rxa->name = name;
rxa->datum = ptr;
if (need_sort && count > 1)
qsort(temp_xattr.items, count, sizeof (rsync_xa), rsync_xal_compare_names);
- ndx = rsync_xal_l.count; /* pre-incremented count */
- rsync_xal_store(&temp_xattr); /* adds item to rsync_xal_l */
+ ndx = rsync_xal_store(&temp_xattr); /* adds item to rsync_xal_l */
F_XATTR(file) = ndx;
}
void uncache_tmp_xattrs(void)
{
if (prior_xattr_count != (size_t)-1) {
- item_list *xattr_item = rsync_xal_l.items;
- item_list *xattr_start = xattr_item + prior_xattr_count;
- xattr_item += rsync_xal_l.count;
+ rsync_xa_list *xa_list_item = rsync_xal_l.items;
+ rsync_xa_list *xa_list_start = xa_list_item + prior_xattr_count;
+ xa_list_item += rsync_xal_l.count;
rsync_xal_l.count = prior_xattr_count;
- while (xattr_item-- > xattr_start) {
- rsync_xal_free(xattr_item);
- free(xattr_item);
+ while (xa_list_item-- > xa_list_start) {
+ struct ht_int64_node *node;
+ rsync_xa_list_ref *ref;
+
+ rsync_xal_free(&xa_list_item->xa_items);
+
+ if (rsync_xal_h == NULL)
+ continue;
+
+ node = hashtable_find(rsync_xal_h, xa_list_item->key, 0);
+ if (node == NULL)
+ continue;
+
+ if (node->data == NULL)
+ continue;
+
+ ref = node->data;
+ if (xa_list_item->ndx == ref->ndx) {
+ /* xa_list_item is the first in the list. */
+ node->data = ref->next;
+ free(ref);
+ continue;
+ }
+
+ while (ref != NULL) {
+ if (ref->next == NULL) {
+ ref = NULL;
+ break;
+ }
+ if (xa_list_item->ndx == ref->next->ndx) {
+ ref->next = ref->next->next;
+ free(ref);
+ break;
+ }
+ ref = ref->next;
+ }
}
prior_xattr_count = (size_t)-1;
}
name = rxas[i].name;
if (XATTR_ABBREV(rxas[i])) {
+ int sum_len;
/* See if the fnamecmp version is identical. */
len = name_len = rxas[i].name_len;
if ((ptr = get_xattr_data(fnamecmp, name, &len, 1)) == NULL) {
goto still_abbrev;
}
- sum_init(checksum_seed);
+ sum_init(-1, checksum_seed);
sum_update(ptr, len);
- sum_end(sum);
- if (memcmp(sum, rxas[i].datum + 1, MAX_DIGEST_LEN) != 0) {
+ sum_len = sum_end(sum);
+ if (memcmp(sum, rxas[i].datum + 1, sum_len) != 0) {
free(ptr);
goto still_abbrev;
}
; /* Value is already set when identical */
else if (sys_lsetxattr(fname, name, ptr, len) < 0) {
rsyserr(FERROR_XFER, errno,
- "rsync_xal_set: lsetxattr(\"%s\",\"%s\") failed",
- fname, name);
+ "rsync_xal_set: lsetxattr(%s,\"%s\") failed",
+ full_fname(fname), name);
ret = -1;
} else /* make sure caller sets mtime */
sxp->st.st_mtime = (time_t)-1;
if (sys_lsetxattr(fname, name, rxas[i].datum, rxas[i].datum_len) < 0) {
rsyserr(FERROR_XFER, errno,
- "rsync_xal_set: lsetxattr(\"%s\",\"%s\") failed",
- fname, name);
+ "rsync_xal_set: lsetxattr(%s,\"%s\") failed",
+ full_fname(fname), name);
ret = -1;
} else /* make sure caller sets mtime */
sxp->st.st_mtime = (time_t)-1;
name_len = strlen(name) + 1;
list_len -= name_len;
+ if (saw_xattr_filter) {
+ if (name_is_excluded(name, NAME_IS_XATTR, ALL_FILTERS))
+ continue;
+ }
#ifdef HAVE_LINUX_XATTRS
- /* We always ignore the system namespace, and non-root
- * ignores everything but the user namespace. */
- if (user_only ? !HAS_PREFIX(name, USER_PREFIX)
- : HAS_PREFIX(name, SYSTEM_PREFIX))
+ /* Choose between ignoring the system namespace or (non-root) ignoring any non-user namespace. */
+ else if (user_only ? !HAS_PREFIX(name, USER_PREFIX) : HAS_PREFIX(name, SYSTEM_PREFIX))
continue;
#endif
- if (am_root < 0 && name_len > RPRE_LEN
- && name[RPRE_LEN] == '%' && strcmp(name, XSTAT_ATTR) == 0)
+ if (am_root < 0 && name_len > RPRE_LEN && name[RPRE_LEN] == '%' && strcmp(name, XSTAT_ATTR) == 0)
continue;
for (i = 0; i < xalp->count; i++) {
if (i == xalp->count) {
if (sys_lremovexattr(fname, name) < 0) {
rsyserr(FERROR_XFER, errno,
- "rsync_xal_clear: lremovexattr(\"%s\",\"%s\") failed",
- fname, name);
+ "rsync_xal_set: lremovexattr(%s,\"%s\") failed",
+ full_fname(fname), name);
ret = -1;
} else /* make sure caller sets mtime */
sxp->st.st_mtime = (time_t)-1;
int set_xattr(const char *fname, const struct file_struct *file,
const char *fnamecmp, stat_x *sxp)
{
+ rsync_xa_list *glst = rsync_xal_l.items;
+ item_list *lst;
int ndx;
- item_list *lst = rsync_xal_l.items;
if (dry_run)
return 1; /* FIXME: --dry-run needs to compute this value */
#endif
ndx = F_XATTR(file);
- return rsync_xal_set(fname, lst + ndx, fnamecmp, sxp);
+ glst += ndx;
+ lst = &glst->xa_items;
+ return rsync_xal_set(fname, lst, fnamecmp, sxp);
}
#ifdef SUPPORT_ACLS
const char *name = is_access_acl ? XACC_ACL_ATTR : XDEF_ACL_ATTR;
if (sys_lsetxattr(fname, name, buf, buf_len) < 0) {
rsyserr(FERROR_XFER, errno,
- "set_xattr_acl: lsetxattr(\"%s\",\"%s\") failed",
- fname, name);
+ "set_xattr_acl: lsetxattr(%s,\"%s\") failed",
+ full_fname(fname), name);
return -1;
}
return 0;