From: Wayne Davison Date: Fri, 13 May 2005 00:27:37 +0000 (+0000) Subject: A slightly improved version of the rawhide xattr patch X-Git-Url: https://mattmccutchen.net/rsync/rsync-patches.git/commitdiff_plain/bbdff76a7bb36f79aa618c931fac2fc8e131330a A slightly improved version of the rawhide xattr patch by Jay Fenlason. --- diff --git a/xattrs.diff b/xattrs.diff new file mode 100644 index 0000000..2fdd46a --- /dev/null +++ b/xattrs.diff @@ -0,0 +1,909 @@ +Depends-On-Patch: acls.diff + +After applying this patch, run these commands for a successful build: + + autoconf + autoheader + ./configure --with-acl-support --with-xattr-support + make proto + make + +--- orig/Makefile.in 2004-10-20 06:32:26 ++++ Makefile.in 2005-03-03 01:20:46 +@@ -27,14 +27,14 @@ VERSION=@VERSION@ + + HEADERS=byteorder.h config.h errcode.h proto.h rsync.h smb_acls.h lib/pool_alloc.h + LIBOBJ=lib/wildmatch.o lib/compat.o lib/snprintf.o lib/mdfour.o \ +- lib/permstring.o lib/pool_alloc.o lib/sysacls.o @LIBOBJS@ ++ lib/permstring.o lib/pool_alloc.o lib/sysacls.o lib/sysxattr.o @LIBOBJS@ + ZLIBOBJ=zlib/deflate.o zlib/infblock.o zlib/infcodes.o zlib/inffast.o \ + zlib/inflate.o zlib/inftrees.o zlib/infutil.o zlib/trees.o \ + zlib/zutil.o zlib/adler32.o + OBJS1=rsync.o generator.o receiver.o cleanup.o sender.o exclude.o util.o \ + main.o checksum.o match.o syscall.o log.o backup.o + OBJS2=options.o flist.o io.o compat.o hlink.o token.o uidlist.o socket.o \ +- fileio.o batch.o clientname.o acls.o ++ fileio.o batch.o clientname.o acls.o xattr.o + OBJS3=progress.o pipe.o + DAEMON_OBJ = params.o loadparm.o clientserver.o access.o connection.o authenticate.o + popt_OBJS=popt/findme.o popt/popt.o popt/poptconfig.o \ +--- orig/backup.c 2004-10-06 00:13:09 ++++ backup.c 2005-03-03 01:20:46 +@@ -136,6 +136,7 @@ static int make_bak_dir(char *fullpath) + do_lchown(fullpath, st.st_uid, st.st_gid); + do_chmod(fullpath, st.st_mode); + (void)DUP_ACL(end, fullpath, st.st_mode); ++ (void)DUP_XATTR(end, fullpath ); + } + } + *p = '/'; +@@ -189,6 +190,7 @@ static int keep_backup(char *fname) + return 0; + + PUSH_KEEP_BACKUP_ACL(file, fname, buf); ++ PUSH_KEEP_BACKUP_XATTR(file, fname, buf); + + /* Check to see if this is a device file, or link */ + if (IS_DEVICE(file->mode)) { +@@ -264,6 +266,7 @@ static int keep_backup(char *fname) + } + set_perms(buf, file, NULL, 0); + CLEANUP_KEEP_BACKUP_ACL(); ++ CLEANUP_KEEP_BACKUP_XATTR(); + free(file); + + if (verbose > 1) { +--- orig/configure.in 2004-08-19 19:53:27 ++++ configure.in 2005-05-12 22:57:53 +@@ -810,6 +810,30 @@ samba_cv_HAVE_ACL_GET_PERM_NP=yes,samba_ + AC_MSG_RESULT(no) + ) + ++AC_CHECK_HEADERS(attr/xattr.h) ++AC_MSG_CHECKING(whether to support extended attributes) ++AC_ARG_WITH(xattr-support, ++[ --with-xattr-support Include extended attribute support (default=no)], ++[ case "$withval" in ++ yes) ++ case "$host_os" in ++ *linux*) ++ AC_MSG_RESULT(Using Linux xattrs) ++ AC_DEFINE(HAVE_LINUX_XATTRS, 1, [True if you have Linux xattrs]) ++ ;; ++ *) ++ AC_MSG_RESULT(Xattrs requested but not linux. Good luck) ++ ;; ++ esac ++ ;; ++ *) ++ AC_MSG_RESULT(no) ++ AC_DEFINE(HAVE_NA_XATTRS, 1, [True if you don't have extended attributes]) ++ esac ], ++ AC_MSG_RESULT(no) ++ AC_DEFINE(HAVE_NO_XATTRL, 1, [True if you don't have extended attributes]) ++) ++ + AC_CONFIG_FILES([Makefile lib/dummy zlib/dummy popt/dummy shconfig]) + AC_OUTPUT + +--- orig/flist.c 2005-03-16 02:24:11 ++++ flist.c 2005-05-12 22:55:41 +@@ -976,6 +976,8 @@ static struct file_struct *send_file_nam + return NULL; + if (!MAKE_ACL(file, fname)) + return NULL; ++ if (!MAKE_XATTR(file, fname)) ++ return NULL; + + maybe_emit_filelist_progress(flist->count + flist_count_offset); + +@@ -985,9 +987,11 @@ static struct file_struct *send_file_nam + flist->files[flist->count++] = file; + send_file_entry(file, f, base_flags); + SEND_ACL(file, f); ++ SEND_XATTR(file, f); + } else { + /* Cleanup unsent ACL(s). */ + SEND_ACL(file, -1); ++ SEND_XATTR(file, -1); + } + return file; + } +@@ -1315,6 +1319,7 @@ struct file_list *recv_file_list(int f) + file = receive_file_entry(flist, flags, f); + + RECEIVE_ACL(file, f); ++ RECEIVE_XATTR(file, f ); + + if (S_ISREG(file->mode)) + stats.total_size += file->length; +@@ -1339,6 +1344,7 @@ struct file_list *recv_file_list(int f) + clean_flist(flist, relative_paths, 1); + + SORT_FILE_ACL_INDEX_LISTS(); ++ SORT_FILE_XATTR_INDEX_LISTS(); + + if (f >= 0) { + /* Now send the uid/gid list. This was introduced in +--- orig/generator.c 2005-05-12 23:34:00 ++++ generator.c 2005-05-12 23:21:08 +@@ -724,6 +724,10 @@ static void recv_generator(char *fname, + if (f_out == -1) + SET_ACL(fname, file); + #endif ++#ifdef SUPPORT_XATTRS ++ if (f_out == -1) ++ SET_XATTR(fname, file); ++#endif + if (delete_during && f_out != -1 && !phase && dry_run < 2 + && (file->flags & FLAG_DEL_HERE)) + delete_in_dir(the_file_list, fname, file); +--- orig/lib/sysxattr.c 2005-05-12 23:23:15 ++++ lib/sysxattr.c 2005-05-12 23:23:15 +@@ -0,0 +1,41 @@ ++/* Extended attribute support for rsync. */ ++/* This file Copyright (C) 2004 Red Hat, Inc. */ ++/* Written by Jay Fenlason */ ++ ++/* 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 ++ the Free Software Foundation; either version 2 of the License, or ++ (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++*/ ++ ++#include "rsync.h" ++ ++#if defined(HAVE_LINUX_XATTRS) ++ ++ssize_t sys_lgetxattr(const char *path, const char *name, void *value, size_t size) ++{ ++ return lgetxattr(path, name, value, size); ++} ++ ++int sys_lsetxattr(const char *path, const char *name, const void *value, size_t size, int flags) ++{ ++ return lsetxattr(path, name, value, size, flags); ++} ++ ++ssize_t sys_llistxattr(const char *path, char *list, size_t size) ++{ ++ return llistxattr(path, list, size); ++} ++ ++#else ++ ++#endif /* No xattrs */ +--- orig/lib/sysxattr.h 2005-05-12 23:56:31 ++++ lib/sysxattr.h 2005-05-12 23:56:31 +@@ -0,0 +1,9 @@ ++#if defined(HAVE_LINUX_XATTRS) ++ ++ssize_t sys_lgetxattr(const char *path, const char *name, void *value, size_t size); ++int sys_lsetxattr(const char *path, const char *name, const void *value, size_t size, int flags); ++ssize_t sys_llistxattr(const char *path, char *list, size_t size); ++ ++#else ++ ++#endif /* No xattrs */ +--- orig/options.c 2005-05-12 23:34:38 ++++ options.c 2005-05-12 23:21:25 +@@ -45,6 +45,7 @@ int copy_links = 0; + int preserve_links = 0; + int preserve_hard_links = 0; + int preserve_acls = 0; ++int preserve_xattrs = 0; + int preserve_perms = 0; + int preserve_devices = 0; + int preserve_uid = 0; +@@ -182,6 +183,7 @@ static void print_rsync_version(enum log + char const *have_inplace = "no "; + char const *hardlinks = "no "; + char const *acls = "no "; ++ char const *xattrs = "no "; + char const *links = "no "; + char const *ipv6 = "no "; + STRUCT_STAT *dumstat; +@@ -201,7 +203,9 @@ static void print_rsync_version(enum log + #ifdef SUPPORT_ACLS + acls = ""; + #endif +- ++#ifdef SUPPORT_XATTRS ++ xattrs = ""; ++#endif + #ifdef SUPPORT_LINKS + links = ""; + #endif +@@ -216,9 +220,9 @@ static void print_rsync_version(enum log + "Copyright (C) 1996-2005 by Andrew Tridgell and others\n"); + rprintf(f, "\n"); + rprintf(f, "Capabilities: %d-bit files, %ssocketpairs, " +- "%shard links, %sACLs, %ssymlinks, batchfiles, \n", ++ "%shard links, %sACLs, %sxattrs, %ssymlinks, batchfiles, \n", + (int) (sizeof (OFF_T) * 8), +- got_socketpair, hardlinks, acls, links); ++ got_socketpair, hardlinks, acls, xattrs, links); + + /* Note that this field may not have type ino_t. It depends + * on the complicated interaction between largefile feature +@@ -289,6 +293,7 @@ void usage(enum logcode F) + rprintf(F," -K, --keep-dirlinks treat symlinked dir on receiver as dir\n"); + rprintf(F," -p, --perms preserve permissions\n"); + rprintf(F," -A, --acls preserve ACLs (implies --perms)\n"); ++ rprintf(F," -X, --xattrs preserve extended attributes (implies --perms)\n"); + rprintf(F," -o, --owner preserve owner (root only)\n"); + rprintf(F," -g, --group preserve group\n"); + rprintf(F," -D, --devices preserve devices (root only)\n"); +@@ -417,6 +422,7 @@ static struct poptOption long_options[] + {"copy-unsafe-links",0, POPT_ARG_NONE, ©_unsafe_links, 0, 0, 0 }, + {"perms", 'p', POPT_ARG_NONE, &preserve_perms, 0, 0, 0 }, + {"acls", 'A', POPT_ARG_NONE, 0, 'A', 0, 0 }, ++ {"xattrs", 'X', POPT_ARG_NONE, 0, 'X', 0, 0 }, + {"owner", 'o', POPT_ARG_NONE, &preserve_uid, 0, 0, 0 }, + {"group", 'g', POPT_ARG_NONE, &preserve_gid, 0, 0, 0 }, + {"devices", 'D', POPT_ARG_NONE, &preserve_devices, 0, 0, 0 }, +@@ -907,6 +913,17 @@ int parse_arguments(int *argc, const cha + #endif /* SUPPORT_ACLS */ + break; + ++ case 'X': ++#ifdef SUPPORT_XATTRS ++ preserve_xattrs = 1; ++ preserve_perms = 1; ++#else ++ snprintf(err_buf,sizeof(err_buf), ++ "extended attributes are not supported on this %s\n", ++ am_server ? "server" : "client"); ++ return 0; ++#endif /* SUPPORT_XATTRS */ ++ break; + + default: + /* A large opt value means that set_refuse_options() +@@ -1314,6 +1331,8 @@ void server_options(char **args,int *arg + argstr[x++] = 'H'; + if (preserve_acls) + argstr[x++] = 'A'; ++ if (preserve_xattrs) ++ argstr[x++] = 'X'; + if (preserve_uid) + argstr[x++] = 'o'; + if (preserve_gid) +--- orig/rsync.c 2004-07-03 20:11:58 ++++ rsync.c 2005-03-03 01:31:22 +@@ -144,6 +144,14 @@ int set_perms(char *fname,struct file_st + if (SET_ACL(fname, file) == 0) + updated = 1; + } ++ /* If this is a directory, SET_XATTR() will be called on the cleanup ++ * receive_generator() pass--if we called it here, we might clobber ++ * writability on the directory (SELinux security contexts are stored ++ * in xattrs). everything else is OK to do now. */ ++ if (!S_ISDIR(st->st_mode)) { ++ if (SET_XATTR(fname, file) == 0) ++ updated = 1; ++ } + + if (verbose > 1 && flags & PERMS_REPORT) { + enum logcode code = daemon_log_format_has_i || dry_run +--- orig/rsync.h 2005-05-12 23:32:56 ++++ rsync.h 2005-05-12 23:19:46 +@@ -676,6 +676,38 @@ struct stats { + #endif /* SUPPORT_ACLS */ + #include "smb_acls.h" + ++#ifdef HAVE_LINUX_XATTRS ++#define SUPPORT_XATTRS 1 ++#endif ++ ++#ifdef SUPPORT_XATTRS ++#ifdef HAVE_ATTR_XATTR_H ++#include ++#endif ++#define MAKE_XATTR(file, fname) make_xattr(file, fname) ++#define SEND_XATTR(file, f) send_xattr(file, f) ++#define RECEIVE_XATTR(file, f) receive_xattr(file, f) ++#define SORT_FILE_XATTR_INDEX_LISTS() sort_file_xattr_index_lists() ++#define SET_XATTR(fname, file) set_xattr(fname, file) ++#define NEXT_XATTR_UID() next_xattr_uid() ++#define XATTR_UID_MAP(uid) xattr_uid_map(uid) ++#define PUSH_KEEP_BACKUP_XATTR(file, orig, dest) \ ++ push_keep_backup_xattr(file, orig, dest) ++#define CLEANUP_KEEP_BACKUP_XATTR() cleanup_keep_backup_xattr() ++#define DUP_XATTR(orig, dest) dup_xattr(orig, dest) ++#else /* SUPPORT_XATTRS */ ++#define MAKE_XATTR(file, fname) 1 /* checked return value */ ++#define SEND_XATTR(file, f) ++#define RECEIVE_XATTR(file, f) ++#define SORT_FILE_XATTR_INDEX_LISTS() ++#define SET_XATTR(fname, file) 0 /* checked return value */ ++#define NEXT_XATTR_UID() ++#define XATTR_UID_MAP(uid) ++#define PUSH_KEEP_BACKUP_XATTR(file, orig, dest) ++#define CLEANUP_KEEP_BACKUP_XATTR() ++#define DUP_XATTR(src, orig) 0 /* checked return value */ ++#endif /* SUPPORT_XATTRS */ ++ + #include "proto.h" + + /* We have replacement versions of these if they're missing. */ +--- orig/rsync.yo 2004-07-03 20:11:58 ++++ rsync.yo 2005-03-03 01:33:53 +@@ -318,6 +318,7 @@ to the detailed description below for a + -K, --keep-dirlinks treat symlinked dir on receiver as dir + -p, --perms preserve permissions + -A, --acls preserve ACLs (implies -p) [local option] ++ -X, --xattrs preserve extended attributes (implies -p) [local option] + -o, --owner preserve owner (root only) + -g, --group preserve group + -D, --devices preserve devices (root only) +@@ -635,6 +636,11 @@ ACLs to be the same as the local ACLs. + remote machine's rsync supports this option also. This is a non-standard + option. + ++dit(bf(-X, --xattrs)) This option causes rsync to update the remote ++extended attributes to be the same as the local ones. This will work ++only if the remote machine's rsync supports this option also. This is ++a non-standard option. ++ + dit(bf(-o, --owner)) This option causes rsync to set the owner of the + destination file to be the same as the source file. On most systems, + only the super-user can set file ownership. By default, the preservation +--- orig/xattr.c 2005-05-12 23:18:33 ++++ xattr.c 2005-05-12 23:18:33 +@@ -0,0 +1,546 @@ ++/* Extended Attribute support for rsync */ ++/* Copyright (C) 2004 Red Hat, Inc */ ++/* Written by Jay Fenlason, vaguely based on the ACLs patch */ ++ ++/* 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 ++ the Free Software Foundation; either version 2 of the License, or ++ (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++*/ ++ ++#include "rsync.h" ++#include "lib/sysxattr.h" ++ ++#ifdef SUPPORT_XATTRS ++ ++extern int preserve_xattrs; ++extern int dry_run; ++ ++#define RSYNC_XAL_INITIAL 5 ++#define RSYNC_XAL_LIST_INITIAL 100 ++ ++typedef struct { ++ size_t name_len; ++ char *name; ++ size_t datum_len; ++ char *datum; ++} rsync_xa; ++ ++typedef struct { ++ size_t count; ++ size_t alloc; ++ rsync_xa *rxas; ++} rsync_xal; ++ ++typedef struct { ++ size_t count; ++ size_t alloc; ++ rsync_xal *rxals; ++} rsync_xal_list; ++ ++static size_t namebuf_len = 0; ++static char *namebuf = NULL; ++ ++static size_t datumbuf_len = 0; ++static char *datumbuf = NULL; ++ ++static rsync_xal curr_rsync_xal = { 0, 0, NULL }; ++static rsync_xal_list rsync_xal_l = { 0, 0, NULL }; ++ ++ ++/* ------------------------------------------------------------------------- */ ++ ++/* the below stuff is only used by the receiver */ ++ ++/* structure to hold index to rsync_xal_l member corresponding to ++ * flist->files[i] */ ++ ++typedef struct { ++ const struct file_struct *file; ++ int xalidx; ++} file_xal_index; ++ ++typedef struct { ++ size_t count; ++ size_t alloc; ++ file_xal_index *filexalidxs; ++} file_xal_index_list; ++ ++static file_xal_index_list fxil = {0, 0, NULL }; ++ ++/* stuff for redirecting calls to set_acl() from set_perms() ++ * for keep_backup() */ ++static const struct file_struct *backup_orig_file = NULL; ++static const char null_string[] = ""; ++static const char *backup_orig_fname = null_string; ++static const char *backup_dest_fname = null_string; ++static rsync_xal backup_xal; ++ ++/* ------------------------------------------------------------------------- */ ++ ++static void rsync_xal_free(rsync_xal *x) ++{ ++ size_t i; ++ ++ for (i = 0; i < x->count; i++) { ++ free(x->rxas[i].name); ++ /* free(x->rxas[i].value); */ ++ } ++ x->count = 0; ++} ++ ++static int rsync_xal_compare_names(const void *x1, const void *x2) ++{ ++ const rsync_xa *xa1; ++ const rsync_xa *xa2; ++ ++ xa1 = x1; ++ xa2 = x2; ++ return strcmp(xa1->name, xa2->name); ++} ++ ++static BOOL rsync_xal_get(const char *fname, rsync_xal *x) ++{ ++ ssize_t name_size; ++ ssize_t datum_size; ++ ssize_t left; ++ char *name; ++ size_t len; ++ char *ptr; ++ ++ if (!namebuf) { ++ namebuf_len = 100; ++ namebuf = new_array(char, namebuf_len); ++ datumbuf_len = 100; ++ datumbuf = new_array(char, datumbuf_len); ++ if (!namebuf || !datumbuf) ++ out_of_memory("rsync_xal_get"); ++ } ++ ++ name_size = sys_llistxattr(fname, namebuf, namebuf_len); ++ if (name_size > (ssize_t)namebuf_len) { ++ name_size = -1; ++ errno = ERANGE; ++ } ++ if (name_size < 0) { ++ if (errno == ENOTSUP) ++ return False; ++ if (errno == ERANGE) { ++ name_size = sys_llistxattr(fname, NULL, 0); ++ if (name_size < 0) { ++ rprintf(FERROR, "%s: rsync_xal_get: llistxattr: %s\n", ++ fname, strerror(errno)); ++ return False; ++ } ++ namebuf = realloc_array(namebuf, char, name_size + 1); ++ if (!namebuf) ++ out_of_memory("rsync_xal_get"); ++ namebuf_len = name_size; ++ name_size = sys_llistxattr(fname, namebuf, namebuf_len); ++ if (name_size < 0) { ++ rprintf(FERROR, ++ "%s: rsync_xal_get: re-llistxattr failed: %s\n", ++ fname, strerror(errno)); ++ return False; ++ } ++ } else { ++ rprintf(FERROR, ++ "%s: rsync_xal_get: llistxattr failed: %s\n", ++ fname, strerror(errno)); ++ return False; ++ } ++ } ++ rsync_xal_free(x); ++ if (name_size == 0) ++ return True; ++ for (left = name_size, name = namebuf; left > 0 ; left -= len, name += len) { ++ len = strlen(name) + 1; ++ ++ if (x->count >= x->alloc) { ++ size_t new_alloc; ++ rsync_xa *new_rxas; ++ ++ new_alloc = x->alloc < RSYNC_XAL_INITIAL ? RSYNC_XAL_INITIAL : x->alloc * 2; ++ new_rxas = realloc_array(x->rxas, rsync_xa, new_alloc); ++ if (!new_rxas) ++ out_of_memory("rsync_xal_get"); ++ x->alloc = new_alloc; ++ x->rxas = new_rxas; ++ } ++ datum_size = sys_lgetxattr(fname, name, datumbuf, datumbuf_len); ++ if (datum_size > (ssize_t)datumbuf_len) { ++ datum_size = -1; ++ errno = ERANGE; ++ } ++ if (datum_size < 0) { ++ if (errno == ENOTSUP) ++ return False; ++ if (errno == ERANGE) { ++ datum_size = sys_lgetxattr(fname, name, NULL, 0); ++ if (datum_size < 0) { ++ rprintf(FERROR, ++ "%s: rsync_xal_get: lgetxattr %s failed: %s\n", ++ fname, name, strerror(errno)); ++ return False; ++ } ++ datumbuf = realloc_array(datumbuf, char, datum_size + 1); ++ if (!datumbuf) ++ out_of_memory("rsync_xal_get"); ++ datumbuf_len = datum_size; ++ datum_size = sys_lgetxattr(fname, name, datumbuf, datumbuf_len); ++ if (datum_size < 0) { ++ rprintf(FERROR, ++ "%s: rsync_xal_get: re-lgetxattr of %s failed: %s\n", ++ name, fname, strerror(errno)); ++ return False; ++ } ++ } else { ++ rprintf(FERROR, ++ "%s: rsync_xal_get: lgetxattr %s failed: %s\n", ++ fname, name, strerror(errno)); ++ return False; ++ } ++ } ++ ptr = new_array(char, len + datum_size); ++ if (!ptr) ++ out_of_memory("rsync_xal_get"); ++ strcpy(ptr, name); ++ if (datum_size) ++ memcpy(ptr + len, datumbuf, datum_size); ++ x->rxas[curr_rsync_xal.count].name_len = len; ++ x->rxas[curr_rsync_xal.count].name = ptr; ++ x->rxas[curr_rsync_xal.count].datum_len = datum_size; ++ x->rxas[curr_rsync_xal.count].datum = ptr + len; ++ x->count++; ++ } ++ if (x->count > 1) { ++ qsort(x->rxas, x->count, sizeof (rsync_xa), rsync_xal_compare_names); ++ } ++ return True; ++} ++ ++ ++/* generate the xattr(s) for this flist entry; ++ * xattr(s) are either sent or cleaned-up by send_xattr() below */ ++ ++BOOL make_xattr(const struct file_struct *file, const char *fname) ++{ ++ if (!preserve_xattrs) ++ return True; ++ ++ rsync_xal_get(fname, &curr_rsync_xal); ++ return True; ++} ++ ++static ssize_t rsync_xal_find_matching(void) ++{ ++ size_t i; ++ size_t j; ++ ++ for (i = 0; i < rsync_xal_l.count; i++) { ++ /* Wrong number of elements? */ ++ if (rsync_xal_l.rxals[i].count != curr_rsync_xal.count) ++ continue; ++ /* any elements different? */ ++ for (j = 0; j < curr_rsync_xal.count; j++) { ++ if (rsync_xal_l.rxals[i].rxas[j].name_len != curr_rsync_xal.rxas[j].name_len ++ || rsync_xal_l.rxals[i].rxas[j].datum_len != curr_rsync_xal.rxas[j].datum_len ++ || strcmp(rsync_xal_l.rxals[i].rxas[j].name, curr_rsync_xal.rxas[j].name) ++ || memcmp(rsync_xal_l.rxals[i].rxas[j].datum, curr_rsync_xal.rxas[j].datum, curr_rsync_xal.rxas[j].datum_len)) ++ break; ++ } ++ /* no differences found. This is The One! */ ++ if (j == curr_rsync_xal.count) ++ break; ++ } ++ if (i < rsync_xal_l.count) ++ return i; ++ return (ssize_t)-1; ++} ++ ++/* Store curr_rsync_xal on the end of rsync_xal_l */ ++static void rsync_xal_store(void) ++{ ++ if (rsync_xal_l.count <= rsync_xal_l.alloc) { ++ size_t new_alloc; ++ void *new_xal; ++ ++ new_alloc = rsync_xal_l.count < RSYNC_XAL_LIST_INITIAL ? RSYNC_XAL_LIST_INITIAL : rsync_xal_l.count * 2; ++ new_xal = realloc_array(rsync_xal_l.rxals, rsync_xal, new_alloc); ++ if (!new_xal) ++ out_of_memory("rsync_xal_store"); ++ rsync_xal_l.alloc = new_alloc; ++ rsync_xal_l.rxals = new_xal; ++ } ++ rsync_xal_l.rxals[rsync_xal_l.count] = curr_rsync_xal; ++ rsync_xal_l.count++; ++ curr_rsync_xal.count = 0; ++ curr_rsync_xal.alloc = 0; ++} ++ ++/* send the make_xattr()-generated xattr list for this flist entry, ++ * or clean up after an flist entry that's not being sent (f == -1) */ ++ ++void send_xattr(const struct file_struct *file, int f) ++{ ++ ssize_t index; ++ ++ if (!preserve_xattrs) ++ return; ++ ++ if (f == -1) { ++ rsync_xal_free(&curr_rsync_xal); ++ return; ++ } ++ index = rsync_xal_find_matching(); ++ if (index != -1) { ++ write_byte(f, 'x'); ++ write_int(f, index); ++ rsync_xal_free(&curr_rsync_xal); ++ } else { ++ rsync_xa *rxa; ++ size_t count; ++ ++ count = curr_rsync_xal.count; ++ write_byte(f, 'X'); ++ write_int(f, count); ++ for (rxa = curr_rsync_xal.rxas; count--; rxa++) { ++ write_int(f, rxa->name_len); ++ write_int(f, rxa->datum_len); ++ write_buf(f, rxa->name, rxa->name_len); ++ write_buf(f, rxa->datum, rxa->datum_len); ++ } ++ rsync_xal_store(); ++ } ++} ++ ++ ++/* ------------------------------------------------------------------------- */ ++/* receive and build the rsync_xattr_lists */ ++ ++void receive_xattr(struct file_struct *file, int f) ++{ ++ char *fname; ++ int tag; ++ ++ if (!preserve_xattrs) ++ return; ++ fname = f_name(file); ++ tag = read_byte(f); ++ if (tag != 'X' && tag != 'x') { ++ rprintf(FERROR, ++ "%s: receive_xattr: unknown extended attribute type tag: %c\n", ++ fname, tag); ++ exit_cleanup(RERR_STREAMIO); ++ } ++ ++ if (fxil.alloc <= fxil.count) { ++ void *new_ptr; ++ size_t new_alloc; ++ ++ if (fxil.count < RSYNC_XAL_LIST_INITIAL) ++ new_alloc = fxil.alloc + RSYNC_XAL_LIST_INITIAL; ++ else ++ new_alloc = fxil.alloc * 2; ++ new_ptr = realloc_array(fxil.filexalidxs, file_xal_index, new_alloc); ++ if (!new_ptr) ++ out_of_memory("receive_xattr"); ++ if (verbose >= 3) { ++ rprintf(FINFO, "receive_xattr to %lu bytes, %s move\n", ++ (unsigned long)(new_alloc * sizeof (file_xal_index)), ++ fxil.filexalidxs == new_ptr ? "did not" : "did"); ++ } ++ ++ fxil.filexalidxs = new_ptr; ++ fxil.alloc = new_alloc; ++ } ++ ++ fxil.filexalidxs[fxil.count].file = file; ++ if (tag == 'X') { ++ size_t count; ++ size_t i; ++ ++ fxil.filexalidxs[fxil.count].xalidx = rsync_xal_l.count; ++ ++ count = read_int(f); ++ curr_rsync_xal.count = count; ++ curr_rsync_xal.alloc = count; ++ curr_rsync_xal.rxas = new_array(rsync_xa, count); ++ if (!curr_rsync_xal.rxas) ++ out_of_memory("receive_xattr"); ++ for (i = 0; i < count; i++) { ++ size_t name_len; ++ size_t datum_len; ++ char *ptr; ++ ++ name_len = read_int(f); ++ datum_len = read_int(f); ++ ptr = new_array(char, name_len + datum_len); ++ if (!ptr) ++ out_of_memory("receive_xattr"); ++ read_buf(f, ptr, name_len); ++ read_buf(f, ptr + name_len, datum_len); ++ curr_rsync_xal.rxas[i].name_len = name_len; ++ curr_rsync_xal.rxas[i].datum_len = datum_len; ++ curr_rsync_xal.rxas[i].name = ptr; ++ curr_rsync_xal.rxas[i].datum = ptr + name_len; ++ } ++ rsync_xal_store(); ++ } else { ++ size_t index; ++ ++ index = read_int(f); ++ if (index >= rsync_xal_l.count) { ++ rprintf(FERROR, "%s: receive_xattr: xa index %lu out of range\n", ++fname, (unsigned long)index); ++ exit_cleanup(RERR_STREAMIO); ++ } ++ fxil.filexalidxs[fxil.count].xalidx = index; ++ } ++ fxil.count++; ++} ++ ++static BOOL rsync_xal_set(const char *fname, rsync_xal *x) ++{ ++ size_t i; ++ int status; ++ BOOL ret; ++ ++ ret = True; ++ for (i = 0; i < x->count; i++) { ++ status = sys_lsetxattr(fname, x->rxas[i].name, x->rxas[i].datum, x->rxas[i].datum_len, 0); ++ if (status < 0) { ++ rprintf(FERROR, "%s: rsync_xal_set: lsetxattr %s failed: %s\n", ++ fname, x->rxas[i].name, strerror(errno)); ++ ret = False; ++ } ++ } ++ return ret; ++} ++ ++/* for duplicating xattrs on backups when using backup_dir */ ++ ++int dup_xattr(const char *orig, const char *bak) ++{ ++ int ret; ++ ++ ret = 0; ++ if (!preserve_xattrs) ++ return ret; ++ ++ ret = rsync_xal_get(orig, &backup_xal); ++ if (ret == True) ++ ret = rsync_xal_set(bak, &backup_xal); ++ rsync_xal_free(&backup_xal); ++ return ret; ++} ++ ++void push_keep_backup_xattr(const struct file_struct *file, const char *orig, const char *dest) ++{ ++ if (!preserve_xattrs) ++ return; ++ ++ backup_orig_file = file; ++ backup_orig_fname = orig; ++ backup_dest_fname = dest; ++ rsync_xal_get(orig, &backup_xal); ++} ++ ++static int set_keep_backup_xal(void) ++{ ++ if (!preserve_xattrs) ++ return 0; ++ return rsync_xal_set(backup_dest_fname, &backup_xal); ++} ++ ++void cleanup_keep_backup_xattr(void) ++{ ++ if (!preserve_xattrs) ++ return; ++ ++ backup_orig_file = NULL; ++ backup_orig_fname = null_string; ++ backup_dest_fname = null_string; ++ rsync_xal_free(&backup_xal); ++} ++ ++static int file_xal_index_compare(const void *x1, const void *x2) ++{ ++ const file_xal_index *xa1; ++ const file_xal_index *xa2; ++ ++ xa1 = x1; ++ xa2 = x2; ++ return xa1->file == xa2->file ? 0 : xa1->file < xa2->file ? -1 : 1; ++} ++ ++void sort_file_xattr_index_lists(void) ++{ ++ if (!preserve_xattrs) ++ return; ++ qsort(fxil.filexalidxs, fxil.count, sizeof (file_xal_index), file_xal_index_compare); ++} ++ ++static int find_file_xal_index(const struct file_struct *file) ++{ ++ int low = 0, high = fxil.count; ++ const struct file_struct *file_mid; ++ ++ if (!high--) { ++ rprintf(FERROR, "find_file_xal_index: no entries\n"); ++ exit_cleanup(RERR_STREAMIO); ++ return -1; ++ } ++ do { ++ int mid = (high + low) / 2; ++ file_mid = fxil.filexalidxs[mid].file; ++ if (file_mid == file) ++ return fxil.filexalidxs[mid].xalidx; ++ if (file_mid > file) ++ high = mid - 1; ++ else ++ low = mid + 1; ++ } while (low < high); ++ if (low == high) { ++ file_mid = fxil.filexalidxs[low].file; ++ if (file_mid == file) ++ return fxil.filexalidxs[low].xalidx; ++ } ++ rprintf(FERROR, ++ "find_file_xal_index: can't find entry for file in list\n"); ++ exit_cleanup(RERR_STREAMIO); ++ return -1; ++} ++ ++ ++/* set extended attributes on rsync-ed or keep_backup-ed file */ ++ ++int set_xattr(const char *fname, const struct file_struct *file) ++{ ++ int updated; ++ int xalidx; ++ rsync_xal *x; ++ ++ updated = 0; ++ if (dry_run || !preserve_xattrs) ++ return 0; ++ if (file == backup_orig_file) { ++ if (!strcmp(fname, backup_dest_fname)) ++ return set_keep_backup_xal(); ++ } ++ xalidx = find_file_xal_index(file); ++ x = &(rsync_xal_l.rxals[xalidx]); ++ updated = rsync_xal_set(fname, x); ++ return updated; ++} ++ ++#endif /* SUPPORT_XATTRS */