acls.c

説明を見る。

/* -*- c-file-style: "linux" -*-
   Copyright (C) Andrew Tridgell 1996
   Copyright (C) Paul Mackerras 1996
   Copyright (C) Matt McCutchen 2006
   Copyright (C) Wayne Davison 2006

   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.
*/

/* handle passing ACLs between systems */

#include "rsync.h"
#include "lib/sysacls.h"

#ifdef SUPPORT_ACLS

extern int am_root;
extern int dry_run;
extern int orig_umask;
extern int preserve_acls;

typedef struct {
        id_t id;
        uchar access;
} id_access;

typedef struct {
        size_t count;
        size_t malloced;
        id_access *idas;
} ida_list;

#define ACL_NO_ENTRY ((uchar)0x80)
typedef struct {
        ida_list users;
        ida_list groups;
        /* These will be ACL_NO_ENTRY if there's no such entry. */
        uchar user_obj;
        uchar group_obj;
        uchar mask;
        uchar other;
} rsync_acl;

static const rsync_acl rsync_acl_initializer = {
        {0, 0, NULL}, {0, 0, NULL},
        ACL_NO_ENTRY, ACL_NO_ENTRY, ACL_NO_ENTRY, ACL_NO_ENTRY
};

#define OTHER_TYPE(t) (SMB_ACL_TYPE_ACCESS+SMB_ACL_TYPE_DEFAULT-(t))
#define BUMP_TYPE(t) ((t = OTHER_TYPE(t)) == SMB_ACL_TYPE_DEFAULT)

/* a few useful calculations */

static int count_racl_entries(const rsync_acl *racl)
{
        return racl->users.count + racl->groups.count
             + (racl->user_obj != ACL_NO_ENTRY)
             + (racl->group_obj != ACL_NO_ENTRY)
             + (racl->mask != ACL_NO_ENTRY)
             + (racl->other != ACL_NO_ENTRY);
}

static int calc_sacl_entries(const rsync_acl *racl)
{
        return racl->users.count + racl->groups.count
#ifdef ACLS_NEED_MASK
             + 4;
#else
             + (racl->mask != ACL_NO_ENTRY) + 3;
#endif
}

static int rsync_acl_get_perms(const rsync_acl *racl)
{
        /* Note that (ACL_NO_ENTRY & 7) is 0. */
        return ((racl->user_obj & 7) << 6)
             + (((racl->mask != ACL_NO_ENTRY ? racl->mask : racl->group_obj) & 7) << 3)
             + (racl->other & 7);
}

static void rsync_acl_strip_perms(rsync_acl *racl)
{
        racl->user_obj = ACL_NO_ENTRY;
        if (racl->mask == ACL_NO_ENTRY)
                racl->group_obj = ACL_NO_ENTRY;
        else
                racl->mask = ACL_NO_ENTRY;
        racl->other = ACL_NO_ENTRY;
}

static void expand_ida_list(ida_list *idal)
{
        /* First time through, 0 <= 0, so list is expanded. */
        if (idal->malloced <= idal->count) {
                id_access *new_ptr;
                size_t new_size = idal->malloced + 10;
                new_ptr = realloc_array(idal->idas, id_access, new_size);
                if (verbose >= 4) {
                        rprintf(FINFO, "expand rsync_acl to %.0f bytes, did%s move\n",
                                (double) new_size * sizeof idal->idas[0],
                                idal->idas ? "" : " not");
                }

                idal->idas = new_ptr;
                idal->malloced = new_size;

                if (!idal->idas)
                        out_of_memory("expand_ida_list");
        }
}

static void ida_list_free(ida_list *idal)
{
        free(idal->idas);
        idal->idas = NULL;
        idal->count = 0;
        idal->malloced = 0;
}

static void rsync_acl_free(rsync_acl *racl)
{
        ida_list_free(&racl->users);
        ida_list_free(&racl->groups);
}

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;
        return rid1 == rid2 ? 0 : rid1 < rid2 ? -1 : 1;
}

static void sort_ida_list(ida_list *idal)
{
        if (!idal->count)
                return;
        qsort((void **)idal->idas, idal->count, sizeof idal->idas[0],
              &id_access_sorter);
}

static BOOL unpack_smb_acl(rsync_acl *racl, SMB_ACL_T sacl)
{
        SMB_ACL_ENTRY_T entry;
        const char *errfun;
        int rc;

        *racl = rsync_acl_initializer;
        errfun = "sys_acl_get_entry";
        for (rc = sys_acl_get_entry(sacl, SMB_ACL_FIRST_ENTRY, &entry);
             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;
                id_access *ida;
                ida_list *idal;
                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";
                        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 given idal */
                switch (tag_type) {
                case SMB_ACL_USER_OBJ:
                        if (racl->user_obj == ACL_NO_ENTRY)
                                racl->user_obj = access;
                        else
                                rprintf(FINFO, "unpack_smb_acl: warning: duplicate USER_OBJ entry ignored\n");
                        continue;
                case SMB_ACL_USER:
                        idal = &racl->users;
                        break;
                case SMB_ACL_GROUP_OBJ:
                        if (racl->group_obj == ACL_NO_ENTRY)
                                racl->group_obj = access;
                        else
                                rprintf(FINFO, "unpack_smb_acl: warning: duplicate GROUP_OBJ entry ignored\n");
                        continue;
                case SMB_ACL_GROUP:
                        idal = &racl->groups;
                        break;
                case SMB_ACL_MASK:
                        if (racl->mask == ACL_NO_ENTRY)
                                racl->mask = access;
                        else
                                rprintf(FINFO, "unpack_smb_acl: warning: duplicate MASK entry ignored\n");
                        continue;
                case SMB_ACL_OTHER:
                        if (racl->other == ACL_NO_ENTRY)
                                racl->other = access;
                        else
                                rprintf(FINFO, "unpack_smb_acl: warning: duplicate OTHER entry ignored\n");
                        continue;
                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;
                }
                expand_ida_list(idal);
                ida = &idal->idas[idal->count++];
                ida->id = *((id_t *)qualifier);
                ida->access = access;
                sys_acl_free_qualifier(qualifier, tag_type);
        }
        if (rc) {
                rprintf(FERROR, "unpack_smb_acl: %s(): %s\n",
                        errfun, strerror(errno));
                rsync_acl_free(racl);
                return False;
        }

        sort_ida_list(&racl->users);
        sort_ida_list(&racl->groups);

        return True;
}

static BOOL ida_lists_equal(const ida_list *ial1, const ida_list *ial2)
{
        id_access *ida1, *ida2;
        size_t count = ial1->count;
        if (count != ial2->count)
                return False;
        ida1 = ial1->idas;
        ida2 = ial2->idas;
        for (; count--; ida1++, ida2++) {
                if (ida1->access != ida2->access || ida1->id != ida2->id)
                        return False;
        }
        return True;
}

static BOOL rsync_acls_equal(const rsync_acl *racl1, const rsync_acl *racl2)
{
        return (racl1->user_obj == racl2->user_obj
             && racl1->group_obj == racl2->group_obj
             && racl1->mask == racl2->mask
             && racl1->other == racl2->other
             && ida_lists_equal(&racl1->users, &racl2->users)
             && ida_lists_equal(&racl1->groups, &racl2->groups));
}

static BOOL rsync_acl_extended_parts_equal(const rsync_acl *racl1, const rsync_acl *racl2)
{
        /* We ignore any differences that chmod() can take care of. */
        if ((racl1->mask ^ racl2->mask) & ACL_NO_ENTRY)
                return False;
        if (racl1->mask != ACL_NO_ENTRY && racl1->group_obj != racl2->group_obj)
                return False;
        return ida_lists_equal(&racl1->users, &racl2->users)
            && ida_lists_equal(&racl1->groups, &racl2->groups);
}

typedef struct {
        size_t count;
        size_t malloced;
        rsync_acl *racls;
} rsync_acl_list;

static rsync_acl_list _rsync_acl_lists[] = {
        { 0, 0, NULL }, /* SMB_ACL_TYPE_ACCESS */
        { 0, 0, NULL }  /* SMB_ACL_TYPE_DEFAULT */
};

static inline rsync_acl_list *rsync_acl_lists(SMB_ACL_TYPE_T type)
{
        return &_rsync_acl_lists[type != SMB_ACL_TYPE_ACCESS];
}

static void expand_rsync_acl_list(rsync_acl_list *racl_list)
{
        /* First time through, 0 <= 0, so list is expanded. */
        if (racl_list->malloced <= racl_list->count) {
                rsync_acl *new_ptr;
                size_t new_size;
                if (racl_list->malloced < 1000)
                        new_size = racl_list->malloced + 1000;
                else
                        new_size = racl_list->malloced * 2;
                new_ptr = realloc_array(racl_list->racls, rsync_acl, new_size);
                if (verbose >= 3) {
                        rprintf(FINFO, "expand_rsync_acl_list to %.0f bytes, did%s move\n",
                                (double) new_size * sizeof racl_list->racls[0],
                                racl_list->racls ? "" : " not");
                }

                racl_list->racls = new_ptr;
                racl_list->malloced = new_size;

                if (!racl_list->racls)
                        out_of_memory("expand_rsync_acl_list");
        }
}

static int find_matching_rsync_acl(SMB_ACL_TYPE_T type,
                                   const rsync_acl_list *racl_list,
                                   const rsync_acl *racl)
{
        static int access_match = -1, default_match = -1;
        int *match = type == SMB_ACL_TYPE_ACCESS ? &access_match : &default_match;
        size_t count = racl_list->count;

        /* If this is the first time through or we didn't match the last
         * time, then start at the end of the list, which should be the
         * best place to start hunting. */
        if (*match == -1)
                *match = racl_list->count - 1;
        while (count--) {
                if (rsync_acls_equal(&racl_list->racls[*match], racl))
                        return *match;
                if (!(*match)--)
                        *match = racl_list->count - 1;
        }

        *match = -1;
        return *match;
}

/* 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. */
static void send_ida_list(int f, const ida_list *idal, char tag_char)
{
        id_access *ida;
        size_t count = idal->count;
        for (ida = idal->idas; count--; ida++) {
                write_byte(f, tag_char);
                write_byte(f, ida->access);
                write_int(f, ida->id);
                /* FIXME: sorta wasteful: we should maybe buffer as
                 * many ids as max(ACL_USER + ACL_GROUP) objects to
                 * keep from making so many calls. */
                if (tag_char == 'U')
                        add_uid(ida->id);
                else
                        add_gid(ida->id);
        }
}

static void send_rsync_acl(int f, const rsync_acl *racl)
{
        size_t count = count_racl_entries(racl);
        write_int(f, count);
        if (racl->user_obj != ACL_NO_ENTRY) {
                write_byte(f, 'u');
                write_byte(f, racl->user_obj);
        }
        send_ida_list(f, &racl->users, 'U');
        if (racl->group_obj != ACL_NO_ENTRY) {
                write_byte(f, 'g');
                write_byte(f, racl->group_obj);
        }
        send_ida_list(f, &racl->groups, 'G');
        if (racl->mask != ACL_NO_ENTRY) {
                write_byte(f, 'm');
                write_byte(f, racl->mask);
        }
        if (racl->other != ACL_NO_ENTRY) {
                write_byte(f, 'o');
                write_byte(f, racl->other);
        }
}

static rsync_acl _curr_rsync_acls[2];

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";
}

/* Generate the ACL(s) for this flist entry;
 * ACL(s) are either sent or cleaned-up by send_acl() below. */
int make_acl(const struct file_struct *file, const char *fname)
{
        SMB_ACL_TYPE_T type;
        rsync_acl *curr_racl;

        if (S_ISLNK(file->mode))
                return 1;

        curr_racl = &_curr_rsync_acls[0];
        type = SMB_ACL_TYPE_ACCESS;
        do {
                SMB_ACL_T sacl;
                BOOL ok;
                if ((sacl = sys_acl_get_file(fname, type)) != 0) {
                        ok = unpack_smb_acl(curr_racl, sacl);
                        sys_acl_free_acl(sacl);
                        if (!ok)
                                return -1;
                        /* Avoid sending a redundant group/mask value. */
                        if (curr_racl->group_obj == curr_racl->mask
                         && (preserve_acls == 1
                          || (!curr_racl->users.count
                           && !curr_racl->groups.count)))
                                curr_racl->mask = ACL_NO_ENTRY;
                        /* Strip access ACLs of permission-bit entries. */
                        if (type == SMB_ACL_TYPE_ACCESS && preserve_acls == 1)
                                rsync_acl_strip_perms(curr_racl);
                } else if (errno == ENOTSUP) {
                        /* ACLs are not supported. Leave list empty. */
                        *curr_racl = rsync_acl_initializer;
                } else {
                        rprintf(FERROR, "send_acl: sys_acl_get_file(%s, %s): %s\n",
                                fname, str_acl_type(type), strerror(errno));
                        return -1;
                }
                curr_racl++;
        } while (BUMP_TYPE(type) && S_ISDIR(file->mode));

        return 0;
}

/* Send the make_acl()-generated ACLs for this flist entry,
 * or clean up after an flist entry that's not being sent (f == -1). */
void send_acl(const struct file_struct *file, int f)
{
        SMB_ACL_TYPE_T type;
        rsync_acl *curr_racl;

        if (S_ISLNK(file->mode))
                return;

        curr_racl = &_curr_rsync_acls[0];
        type = SMB_ACL_TYPE_ACCESS;
        do {
                int index;
                rsync_acl_list *racl_list = rsync_acl_lists(type);
                if (f == -1) {
                        rsync_acl_free(curr_racl);
                        continue;
                }
                if ((index = find_matching_rsync_acl(type, racl_list, curr_racl))
                    != -1) {
                        write_byte(f, type == SMB_ACL_TYPE_ACCESS ? 'a' : 'd');
                        write_int(f, index);
                        rsync_acl_free(curr_racl);
                } else {
                        write_byte(f, type == SMB_ACL_TYPE_ACCESS ? 'A' : 'D');
                        send_rsync_acl(f, curr_racl);
                        expand_rsync_acl_list(racl_list);
                        racl_list->racls[racl_list->count++] = *curr_racl;
                }
                curr_racl++;
        } while (BUMP_TYPE(type) && S_ISDIR(file->mode));
}

/* The below stuff is only used by the receiver: */

/* structure to hold index to rsync_acl_list member corresponding to
 * flist->files[i] */

typedef struct {
        const struct file_struct *file;
        int aclidx;
} file_acl_index;

typedef struct {
        size_t count;
        size_t malloced;
        file_acl_index *fais;
} file_acl_index_list;

static file_acl_index_list _file_acl_index_lists[] = {
        {0, 0, NULL }, /* SMB_ACL_TYPE_ACCESS */
        {0, 0, NULL }  /* SMB_ACL_TYPE_DEFAULT */
};

static inline file_acl_index_list *file_acl_index_lists(SMB_ACL_TYPE_T type)
{
        return &_file_acl_index_lists[type != SMB_ACL_TYPE_ACCESS];
}

static void expand_file_acl_index_list(file_acl_index_list *flst)
{
        /* First time through, 0 <= 0, so list is expanded. */
        if (flst->malloced <= flst->count) {
                file_acl_index *new_ptr;
                size_t new_size;

                if (flst->malloced < 1000)
                        new_size = flst->malloced + 1000;
                else
                        new_size = flst->malloced * 2;
                new_ptr = realloc_array(flst->fais, file_acl_index, new_size);
                if (verbose >= 3) {
                        rprintf(FINFO, "expand_file_acl_index_list to %.0f bytes, did%s move\n",
                                (double) new_size * sizeof flst->fais[0],
                                flst->fais ? "" : " not");
                }

                flst->fais = new_ptr;
                flst->malloced = new_size;

                if (!flst->fais)
                        out_of_memory("expand_file_acl_index_list");
        }
}

/* lists to hold the SMB_ACL_Ts corresponding to the rsync_acl_list entries */

typedef struct {
        size_t count;
        size_t malloced;
        SMB_ACL_T *sacls;
} smb_acl_list;

static smb_acl_list _smb_acl_lists[] = {
        { 0, 0, NULL }, /* SMB_ACL_TYPE_ACCESS */
        { 0, 0, NULL }  /* SMB_ACL_TYPE_DEFAULT */
};

static inline smb_acl_list *smb_acl_lists(SMB_ACL_TYPE_T type)
{
        return &_smb_acl_lists[type != SMB_ACL_TYPE_ACCESS];
}

static void expand_smb_acl_list(smb_acl_list *sacl_list)
{
        /* First time through, 0 <= 0, so list is expanded. */
        if (sacl_list->malloced <= sacl_list->count) {
                SMB_ACL_T *new_ptr;
                size_t new_size;
                if (sacl_list->malloced < 1000)
                        new_size = sacl_list->malloced + 1000;
                else
                        new_size = sacl_list->malloced * 2;
                new_ptr = realloc_array(sacl_list->sacls, SMB_ACL_T, new_size);
                if (verbose >= 3) {
                        rprintf(FINFO, "expand_smb_acl_list to %.0f bytes, did%s move\n",
                                (double) new_size * sizeof sacl_list->sacls[0],
                                sacl_list->sacls ? "" : " not");
                }

                sacl_list->sacls = new_ptr;
                sacl_list->malloced = new_size;

                if (!sacl_list->sacls)
                        out_of_memory("expand_smb_acl_list");
        }
}

#define CALL_OR_ERROR(func,args,str) \
        do { \
                if (func args) { \
                        errfun = str; \
                        goto error_exit; \
                } \
        } while (0)

#define COE(func,args) CALL_OR_ERROR(func,args,#func)
#define COE2(func,args) CALL_OR_ERROR(func,args,NULL)

static int store_access_in_entry(uchar 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) );

        return 0;

  error_exit:
        rprintf(FERROR, "store_access_in_entry %s(): %s\n", errfun,
                strerror(errno));
        return -1;
}

/* build an SMB_ACL_T corresponding to an rsync_acl */
static BOOL pack_smb_acl(SMB_ACL_T *smb_acl, const rsync_acl *racl)
{
        size_t count;
        id_access *ida;
        const char *errfun = NULL;
        SMB_ACL_ENTRY_T entry;

        if (!(*smb_acl = sys_acl_init(calc_sacl_entries(racl)))) {
                rprintf(FERROR, "pack_smb_acl: sys_acl_init(): %s\n",
                        strerror(errno));
                return False;
        }

        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) );

        for (ida = racl->users.idas, count = racl->users.count;
             count--; ida++) {
                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_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) );

        for (ida = racl->groups.idas, count = racl->groups.count;
             count--; ida++) {
                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) );
        }
#ifndef ACLS_NEED_MASK
        if (racl->mask != ACL_NO_ENTRY) {
#endif
                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, entry) );
#ifndef ACLS_NEED_MASK
        }
#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 & 7, entry) );

#ifdef DEBUG
        if (sys_acl_valid(*smb_acl) < 0)
                rprintf(FINFO, "pack_smb_acl: warning: system says the ACL I packed is invalid\n");
#endif

        return True;

  error_exit:
        if (errfun) {
                rprintf(FERROR, "pack_smb_acl %s(): %s\n", errfun,
                        strerror(errno));
        }
        sys_acl_free_acl(*smb_acl);
        return False;
}

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;
        const char *errfun;
        int rc;

        if (S_ISDIR(mode)) {
                /* If the sticky bit is going on, it's not safe to allow all
                 * the new ACLs to go into effect before it gets set. */
#ifdef SMB_ACL_LOSES_SPECIAL_MODE_BITS
                if (mode & S_ISVTX)
                        mode &= ~0077;
#else
                if (mode & S_ISVTX && !(old_mode & S_ISVTX))
                        mode &= ~0077;
        } else {
                /* If setuid or setgid is going off, it's not safe to allow all
                 * the new ACLs to go into effect before they get cleared. */
                if ((old_mode & S_ISUID && !(mode & S_ISUID))
                 || (old_mode & S_ISGID && !(mode & S_ISGID)))
                        mode &= ~0077;
#endif
        }

        errfun = "sys_acl_get_entry";
        for (rc = sys_acl_get_entry(sacl, SMB_ACL_FIRST_ENTRY, &entry);
             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))) {
                        errfun = "sys_acl_get_tag_type";
                        break;
                }
                switch (tag_type) {
                case SMB_ACL_USER_OBJ:
                        COE2( store_access_in_entry,((mode >> 6) & 7, entry) );
                        break;
                case SMB_ACL_GROUP_OBJ:
                        /* group is only empty when identical to group perms. */
                        if (racl->group_obj != ACL_NO_ENTRY)
                                break;
                        COE2( store_access_in_entry,((mode >> 3) & 7, entry) );
                        break;
                case SMB_ACL_MASK:
#ifndef ACLS_NEED_MASK
                        /* mask is only empty when we don't need it. */
                        if (racl->mask == ACL_NO_ENTRY)
                                break;
#endif
                        COE2( store_access_in_entry,((mode >> 3) & 7, entry) );
                        break;
                case SMB_ACL_OTHER:
                        COE2( store_access_in_entry,(mode & 7, entry) );
                        break;
                }
        }
        if (rc) {
          error_exit:
                if (errfun) {
                        rprintf(FERROR, "change_sacl_perms: %s(): %s\n",
                                errfun, strerror(errno));
                }
                return ~0u;
        }

#ifdef SMB_ACL_LOSES_SPECIAL_MODE_BITS
        /* Ensure that chmod() will be called to restore any lost setid bits. */
        if (old_mode & (S_ISUID | S_ISGID | S_ISVTX)
         && (old_mode & CHMOD_BITS) == (mode & CHMOD_BITS))
                old_mode &= ~(S_ISUID | S_ISGID | S_ISVTX);
#endif

        /* Return the mode of the file on disk, as we will set them. */
        return (old_mode & ~ACCESSPERMS) | (mode & ACCESSPERMS);
}

static void receive_rsync_acl(rsync_acl *racl, int f, SMB_ACL_TYPE_T type)
{
        uchar computed_mask_bits = 0;
        ida_list *idal = NULL;
        id_access *ida;
        size_t count;

        *racl = rsync_acl_initializer;

        if (!(count = read_int(f)))
                return;

        while (count--) {
                char tag = read_byte(f);
                uchar access = read_byte(f);
                if (access & ~ (4 | 2 | 1)) {
                        rprintf(FERROR, "receive_rsync_acl: bogus permset %o\n",
                                access);
                        exit_cleanup(RERR_STREAMIO);
                }
                switch (tag) {
                case 'u':
                        if (racl->user_obj != ACL_NO_ENTRY) {
                                rprintf(FERROR, "receive_rsync_acl: error: duplicate USER_OBJ entry\n");
                                exit_cleanup(RERR_STREAMIO);
                        }
                        racl->user_obj = access;
                        continue;
                case 'U':
                        idal = &racl->users;
                        break;
                case 'g':
                        if (racl->group_obj != ACL_NO_ENTRY) {
                                rprintf(FERROR, "receive_rsync_acl: error: duplicate GROUP_OBJ entry\n");
                                exit_cleanup(RERR_STREAMIO);
                        }
                        racl->group_obj = access;
                        continue;
                case 'G':
                        idal = &racl->groups;
                        break;
                case 'm':
                        if (racl->mask != ACL_NO_ENTRY) {
                                rprintf(FERROR, "receive_rsync_acl: error: duplicate MASK entry\n");
                                exit_cleanup(RERR_STREAMIO);
                        }
                        racl->mask = access;
                        continue;
                case 'o':
                        if (racl->other != ACL_NO_ENTRY) {
                                rprintf(FERROR, "receive_rsync_acl: error: duplicate OTHER entry\n");
                                exit_cleanup(RERR_STREAMIO);
                        }
                        racl->other = access;
                        continue;
                default:
                        rprintf(FERROR, "receive_rsync_acl: unknown tag %c\n",
                                tag);
                        exit_cleanup(RERR_STREAMIO);
                }
                expand_ida_list(idal);
                ida = &idal->idas[idal->count++];
                ida->access = access;
                ida->id = read_int(f);
                computed_mask_bits |= access;
        }

        if (type == SMB_ACL_TYPE_DEFAULT) {
                /* Ensure that these are never unset. */
                if (racl->user_obj == ACL_NO_ENTRY)
                        racl->user_obj = 7;
                if (racl->group_obj == ACL_NO_ENTRY)
                        racl->group_obj = 0;
                if (racl->other == ACL_NO_ENTRY)
                        racl->other = 0;
        }
#ifndef ACLS_NEED_MASK
        if (!racl->users.count && !racl->groups.count) {
                /* If we, a system without ACLS_NEED_MASK, received a
                 * superfluous mask, throw it away. */
                if (racl->mask != ACL_NO_ENTRY) {
                        /* mask off group perms with it first */
                        racl->group_obj &= racl->mask | ACL_NO_ENTRY;
                        racl->mask = ACL_NO_ENTRY;
                }
        } else
#endif
        if (racl->mask == ACL_NO_ENTRY) /* Always non-empty when needed. */
                racl->mask = computed_mask_bits | (racl->group_obj & 7);
}

/* receive and build the rsync_acl_lists */
void receive_acl(struct file_struct *file, int f)
{
        SMB_ACL_TYPE_T type;
        char *fname;

        if (S_ISLNK(file->mode))
                return;

        fname = f_name(file, NULL);
        type = SMB_ACL_TYPE_ACCESS;
        do {
                char tag;
                file_acl_index_list *flst = file_acl_index_lists(type);

                expand_file_acl_index_list(flst);

                tag = read_byte(f);
                if (tag == 'A' || tag == 'a') {
                        if (type != SMB_ACL_TYPE_ACCESS) {
                                rprintf(FERROR, "receive_acl %s: duplicate access ACL\n",
                                        fname);
                                exit_cleanup(RERR_STREAMIO);
                        }
                } else if (tag == 'D' || tag == 'd') {
                        if (type == SMB_ACL_TYPE_ACCESS) {
                                rprintf(FERROR, "receive_acl %s: expecting access ACL; got default\n",
                                        fname);
                                exit_cleanup(RERR_STREAMIO);
                        }
                } else {
                        rprintf(FERROR, "receive_acl %s: unknown ACL type tag: %c\n",
                                fname, tag);
                        exit_cleanup(RERR_STREAMIO);
                }
                if (tag == 'A' || tag == 'D') {
                        rsync_acl racl;
                        rsync_acl_list *racl_list = rsync_acl_lists(type);
                        smb_acl_list *sacl_list = smb_acl_lists(type);
                        flst->fais[flst->count].aclidx = racl_list->count;
                        flst->fais[flst->count++].file = file;
                        receive_rsync_acl(&racl, f, type);
                        expand_rsync_acl_list(racl_list);
                        racl_list->racls[racl_list->count++] = racl;
                        expand_smb_acl_list(sacl_list);
                        sacl_list->sacls[sacl_list->count++] = NULL;
                } else {
                        int index = read_int(f);
                        rsync_acl_list *racl_list = rsync_acl_lists(type);
                        if ((size_t) index >= racl_list->count) {
                                rprintf(FERROR, "receive_acl %s: %s ACL index %d out of range\n",
                                        fname,
                                        str_acl_type(type),
                                        index);
                                exit_cleanup(RERR_STREAMIO);
                        }
                        flst->fais[flst->count].aclidx = index;
                        flst->fais[flst->count++].file = file;
                }
        } while (BUMP_TYPE(type) && S_ISDIR(file->mode));
}

static int file_acl_index_list_sorter(const void *f1, const void *f2)
{
        const file_acl_index *fileaclidx1 = (const file_acl_index *)f1;
        const file_acl_index *fileaclidx2 = (const file_acl_index *)f2;
        return fileaclidx1->file == fileaclidx2->file ? 0
             : fileaclidx1->file < fileaclidx2->file ? -1 : 1;
}

void sort_file_acl_index_lists()
{
        SMB_ACL_TYPE_T type;

        type = SMB_ACL_TYPE_ACCESS;
        do {
                file_acl_index_list *flst = file_acl_index_lists(type);

                if (!flst->count)
                        continue;

                qsort(flst->fais, flst->count, sizeof flst->fais[0],
                      &file_acl_index_list_sorter);
        } while (BUMP_TYPE(type));
}

static int find_file_acl_index(const file_acl_index_list *flst,
                               const struct file_struct *file)
{
        int low = 0, high = flst->count;
        const struct file_struct *file_mid;

        if (!high--)
                return -1;
        do {
                int mid = (high + low) / 2;
                file_mid = flst->fais[mid].file;
                if (file_mid == file)
                        return flst->fais[mid].aclidx;
                if (file_mid > file)
                        high = mid - 1;
                else
                        low = mid + 1;
        } while (low < high);
        if (low == high) {
                file_mid = flst->fais[low].file;
                if (file_mid == file)
                        return flst->fais[low].aclidx;
        }
        rprintf(FERROR,
                "find_file_acl_index: can't find entry for file in list\n");
        exit_cleanup(RERR_STREAMIO);
        return -1;
}

/* for duplicating ACLs on backups when using backup_dir */
int dup_acl(const char *orig, const char *bak, mode_t mode)
{
        SMB_ACL_TYPE_T type;
        int ret = 0;

        type = SMB_ACL_TYPE_ACCESS;
        do {
                SMB_ACL_T sacl_orig, sacl_bak;
                rsync_acl racl_orig, racl_bak;
                if (!(sacl_orig = sys_acl_get_file(orig, type))) {
                        rprintf(FERROR, "dup_acl: sys_acl_get_file(%s, %s): %s\n",
                                orig, str_acl_type(type), strerror(errno));
                        ret = -1;
                        continue;
                }
                if (!(sacl_bak = sys_acl_get_file(orig, type))) {
                        rprintf(FERROR, "dup_acl: sys_acl_get_file(%s, %s): %s. ignoring\n",
                                bak, str_acl_type(type), strerror(errno));
                        ret = -1;
                        /* try to forge on through */
                }
                if (!unpack_smb_acl(&racl_orig, sacl_orig)) {
                        ret = -1;
                        goto out_with_sacls;
                }
                if (sacl_bak) {
                        if (!unpack_smb_acl(&racl_bak, sacl_bak)) {
                                ret = -1;
                                goto out_with_one_racl;
                        }
                        if (rsync_acls_equal(&racl_orig, &racl_bak))
                                goto out_with_all;
                } else {
                        ; /* presume they're unequal */
                }
                if (type == SMB_ACL_TYPE_DEFAULT
                 && racl_orig.user_obj == ACL_NO_ENTRY) {
                        if (sys_acl_delete_def_file(bak) < 0) {
                                rprintf(FERROR, "dup_acl: sys_acl_delete_def_file(%s): %s\n",
                                        bak, strerror(errno));
                                ret = -1;
                        }
                } else if (sys_acl_set_file(bak, type, sacl_bak) < 0) {
                        rprintf(FERROR, "dup_acl: sys_acl_set_file(%s, %s): %s\n",
                                bak, str_acl_type(type), strerror(errno));
                        ret = -1;
                }
                out_with_all:
                        if (sacl_bak)
                                rsync_acl_free(&racl_bak);
                out_with_one_racl:
                        rsync_acl_free(&racl_orig);
                out_with_sacls:
                        if (sacl_bak)
                                sys_acl_free_acl(sacl_bak);
                /* out_with_one_sacl: */
                        if (sacl_orig)
                                sys_acl_free_acl(sacl_orig);
        } while (BUMP_TYPE(type) && S_ISDIR(mode));

        return ret;
}

/* Stuff for redirecting calls to set_acl() from set_file_attrs()
 * 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 SMB_ACL_T _backup_sacl[] = { NULL, NULL };

void push_keep_backup_acl(const struct file_struct *file,
                          const char *orig, const char *dest)
{
        SMB_ACL_TYPE_T type;
        SMB_ACL_T *sacl;

        backup_orig_file = file;
        backup_orig_fname = orig;
        backup_dest_fname = dest;

        sacl = &_backup_sacl[0];
        type = SMB_ACL_TYPE_ACCESS;
        do {
                if (type == SMB_ACL_TYPE_DEFAULT && !S_ISDIR(file->mode)) {
                        *sacl = NULL;
                        break;
                }
                if (!(*sacl = sys_acl_get_file(orig, type))) {
                        rprintf(FERROR,
                                "push_keep_backup_acl: sys_acl_get_file(%s, %s): %s\n",
                                orig, str_acl_type(type),
                                strerror(errno));
                }
        } while (BUMP_TYPE(type));
}

static int set_keep_backup_acl()
{
        SMB_ACL_TYPE_T type;
        SMB_ACL_T *sacl;
        int ret = 0;

        sacl = &_backup_sacl[0];
        type = SMB_ACL_TYPE_ACCESS;
        do {
                if (*sacl
                 && sys_acl_set_file(backup_dest_fname, type, *sacl) < 0) {
                        rprintf(FERROR,
                                "push_keep_backup_acl: sys_acl_get_file(%s, %s): %s\n",
                                backup_dest_fname,
                                str_acl_type(type),
                                strerror(errno));
                        ret = -1;
                }
        } while (BUMP_TYPE(type));

        return ret;
}

void cleanup_keep_backup_acl()
{
        SMB_ACL_TYPE_T type;
        SMB_ACL_T *sacl;

        backup_orig_file = NULL;
        backup_orig_fname = null_string;
        backup_dest_fname = null_string;

        sacl = &_backup_sacl[0];
        type = SMB_ACL_TYPE_ACCESS;
        do {
                if (*sacl) {
                        sys_acl_free_acl(*sacl);
                        *sacl = NULL;
                }
        } while (BUMP_TYPE(type));
}

/* set ACL on rsync-ed or keep_backup-ed file
 *
 * This sets extended access ACL entries and default ACLs.  If convenient,
 * it sets permission bits along with the access ACLs and signals having
 * done so by modifying mode_p, which should point into the stat buffer.
 *
 * returns: 1 for unchanged, 0 for changed, -1 for failed
 * Pass NULL for mode_p to get the return code without changing anything. */
int set_acl(const char *fname, const struct file_struct *file, mode_t *mode_p)
{
        int unchanged = 1;
        SMB_ACL_TYPE_T type;

        if (S_ISLNK(file->mode))
                return 1;

        if (file == backup_orig_file) {
                if (!strcmp(fname, backup_dest_fname))
                        return set_keep_backup_acl();
        }
        type = SMB_ACL_TYPE_ACCESS;
        do {
                BOOL ok;
                SMB_ACL_T sacl_orig, *sacl_new;
                rsync_acl racl_orig, *racl_new;
                int aclidx = find_file_acl_index(file_acl_index_lists(type), file);

                racl_new = &(rsync_acl_lists(type)->racls[aclidx]);
                sacl_new = &(smb_acl_lists(type)->sacls[aclidx]);
                sacl_orig = sys_acl_get_file(fname, type);
                if (!sacl_orig) {
                        rprintf(FERROR, "set_acl: sys_acl_get_file(%s, %s): %s\n",
                                fname, str_acl_type(type), strerror(errno));
                        unchanged = -1;
                        continue;
                }
                ok = unpack_smb_acl(&racl_orig, sacl_orig);
                sys_acl_free_acl(sacl_orig);
                if (!ok) {
                        unchanged = -1;
                        continue;
                }
                if (type == SMB_ACL_TYPE_ACCESS)
                        ok = rsync_acl_extended_parts_equal(&racl_orig, racl_new);
                else
                        ok = rsync_acls_equal(&racl_orig, racl_new);
                rsync_acl_free(&racl_orig);
                if (ok)
                        continue;
                if (!dry_run && mode_p) {
                        if (type == SMB_ACL_TYPE_DEFAULT
                         && racl_new->user_obj == ACL_NO_ENTRY) {
                                if (sys_acl_delete_def_file(fname) < 0) {
                                        rprintf(FERROR, "set_acl: sys_acl_delete_def_file(%s): %s\n",
                                                fname, strerror(errno));
                                        unchanged = -1;
                                        continue;
                                }
                        } else {
                                mode_t cur_mode = *mode_p;
                                if (!*sacl_new
                                 && !pack_smb_acl(sacl_new, racl_new)) {
                                        unchanged = -1;
                                        continue;
                                }
                                if (type == SMB_ACL_TYPE_ACCESS) {
                                        cur_mode = change_sacl_perms(*sacl_new, racl_new,
                                                                     cur_mode, file->mode);
                                        if (cur_mode == ~0u)
                                                continue;
                                }
                                if (sys_acl_set_file(fname, type, *sacl_new) < 0) {
                                        rprintf(FERROR, "set_acl: sys_acl_set_file(%s, %s): %s\n",
                                                fname, str_acl_type(type),
                                                strerror(errno));
                                        unchanged = -1;
                                        continue;
                                }
                                if (type == SMB_ACL_TYPE_ACCESS)
                                        *mode_p = cur_mode;
                        }
                }
                if (unchanged == 1)
                        unchanged = 0;
        } while (BUMP_TYPE(type) && S_ISDIR(file->mode));

        return unchanged;
}

/* Enumeration functions for uid mapping: */

/* Context -- one and only one.  Should be cycled through once on uid
 * mapping and once on gid mapping. */
static rsync_acl_list *_enum_racl_lists[] = {
        &_rsync_acl_lists[0], &_rsync_acl_lists[1], NULL
};

static rsync_acl_list **enum_racl_list = &_enum_racl_lists[0];
static size_t enum_racl_index = 0;
static size_t enum_ida_index = 0;

/* This returns the next tag_type id from the given acl for the next entry,
 * or it returns 0 if there are no more tag_type ids in the acl. */
static id_t *next_ace_id(SMB_ACL_TAG_T tag_type, const rsync_acl *racl)
{
        const ida_list *idal = tag_type == SMB_ACL_USER ? &racl->users : &racl->groups;
        if (enum_ida_index < idal->count) {
                id_access *ida = &idal->idas[enum_ida_index++];
                return &ida->id;
        }
        enum_ida_index = 0;
        return NULL;
}

static id_t *next_acl_id(SMB_ACL_TAG_T tag_type, const rsync_acl_list *racl_list)
{
        for (; enum_racl_index < racl_list->count; enum_racl_index++) {
                rsync_acl *racl = &racl_list->racls[enum_racl_index];
                id_t *id = next_ace_id(tag_type, racl);
                if (id)
                        return id;
        }
        enum_racl_index = 0;
        return NULL;
}

static id_t *next_acl_list_id(SMB_ACL_TAG_T tag_type)
{
        for (; *enum_racl_list; enum_racl_list++) {
                id_t *id = next_acl_id(tag_type, *enum_racl_list);
                if (id)
                        return id;
        }
        enum_racl_list = &_enum_racl_lists[0];
        return NULL;
}

id_t *next_acl_uid()
{
        return next_acl_list_id(SMB_ACL_USER);
}

id_t *next_acl_gid()
{
        return next_acl_list_id(SMB_ACL_GROUP);
}

int default_perms_for_dir(const char *dir)
{
        rsync_acl racl;
        SMB_ACL_T sacl;
        BOOL ok;
        int perms;

        if (dir == NULL)
                dir = ".";
        perms = ACCESSPERMS & ~orig_umask;
        /* Read the directory's default ACL.  If it has none, this will successfully return an empty ACL. */
        sacl = sys_acl_get_file(dir, SMB_ACL_TYPE_DEFAULT);
        if (sacl == NULL) {
                /* Couldn't get an ACL.  Darn. */
                switch (errno) {
                case ENOTSUP:
                        /* ACLs are disabled.  We could yell at the user to turn them on, but... */
                        break;
                case ENOENT:
                        if (dry_run) {
                                /* We're doing a dry run, so the containing directory
                                 * wasn't actually created.  Don't worry about it. */
                                break;
                        }
                        /* Otherwise fall through. */
                default:
                        rprintf(FERROR, "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;
        }

        /* Convert it. */
        ok = unpack_smb_acl(&racl, sacl);
        sys_acl_free_acl(sacl);
        if (!ok) {
                rprintf(FERROR, "default_perms_for_dir: unpack_smb_acl failed, falling back on umask\n");
                return perms;
        }

        /* Apply the permission-bit entries of the default ACL, if any. */
        if (racl.user_obj != ACL_NO_ENTRY) {
                perms = rsync_acl_get_perms(&racl);
                if (verbose > 2)
                        rprintf(FINFO, "got ACL-based default perms %o for directory %s\n", perms, dir);
        }

        rsync_acl_free(&racl);
        return perms;
}

#endif /* SUPPORT_ACLS */

---