* Written by Jay Fenlason, vaguely based on the ACLs patch.
*
* Copyright (C) 2004 Red Hat, Inc.
- * Copyright (C) 2006-2015 Wayne Davison
+ * Copyright (C) 2006-2022 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 preserve_devices;
extern int preserve_specials;
extern int checksum_seed;
+extern int saw_xattr_filter;
+
+extern struct name_num_item *xattr_sum_nni;
+extern int xattr_sum_len;
#define RSYNC_XAL_INITIAL 5
#define RSYNC_XAL_LIST_INITIAL 100
+#define MAX_XATTR_DIGEST_LEN MD5_DIGEST_LEN
#define MAX_FULL_DATUM 32
-#define HAS_PREFIX(str, prfx) (*(str) == *(prfx) \
- && strncmp(str, prfx, sizeof (prfx) - 1) == 0)
+#define HAS_PREFIX(str, prfx) (*(str) == *(prfx) && strncmp(str, prfx, sizeof (prfx) - 1) == 0)
#define XATTR_ABBREV(x) ((size_t)((x).name - (x).datum) < (x).datum_len)
#define SPRE_LEN ((int)sizeof SYSTEM_PREFIX - 1)
#ifdef HAVE_LINUX_XATTRS
-#define MIGHT_NEED_RPRE (am_root < 0)
+#define MIGHT_NEED_RPRE (am_root <= 0)
#define RSYNC_PREFIX USER_PREFIX "rsync."
#else
#define MIGHT_NEED_RPRE am_root
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 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;
if (!namebuf) {
namebuf_len = 1024;
namebuf = new_array(char, namebuf_len);
- if (!namebuf)
- out_of_memory("get_xattr_names");
}
while (1) {
arg = namebuf_len;
got_error:
rsyserr(FERROR_XFER, errno,
- "get_xattr_names: llistxattr(\"%s\",%s) failed",
+ "get_xattr_names: llistxattr(%s,%s) failed",
full_fname(fname), big_num(arg));
return -1;
}
free(namebuf);
namebuf_len = list_len + 1024;
namebuf = new_array(char, namebuf_len);
- if (!namebuf)
- out_of_memory("get_xattr_names");
}
return list_len;
/* On entry, the *len_ptr parameter contains the size of the extra space we
* should allocate when we create a buffer for the data. On exit, it contains
* the length of the datum. */
-static char *get_xattr_data(const char *fname, const char *name, size_t *len_ptr,
- int no_missing_error)
+static char *get_xattr_data(const char *fname, const char *name, size_t *len_ptr, int no_missing_error)
{
size_t datum_len = sys_lgetxattr(fname, name, NULL, 0);
size_t extra_len = *len_ptr;
if (errno == ENOTSUP || no_missing_error)
return NULL;
rsyserr(FERROR_XFER, errno,
- "get_xattr_data: lgetxattr(\"%s\",\"%s\",0) failed",
+ "get_xattr_data: lgetxattr(%s,\"%s\",0) failed",
full_fname(fname), name);
return NULL;
}
if (!datum_len && !extra_len)
extra_len = 1; /* request non-zero amount of memory */
- if (datum_len + extra_len < datum_len)
+ if (SIZE_MAX - datum_len < extra_len)
overflow_exit("get_xattr_data");
- if (!(ptr = new_array(char, datum_len + extra_len)))
- out_of_memory("get_xattr_data");
+ ptr = new_array(char, datum_len + extra_len);
if (datum_len) {
size_t len = sys_lgetxattr(fname, name, ptr, datum_len);
if (len != datum_len) {
if (len == (size_t)-1) {
rsyserr(FERROR_XFER, errno,
- "get_xattr_data: lgetxattr(\"%s\",\"%s\",%ld)"
- " failed", full_fname(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", full_fname(fname), name,
- (long)datum_len, (long)len);
+ "get_xattr_data: lgetxattr(%s,\"%s\",%ld) returned %ld\n",
+ full_fname(fname), name,
+ (long)datum_len, (long)len);
}
free(ptr);
return NULL;
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(-1, checksum_seed);
+ name_offset = 1 + MAX_XATTR_DIGEST_LEN;
+ sum_init(xattr_sum_nni, checksum_seed);
sum_update(ptr, datum_len);
free(ptr);
- if (!(ptr = new_array(char, name_offset + name_len)))
- out_of_memory("rsync_xal_get");
+ ptr = new_array(char, name_offset + name_len);
*ptr = XSTATE_ABBREV;
sum_end(ptr + 1);
} else
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,
- "copy_xattrs: lsetxattr(\"%s\",\"%s\") failed",
+ "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)
+{
+ const rsync_xa *rxas = xalp->items;
+ size_t i;
+ int64 key = hashlittle2(&xalp->count, sizeof xalp->count);
+
+ for (i = 0; i < xalp->count; i++) {
+ key += hashlittle2(rxas[i].name, rxas[i].name_len);
+ if (rxas[i].datum_len > MAX_FULL_DATUM)
+ key += hashlittle2(rxas[i].datum, xattr_sum_len);
+ else
+ key += hashlittle2(rxas[i].datum, rxas[i].datum_len);
+ }
+
+ return key;
+}
+
+static int find_matching_xattr(const item_list *xalp)
{
- size_t i, j;
- item_list *lst = rsync_xal_l.items;
+ const struct ht_int64_node *node;
+ const rsync_xa_list_ref *ref;
+ int64 key;
- for (i = 0; i < rsync_xal_l.count; i++) {
- rsync_xa *rxas1 = lst[i].items;
- rsync_xa *rxas2 = xalp->items;
+ if (rsync_xal_h == NULL)
+ return -1;
+
+ key = xattr_lookup_hash(xalp);
+
+ node = hashtable_find(rsync_xal_h, key, NULL);
+ 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++) {
if (rxas1[j].datum_len > MAX_FULL_DATUM) {
if (memcmp(rxas1[j].datum + 1,
rxas2[j].datum + 1,
- MAX_DIGEST_LEN) != 0)
+ xattr_sum_len) != 0)
break;
} else {
if (memcmp(rxas1[j].datum, rxas2[j].datum,
}
/* 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, HT_KEY64);
+
+ new_ref = new0(rsync_xa_list_ref);
+ new_ref->ndx = ndx;
+
+ node = hashtable_find(rsync_xal_h, new_list->key, new_ref);
+ if (node->data != (void*)new_ref) {
+ rsync_xa_list_ref *ref = node->data;
+
+ while (ref != NULL) {
+ if (ref->next != NULL) {
+ ref = ref->next;
+ continue;
+ }
+
+ ref->next = new_ref;
+ break;
+ }
+ }
+
+ return ndx;
}
/* Send the make_xattr()-generated xattr list for this flist entry. */
#endif
write_buf(f, name, name_len);
if (rxa->datum_len > MAX_FULL_DATUM)
- write_buf(f, rxa->datum + 1, MAX_DIGEST_LEN);
+ write_buf(f, rxa->datum + 1, xattr_sum_len);
else
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)
{
- const 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;
else if (snd_rxa->datum_len > MAX_FULL_DATUM) {
same = cmp == 0 && snd_rxa->datum_len == rec_rxa->datum_len
&& memcmp(snd_rxa->datum + 1, rec_rxa->datum + 1,
- MAX_DIGEST_LEN) == 0;
+ xattr_sum_len) == 0;
/* Flag unrequested items that we need. */
if (!same && find_all && snd_rxa->datum[0] == XSTATE_ABBREV)
snd_rxa->datum[0] = XSTATE_TODO;
* 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;
* 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;
rprintf(FERROR, "recv_xattr_request: internal data error!\n");
exit_cleanup(RERR_PROTOCOL);
}
- lst += F_XATTR(file);
+ glst += F_XATTR(file);
+ lst = &glst->xa_items;
cnt = lst->count;
rxa = lst->items;
num += rel_pos;
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. */
+ * We use that order here to scan forward or backward as needed. */
if (rel_pos < 0) {
while (cnt < (int)lst->count && rxa->num > num) {
rxa--;
old_datum = rxa->datum;
rxa->datum_len = read_varint(f_in);
- if (rxa->name_len + rxa->datum_len < rxa->name_len)
+ if (SIZE_MAX - rxa->name_len < rxa->datum_len)
overflow_exit("recv_xattr_request");
rxa->datum = new_array(char, rxa->datum_len + rxa->name_len);
- if (!rxa->datum)
- out_of_memory("recv_xattr_request");
name = rxa->datum + rxa->datum_len;
memcpy(name, rxa->name, rxa->name_len);
rxa->name = name;
rsync_xa *rxa;
size_t name_len = read_varint(f);
size_t datum_len = read_varint(f);
- size_t dget_len = datum_len > MAX_FULL_DATUM ? 1 + MAX_DIGEST_LEN : datum_len;
+ size_t dget_len = datum_len > MAX_FULL_DATUM ? 1 + (size_t)xattr_sum_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))
+ if (SIZE_MAX - dget_len < extra_len || SIZE_MAX - dget_len - extra_len < name_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);
+ read_buf(f, ptr + 1, xattr_sum_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);
+ 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, NULL);
+ 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 (1) {
+ rsync_xa_list_ref *next = ref->next;
+ if (next == NULL)
+ break;
+ if (xa_list_item->ndx == next->ndx) {
+ ref->next = next->next;
+ free(next);
+ break;
+ }
+ ref = next;
+ }
+ }
prior_xattr_count = (size_t)-1;
}
}
rsync_xa *rxas = xalp->items;
ssize_t list_len;
size_t i, len;
- char *name, *ptr, sum[MAX_DIGEST_LEN];
+ char *name, *ptr, sum[MAX_XATTR_DIGEST_LEN];
#ifdef HAVE_LINUX_XATTRS
int user_only = am_root <= 0;
#endif
goto still_abbrev;
}
- sum_init(-1, checksum_seed);
+ sum_init(xattr_sum_nni, checksum_seed);
sum_update(ptr, len);
sum_end(sum);
- if (memcmp(sum, rxas[i].datum + 1, MAX_DIGEST_LEN) != 0) {
+ if (memcmp(sum, rxas[i].datum + 1, xattr_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",
+ "rsync_xal_set: lsetxattr(%s,\"%s\") failed",
full_fname(fname), name);
ret = -1;
} else /* make sure caller sets mtime */
if (sys_lsetxattr(fname, name, rxas[i].datum, rxas[i].datum_len) < 0) {
rsyserr(FERROR_XFER, errno,
- "rsync_xal_set: lsetxattr(\"%s\",\"%s\") failed",
+ "rsync_xal_set: lsetxattr(%s,\"%s\") failed",
full_fname(fname), name);
ret = -1;
} else /* make sure caller sets mtime */
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_set: lremovexattr(\"%s\",\"%s\") failed",
+ "rsync_xal_set: lremovexattr(%s,\"%s\") failed",
full_fname(fname), name);
ret = -1;
} else /* make sure caller sets mtime */
}
/* Set extended attributes on indicated filename. */
-int set_xattr(const char *fname, const struct file_struct *file,
- const char *fnamecmp, stat_x *sxp)
+int set_xattr(const char *fname, const struct file_struct *file, const char *fnamecmp, stat_x *sxp)
{
- int ndx;
- item_list *lst = rsync_xal_l.items;
+ rsync_xa_list *glst = rsync_xal_l.items;
+ item_list *lst;
+ int ndx, added_write_perm = 0;
if (dry_run)
return 1; /* FIXME: --dry-run needs to compute this value */
}
#endif
+ /* If the target file lacks write permission, we try to add it
+ * temporarily so we can change the extended attributes. */
+ if (!am_root
+#ifdef SUPPORT_LINKS
+ && !S_ISLNK(sxp->st.st_mode)
+#endif
+ && access(fname, W_OK) < 0
+ && do_chmod(fname, (sxp->st.st_mode & CHMOD_BITS) | S_IWUSR) == 0)
+ added_write_perm = 1;
+
ndx = F_XATTR(file);
- return rsync_xal_set(fname, lst + ndx, fnamecmp, sxp);
+ glst += ndx;
+ lst = &glst->xa_items;
+ int return_value = rsync_xal_set(fname, lst, fnamecmp, sxp);
+ if (added_write_perm) /* remove the temporary write permission */
+ do_chmod(fname, sxp->st.st_mode);
+ return return_value;
}
#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",
+ "set_xattr_acl: lsetxattr(%s,\"%s\") failed",
full_fname(fname), name);
return -1;
}
int get_stat_xattr(const char *fname, int fd, STRUCT_STAT *fst, STRUCT_STAT *xst)
{
- int mode, rdev_major, rdev_minor, uid, gid, len;
+ unsigned int mode;
+ int rdev_major, rdev_minor, uid, gid, len;
char buf[256];
if (am_root >= 0 || IS_DEVICE(fst->st_mode) || IS_SPECIAL(fst->st_mode))