2 * Extended Attribute support for rsync.
3 * Written by Jay Fenlason, vaguely based on the ACLs patch.
5 * Copyright (C) 2004 Red Hat, Inc.
6 * Copyright (C) 2006-2015 Wayne Davison
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, visit the http://fsf.org website.
25 #include "lib/sysxattrs.h"
32 extern int am_generator
;
35 extern int preserve_xattrs
;
36 extern int preserve_links
;
37 extern int preserve_devices
;
38 extern int preserve_specials
;
39 extern int checksum_seed
;
41 #define RSYNC_XAL_INITIAL 5
42 #define RSYNC_XAL_LIST_INITIAL 100
44 #define MAX_FULL_DATUM 32
46 #define HAS_PREFIX(str, prfx) (*(str) == *(prfx) \
47 && strncmp(str, prfx, sizeof (prfx) - 1) == 0)
49 #define XATTR_ABBREV(x) ((size_t)((x).name - (x).datum) < (x).datum_len)
51 #define XSTATE_ABBREV 1
55 #define USER_PREFIX "user."
56 #define UPRE_LEN ((int)sizeof USER_PREFIX - 1)
57 #define SYSTEM_PREFIX "system."
58 #define SPRE_LEN ((int)sizeof SYSTEM_PREFIX - 1)
60 #ifdef HAVE_LINUX_XATTRS
61 #define MIGHT_NEED_RPRE (am_root < 0)
62 #define RSYNC_PREFIX USER_PREFIX "rsync."
64 #define MIGHT_NEED_RPRE am_root
65 #define RSYNC_PREFIX "rsync."
67 #define RPRE_LEN ((int)sizeof RSYNC_PREFIX - 1)
69 #define XSTAT_SUFFIX "stat"
70 #define XSTAT_ATTR RSYNC_PREFIX "%" XSTAT_SUFFIX
71 #define XACC_ACL_SUFFIX "aacl"
72 #define XACC_ACL_ATTR RSYNC_PREFIX "%" XACC_ACL_SUFFIX
73 #define XDEF_ACL_SUFFIX "dacl"
74 #define XDEF_ACL_ATTR RSYNC_PREFIX "%" XDEF_ACL_SUFFIX
78 size_t datum_len
, name_len
;
82 struct _rsync_xa_list
;
84 typedef struct _rsync_xa_list_ref
{
85 struct _rsync_xa_list_ref
*next
;
89 typedef struct _rsync_xa_list
{
95 static size_t namebuf_len
= 0;
96 static char *namebuf
= NULL
;
98 static const rsync_xa_list empty_xa_list
= {
99 .xa_items
= EMPTY_ITEM_LIST
,
101 static const item_list empty_xattr
= EMPTY_ITEM_LIST
;
102 static item_list rsync_xal_l
= EMPTY_ITEM_LIST
;
103 static struct hashtable
*rsync_xal_h
= NULL
;
105 static size_t prior_xattr_count
= (size_t)-1;
107 /* ------------------------------------------------------------------------- */
109 static void rsync_xal_free(item_list
*xalp
)
112 rsync_xa
*rxas
= xalp
->items
;
117 for (i
= 0; i
< xalp
->count
; i
++) {
119 /*free(rxas[i].name);*/
124 void free_xattr(stat_x
*sxp
)
128 rsync_xal_free(sxp
->xattr
);
133 static int rsync_xal_compare_names(const void *x1
, const void *x2
)
135 const rsync_xa
*xa1
= x1
;
136 const rsync_xa
*xa2
= x2
;
137 return strcmp(xa1
->name
, xa2
->name
);
140 static ssize_t
get_xattr_names(const char *fname
)
147 namebuf
= new_array(char, namebuf_len
);
149 out_of_memory("get_xattr_names");
153 /* The length returned includes all the '\0' terminators. */
154 list_len
= sys_llistxattr(fname
, namebuf
, namebuf_len
);
156 if ((size_t)list_len
<= namebuf_len
)
158 } else if (errno
== ENOTSUP
)
160 else if (errno
!= ERANGE
) {
163 rsyserr(FERROR_XFER
, errno
,
164 "get_xattr_names: llistxattr(%s,%s) failed",
165 full_fname(fname
), big_num(arg
));
168 list_len
= sys_llistxattr(fname
, NULL
, 0);
175 namebuf_len
= list_len
+ 1024;
176 namebuf
= new_array(char, namebuf_len
);
178 out_of_memory("get_xattr_names");
184 /* On entry, the *len_ptr parameter contains the size of the extra space we
185 * should allocate when we create a buffer for the data. On exit, it contains
186 * the length of the datum. */
187 static char *get_xattr_data(const char *fname
, const char *name
, size_t *len_ptr
,
188 int no_missing_error
)
190 size_t datum_len
= sys_lgetxattr(fname
, name
, NULL
, 0);
191 size_t extra_len
= *len_ptr
;
194 *len_ptr
= datum_len
;
196 if (datum_len
== (size_t)-1) {
197 if (errno
== ENOTSUP
|| no_missing_error
)
199 rsyserr(FERROR_XFER
, errno
,
200 "get_xattr_data: lgetxattr(%s,\"%s\",0) failed",
201 full_fname(fname
), name
);
205 if (!datum_len
&& !extra_len
)
206 extra_len
= 1; /* request non-zero amount of memory */
207 if (datum_len
+ extra_len
< datum_len
)
208 overflow_exit("get_xattr_data");
209 if (!(ptr
= new_array(char, datum_len
+ extra_len
)))
210 out_of_memory("get_xattr_data");
213 size_t len
= sys_lgetxattr(fname
, name
, ptr
, datum_len
);
214 if (len
!= datum_len
) {
215 if (len
== (size_t)-1) {
216 rsyserr(FERROR_XFER
, errno
,
217 "get_xattr_data: lgetxattr(%s,\"%s\",%ld) failed",
218 full_fname(fname
), name
, (long)datum_len
);
221 "get_xattr_data: lgetxattr(%s,\"%s\",%ld) returned %ld\n",
222 full_fname(fname
), name
,
223 (long)datum_len
, (long)len
);
233 static int rsync_xal_get(const char *fname
, item_list
*xalp
)
235 ssize_t list_len
, name_len
;
236 size_t datum_len
, name_offset
;
238 #ifdef HAVE_LINUX_XATTRS
239 int user_only
= am_sender
? 0 : !am_root
;
244 /* This puts the name list into the "namebuf" buffer. */
245 if ((list_len
= get_xattr_names(fname
)) < 0)
248 for (name
= namebuf
; list_len
> 0; name
+= name_len
) {
249 name_len
= strlen(name
) + 1;
250 list_len
-= name_len
;
252 #ifdef HAVE_LINUX_XATTRS
253 /* Choose between ignoring the system namespace or (non-root) ignoring any non-user namespace. */
254 if (user_only
? !HAS_PREFIX(name
, USER_PREFIX
) : HAS_PREFIX(name
, SYSTEM_PREFIX
))
258 /* No rsync.%FOO attributes are copied w/o 2 -X options. */
259 if (name_len
> RPRE_LEN
&& name
[RPRE_LEN
] == '%' && HAS_PREFIX(name
, RSYNC_PREFIX
)) {
260 if ((am_sender
&& preserve_xattrs
< 2)
262 && (strcmp(name
+RPRE_LEN
+1, XSTAT_SUFFIX
) == 0
263 || strcmp(name
+RPRE_LEN
+1, XACC_ACL_SUFFIX
) == 0
264 || strcmp(name
+RPRE_LEN
+1, XDEF_ACL_SUFFIX
) == 0)))
268 datum_len
= name_len
; /* Pass extra size to get_xattr_data() */
269 if (!(ptr
= get_xattr_data(fname
, name
, &datum_len
, 0)))
272 if (datum_len
> MAX_FULL_DATUM
) {
273 /* For large datums, we store a flag and a checksum. */
274 name_offset
= 1 + MAX_DIGEST_LEN
;
275 sum_init(-1, checksum_seed
);
276 sum_update(ptr
, datum_len
);
279 if (!(ptr
= new_array(char, name_offset
+ name_len
)))
280 out_of_memory("rsync_xal_get");
281 *ptr
= XSTATE_ABBREV
;
284 name_offset
= datum_len
;
286 rxa
= EXPAND_ITEM_LIST(xalp
, rsync_xa
, RSYNC_XAL_INITIAL
);
287 rxa
->name
= ptr
+ name_offset
;
288 memcpy(rxa
->name
, name
, name_len
);
290 rxa
->name_len
= name_len
;
291 rxa
->datum_len
= datum_len
;
296 qsort(rxa
, count
, sizeof (rsync_xa
), rsync_xal_compare_names
);
297 for (rxa
+= count
-1; count
; count
--, rxa
--)
302 /* Read the xattr(s) for this filename. */
303 int get_xattr(const char *fname
, stat_x
*sxp
)
305 sxp
->xattr
= new(item_list
);
306 *sxp
->xattr
= empty_xattr
;
308 if (S_ISREG(sxp
->st
.st_mode
) || S_ISDIR(sxp
->st
.st_mode
)) {
309 /* Everyone supports this. */
310 } else if (S_ISLNK(sxp
->st
.st_mode
)) {
311 #ifndef NO_SYMLINK_XATTRS
315 } else if (IS_SPECIAL(sxp
->st
.st_mode
)) {
316 #ifndef NO_SPECIAL_XATTRS
317 if (!preserve_specials
)
320 } else if (IS_DEVICE(sxp
->st
.st_mode
)) {
321 #ifndef NO_DEVICE_XATTRS
322 if (!preserve_devices
)
325 } else if (IS_MISSING_FILE(sxp
->st
))
328 if (rsync_xal_get(fname
, sxp
->xattr
) < 0) {
335 int copy_xattrs(const char *source
, const char *dest
)
337 ssize_t list_len
, name_len
;
340 #ifdef HAVE_LINUX_XATTRS
341 int user_only
= am_sender
? 0 : am_root
<= 0;
344 /* This puts the name list into the "namebuf" buffer. */
345 if ((list_len
= get_xattr_names(source
)) < 0)
348 for (name
= namebuf
; list_len
> 0; name
+= name_len
) {
349 name_len
= strlen(name
) + 1;
350 list_len
-= name_len
;
352 #ifdef HAVE_LINUX_XATTRS
353 /* Choose between ignoring the system namespace or (non-root) ignoring any non-user namespace. */
354 if (user_only
? !HAS_PREFIX(name
, USER_PREFIX
) : HAS_PREFIX(name
, SYSTEM_PREFIX
))
359 if (!(ptr
= get_xattr_data(source
, name
, &datum_len
, 0)))
361 if (sys_lsetxattr(dest
, name
, ptr
, datum_len
) < 0) {
362 int save_errno
= errno
? errno
: EINVAL
;
363 rsyserr(FERROR_XFER
, errno
,
364 "copy_xattrs: lsetxattr(%s,\"%s\") failed",
365 full_fname(dest
), name
);
375 static int64
xattr_lookup_hash(const item_list
*xalp
)
377 const rsync_xa
*rxas
= xalp
->items
;
379 int64 key
= hashlittle(&xalp
->count
, sizeof xalp
->count
);
381 for (i
= 0; i
< xalp
->count
; i
++) {
382 key
+= hashlittle(rxas
[i
].name
, rxas
[i
].name_len
);
383 if (rxas
[i
].datum_len
> MAX_FULL_DATUM
)
384 key
+= hashlittle(rxas
[i
].datum
, MAX_DIGEST_LEN
);
386 key
+= hashlittle(rxas
[i
].datum
, rxas
[i
].datum_len
);
390 /* This is very unlikely, but we should never
391 * return 0 as hashtable_find() doesn't like it. */
398 static int find_matching_xattr(const item_list
*xalp
)
400 const struct ht_int64_node
*node
;
401 const rsync_xa_list_ref
*ref
;
404 if (rsync_xal_h
== NULL
)
407 key
= xattr_lookup_hash(xalp
);
409 node
= hashtable_find(rsync_xal_h
, key
, 0);
413 if (node
->data
== NULL
)
416 for (ref
= node
->data
; ref
!= NULL
; ref
= ref
->next
) {
417 const rsync_xa_list
*ptr
= rsync_xal_l
.items
;
418 const rsync_xa
*rxas1
;
419 const rsync_xa
*rxas2
= xalp
->items
;
423 rxas1
= ptr
->xa_items
.items
;
425 /* Wrong number of elements? */
426 if (ptr
->xa_items
.count
!= xalp
->count
)
428 /* any elements different? */
429 for (j
= 0; j
< xalp
->count
; j
++) {
430 if (rxas1
[j
].name_len
!= rxas2
[j
].name_len
431 || rxas1
[j
].datum_len
!= rxas2
[j
].datum_len
432 || strcmp(rxas1
[j
].name
, rxas2
[j
].name
))
434 if (rxas1
[j
].datum_len
> MAX_FULL_DATUM
) {
435 if (memcmp(rxas1
[j
].datum
+ 1,
437 MAX_DIGEST_LEN
) != 0)
440 if (memcmp(rxas1
[j
].datum
, rxas2
[j
].datum
,
445 /* no differences found. This is The One! */
446 if (j
== xalp
->count
)
453 /* Store *xalp on the end of rsync_xal_l */
454 static int rsync_xal_store(item_list
*xalp
)
456 struct ht_int64_node
*node
;
457 int ndx
= rsync_xal_l
.count
; /* pre-incremented count */
458 rsync_xa_list
*new_list
= EXPAND_ITEM_LIST(&rsync_xal_l
, rsync_xa_list
, RSYNC_XAL_LIST_INITIAL
);
459 rsync_xa_list_ref
*new_ref
;
460 /* Since the following call starts a new list, we know it will hold the
461 * entire initial-count, not just enough space for one new item. */
462 *new_list
= empty_xa_list
;
463 (void)EXPAND_ITEM_LIST(&new_list
->xa_items
, rsync_xa
, xalp
->count
);
464 memcpy(new_list
->xa_items
.items
, xalp
->items
, xalp
->count
* sizeof (rsync_xa
));
465 new_list
->xa_items
.count
= xalp
->count
;
469 new_list
->key
= xattr_lookup_hash(&new_list
->xa_items
);
471 if (rsync_xal_h
== NULL
)
472 rsync_xal_h
= hashtable_create(512, 1);
473 if (rsync_xal_h
== NULL
)
474 out_of_memory("rsync_xal_h hashtable_create()");
476 node
= hashtable_find(rsync_xal_h
, new_list
->key
, 1);
478 out_of_memory("rsync_xal_h hashtable_find()");
480 new_ref
= new0(rsync_xa_list_ref
);
482 out_of_memory("new0(rsync_xa_list_ref)");
486 if (node
->data
!= NULL
) {
487 rsync_xa_list_ref
*ref
= node
->data
;
489 while (ref
!= NULL
) {
490 if (ref
->next
!= NULL
) {
499 node
->data
= new_ref
;
504 /* Send the make_xattr()-generated xattr list for this flist entry. */
505 int send_xattr(int f
, stat_x
*sxp
)
507 int ndx
= find_matching_xattr(sxp
->xattr
);
509 /* Send 0 (-1 + 1) to indicate that literal xattr data follows. */
510 write_varint(f
, ndx
+ 1);
514 int count
= sxp
->xattr
->count
;
515 write_varint(f
, count
);
516 for (rxa
= sxp
->xattr
->items
; count
--; rxa
++) {
517 size_t name_len
= rxa
->name_len
;
518 const char *name
= rxa
->name
;
519 /* Strip the rsync prefix from disguised namespaces. */
520 if (name_len
> RPRE_LEN
521 #ifdef HAVE_LINUX_XATTRS
524 && name
[RPRE_LEN
] != '%' && HAS_PREFIX(name
, RSYNC_PREFIX
)) {
526 name_len
-= RPRE_LEN
;
528 #ifndef HAVE_LINUX_XATTRS
530 /* Put everything else in the user namespace. */
531 name_len
+= UPRE_LEN
;
534 write_varint(f
, name_len
);
535 write_varint(f
, rxa
->datum_len
);
536 #ifndef HAVE_LINUX_XATTRS
537 if (name_len
> rxa
->name_len
) {
538 write_buf(f
, USER_PREFIX
, UPRE_LEN
);
539 name_len
-= UPRE_LEN
;
542 write_buf(f
, name
, name_len
);
543 if (rxa
->datum_len
> MAX_FULL_DATUM
)
544 write_buf(f
, rxa
->datum
+ 1, MAX_DIGEST_LEN
);
546 write_bigbuf(f
, rxa
->datum
, rxa
->datum_len
);
548 ndx
= rsync_xal_store(sxp
->xattr
); /* adds item to rsync_xal_l */
554 /* Return a flag indicating if we need to change a file's xattrs. If
555 * "find_all" is specified, also mark any abbreviated xattrs that we
556 * need so that send_xattr_request() can tell the sender about them. */
557 int xattr_diff(struct file_struct
*file
, stat_x
*sxp
, int find_all
)
559 const rsync_xa_list
*glst
= rsync_xal_l
.items
;
560 const item_list
*lst
;
561 rsync_xa
*snd_rxa
, *rec_rxa
;
562 int snd_cnt
, rec_cnt
;
563 int cmp
, same
, xattrs_equal
= 1;
565 if (sxp
&& XATTR_READY(*sxp
)) {
566 rec_rxa
= sxp
->xattr
->items
;
567 rec_cnt
= sxp
->xattr
->count
;
573 if (F_XATTR(file
) >= 0) {
574 glst
+= F_XATTR(file
);
575 lst
= &glst
->xa_items
;
579 snd_rxa
= lst
->items
;
580 snd_cnt
= lst
->count
;
582 /* If the count of the sender's xattrs is different from our
583 * (receiver's) xattrs, the lists are not the same. */
584 if (snd_cnt
!= rec_cnt
) {
591 cmp
= rec_cnt
? strcmp(snd_rxa
->name
, rec_rxa
->name
) : -1;
594 else if (snd_rxa
->datum_len
> MAX_FULL_DATUM
) {
595 same
= cmp
== 0 && snd_rxa
->datum_len
== rec_rxa
->datum_len
596 && memcmp(snd_rxa
->datum
+ 1, rec_rxa
->datum
+ 1,
597 MAX_DIGEST_LEN
) == 0;
598 /* Flag unrequested items that we need. */
599 if (!same
&& find_all
&& snd_rxa
->datum
[0] == XSTATE_ABBREV
)
600 snd_rxa
->datum
[0] = XSTATE_TODO
;
602 same
= cmp
== 0 && snd_rxa
->datum_len
== rec_rxa
->datum_len
603 && memcmp(snd_rxa
->datum
, rec_rxa
->datum
,
604 snd_rxa
->datum_len
) == 0;
625 return !xattrs_equal
;
628 /* When called by the generator (with a NULL fname), this tells the sender
629 * all the abbreviated xattr values we need. When called by the sender
630 * (with a non-NULL fname), we send all the extra xattr data it needs.
631 * The generator may also call with f_out < 0 to just change all the
632 * XSTATE_ABBREV states into XSTATE_DONE. */
633 void send_xattr_request(const char *fname
, struct file_struct
*file
, int f_out
)
635 const rsync_xa_list
*glst
= rsync_xal_l
.items
;
636 const item_list
*lst
;
637 int cnt
, prior_req
= 0;
640 glst
+= F_XATTR(file
);
641 lst
= &glst
->xa_items
;
643 for (rxa
= lst
->items
, cnt
= lst
->count
; cnt
--; rxa
++) {
644 if (rxa
->datum_len
<= MAX_FULL_DATUM
)
646 switch (rxa
->datum
[0]) {
648 /* Items left abbreviated matched the sender's checksum, so
649 * the receiver will cache the local data for future use. */
651 rxa
->datum
[0] = XSTATE_DONE
;
660 /* Flag that we handled this abbreviated item. */
661 rxa
->datum
[0] = XSTATE_DONE
;
663 write_varint(f_out
, rxa
->num
- prior_req
);
664 prior_req
= rxa
->num
;
670 /* Re-read the long datum. */
671 if (!(ptr
= get_xattr_data(fname
, rxa
->name
, &len
, 0))) {
672 rprintf(FERROR_XFER
, "failed to re-read xattr %s for %s\n", rxa
->name
, fname
);
673 write_varint(f_out
, 0);
677 write_varint(f_out
, len
); /* length might have changed! */
678 write_bigbuf(f_out
, ptr
, len
);
684 write_byte(f_out
, 0); /* end the list */
687 /* When called by the sender, read the request from the generator and mark
688 * any needed xattrs with a flag that lets us know they need to be sent to
689 * the receiver. When called by the receiver, reads the sent data and
690 * stores it in place of its checksum. */
691 int recv_xattr_request(struct file_struct
*file
, int f_in
)
693 const rsync_xa_list
*glst
= rsync_xal_l
.items
;
694 const item_list
*lst
;
695 char *old_datum
, *name
;
697 int rel_pos
, cnt
, num
, got_xattr_data
= 0;
699 if (F_XATTR(file
) < 0) {
700 rprintf(FERROR
, "recv_xattr_request: internal data error!\n");
701 exit_cleanup(RERR_PROTOCOL
);
703 glst
+= F_XATTR(file
);
704 lst
= &glst
->xa_items
;
709 while ((rel_pos
= read_varint(f_in
)) != 0) {
712 /* The sender-related num values are only in order on the sender.
713 * We use that order here to scan foward or backward as needed. */
715 while (cnt
< (int)lst
->count
&& rxa
->num
> num
) {
720 while (cnt
> 1 && rxa
->num
< num
) {
727 /* The receiving side has no known num order, so we just scan
728 * forward (w/wrap) and hope that the next value is near by. */
729 for (j
= lst
->count
; j
> 1 && rxa
->num
!= num
; j
--) {
738 if (!cnt
|| rxa
->num
!= num
) {
739 rprintf(FERROR
, "[%s] could not find xattr #%d for %s\n",
740 who_am_i(), num
, f_name(file
, NULL
));
741 exit_cleanup(RERR_PROTOCOL
);
743 if (!XATTR_ABBREV(*rxa
) || rxa
->datum
[0] != XSTATE_ABBREV
) {
744 rprintf(FERROR
, "[%s] internal abbrev error on %s (%s, len=%ld)!\n",
745 who_am_i(), f_name(file
, NULL
), rxa
->name
, (long)rxa
->datum_len
);
746 exit_cleanup(RERR_PROTOCOL
);
750 rxa
->datum
[0] = XSTATE_TODO
;
754 old_datum
= rxa
->datum
;
755 rxa
->datum_len
= read_varint(f_in
);
757 if (rxa
->name_len
+ rxa
->datum_len
< rxa
->name_len
)
758 overflow_exit("recv_xattr_request");
759 rxa
->datum
= new_array(char, rxa
->datum_len
+ rxa
->name_len
);
761 out_of_memory("recv_xattr_request");
762 name
= rxa
->datum
+ rxa
->datum_len
;
763 memcpy(name
, rxa
->name
, rxa
->name_len
);
766 read_buf(f_in
, rxa
->datum
, rxa
->datum_len
);
770 return got_xattr_data
;
773 /* ------------------------------------------------------------------------- */
775 /* receive and build the rsync_xattr_lists */
776 void receive_xattr(int f
, struct file_struct
*file
)
778 static item_list temp_xattr
= EMPTY_ITEM_LIST
;
780 #ifdef HAVE_LINUX_XATTRS
785 int ndx
= read_varint(f
);
787 if (ndx
< 0 || (size_t)ndx
> rsync_xal_l
.count
) {
788 rprintf(FERROR
, "receive_xattr: xa index %d out of"
789 " range for %s\n", ndx
, f_name(file
, NULL
));
790 exit_cleanup(RERR_STREAMIO
);
794 F_XATTR(file
) = ndx
- 1;
798 if ((count
= read_varint(f
)) != 0) {
799 (void)EXPAND_ITEM_LIST(&temp_xattr
, rsync_xa
, count
);
800 temp_xattr
.count
= 0;
803 for (num
= 1; num
<= count
; num
++) {
806 size_t name_len
= read_varint(f
);
807 size_t datum_len
= read_varint(f
);
808 size_t dget_len
= datum_len
> MAX_FULL_DATUM
? 1 + MAX_DIGEST_LEN
: datum_len
;
809 size_t extra_len
= MIGHT_NEED_RPRE
? RPRE_LEN
: 0;
810 if ((dget_len
+ extra_len
< dget_len
)
811 || (dget_len
+ extra_len
+ name_len
< dget_len
))
812 overflow_exit("receive_xattr");
813 ptr
= new_array(char, dget_len
+ extra_len
+ name_len
);
815 out_of_memory("receive_xattr");
816 name
= ptr
+ dget_len
+ extra_len
;
817 read_buf(f
, name
, name_len
);
818 if (dget_len
== datum_len
)
819 read_buf(f
, ptr
, dget_len
);
821 *ptr
= XSTATE_ABBREV
;
822 read_buf(f
, ptr
+ 1, MAX_DIGEST_LEN
);
824 #ifdef HAVE_LINUX_XATTRS
825 /* Non-root can only save the user namespace. */
826 if (am_root
<= 0 && !HAS_PREFIX(name
, USER_PREFIX
)) {
832 name_len
+= RPRE_LEN
;
833 memcpy(name
, RSYNC_PREFIX
, RPRE_LEN
);
837 /* This OS only has a user namespace, so we either
838 * strip the user prefix, or we put a non-user
839 * namespace inside our rsync hierarchy. */
840 if (HAS_PREFIX(name
, USER_PREFIX
)) {
842 name_len
-= UPRE_LEN
;
843 } else if (am_root
) {
845 name_len
+= RPRE_LEN
;
846 memcpy(name
, RSYNC_PREFIX
, RPRE_LEN
);
852 /* No rsync.%FOO attributes are copied w/o 2 -X options. */
853 if (preserve_xattrs
< 2 && name_len
> RPRE_LEN
854 && name
[RPRE_LEN
] == '%' && HAS_PREFIX(name
, RSYNC_PREFIX
)) {
859 rxa
= EXPAND_ITEM_LIST(&temp_xattr
, rsync_xa
, 1);
862 rxa
->name_len
= name_len
;
863 rxa
->datum_len
= datum_len
;
867 if (need_sort
&& count
> 1)
868 qsort(temp_xattr
.items
, count
, sizeof (rsync_xa
), rsync_xal_compare_names
);
870 ndx
= rsync_xal_store(&temp_xattr
); /* adds item to rsync_xal_l */
875 /* Turn the xattr data in stat_x into cached xattr data, setting the index
876 * values in the file struct. */
877 void cache_tmp_xattr(struct file_struct
*file
, stat_x
*sxp
)
884 if (prior_xattr_count
== (size_t)-1)
885 prior_xattr_count
= rsync_xal_l
.count
;
886 ndx
= find_matching_xattr(sxp
->xattr
);
888 rsync_xal_store(sxp
->xattr
); /* adds item to rsync_xal_l */
893 void uncache_tmp_xattrs(void)
895 if (prior_xattr_count
!= (size_t)-1) {
896 rsync_xa_list
*xa_list_item
= rsync_xal_l
.items
;
897 rsync_xa_list
*xa_list_start
= xa_list_item
+ prior_xattr_count
;
898 xa_list_item
+= rsync_xal_l
.count
;
899 rsync_xal_l
.count
= prior_xattr_count
;
900 while (xa_list_item
-- > xa_list_start
) {
901 struct ht_int64_node
*node
;
902 rsync_xa_list_ref
*ref
;
904 rsync_xal_free(&xa_list_item
->xa_items
);
906 if (rsync_xal_h
== NULL
)
909 node
= hashtable_find(rsync_xal_h
, xa_list_item
->key
, 0);
913 if (node
->data
== NULL
)
917 if (xa_list_item
->ndx
== ref
->ndx
) {
918 /* xa_list_item is the first in the list. */
919 node
->data
= ref
->next
;
924 while (ref
!= NULL
) {
925 if (ref
->next
== NULL
) {
929 if (xa_list_item
->ndx
== ref
->next
->ndx
) {
930 ref
->next
= ref
->next
->next
;
937 prior_xattr_count
= (size_t)-1;
941 static int rsync_xal_set(const char *fname
, item_list
*xalp
,
942 const char *fnamecmp
, stat_x
*sxp
)
944 rsync_xa
*rxas
= xalp
->items
;
947 char *name
, *ptr
, sum
[MAX_DIGEST_LEN
];
948 #ifdef HAVE_LINUX_XATTRS
949 int user_only
= am_root
<= 0;
954 /* This puts the current name list into the "namebuf" buffer. */
955 if ((list_len
= get_xattr_names(fname
)) < 0)
958 for (i
= 0; i
< xalp
->count
; i
++) {
961 if (XATTR_ABBREV(rxas
[i
])) {
962 /* See if the fnamecmp version is identical. */
963 len
= name_len
= rxas
[i
].name_len
;
964 if ((ptr
= get_xattr_data(fnamecmp
, name
, &len
, 1)) == NULL
) {
968 rprintf(FERROR
, "Missing abbreviated xattr value, %s, for %s\n",
969 rxas
[i
].name
, full_fname(fname
));
973 if (len
!= rxas
[i
].datum_len
) {
978 sum_init(-1, checksum_seed
);
979 sum_update(ptr
, len
);
981 if (memcmp(sum
, rxas
[i
].datum
+ 1, MAX_DIGEST_LEN
) != 0) {
986 if (fname
== fnamecmp
)
987 ; /* Value is already set when identical */
988 else if (sys_lsetxattr(fname
, name
, ptr
, len
) < 0) {
989 rsyserr(FERROR_XFER
, errno
,
990 "rsync_xal_set: lsetxattr(%s,\"%s\") failed",
991 full_fname(fname
), name
);
993 } else /* make sure caller sets mtime */
994 sxp
->st
.st_mtime
= (time_t)-1;
996 if (am_generator
) { /* generator items stay abbreviated */
1001 memcpy(ptr
+ len
, name
, name_len
);
1002 free(rxas
[i
].datum
);
1004 rxas
[i
].name
= name
= ptr
+ len
;
1005 rxas
[i
].datum
= ptr
;
1009 if (sys_lsetxattr(fname
, name
, rxas
[i
].datum
, rxas
[i
].datum_len
) < 0) {
1010 rsyserr(FERROR_XFER
, errno
,
1011 "rsync_xal_set: lsetxattr(%s,\"%s\") failed",
1012 full_fname(fname
), name
);
1014 } else /* make sure caller sets mtime */
1015 sxp
->st
.st_mtime
= (time_t)-1;
1018 /* Remove any extraneous names. */
1019 for (name
= namebuf
; list_len
> 0; name
+= name_len
) {
1020 name_len
= strlen(name
) + 1;
1021 list_len
-= name_len
;
1023 #ifdef HAVE_LINUX_XATTRS
1024 /* Choose between ignoring the system namespace or (non-root) ignoring any non-user namespace. */
1025 if (user_only
? !HAS_PREFIX(name
, USER_PREFIX
) : HAS_PREFIX(name
, SYSTEM_PREFIX
))
1028 if (am_root
< 0 && name_len
> RPRE_LEN
&& name
[RPRE_LEN
] == '%' && strcmp(name
, XSTAT_ATTR
) == 0)
1031 for (i
= 0; i
< xalp
->count
; i
++) {
1032 if (strcmp(name
, rxas
[i
].name
) == 0)
1035 if (i
== xalp
->count
) {
1036 if (sys_lremovexattr(fname
, name
) < 0) {
1037 rsyserr(FERROR_XFER
, errno
,
1038 "rsync_xal_set: lremovexattr(%s,\"%s\") failed",
1039 full_fname(fname
), name
);
1041 } else /* make sure caller sets mtime */
1042 sxp
->st
.st_mtime
= (time_t)-1;
1049 /* Set extended attributes on indicated filename. */
1050 int set_xattr(const char *fname
, const struct file_struct
*file
,
1051 const char *fnamecmp
, stat_x
*sxp
)
1053 rsync_xa_list
*glst
= rsync_xal_l
.items
;
1058 return 1; /* FIXME: --dry-run needs to compute this value */
1060 if (read_only
|| list_only
) {
1065 #ifdef NO_SPECIAL_XATTRS
1066 if (IS_SPECIAL(sxp
->st
.st_mode
)) {
1071 #ifdef NO_DEVICE_XATTRS
1072 if (IS_DEVICE(sxp
->st
.st_mode
)) {
1077 #ifdef NO_SYMLINK_XATTRS
1078 if (S_ISLNK(sxp
->st
.st_mode
)) {
1084 ndx
= F_XATTR(file
);
1086 lst
= &glst
->xa_items
;
1087 return rsync_xal_set(fname
, lst
, fnamecmp
, sxp
);
1091 char *get_xattr_acl(const char *fname
, int is_access_acl
, size_t *len_p
)
1093 const char *name
= is_access_acl
? XACC_ACL_ATTR
: XDEF_ACL_ATTR
;
1094 *len_p
= 0; /* no extra data alloc needed from get_xattr_data() */
1095 return get_xattr_data(fname
, name
, len_p
, 1);
1098 int set_xattr_acl(const char *fname
, int is_access_acl
, const char *buf
, size_t buf_len
)
1100 const char *name
= is_access_acl
? XACC_ACL_ATTR
: XDEF_ACL_ATTR
;
1101 if (sys_lsetxattr(fname
, name
, buf
, buf_len
) < 0) {
1102 rsyserr(FERROR_XFER
, errno
,
1103 "set_xattr_acl: lsetxattr(%s,\"%s\") failed",
1104 full_fname(fname
), name
);
1110 int del_def_xattr_acl(const char *fname
)
1112 return sys_lremovexattr(fname
, XDEF_ACL_ATTR
);
1116 int get_stat_xattr(const char *fname
, int fd
, STRUCT_STAT
*fst
, STRUCT_STAT
*xst
)
1118 int mode
, rdev_major
, rdev_minor
, uid
, gid
, len
;
1121 if (am_root
>= 0 || IS_DEVICE(fst
->st_mode
) || IS_SPECIAL(fst
->st_mode
))
1130 len
= sys_lgetxattr(fname
, XSTAT_ATTR
, buf
, sizeof buf
- 1);
1133 len
= sys_fgetxattr(fd
, XSTAT_ATTR
, buf
, sizeof buf
- 1);
1135 if (len
>= (int)sizeof buf
) {
1140 if (errno
== ENOTSUP
|| errno
== ENOATTR
)
1142 if (errno
== EPERM
&& S_ISLNK(fst
->st_mode
)) {
1147 rsyserr(FERROR_XFER
, errno
, "failed to read xattr %s for %s",
1148 XSTAT_ATTR
, full_fname(fname
));
1153 if (sscanf(buf
, "%o %d,%d %d:%d",
1154 &mode
, &rdev_major
, &rdev_minor
, &uid
, &gid
) != 5) {
1155 rprintf(FERROR
, "Corrupt %s xattr attached to %s: \"%s\"\n",
1156 XSTAT_ATTR
, full_fname(fname
), buf
);
1157 exit_cleanup(RERR_FILEIO
);
1160 xst
->st_mode
= from_wire_mode(mode
);
1161 xst
->st_rdev
= MAKEDEV(rdev_major
, rdev_minor
);
1168 int set_stat_xattr(const char *fname
, struct file_struct
*file
, mode_t new_mode
)
1170 STRUCT_STAT fst
, xst
;
1177 if (read_only
|| list_only
) {
1178 rsyserr(FERROR_XFER
, EROFS
, "failed to write xattr %s for %s",
1179 XSTAT_ATTR
, full_fname(fname
));
1183 if (x_lstat(fname
, &fst
, &xst
) < 0) {
1184 rsyserr(FERROR_XFER
, errno
, "failed to re-stat %s",
1189 fst
.st_mode
&= (_S_IFMT
| CHMOD_BITS
);
1190 fmode
= new_mode
& (_S_IFMT
| CHMOD_BITS
);
1192 if (IS_DEVICE(fmode
)) {
1193 uint32
*devp
= F_RDEV_P(file
);
1194 rdev
= MAKEDEV(DEV_MAJOR(devp
), DEV_MINOR(devp
));
1198 /* Dump the special permissions and enable full owner access. */
1199 mode
= (fst
.st_mode
& _S_IFMT
) | (fmode
& ACCESSPERMS
)
1200 | (S_ISDIR(fst
.st_mode
) ? 0700 : 0600);
1201 if (fst
.st_mode
!= mode
)
1202 do_chmod(fname
, mode
);
1203 if (!IS_DEVICE(fst
.st_mode
))
1204 fst
.st_rdev
= 0; /* just in case */
1206 if (mode
== fmode
&& fst
.st_rdev
== rdev
1207 && fst
.st_uid
== F_OWNER(file
) && fst
.st_gid
== F_GROUP(file
)) {
1208 /* xst.st_mode will be 0 if there's no current stat xattr */
1209 if (xst
.st_mode
&& sys_lremovexattr(fname
, XSTAT_ATTR
) < 0) {
1210 rsyserr(FERROR_XFER
, errno
,
1211 "delete of stat xattr failed for %s",
1218 if (xst
.st_mode
!= fmode
|| xst
.st_rdev
!= rdev
1219 || xst
.st_uid
!= F_OWNER(file
) || xst
.st_gid
!= F_GROUP(file
)) {
1221 int len
= snprintf(buf
, sizeof buf
, "%o %u,%u %u:%u",
1222 to_wire_mode(fmode
),
1223 (int)major(rdev
), (int)minor(rdev
),
1224 F_OWNER(file
), F_GROUP(file
));
1225 if (sys_lsetxattr(fname
, XSTAT_ATTR
, buf
, len
) < 0) {
1226 if (errno
== EPERM
&& S_ISLNK(fst
.st_mode
))
1228 rsyserr(FERROR_XFER
, errno
,
1229 "failed to write xattr %s for %s",
1230 XSTAT_ATTR
, full_fname(fname
));
1238 int x_stat(const char *fname
, STRUCT_STAT
*fst
, STRUCT_STAT
*xst
)
1240 int ret
= do_stat(fname
, fst
);
1241 if ((ret
< 0 || get_stat_xattr(fname
, -1, fst
, xst
) < 0) && xst
)
1246 int x_lstat(const char *fname
, STRUCT_STAT
*fst
, STRUCT_STAT
*xst
)
1248 int ret
= do_lstat(fname
, fst
);
1249 if ((ret
< 0 || get_stat_xattr(fname
, -1, fst
, xst
) < 0) && xst
)
1254 int x_fstat(int fd
, STRUCT_STAT
*fst
, STRUCT_STAT
*xst
)
1256 int ret
= do_fstat(fd
, fst
);
1257 if ((ret
< 0 || get_stat_xattr(NULL
, fd
, fst
, xst
) < 0) && xst
)
1262 #endif /* SUPPORT_XATTRS */