Fixed a thinko and a typo in the --append option.
[rsync.git] / acls.c
diff --git a/acls.c b/acls.c
index bfb12c7bdfd702d1d135d0fa1924f5840f6b8d8b..d9023e2f4bf68bbad1915ae0d0fb2ccc73f80d56 100644 (file)
--- a/acls.c
+++ b/acls.c
@@ -3,11 +3,12 @@
  *
  * Copyright (C) 1996 Andrew Tridgell
  * Copyright (C) 1996 Paul Mackerras
- * Copyright (C) 2006 Wayne Davison
+ * Copyright (C) 2006-2008 Wayne Davison
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 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
@@ -15,8 +16,7 @@
  * 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.,
- * 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
+ * with this program; if not, visit the http://fsf.org website.
  */
 
 #include "rsync.h"
@@ -29,22 +29,32 @@ extern int am_root;
 extern int read_only;
 extern int list_only;
 extern int orig_umask;
-extern int protocol_version;
 extern int numeric_ids;
 extern int inc_recurse;
 
+/* Flags used to indicate what items are being transmitted for an entry. */
 #define XMIT_USER_OBJ (1<<0)
-#define XMIT_USER_LIST (1<<1)
-#define XMIT_GROUP_OBJ (1<<2)
-#define XMIT_GROUP_LIST (1<<3)
-#define XMIT_MASK_OBJ (1<<4)
-#define XMIT_OTHER_OBJ (1<<5)
+#define XMIT_GROUP_OBJ (1<<1)
+#define XMIT_MASK_OBJ (1<<2)
+#define XMIT_OTHER_OBJ (1<<3)
+#define XMIT_NAME_LIST (1<<4)
+
+#define NO_ENTRY ((uchar)0x80) /* Default value of a NON-name-list entry. */
+
+#define NAME_IS_USER (1u<<31) /* Bit used only on a name-list entry. */
+
+/* When we send the access bits over the wire, we shift them 2 bits to the
+ * left and use the lower 2 bits as flags (relevant only to a name entry).
+ * This makes the protocol more efficient than sending a value that would
+ * be likely to have its hightest bits set. */
+#define XFLAG_NAME_FOLLOWS 0x0001u
+#define XFLAG_NAME_IS_USER 0x0002u
 
 /* === ACL structures === */
 
 typedef struct {
        id_t id;
-       uchar access;
+       uint32 access;
 } id_access;
 
 typedef struct {
@@ -57,10 +67,8 @@ typedef struct {
        uchar len;
 } idname;
 
-#define NO_ENTRY ((uchar)0x80)
 typedef struct rsync_acl {
-       ida_entries users;
-       ida_entries groups;
+       ida_entries names;
        /* These will be NO_ENTRY if there's no such entry. */
        uchar user_obj;
        uchar group_obj;
@@ -74,7 +82,7 @@ typedef struct {
 } acl_duo;
 
 static const rsync_acl empty_rsync_acl = {
-       {NULL, 0}, {NULL, 0}, NO_ENTRY, NO_ENTRY, NO_ENTRY, NO_ENTRY
+       {NULL, 0}, NO_ENTRY, NO_ENTRY, NO_ENTRY, NO_ENTRY
 };
 
 static item_list access_acl_list = EMPTY_ITEM_LIST;
@@ -84,15 +92,25 @@ static item_list default_acl_list = EMPTY_ITEM_LIST;
 
 static const char *str_acl_type(SMB_ACL_TYPE_T type)
 {
-       return type == SMB_ACL_TYPE_ACCESS ? "SMB_ACL_TYPE_ACCESS"
-            : type == SMB_ACL_TYPE_DEFAULT ? "SMB_ACL_TYPE_DEFAULT"
-            : "unknown SMB_ACL_TYPE_T";
+       switch (type) {
+       case SMB_ACL_TYPE_ACCESS:
+#ifdef HAVE_OSX_ACLS
+               return "ACL_TYPE_EXTENDED";
+#else
+               return "ACL_TYPE_ACCESS";
+#endif
+       case SMB_ACL_TYPE_DEFAULT:
+               return "ACL_TYPE_DEFAULT";
+       default:
+               break;
+       }
+       return "unknown ACL type!";
 }
 
 static int calc_sacl_entries(const rsync_acl *racl)
 {
        /* A System ACL always gets user/group/other permission entries. */
-       return racl->users.count + racl->groups.count
+       return racl->names.count
 #ifdef ACLS_NEED_MASK
             + 4;
 #else
@@ -166,8 +184,7 @@ static BOOL rsync_acl_equal(const rsync_acl *racl1, const rsync_acl *racl2)
            && racl1->group_obj == racl2->group_obj
            && racl1->mask_obj == racl2->mask_obj
            && racl1->other_obj == racl2->other_obj
-           && ida_entries_equal(&racl1->users, &racl2->users)
-           && ida_entries_equal(&racl1->groups, &racl2->groups);
+           && ida_entries_equal(&racl1->names, &racl2->names);
 }
 
 /* Are the extended (non-permission-bit) entries equal?  If so, the rest of
@@ -193,20 +210,17 @@ static BOOL rsync_acl_equal_enough(const rsync_acl *racl1,
                } else if (racl1->group_obj != racl2->group_obj)
                        return False;
        }
-       return ida_entries_equal(&racl1->users, &racl2->users)
-           && ida_entries_equal(&racl1->groups, &racl2->groups);
+       return ida_entries_equal(&racl1->names, &racl2->names);
 }
 
 static void rsync_acl_free(rsync_acl *racl)
 {
-       if (racl->users.idas)
-               free(racl->users.idas);
-       if (racl->groups.idas)
-               free(racl->groups.idas);
+       if (racl->names.idas)
+               free(racl->names.idas);
        *racl = empty_rsync_acl;
 }
 
-void free_acl(statx *sxp)
+void free_acl(stat_x *sxp)
 {
        if (sxp->acc_acl) {
                rsync_acl_free(sxp->acc_acl);
@@ -220,57 +234,24 @@ void free_acl(statx *sxp)
        }
 }
 
+#ifdef SMB_ACL_NEED_SORT
 static int id_access_sorter(const void *r1, const void *r2)
 {
        id_access *ida1 = (id_access *)r1;
        id_access *ida2 = (id_access *)r2;
        id_t rid1 = ida1->id, rid2 = ida2->id;
+       if ((ida1->access ^ ida2->access) & NAME_IS_USER)
+               return ida1->access & NAME_IS_USER ? -1 : 1;
        return rid1 == rid2 ? 0 : rid1 < rid2 ? -1 : 1;
 }
-
-static void sort_ida_entries(ida_entries *idal)
-{
-       if (!idal->count)
-               return;
-       qsort(idal->idas, idal->count, sizeof idal->idas[0], id_access_sorter);
-}
+#endif
 
 /* === System ACLs === */
 
-/* Transfer the count id_access items out of the temp_ida_list into either
- * the users or groups ida_entries list in racl. */
-static void save_idas(rsync_acl *racl, SMB_ACL_TAG_T type, item_list *temp_ida_list)
-{
-       id_access *idas;
-       ida_entries *ent;
-
-       if (temp_ida_list->count) {
-               int cnt = temp_ida_list->count;
-               id_access *temp_idas = temp_ida_list->items;
-               if (!(idas = new_array(id_access, cnt)))
-                       out_of_memory("save_idas");
-               memcpy(idas, temp_idas, cnt * sizeof *temp_idas);
-       } else
-               idas = NULL;
-
-       ent = type == SMB_ACL_USER ? &racl->users : &racl->groups;
-
-       if (ent->count) {
-               rprintf(FERROR, "save_idas: disjoint list found for type %d\n", type);
-               exit_cleanup(RERR_UNSUPPORTED);
-       }
-       ent->count = temp_ida_list->count;
-       ent->idas = idas;
-
-       /* Truncate the temporary list now that its idas have been saved. */
-       temp_ida_list->count = 0;
-}
-
 /* Unpack system ACL -> rsync ACL verbatim.  Return whether we succeeded. */
 static BOOL unpack_smb_acl(SMB_ACL_T sacl, rsync_acl *racl)
 {
        static item_list temp_ida_list = EMPTY_ITEM_LIST;
-       SMB_ACL_TAG_T prior_list_type = 0;
        SMB_ACL_ENTRY_T entry;
        const char *errfun;
        int rc;
@@ -280,39 +261,28 @@ static BOOL unpack_smb_acl(SMB_ACL_T sacl, rsync_acl *racl)
             rc == 1;
             rc = sys_acl_get_entry(sacl, SMB_ACL_NEXT_ENTRY, &entry)) {
                SMB_ACL_TAG_T tag_type;
-               SMB_ACL_PERMSET_T permset;
-               uchar access;
-               void *qualifier;
+               uint32 access;
+               id_t g_u_id;
                id_access *ida;
-               if ((rc = sys_acl_get_tag_type(entry, &tag_type))) {
-                       errfun = "sys_acl_get_tag_type";
-                       break;
-               }
-               if ((rc = sys_acl_get_permset(entry, &permset))) {
-                       errfun = "sys_acl_get_tag_type";
+               if ((rc = sys_acl_get_info(entry, &tag_type, &access, &g_u_id)) != 0) {
+                       errfun = "sys_acl_get_info";
                        break;
                }
-               access = (sys_acl_get_perm(permset, SMB_ACL_READ) ? 4 : 0)
-                      | (sys_acl_get_perm(permset, SMB_ACL_WRITE) ? 2 : 0)
-                      | (sys_acl_get_perm(permset, SMB_ACL_EXECUTE) ? 1 : 0);
                /* continue == done with entry; break == store in temporary ida list */
                switch (tag_type) {
+#ifndef HAVE_OSX_ACLS
                case SMB_ACL_USER_OBJ:
                        if (racl->user_obj == NO_ENTRY)
                                racl->user_obj = access;
                        else
                                rprintf(FINFO, "unpack_smb_acl: warning: duplicate USER_OBJ entry ignored\n");
                        continue;
-               case SMB_ACL_USER:
-                       break;
                case SMB_ACL_GROUP_OBJ:
                        if (racl->group_obj == NO_ENTRY)
                                racl->group_obj = access;
                        else
                                rprintf(FINFO, "unpack_smb_acl: warning: duplicate GROUP_OBJ entry ignored\n");
                        continue;
-               case SMB_ACL_GROUP:
-                       break;
                case SMB_ACL_MASK:
                        if (racl->mask_obj == NO_ENTRY)
                                racl->mask_obj = access;
@@ -325,38 +295,49 @@ static BOOL unpack_smb_acl(SMB_ACL_T sacl, rsync_acl *racl)
                        else
                                rprintf(FINFO, "unpack_smb_acl: warning: duplicate OTHER entry ignored\n");
                        continue;
+#endif
+               case SMB_ACL_USER:
+                       access |= NAME_IS_USER;
+                       break;
+               case SMB_ACL_GROUP:
+                       break;
                default:
                        rprintf(FINFO, "unpack_smb_acl: warning: entry with unrecognized tag type ignored\n");
                        continue;
                }
-               if (!(qualifier = sys_acl_get_qualifier(entry))) {
-                       errfun = "sys_acl_get_tag_type";
-                       rc = EINVAL;
-                       break;
-               }
-               if (tag_type != prior_list_type) {
-                       if (prior_list_type)
-                               save_idas(racl, prior_list_type, &temp_ida_list);
-                       prior_list_type = tag_type;
-               }
                ida = EXPAND_ITEM_LIST(&temp_ida_list, id_access, -10);
-               ida->id = *((id_t *)qualifier);
+               ida->id = g_u_id;
                ida->access = access;
-               sys_acl_free_qualifier(qualifier, tag_type);
        }
        if (rc) {
-               rsyserr(FERROR, errno, "unpack_smb_acl: %s()", errfun);
+               rsyserr(FERROR_XFER, errno, "unpack_smb_acl: %s()", errfun);
                rsync_acl_free(racl);
                return False;
        }
-       if (prior_list_type)
-               save_idas(racl, prior_list_type, &temp_ida_list);
 
-       sort_ida_entries(&racl->users);
-       sort_ida_entries(&racl->groups);
+       /* Transfer the count id_access items out of the temp_ida_list
+        * into the names ida_entries list in racl. */
+       if (temp_ida_list.count) {
+#ifdef SMB_ACL_NEED_SORT
+               if (temp_ida_list.count > 1) {
+                       qsort(temp_ida_list.items, temp_ida_list.count,
+                             sizeof (id_access), id_access_sorter);
+               }
+#endif
+               if (!(racl->names.idas = new_array(id_access, temp_ida_list.count)))
+                       out_of_memory("unpack_smb_acl");
+               memcpy(racl->names.idas, temp_ida_list.items,
+                      temp_ida_list.count * sizeof (id_access));
+       } else
+               racl->names.idas = NULL;
+
+       racl->names.count = temp_ida_list.count;
+
+       /* Truncate the temporary list now that its idas have been saved. */
+       temp_ida_list.count = 0;
 
 #ifdef ACLS_NEED_MASK
-       if (!racl->users.count && !racl->groups.count && racl->mask_obj != NO_ENTRY) {
+       if (!racl->names.count && racl->mask_obj != NO_ENTRY) {
                /* Throw away a superfluous mask, but mask off the
                 * group perms with it first. */
                racl->group_obj &= racl->mask_obj;
@@ -380,28 +361,17 @@ static BOOL unpack_smb_acl(SMB_ACL_T sacl, rsync_acl *racl)
 #define COE(func,args) CALL_OR_ERROR(func,args,#func)
 #define COE2(func,args) CALL_OR_ERROR(func,args,NULL)
 
+#ifndef HAVE_OSX_ACLS
 /* Store the permissions in the system ACL entry. */
-static int store_access_in_entry(uchar access, SMB_ACL_ENTRY_T entry)
+static int store_access_in_entry(uint32 access, SMB_ACL_ENTRY_T entry)
 {
-       const char *errfun = NULL;
-       SMB_ACL_PERMSET_T permset;
-
-       COE( sys_acl_get_permset,(entry, &permset) );
-       COE( sys_acl_clear_perms,(permset) );
-       if (access & 4)
-               COE( sys_acl_add_perm,(permset, SMB_ACL_READ) );
-       if (access & 2)
-               COE( sys_acl_add_perm,(permset, SMB_ACL_WRITE) );
-       if (access & 1)
-               COE( sys_acl_add_perm,(permset, SMB_ACL_EXECUTE) );
-       COE( sys_acl_set_permset,(entry, permset) );
-
+       if (sys_acl_set_access_bits(entry, access)) {
+               rsyserr(FERROR_XFER, errno, "store_access_in_entry sys_acl_set_access_bits()");
+               return -1;
+       }
        return 0;
-
-  error_exit:
-       rsyserr(FERROR, errno, "store_access_in_entry %s()", errfun);
-       return -1;
 }
+#endif
 
 /* Pack rsync ACL -> system ACL verbatim.  Return whether we succeeded. */
 static BOOL pack_smb_acl(SMB_ACL_T *smb_acl, const rsync_acl *racl)
@@ -415,59 +385,63 @@ static BOOL pack_smb_acl(SMB_ACL_T *smb_acl, const rsync_acl *racl)
        SMB_ACL_ENTRY_T entry;
 
        if (!(*smb_acl = sys_acl_init(calc_sacl_entries(racl)))) {
-               rsyserr(FERROR, errno, "pack_smb_acl: sys_acl_init()");
+               rsyserr(FERROR_XFER, errno, "pack_smb_acl: sys_acl_init()");
                return False;
        }
 
+#ifndef HAVE_OSX_ACLS
        COE( sys_acl_create_entry,(smb_acl, &entry) );
-       COE( sys_acl_set_tag_type,(entry, SMB_ACL_USER_OBJ) );
-       COE2( store_access_in_entry,(racl->user_obj & 7, entry) );
+       COE( sys_acl_set_info,(entry, SMB_ACL_USER_OBJ, racl->user_obj & ~NO_ENTRY, 0) );
+#endif
 
-       for (ida = racl->users.idas, count = racl->users.count; count--; ida++) {
+       for (ida = racl->names.idas, count = racl->names.count; count; ida++, count--) {
+#ifdef SMB_ACL_NEED_SORT
+               if (!(ida->access & NAME_IS_USER))
+                       break;
+#endif
                COE( sys_acl_create_entry,(smb_acl, &entry) );
-               COE( sys_acl_set_tag_type,(entry, SMB_ACL_USER) );
-               COE( sys_acl_set_qualifier,(entry, (void*)&ida->id) );
-               COE2( store_access_in_entry,(ida->access, entry) );
+               COE( sys_acl_set_info,
+                   (entry,
+                    ida->access & NAME_IS_USER ? SMB_ACL_USER : SMB_ACL_GROUP,
+                    ida->access & ~NAME_IS_USER, ida->id) );
        }
 
+#ifndef HAVE_OSX_ACLS
        COE( sys_acl_create_entry,(smb_acl, &entry) );
-       COE( sys_acl_set_tag_type,(entry, SMB_ACL_GROUP_OBJ) );
-       COE2( store_access_in_entry,(racl->group_obj & 7, entry) );
+       COE( sys_acl_set_info,(entry, SMB_ACL_GROUP_OBJ, racl->group_obj & ~NO_ENTRY, 0) );
 
-       for (ida = racl->groups.idas, count = racl->groups.count; count--; ida++) {
+#ifdef SMB_ACL_NEED_SORT
+       for ( ; count; ida++, count--) {
                COE( sys_acl_create_entry,(smb_acl, &entry) );
-               COE( sys_acl_set_tag_type,(entry, SMB_ACL_GROUP) );
-               COE( sys_acl_set_qualifier,(entry, (void*)&ida->id) );
-               COE2( store_access_in_entry,(ida->access, entry) );
+               COE( sys_acl_set_info,(entry, SMB_ACL_GROUP, ida->access, ida->id) );
        }
+#endif
 
 #ifdef ACLS_NEED_MASK
-       mask_bits = racl->mask_obj == NO_ENTRY ? racl->group_obj & 7 : racl->mask_obj;
+       mask_bits = racl->mask_obj == NO_ENTRY ? racl->group_obj & ~NO_ENTRY : racl->mask_obj;
        COE( sys_acl_create_entry,(smb_acl, &entry) );
-       COE( sys_acl_set_tag_type,(entry, SMB_ACL_MASK) );
-       COE2( store_access_in_entry,(mask_bits, entry) );
+       COE( sys_acl_set_info,(entry, SMB_ACL_MASK, mask_bits, NULL) );
 #else
        if (racl->mask_obj != NO_ENTRY) {
                COE( sys_acl_create_entry,(smb_acl, &entry) );
-               COE( sys_acl_set_tag_type,(entry, SMB_ACL_MASK) );
-               COE2( store_access_in_entry,(racl->mask_obj, entry) );
+               COE( sys_acl_set_info,(entry, SMB_ACL_MASK, racl->mask_obj, 0) );
        }
 #endif
 
        COE( sys_acl_create_entry,(smb_acl, &entry) );
-       COE( sys_acl_set_tag_type,(entry, SMB_ACL_OTHER) );
-       COE2( store_access_in_entry,(racl->other_obj & 7, entry) );
+       COE( sys_acl_set_info,(entry, SMB_ACL_OTHER, racl->other_obj & ~NO_ENTRY, 0) );
+#endif
 
 #ifdef DEBUG
        if (sys_acl_valid(*smb_acl) < 0)
-               rprintf(FERROR, "pack_smb_acl: warning: system says the ACL I packed is invalid\n");
+               rprintf(FERROR_XFER, "pack_smb_acl: warning: system says the ACL I packed is invalid\n");
 #endif
 
        return True;
 
   error_exit:
        if (errfun) {
-               rsyserr(FERROR, errno, "pack_smb_acl %s()", errfun);
+               rsyserr(FERROR_XFER, errno, "pack_smb_acl %s()", errfun);
        }
        sys_acl_free_acl(*smb_acl);
        return False;
@@ -500,9 +474,45 @@ static int find_matching_rsync_acl(const rsync_acl *racl, SMB_ACL_TYPE_T type,
 static int get_rsync_acl(const char *fname, rsync_acl *racl,
                         SMB_ACL_TYPE_T type, mode_t mode)
 {
-       SMB_ACL_T sacl = sys_acl_get_file(fname, type);
+       SMB_ACL_T sacl;
+
+#ifdef SUPPORT_XATTRS
+       /* --fake-super support: load ACLs from an xattr. */
+       if (am_root < 0) {
+               char *buf;
+               size_t len;
+               int cnt;
+
+               if ((buf = get_xattr_acl(fname, type == SMB_ACL_TYPE_ACCESS, &len)) == NULL)
+                       return 0;
+               cnt = (len - 4*4) / (4+4);
+               if (len < 4*4 || len != (size_t)cnt*(4+4) + 4*4) {
+                       free(buf);
+                       return -1;
+               }
 
-       if (sacl) {
+               racl->user_obj = IVAL(buf, 0);
+               racl->group_obj = IVAL(buf, 4);
+               racl->mask_obj = IVAL(buf, 8);
+               racl->other_obj = IVAL(buf, 12);
+
+               if (cnt) {
+                       char *bp = buf + 4*4;
+                       id_access *ida;
+                       if (!(ida = racl->names.idas = new_array(id_access, cnt)))
+                               out_of_memory("get_rsync_acl");
+                       racl->names.count = cnt;
+                       for ( ; cnt--; ida++, bp += 4+4) {
+                               ida->id = IVAL(bp, 0);
+                               ida->access = IVAL(bp, 4);
+                       }
+               }
+               free(buf);
+               return 0;
+       }
+#endif
+
+       if ((sacl = sys_acl_get_file(fname, type)) != 0) {
                BOOL ok = unpack_smb_acl(sacl, racl);
 
                sys_acl_free_acl(sacl);
@@ -514,7 +524,7 @@ static int get_rsync_acl(const char *fname, rsync_acl *racl,
                if (type == SMB_ACL_TYPE_ACCESS)
                        rsync_acl_fake_perms(racl, mode);
        } else {
-               rsyserr(FERROR, errno, "get_acl: sys_acl_get_file(%s, %s)",
+               rsyserr(FERROR_XFER, errno, "get_acl: sys_acl_get_file(%s, %s)",
                        fname, str_acl_type(type));
                return -1;
        }
@@ -523,7 +533,7 @@ static int get_rsync_acl(const char *fname, rsync_acl *racl,
 }
 
 /* Return the Access Control List for the given filename. */
-int get_acl(const char *fname, statx *sxp)
+int get_acl(const char *fname, stat_x *sxp)
 {
        sxp->acc_acl = create_racl();
        if (get_rsync_acl(fname, sxp->acc_acl, SMB_ACL_TYPE_ACCESS,
@@ -546,31 +556,30 @@ int get_acl(const char *fname, statx *sxp)
 
 /* === Send functions === */
 
-/* The general strategy with the tag_type <-> character mapping is that
- * lowercase implies that no qualifier follows, where uppercase does.
- * A similar idiom for the ACL type (access or default) itself, but
- * lowercase in this instance means there's no ACL following, so the
- * ACL is a repeat, so the receiver should reuse the last of the same
- * type ACL. */
-
 /* Send the ida list over the file descriptor. */
-static void send_ida_entries(const ida_entries *idal, int user_names, int f)
+static void send_ida_entries(const ida_entries *idal, int f)
 {
        id_access *ida;
        size_t count = idal->count;
 
-       write_abbrevint(f, idal->count);
+       write_varint(f, idal->count);
 
        for (ida = idal->idas; count--; ida++) {
-               char *name = user_names ? add_uid(ida->id) : add_gid(ida->id);
-               write_abbrevint(f, ida->id);
+               uint32 xbits = ida->access << 2;
+               const char *name;
+               if (ida->access & NAME_IS_USER) {
+                       xbits |= XFLAG_NAME_IS_USER;
+                       name = add_uid(ida->id);
+               } else
+                       name = add_gid(ida->id);
+               write_varint(f, ida->id);
                if (inc_recurse && name) {
                        int len = strlen(name);
-                       write_byte(f, ida->access | (uchar)0x80);
+                       write_varint(f, xbits | XFLAG_NAME_FOLLOWS);
                        write_byte(f, len);
                        write_buf(f, name, len);
                } else
-                       write_byte(f, ida->access);
+                       write_varint(f, xbits);
        }
 }
 
@@ -580,7 +589,7 @@ static void send_rsync_acl(rsync_acl *racl, SMB_ACL_TYPE_T type,
        int ndx = find_matching_rsync_acl(racl, type, racl_list);
 
        /* Send 0 (-1 + 1) to indicate that literal ACL data follows. */
-       write_abbrevint(f, ndx + 1);
+       write_varint(f, ndx + 1);
 
        if (ndx < 0) {
                rsync_acl *new_racl = EXPAND_ITEM_LIST(racl_list, rsync_acl, 1000);
@@ -588,37 +597,27 @@ static void send_rsync_acl(rsync_acl *racl, SMB_ACL_TYPE_T type,
 
                if (racl->user_obj != NO_ENTRY)
                        flags |= XMIT_USER_OBJ;
-               if (racl->users.count)
-                       flags |= XMIT_USER_LIST;
-
                if (racl->group_obj != NO_ENTRY)
                        flags |= XMIT_GROUP_OBJ;
-               if (racl->groups.count)
-                       flags |= XMIT_GROUP_LIST;
-
                if (racl->mask_obj != NO_ENTRY)
                        flags |= XMIT_MASK_OBJ;
-
                if (racl->other_obj != NO_ENTRY)
                        flags |= XMIT_OTHER_OBJ;
+               if (racl->names.count)
+                       flags |= XMIT_NAME_LIST;
 
                write_byte(f, flags);
 
                if (flags & XMIT_USER_OBJ)
-                       write_byte(f, racl->user_obj);
-               if (flags & XMIT_USER_LIST)
-                       send_ida_entries(&racl->users, 1, f);
-
+                       write_varint(f, racl->user_obj);
                if (flags & XMIT_GROUP_OBJ)
-                       write_byte(f, racl->group_obj);
-               if (flags & XMIT_GROUP_LIST)
-                       send_ida_entries(&racl->groups, 0, f);
-
+                       write_varint(f, racl->group_obj);
                if (flags & XMIT_MASK_OBJ)
-                       write_byte(f, racl->mask_obj);
-
+                       write_varint(f, racl->mask_obj);
                if (flags & XMIT_OTHER_OBJ)
-                       write_byte(f, racl->other_obj);
+                       write_varint(f, racl->other_obj);
+               if (flags & XMIT_NAME_LIST)
+                       send_ida_entries(&racl->names, f);
 
                /* Give the allocated data to the new list object. */
                *new_racl = *racl;
@@ -626,9 +625,9 @@ static void send_rsync_acl(rsync_acl *racl, SMB_ACL_TYPE_T type,
        }
 }
 
-/* Send the ACL from the statx structure down the indicated file descriptor.
+/* Send the ACL from the stat_x structure down the indicated file descriptor.
  * This also frees the ACL data. */
-void send_acl(statx *sxp, int f)
+void send_acl(stat_x *sxp, int f)
 {
        if (!sxp->acc_acl) {
                sxp->acc_acl = create_racl();
@@ -649,33 +648,38 @@ void send_acl(statx *sxp, int f)
 
 /* === Receive functions === */
 
-static uchar recv_acl_access(uchar *name_follows_val, int f)
+static uint32 recv_acl_access(uchar *name_follows_ptr, int f)
 {
-       uchar access = read_byte(f);
-
-       if (name_follows_val) {
-               if (access & (uchar)0x80) {
-                       access &= ~(uchar)0x80;
-                       *name_follows_val = 1;
-               } else
-                       *name_follows_val = 0;
-       }
-
-       if (access & ~(4 | 2 | 1)) {
-               rprintf(FERROR, "recv_acl_access: bogus permset %o\n", access);
+       uint32 access = read_varint(f);
+
+       if (name_follows_ptr) {
+               int flags = access & 3;
+               access >>= 2;
+               if (am_root >= 0 && access & ~SMB_ACL_VALID_NAME_BITS)
+                       goto value_error;
+               if (flags & XFLAG_NAME_FOLLOWS)
+                       *name_follows_ptr = 1;
+               else
+                       *name_follows_ptr = 0;
+               if (flags & XFLAG_NAME_IS_USER)
+                       access |= NAME_IS_USER;
+       } else if (am_root >= 0 && access & ~SMB_ACL_VALID_OBJ_BITS) {
+         value_error:
+               rprintf(FERROR_XFER, "recv_acl_access: value out of range: %x\n",
+                       access);
                exit_cleanup(RERR_STREAMIO);
        }
 
        return access;
 }
 
-static uchar recv_ida_entries(ida_entries *ent, int user_names, int f)
+static uchar recv_ida_entries(ida_entries *ent, int f)
 {
        uchar computed_mask_bits = 0;
-       int i, count = read_abbrevint(f);
+       int i, count = read_varint(f);
 
        if (count) {
-               if (!(ent->idas = new_array(id_access, ent->count)))
+               if (!(ent->idas = new_array(id_access, count)))
                        out_of_memory("recv_ida_entries");
        } else
                ent->idas = NULL;
@@ -684,20 +688,20 @@ static uchar recv_ida_entries(ida_entries *ent, int user_names, int f)
 
        for (i = 0; i < count; i++) {
                uchar has_name;
-               id_t id = read_abbrevint(f);
-               int access = recv_acl_access(&has_name, f);
+               id_t id = read_varint(f);
+               uint32 access = recv_acl_access(&has_name, f);
 
                if (has_name) {
-                       if (user_names)
+                       if (access & NAME_IS_USER)
                                id = recv_user_name(f, id);
                        else
-                               id = recv_group_name(f, id);
-               } else if (user_names) {
+                               id = recv_group_name(f, id, NULL);
+               } else if (access & NAME_IS_USER) {
                        if (inc_recurse && am_root && !numeric_ids)
                                id = match_uid(id);
                } else {
                        if (inc_recurse && (!am_root || !numeric_ids))
-                               id = match_gid(id);
+                               id = match_gid(id, NULL);
                }
 
                ent->idas[i].id = id;
@@ -705,7 +709,7 @@ static uchar recv_ida_entries(ida_entries *ent, int user_names, int f)
                computed_mask_bits |= access;
        }
 
-       return computed_mask_bits;
+       return computed_mask_bits & ~NO_ENTRY;
 }
 
 static int recv_rsync_acl(item_list *racl_list, SMB_ACL_TYPE_T type, int f)
@@ -713,10 +717,10 @@ static int recv_rsync_acl(item_list *racl_list, SMB_ACL_TYPE_T type, int f)
        uchar computed_mask_bits = 0;
        acl_duo *duo_item;
        uchar flags;
-       int ndx = read_abbrevint(f);
+       int ndx = read_varint(f);
 
        if (ndx < 0 || (size_t)ndx > racl_list->count) {
-               rprintf(FERROR, "recv_acl_index: %s ACL index %d > %d\n",
+               rprintf(FERROR_XFER, "recv_acl_index: %s ACL index %d > %d\n",
                        str_acl_type(type), ndx, (int)racl_list->count);
                exit_cleanup(RERR_STREAMIO);
        }
@@ -732,23 +736,20 @@ static int recv_rsync_acl(item_list *racl_list, SMB_ACL_TYPE_T type, int f)
 
        if (flags & XMIT_USER_OBJ)
                duo_item->racl.user_obj = recv_acl_access(NULL, f);
-
-       if (flags & XMIT_USER_LIST)
-               computed_mask_bits |= recv_ida_entries(&duo_item->racl.users, 1, f);
-
        if (flags & XMIT_GROUP_OBJ)
                duo_item->racl.group_obj = recv_acl_access(NULL, f);
-
-       if (flags & XMIT_GROUP_LIST)
-               computed_mask_bits |= recv_ida_entries(&duo_item->racl.groups, 0, f);
-
        if (flags & XMIT_MASK_OBJ)
                duo_item->racl.mask_obj = recv_acl_access(NULL, f);
-
        if (flags & XMIT_OTHER_OBJ)
                duo_item->racl.other_obj = recv_acl_access(NULL, f);
+       if (flags & XMIT_NAME_LIST)
+               computed_mask_bits |= recv_ida_entries(&duo_item->racl.names, f);
 
-       if (!duo_item->racl.users.count && !duo_item->racl.groups.count) {
+#ifdef HAVE_OSX_ACLS
+       /* If we received a superfluous mask, throw it away. */
+       duo_item->racl.mask_obj = NO_ENTRY;
+#else
+       if (!duo_item->racl.names.count) {
                /* If we received a superfluous mask, throw it away. */
                if (duo_item->racl.mask_obj != NO_ENTRY) {
                        /* Mask off the group perms with it first. */
@@ -756,7 +757,8 @@ static int recv_rsync_acl(item_list *racl_list, SMB_ACL_TYPE_T type, int f)
                        duo_item->racl.mask_obj = NO_ENTRY;
                }
        } else if (duo_item->racl.mask_obj == NO_ENTRY) /* Must be non-empty with lists. */
-               duo_item->racl.mask_obj = computed_mask_bits | (duo_item->racl.group_obj & 7);
+               duo_item->racl.mask_obj = (computed_mask_bits | duo_item->racl.group_obj) & ~NO_ENTRY;
+#endif
 
        duo_item->sacl = NULL;
 
@@ -769,7 +771,7 @@ void receive_acl(struct file_struct *file, int f)
        F_ACL(file) = recv_rsync_acl(&access_acl_list, SMB_ACL_TYPE_ACCESS, f);
 
        if (S_ISDIR(file->mode))
-               F_DEF_ACL(file) = recv_rsync_acl(&default_acl_list, SMB_ACL_TYPE_DEFAULT, f);
+               F_DIR_DEFACL(file) = recv_rsync_acl(&default_acl_list, SMB_ACL_TYPE_DEFAULT, f);
 }
 
 static int cache_rsync_acl(rsync_acl *racl, SMB_ACL_TYPE_T type, item_list *racl_list)
@@ -790,19 +792,20 @@ static int cache_rsync_acl(rsync_acl *racl, SMB_ACL_TYPE_T type, item_list *racl
        return ndx;
 }
 
-/* Turn the ACL data in statx into cached ACL data, setting the index
+/* Turn the ACL data in stat_x into cached ACL data, setting the index
  * values in the file struct. */
-void cache_acl(struct file_struct *file, statx *sxp)
+void cache_acl(struct file_struct *file, stat_x *sxp)
 {
        F_ACL(file) = cache_rsync_acl(sxp->acc_acl,
                                      SMB_ACL_TYPE_ACCESS, &access_acl_list);
 
        if (S_ISDIR(sxp->st.st_mode)) {
-               F_DEF_ACL(file) = cache_rsync_acl(sxp->def_acl,
+               F_DIR_DEFACL(file) = cache_rsync_acl(sxp->def_acl,
                                      SMB_ACL_TYPE_DEFAULT, &default_acl_list);
        }
 }
 
+#ifndef HAVE_OSX_ACLS
 static mode_t change_sacl_perms(SMB_ACL_T sacl, rsync_acl *racl, mode_t old_mode, mode_t mode)
 {
        SMB_ACL_ENTRY_T entry;
@@ -832,7 +835,7 @@ static mode_t change_sacl_perms(SMB_ACL_T sacl, rsync_acl *racl, mode_t old_mode
             rc == 1;
             rc = sys_acl_get_entry(sacl, SMB_ACL_NEXT_ENTRY, &entry)) {
                SMB_ACL_TAG_T tag_type;
-               if ((rc = sys_acl_get_tag_type(entry, &tag_type))) {
+               if ((rc = sys_acl_get_tag_type(entry, &tag_type)) != 0) {
                        errfun = "sys_acl_get_tag_type";
                        break;
                }
@@ -862,7 +865,7 @@ static mode_t change_sacl_perms(SMB_ACL_T sacl, rsync_acl *racl, mode_t old_mode
        if (rc) {
          error_exit:
                if (errfun) {
-                       rsyserr(FERROR, errno, "change_sacl_perms: %s()",
+                       rsyserr(FERROR_XFER, errno, "change_sacl_perms: %s()",
                                errfun);
                }
                return (mode_t)~0;
@@ -878,31 +881,69 @@ static mode_t change_sacl_perms(SMB_ACL_T sacl, rsync_acl *racl, mode_t old_mode
        /* Return the mode of the file on disk, as we will set them. */
        return (old_mode & ~ACCESSPERMS) | (mode & ACCESSPERMS);
 }
+#endif
 
 static int set_rsync_acl(const char *fname, acl_duo *duo_item,
-                        SMB_ACL_TYPE_T type, statx *sxp, mode_t mode)
+                        SMB_ACL_TYPE_T type, stat_x *sxp, mode_t mode)
 {
        if (type == SMB_ACL_TYPE_DEFAULT
         && duo_item->racl.user_obj == NO_ENTRY) {
-               if (sys_acl_delete_def_file(fname) < 0) {
-                       rsyserr(FERROR, errno, "set_acl: sys_acl_delete_def_file(%s)",
+               int rc;
+#ifdef SUPPORT_XATTRS
+               /* --fake-super support: delete default ACL from xattrs. */
+               if (am_root < 0)
+                       rc = del_def_xattr_acl(fname);
+               else
+#endif
+                       rc = sys_acl_delete_def_file(fname);
+               if (rc < 0) {
+                       rsyserr(FERROR_XFER, errno, "set_acl: sys_acl_delete_def_file(%s)",
                                fname);
                        return -1;
                }
+#ifdef SUPPORT_XATTRS
+       } else if (am_root < 0) {
+               /* --fake-super support: store ACLs in an xattr. */
+               int cnt = duo_item->racl.names.count;
+               size_t len = 4*4 + cnt * (4+4);
+               char *buf = new_array(char, len);
+               int rc;
+
+               SIVAL(buf, 0, duo_item->racl.user_obj);
+               SIVAL(buf, 4, duo_item->racl.group_obj);
+               SIVAL(buf, 8, duo_item->racl.mask_obj);
+               SIVAL(buf, 12, duo_item->racl.other_obj);
+
+               if (cnt) {
+                       char *bp = buf + 4*4;
+                       id_access *ida = duo_item->racl.names.idas;
+                       for ( ; cnt--; ida++, bp += 4+4) {
+                               SIVAL(bp, 0, ida->id);
+                               SIVAL(bp, 4, ida->access);
+                       }
+               }
+               rc = set_xattr_acl(fname, type == SMB_ACL_TYPE_ACCESS, buf, len);
+               free(buf);
+               return rc;
+#endif
        } else {
                mode_t cur_mode = sxp->st.st_mode;
                if (!duo_item->sacl
                 && !pack_smb_acl(&duo_item->sacl, &duo_item->racl))
                        return -1;
+#ifdef HAVE_OSX_ACLS
+               mode = 0; /* eliminate compiler warning */
+#else
                if (type == SMB_ACL_TYPE_ACCESS) {
                        cur_mode = change_sacl_perms(duo_item->sacl, &duo_item->racl,
                                                     cur_mode, mode);
                        if (cur_mode == (mode_t)~0)
                                return 0;
                }
+#endif
                if (sys_acl_set_file(fname, type, duo_item->sacl) < 0) {
-                       rsyserr(FERROR, errno, "set_acl: sys_acl_set_file(%s, %s)",
-                       fname, str_acl_type(type));
+                       rsyserr(FERROR_XFER, errno, "set_acl: sys_acl_set_file(%s, %s)",
+                               fname, str_acl_type(type));
                        return -1;
                }
                if (type == SMB_ACL_TYPE_ACCESS)
@@ -920,7 +961,7 @@ static int set_rsync_acl(const char *fname, acl_duo *duo_item,
  *
  * Returns 1 for unchanged, 0 for changed, -1 for failed.  Call this
  * with fname set to NULL to just check if the ACL is unchanged. */
-int set_acl(const char *fname, const struct file_struct *file, statx *sxp)
+int set_acl(const char *fname, const struct file_struct *file, stat_x *sxp)
 {
        int unchanged = 1;
        int32 ndx;
@@ -949,7 +990,7 @@ int set_acl(const char *fname, const struct file_struct *file, statx *sxp)
        if (!S_ISDIR(sxp->st.st_mode))
                return unchanged;
 
-       ndx = F_DEF_ACL(file);
+       ndx = F_DIR_DEFACL(file);
        if (ndx >= 0 && (size_t)ndx < default_acl_list.count) {
                acl_duo *duo_item = default_acl_list.items;
                duo_item += ndx;
@@ -967,22 +1008,20 @@ int set_acl(const char *fname, const struct file_struct *file, statx *sxp)
        return unchanged;
 }
 
-/* Non-incremental recursion needs to convert all the received IDs
- * in a single pass after the file-list is complete. */
+/* Non-incremental recursion needs to convert all the received IDs.
+ * This is done in a single pass after receiving the whole file-list. */
 static void match_racl_ids(const item_list *racl_list)
 {
        int list_cnt, name_cnt;
        acl_duo *duo_item = racl_list->items;
        for (list_cnt = racl_list->count; list_cnt--; duo_item++) {
-               ida_entries *idal = &duo_item->racl.users;
-               for (name_cnt = idal->count; name_cnt--; idal++) {
-                       id_access *ida = idal->idas;
-                       ida->id = match_uid(ida->id);
-               }
-               idal = &duo_item->racl.groups;
-               for (name_cnt = idal->count; name_cnt--; idal++) {
-                       id_access *ida = idal->idas;
-                       ida->id = match_gid(ida->id);
+               ida_entries *idal = &duo_item->racl.names;
+               id_access *ida = idal->idas;
+               for (name_cnt = idal->count; name_cnt--; ida++) {
+                       if (ida->access & NAME_IS_USER)
+                               ida->id = match_uid(ida->id);
+                       else
+                               ida->id = match_gid(ida->id, NULL);
                }
        }
 }
@@ -1023,7 +1062,8 @@ int default_perms_for_dir(const char *dir)
                        }
                        /* Otherwise fall through. */
                default:
-                       rprintf(FERROR, "default_perms_for_dir: sys_acl_get_file(%s, %s): %s, falling back on umask\n",
+                       rprintf(FWARNING,
+                               "default_perms_for_dir: sys_acl_get_file(%s, %s): %s, falling back on umask\n",
                                dir, str_acl_type(SMB_ACL_TYPE_DEFAULT), strerror(errno));
                }
                return perms;
@@ -1034,7 +1074,7 @@ int default_perms_for_dir(const char *dir)
        ok = unpack_smb_acl(sacl, &racl);
        sys_acl_free_acl(sacl);
        if (!ok) {
-               rprintf(FERROR, "default_perms_for_dir: unpack_smb_acl failed, falling back on umask\n");
+               rprintf(FWARNING, "default_perms_for_dir: unpack_smb_acl failed, falling back on umask\n");
                return perms;
        }