*/
#include "rsync.h"
+#include "ifuncs.h"
#include "lib/sysxattrs.h"
#ifdef SUPPORT_XATTRS
#define XSTATE_ABBREV 0
#define XSTATE_DONE 1
#define XSTATE_TODO 2
-#define XSTATE_LOCAL 3
#define USER_PREFIX "user."
#define UPRE_LEN ((int)sizeof USER_PREFIX - 1)
#define RPRE_LEN ((int)sizeof RSYNC_PREFIX - 1)
#define XSTAT_ATTR RSYNC_PREFIX "%stat"
+#define XACC_ACL_ATTR RSYNC_PREFIX "%aacl"
+#define XDEF_ACL_ATTR RSYNC_PREFIX "%dacl"
typedef struct {
char *datum, *name;
size_t datum_len, name_len;
+ int num;
} rsync_xa;
static size_t namebuf_len = 0;
xalp->count = 0;
}
-void free_xattr(statx *sxp)
+void free_xattr(stat_x *sxp)
{
if (!sxp->xattr)
return;
static ssize_t get_xattr_names(const char *fname)
{
ssize_t list_len;
+ double arg;
if (!namebuf) {
namebuf_len = 1024;
out_of_memory("get_xattr_names");
}
- /* The length returned includes all the '\0' terminators. */
- list_len = sys_llistxattr(fname, namebuf, namebuf_len);
- if (list_len > (ssize_t)namebuf_len) {
- list_len = -1;
- errno = ERANGE;
- }
- if (list_len >= 0)
- return list_len;
- if (errno == ENOTSUP)
- return 0;
- if (errno == ERANGE) {
+ while (1) {
+ /* The length returned includes all the '\0' terminators. */
+ list_len = sys_llistxattr(fname, namebuf, namebuf_len);
+ if (list_len >= 0) {
+ if ((size_t)list_len <= namebuf_len)
+ break;
+ } else if (errno == ENOTSUP)
+ return 0;
+ else if (errno != ERANGE) {
+ arg = (double)namebuf_len;
+ got_error:
+ rsyserr(FERROR_XFER, errno,
+ "get_xattr_names: llistxattr(\"%s\",%.0f) failed",
+ fname, arg);
+ return -1;
+ }
list_len = sys_llistxattr(fname, NULL, 0);
if (list_len < 0) {
- rsyserr(FERROR, errno,
- "get_xattr_names: llistxattr(\"%s\",0) failed",
- fname);
- return -1;
+ arg = 0;
+ goto got_error;
}
if (namebuf_len)
free(namebuf);
namebuf = new_array(char, namebuf_len);
if (!namebuf)
out_of_memory("get_xattr_names");
- list_len = sys_llistxattr(fname, namebuf, namebuf_len);
- if (list_len >= 0)
- return list_len;
}
- rsyserr(FERROR, errno,
- "get_xattr_names: llistxattr(\"%s\",%ld) failed",
- fname, (long)namebuf_len);
- return -1;
+ return list_len;
}
/* On entry, the *len_ptr parameter contains the size of the extra space we
int no_missing_error)
{
size_t datum_len = sys_lgetxattr(fname, name, NULL, 0);
+ size_t extra_len = *len_ptr;
char *ptr;
+ *len_ptr = datum_len;
+
if (datum_len == (size_t)-1) {
if (errno == ENOTSUP || no_missing_error)
return NULL;
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"get_xattr_data: lgetxattr(\"%s\",\"%s\",0) failed",
fname, name);
return NULL;
}
- if (datum_len + *len_ptr < datum_len /* checks for overflow */
- || !(ptr = new_array(char, datum_len + *len_ptr)))
+ if (!datum_len && !extra_len)
+ extra_len = 1; /* request non-zero amount of memory */
+ if (datum_len + extra_len < datum_len /* checks for overflow */
+ || !(ptr = new_array(char, datum_len + extra_len)))
out_of_memory("get_xattr_data");
- *len_ptr = datum_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, errno,
+ rsyserr(FERROR_XFER, errno,
"get_xattr_data: lgetxattr(\"%s\",\"%s\",%ld)"
" failed", fname, name, (long)datum_len);
} else {
- rprintf(FERROR,
+ rprintf(FERROR_XFER,
"get_xattr_data: lgetxattr(\"%s\",\"%s\",%ld)"
" returned %ld\n", fname, name,
(long)datum_len, (long)len);
#ifdef HAVE_LINUX_XATTRS
int user_only = am_sender ? 0 : !am_root;
#endif
+ rsync_xa *rxa;
+ int count;
/* This puts the name list into the "namebuf" buffer. */
if ((list_len = get_xattr_names(fname)) < 0)
return -1;
for (name = namebuf; list_len > 0; name += name_len) {
- rsync_xa *rxas;
-
name_len = strlen(name) + 1;
list_len -= name_len;
#endif
/* No rsync.%FOO attributes are copied w/o 2 -X options. */
- if (preserve_xattrs < 2 && name_len > RPRE_LEN
- && name[RPRE_LEN] == '%' && HAS_PREFIX(name, RSYNC_PREFIX))
- continue;
+ if (name_len > RPRE_LEN && name[RPRE_LEN] == '%'
+ && HAS_PREFIX(name, RSYNC_PREFIX)) {
+ if ((am_sender && preserve_xattrs < 2)
+ || (am_root < 0 && strcmp(name, XSTAT_ATTR) == 0))
+ continue;
+ }
datum_len = name_len; /* Pass extra size to get_xattr_data() */
if (!(ptr = get_xattr_data(fname, name, &datum_len, 0)))
name_offset = datum_len;
#ifdef HAVE_LINUX_XATTRS
- if (am_root < 0 && name_len > RPRE_LEN
+ if (am_root < 0 && name_len > RPRE_LEN && name[RPRE_LEN] != '%'
&& HAS_PREFIX(name, RSYNC_PREFIX)) {
name += RPRE_LEN;
name_len -= RPRE_LEN;
}
#endif
- rxas = EXPAND_ITEM_LIST(xalp, rsync_xa, RSYNC_XAL_INITIAL);
- rxas->name = ptr + name_offset;
- memcpy(rxas->name, name, name_len);
- rxas->datum = ptr;
- rxas->name_len = name_len;
- rxas->datum_len = datum_len;
+ rxa = EXPAND_ITEM_LIST(xalp, rsync_xa, RSYNC_XAL_INITIAL);
+ rxa->name = ptr + name_offset;
+ memcpy(rxa->name, name, name_len);
+ rxa->datum = ptr;
+ rxa->name_len = name_len;
+ rxa->datum_len = datum_len;
}
- if (xalp->count > 1)
- qsort(xalp->items, xalp->count, sizeof (rsync_xa), rsync_xal_compare_names);
+ count = xalp->count;
+ rxa = xalp->items;
+ if (count > 1)
+ qsort(rxa, count, sizeof (rsync_xa), rsync_xal_compare_names);
+ for (rxa += count-1; count; count--, rxa--)
+ rxa->num = count;
return 0;
}
/* Read the xattr(s) for this filename. */
-int get_xattr(const char *fname, statx *sxp)
+int get_xattr(const char *fname, stat_x *sxp)
{
sxp->xattr = new(item_list);
*sxp->xattr = empty_xattr;
}
/* Send the make_xattr()-generated xattr list for this flist entry. */
-int send_xattr(statx *sxp, int f)
+int send_xattr(stat_x *sxp, int f)
{
int ndx = find_matching_xattr(sxp->xattr);
/* Return a flag indicating if we need to change a file's xattrs. If
* "find_all" is specified, also mark any abbreviated xattrs that we
* need so that send_xattr_request() can tell the sender about them. */
-int xattr_diff(struct file_struct *file, statx *sxp, int find_all)
+int xattr_diff(struct file_struct *file, stat_x *sxp, int find_all)
{
item_list *lst = rsync_xal_l.items;
rsync_xa *snd_rxa, *rec_rxa;
void send_xattr_request(const char *fname, struct file_struct *file, int f_out)
{
item_list *lst = rsync_xal_l.items;
- int j, cnt, prior_req = -1;
+ int cnt, prior_req = 0;
rsync_xa *rxa;
lst += F_XATTR(file);
- cnt = lst->count;
- for (rxa = lst->items, j = 0; j < cnt; rxa++, j++) {
+ for (rxa = lst->items, cnt = lst->count; cnt--; rxa++) {
if (rxa->datum_len <= MAX_FULL_DATUM)
continue;
switch (rxa->datum[0]) {
- case XSTATE_LOCAL:
- /* Items set locally will get cached by receiver. */
- rxa->datum[0] = XSTATE_DONE;
+ case XSTATE_ABBREV:
+ /* Items left abbreviated matched the sender's checksum, so
+ * the receiver will cache the local data for future use. */
+ if (am_generator)
+ rxa->datum[0] = XSTATE_DONE;
continue;
case XSTATE_TODO:
break;
/* Flag that we handled this abbreviated item. */
rxa->datum[0] = XSTATE_DONE;
- write_varint(f_out, j - prior_req);
- prior_req = j;
+ write_varint(f_out, rxa->num - prior_req);
+ prior_req = rxa->num;
if (fname) {
size_t len = 0;
char *ptr;
/* Re-read the long datum. */
- if (!(ptr = get_xattr_data(fname, rxa->name, &len, 0)))
+ if (!(ptr = get_xattr_data(fname, rxa->name, &len, 0))) {
+ rprintf(FERROR_XFER, "failed to re-read xattr %s for %s\n", rxa->name, fname);
+ write_varint(f_out, 0);
continue;
+ }
write_varint(f_out, len); /* length might have changed! */
write_buf(f_out, ptr, len);
write_byte(f_out, 0); /* end the list */
}
-/* Any items set locally by the generator that the receiver doesn't
- * get told about get changed back to XSTATE_ABBREV. */
-void xattr_clear_locals(struct file_struct *file)
-{
- item_list *lst = rsync_xal_l.items;
- rsync_xa *rxa;
- int cnt;
-
- if (F_XATTR(file) < 0)
- return;
-
- lst += F_XATTR(file);
- cnt = lst->count;
- for (rxa = lst->items; cnt--; rxa++) {
- if (rxa->datum_len <= MAX_FULL_DATUM)
- continue;
- if (rxa->datum[0] == XSTATE_LOCAL)
- rxa->datum[0] = XSTATE_ABBREV;
- }
-}
-
/* When called by the sender, read the request from the generator and mark
* any needed xattrs with a flag that lets us know they need to be sent to
* the receiver. When called by the receiver, reads the sent data and
* stores it in place of its checksum. */
-void recv_xattr_request(struct file_struct *file, int f_in)
+int recv_xattr_request(struct file_struct *file, int f_in)
{
item_list *lst = rsync_xal_l.items;
char *old_datum, *name;
rsync_xa *rxa;
- int rel_pos, cnt;
+ int rel_pos, cnt, num, got_xattr_data = 0;
if (F_XATTR(file) < 0) {
rprintf(FERROR, "recv_xattr_request: internal data error!\n");
cnt = lst->count;
rxa = lst->items;
- rxa -= 1;
+ num = 0;
while ((rel_pos = read_varint(f_in)) != 0) {
- rxa += rel_pos;
- cnt -= rel_pos;
- if (cnt < 0 || rxa->datum_len <= MAX_FULL_DATUM
- || rxa->datum[0] != XSTATE_ABBREV) {
- rprintf(FERROR, "recv_xattr_request: internal abbrev error!\n");
+ num += rel_pos;
+ while (cnt && rxa->num < num) {
+ rxa++;
+ cnt--;
+ }
+ 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);
+ }
+ if (rxa->datum_len <= MAX_FULL_DATUM || rxa->datum[0] != XSTATE_ABBREV) {
+ rprintf(FERROR, "[%s] internal abbrev error!\n", who_am_i());
exit_cleanup(RERR_STREAMIO);
}
rxa->name = name;
free(old_datum);
read_buf(f_in, rxa->datum, rxa->datum_len);
+ got_xattr_data = 1;
}
+
+ return got_xattr_data;
}
/* ------------------------------------------------------------------------- */
void receive_xattr(struct file_struct *file, int f)
{
static item_list temp_xattr = EMPTY_ITEM_LIST;
- int count;
+ int count, num;
int ndx = read_varint(f);
if (ndx < 0 || (size_t)ndx > rsync_xal_l.count) {
temp_xattr.count = 0;
}
- while (count--) {
+ for (num = 1; num <= count; num++) {
char *ptr, *name;
rsync_xa *rxa;
size_t name_len = read_varint(f);
}
#ifdef HAVE_LINUX_XATTRS
/* Non-root can only save the user namespace. */
- if (am_root <= 0 && !HAS_PREFIX(name, USER_PREFIX)) {
- if (!am_root) {
- free(ptr);
- continue;
- }
- name -= RPRE_LEN;
- name_len += RPRE_LEN;
- memcpy(name, RSYNC_PREFIX, RPRE_LEN);
+ if (am_root <= 0 && !HAS_PREFIX(name, USER_PREFIX)) {
+ if (!am_root) {
+ free(ptr);
+ continue;
+ }
+ name -= RPRE_LEN;
+ name_len += RPRE_LEN;
+ memcpy(name, RSYNC_PREFIX, RPRE_LEN);
}
#else
/* This OS only has a user namespace, so we either
rxa->datum = ptr;
rxa->name_len = name_len;
rxa->datum_len = datum_len;
+ rxa->num = num;
}
ndx = rsync_xal_l.count; /* pre-incremented count */
F_XATTR(file) = ndx;
}
-/* Turn the xattr data in statx into cached xattr data, setting the index
+/* Turn the xattr data in stat_x into cached xattr data, setting the index
* values in the file struct. */
-void cache_xattr(struct file_struct *file, statx *sxp)
+void cache_xattr(struct file_struct *file, stat_x *sxp)
{
int ndx;
}
static int rsync_xal_set(const char *fname, item_list *xalp,
- const char *fnamecmp, statx *sxp)
+ const char *fnamecmp, stat_x *sxp)
{
rsync_xa *rxas = xalp->items;
ssize_t list_len;
if (fname == fnamecmp)
; /* Value is already set when identical */
else if (sys_lsetxattr(fname, name, ptr, len) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"rsync_xal_set: lsetxattr(\"%s\",\"%s\") failed",
fname, name);
ret = -1;
sxp->st.st_mtime = (time_t)-1;
if (am_generator) { /* generator items stay abbreviated */
- if (rxas[i].datum[0] == XSTATE_ABBREV)
- rxas[i].datum[0] = XSTATE_LOCAL;
free(ptr);
continue;
}
}
if (sys_lsetxattr(fname, name, rxas[i].datum, rxas[i].datum_len) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"rsync_xal_set: lsetxattr(\"%s\",\"%s\") failed",
fname, name);
ret = -1;
: !HAS_PREFIX(name, USER_PREFIX))
continue;
#endif
+ 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 (strcmp(name, rxas[i].name) == 0)
}
if (i == xalp->count) {
if (sys_lremovexattr(fname, name) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"rsync_xal_clear: lremovexattr(\"%s\",\"%s\") failed",
fname, name);
ret = -1;
/* Set extended attributes on indicated filename. */
int set_xattr(const char *fname, const struct file_struct *file,
- const char *fnamecmp, statx *sxp)
+ const char *fnamecmp, stat_x *sxp)
{
int ndx;
item_list *lst = rsync_xal_l.items;
return rsync_xal_set(fname, lst + ndx, fnamecmp, sxp);
}
+#ifdef SUPPORT_ACLS
+char *get_xattr_acl(const char *fname, int is_access_acl, size_t *len_p)
+{
+ const char *name = is_access_acl ? XACC_ACL_ATTR : XDEF_ACL_ATTR;
+ *len_p = 0; /* no extra data alloc needed from get_xattr_data() */
+ return get_xattr_data(fname, name, len_p, 1);
+}
+
+int set_xattr_acl(const char *fname, int is_access_acl, const char *buf, size_t buf_len)
+{
+ 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);
+ return -1;
+ }
+ return 0;
+}
+
+int del_def_xattr_acl(const char *fname)
+{
+ return sys_lremovexattr(fname, XDEF_ACL_ATTR);
+}
+#endif
+
int get_stat_xattr(const char *fname, int fd, STRUCT_STAT *fst, STRUCT_STAT *xst)
{
int mode, rdev_major, rdev_minor, uid, gid, len;
xst->st_gid = 0;
return 0;
}
- rsyserr(FERROR, errno, "failed to read xattr %s for %s",
+ rsyserr(FERROR_XFER, errno, "failed to read xattr %s for %s",
XSTAT_ATTR, full_fname(fname));
return -1;
}
return 0;
}
-int set_stat_xattr(const char *fname, struct file_struct *file)
+int set_stat_xattr(const char *fname, struct file_struct *file, mode_t new_mode)
{
STRUCT_STAT fst, xst;
dev_t rdev;
return 0;
if (read_only || list_only) {
- rsyserr(FERROR, EROFS, "failed to write xattr %s for %s",
+ rsyserr(FERROR_XFER, EROFS, "failed to write xattr %s for %s",
XSTAT_ATTR, full_fname(fname));
return -1;
}
if (x_lstat(fname, &fst, &xst) < 0) {
- rsyserr(FERROR, errno, "failed to re-stat %s",
+ rsyserr(FERROR_XFER, errno, "failed to re-stat %s",
full_fname(fname));
return -1;
}
fst.st_mode &= (_S_IFMT | CHMOD_BITS);
- fmode = file->mode & (_S_IFMT | CHMOD_BITS);
+ fmode = new_mode & (_S_IFMT | CHMOD_BITS);
if (IS_DEVICE(fmode) || IS_SPECIAL(fmode)) {
uint32 *devp = F_RDEV_P(file);
&& fst.st_uid == F_OWNER(file) && fst.st_gid == F_GROUP(file)) {
/* xst.st_mode will be 0 if there's no current stat xattr */
if (xst.st_mode && sys_lremovexattr(fname, XSTAT_ATTR) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"delete of stat xattr failed for %s",
full_fname(fname));
return -1;
if (sys_lsetxattr(fname, XSTAT_ATTR, buf, len) < 0) {
if (errno == EPERM && S_ISLNK(fst.st_mode))
return 0;
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"failed to write xattr %s for %s",
XSTAT_ATTR, full_fname(fname));
return -1;
Matt McCutchen's Web Site / rsync / rsync.git / blobdiff