acls.c

ソースコードを見る。

データ構造
struct	id_access
struct	ida_list
struct	rsync_acl
struct	rsync_acl_list
struct	file_acl_index
struct	file_acl_index_list
struct	smb_acl_list
関数
static int	count_racl_entries (const rsync_acl *racl)
static int	calc_sacl_entries (const rsync_acl *racl)
static int	rsync_acl_get_perms (const rsync_acl *racl)
static void	rsync_acl_strip_perms (rsync_acl *racl)
static void	expand_ida_list (ida_list *idal)
static void	ida_list_free (ida_list *idal)
static void	rsync_acl_free (rsync_acl *racl)
static int	id_access_sorter (const void *r1, const void *r2)
static void	sort_ida_list (ida_list *idal)
static BOOL	unpack_smb_acl (rsync_acl *racl, SMB_ACL_T sacl)
static BOOL	ida_lists_equal (const ida_list *ial1, const ida_list *ial2)
static BOOL	rsync_acls_equal (const rsync_acl *racl1, const rsync_acl *racl2)
static BOOL	rsync_acl_extended_parts_equal (const rsync_acl *racl1, const rsync_acl *racl2)
static rsync_acl_list *	rsync_acl_lists (SMB_ACL_TYPE_T type)
static void	expand_rsync_acl_list (rsync_acl_list *racl_list)
static int	find_matching_rsync_acl (SMB_ACL_TYPE_T type, const rsync_acl_list *racl_list, const rsync_acl *racl)
static void	send_ida_list (int f, const ida_list *idal, char tag_char)
static void	send_rsync_acl (int f, const rsync_acl *racl)
static const char *	str_acl_type (SMB_ACL_TYPE_T type)
int	make_acl (const struct file_struct *file, const char *fname)
void	send_acl (const struct file_struct *file, int f)
static file_acl_index_list *	file_acl_index_lists (SMB_ACL_TYPE_T type)
static void	expand_file_acl_index_list (file_acl_index_list *flst)
static smb_acl_list *	smb_acl_lists (SMB_ACL_TYPE_T type)
static void	expand_smb_acl_list (smb_acl_list *sacl_list)
static int	store_access_in_entry (uchar access, SMB_ACL_ENTRY_T entry)
static BOOL	pack_smb_acl (SMB_ACL_T *smb_acl, const rsync_acl *racl)
static mode_t	change_sacl_perms (SMB_ACL_T sacl, rsync_acl *racl, mode_t old_mode, mode_t mode)
static void	receive_rsync_acl (rsync_acl *racl, int f, SMB_ACL_TYPE_T type)
void	receive_acl (struct file_struct *file, int f)
static int	file_acl_index_list_sorter (const void *f1, const void *f2)
void	sort_file_acl_index_lists ()
static int	find_file_acl_index (const file_acl_index_list *flst, const struct file_struct *file)
int	dup_acl (const char *orig, const char *bak, mode_t mode)
void	push_keep_backup_acl (const struct file_struct *file, const char *orig, const char *dest)
static int	set_keep_backup_acl ()
void	cleanup_keep_backup_acl ()
int	set_acl (const char *fname, const struct file_struct *file, mode_t *mode_p)
static id_t *	next_ace_id (SMB_ACL_TAG_T tag_type, const rsync_acl *racl)
static id_t *	next_acl_id (SMB_ACL_TAG_T tag_type, const rsync_acl_list *racl_list)
static id_t *	next_acl_list_id (SMB_ACL_TAG_T tag_type)
id_t *	next_acl_uid ()
id_t *	next_acl_gid ()
int	default_perms_for_dir (const char *dir)
変数
int	am_root
int	dry_run
int	orig_umask
int	preserve_acls
static const rsync_acl	rsync_acl_initializer
static rsync_acl_list	_rsync_acl_lists []
static rsync_acl	_curr_rsync_acls [2]
static file_acl_index_list	_file_acl_index_lists []
static smb_acl_list	_smb_acl_lists []
static 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 }
static rsync_acl_list *	_enum_racl_lists []
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

---

関数

static int count_racl_entries

(

const rsync_acl *

racl

)

[static]

acls.c の 66 行で定義されています。

参照先 ida_list::count・rsync_acl::group_obj・rsync_acl::groups・rsync_acl::mask・rsync_acl::other・rsync_acl::user_obj・rsync_acl::users.

参照元 send_rsync_acl().

{
        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

)

[static]

acls.c の 75 行で定義されています。

参照先 ida_list::count・rsync_acl::groups・rsync_acl::mask・rsync_acl::users.

参照元 pack_smb_acl().

{
        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

)

[static]

acls.c の 85 行で定義されています。

参照先 rsync_acl::group_obj・rsync_acl::mask・rsync_acl::other・rsync_acl::user_obj.

参照元 default_perms_for_dir().

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

)

[static]

acls.c の 93 行で定義されています。

参照先 rsync_acl::group_obj・rsync_acl::mask・rsync_acl::other・rsync_acl::user_obj.

参照元 make_acl().

{
        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

)

[static]

acls.c の 103 行で定義されています。

参照先 ida_list::count・FINFO・ida_list::idas・ida_list::malloced・out_of_memory()・rprintf()・verbose.

参照元 receive_rsync_acl()・unpack_smb_acl().

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

)

[static]

acls.c の 124 行で定義されています。

参照先 ida_list::count・ida_list::idas・ida_list::malloced.

参照元 rsync_acl_free().

{
        free(idal->idas);
        idal->idas = NULL;
        idal->count = 0;
        idal->malloced = 0;
}

static void rsync_acl_free

(

rsync_acl *

racl

)

[static]

acls.c の 132 行で定義されています。

参照先 rsync_acl::groups・ida_list_free()・rsync_acl::users.

参照元 default_perms_for_dir()・dup_acl()・send_acl()・set_acl()・unpack_smb_acl().

{
        ida_list_free(&racl->users);
        ida_list_free(&racl->groups);
}

static int id_access_sorter	(	const void *	r1,
		const void *	r2
	)			[static]

acls.c の 138 行で定義されています。

参照先 id_access::id.

参照元 sort_ida_list().

{
        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

)

[static]

acls.c の 146 行で定義されています。

参照先 ida_list::count・id_access_sorter()・ida_list::idas.

参照元 unpack_smb_acl().

{
        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
	)			[static]

acls.c の 154 行で定義されています。

参照先 id_access::access・ida_list::count・errno・expand_ida_list()・FERROR・FINFO・rsync_acl::group_obj・rsync_acl::groups・id_access::id・ida_list::idas・rsync_acl::mask・rsync_acl::other・rprintf()・rsync_acl_free()・rsync_acl_initializer・sort_ida_list()・sys_acl_free_qualifier()・sys_acl_get_entry()・sys_acl_get_perm()・sys_acl_get_permset()・sys_acl_get_qualifier()・sys_acl_get_tag_type()・rsync_acl::user_obj・rsync_acl::users.

参照元 default_perms_for_dir()・dup_acl()・make_acl()・set_acl().

{
        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
	)			[static]

acls.c の 242 行で定義されています。

参照先 id_access::access・ida_list::count・id_access::id・ida_list::idas.

参照元 rsync_acl_extended_parts_equal()・rsync_acls_equal().

{
        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
	)			[static]

acls.c の 257 行で定義されています。

参照先 rsync_acl::group_obj・rsync_acl::groups・ida_lists_equal()・rsync_acl::mask・rsync_acl::other・rsync_acl::user_obj・rsync_acl::users.

参照元 dup_acl()・find_matching_rsync_acl()・set_acl().

{
        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
	)			[static]

acls.c の 267 行で定義されています。

参照先 rsync_acl::group_obj・rsync_acl::groups・ida_lists_equal()・rsync_acl::mask・rsync_acl::users.

参照元 set_acl().

{
        /* 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);
}

static rsync_acl_list* rsync_acl_lists

(

SMB_ACL_TYPE_T

type

)

[inline, static]

acls.c の 289 行で定義されています。

参照先 _rsync_acl_lists.

参照元 receive_acl()・send_acl()・set_acl().

{
        return &_rsync_acl_lists[type != SMB_ACL_TYPE_ACCESS];
}

static void expand_rsync_acl_list

(

rsync_acl_list *

racl_list

)

[static]

acls.c の 294 行で定義されています。

参照先 rsync_acl_list::count・FINFO・rsync_acl_list::malloced・out_of_memory()・rsync_acl_list::racls・rprintf()・verbose.

参照元 receive_acl()・send_acl().

{
        /* 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]

acls.c の 319 行で定義されています。

参照先 access_match()・rsync_acl_list::count・rsync_acl_list::racls・rsync_acls_equal().

参照元 send_acl().

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

static void send_ida_list	(	int	f,
		const ida_list *	idal,
		char	tag_char
	)			[static]

acls.c の 349 行で定義されています。

参照先 id_access::access・add_gid()・add_uid()・ida_list::count・id_access::id・ida_list::idas・write_byte()・write_int().

参照元 send_rsync_acl().

{
        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
	)			[static]

acls.c の 367 行で定義されています。

参照先 count_racl_entries()・rsync_acl::group_obj・rsync_acl::groups・rsync_acl::mask・rsync_acl::other・send_ida_list()・rsync_acl::user_obj・rsync_acl::users・write_byte()・write_int().

参照元 send_acl().

{
        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 const char* str_acl_type

(

SMB_ACL_TYPE_T

type

)

[static]

acls.c の 393 行で定義されています。

参照元 default_perms_for_dir()・dup_acl()・make_acl()・push_keep_backup_acl()・receive_acl()・set_acl()・set_keep_backup_acl().

{
        return type == SMB_ACL_TYPE_ACCESS ? "SMB_ACL_TYPE_ACCESS"
             : type == SMB_ACL_TYPE_DEFAULT ? "SMB_ACL_TYPE_DEFAULT"
             : "unknown SMB_ACL_TYPE_T";
}

int make_acl	(	const struct file_struct *	file,
		const char *	fname
	)

acls.c の 402 行で定義されています。

参照先 _curr_rsync_acls・ida_list::count・errno・FERROR・rsync_acl::group_obj・rsync_acl::groups・rsync_acl::mask・file_struct::mode・preserve_acls・rprintf()・rsync_acl_initializer・rsync_acl_strip_perms()・str_acl_type()・sys_acl_free_acl()・sys_acl_get_file()・unpack_smb_acl()・rsync_acl::users.

参照元 send_file_name().

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

void send_acl	(	const struct file_struct *	file,
		int	f
	)

acls.c の 445 行で定義されています。

参照先 _curr_rsync_acls・rsync_acl_list::count・expand_rsync_acl_list()・find_matching_rsync_acl()・file_struct::mode・rsync_acl_list::racls・rsync_acl_free()・rsync_acl_lists()・send_rsync_acl()・write_byte()・write_int().

参照元 send_file_name().

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

static file_acl_index_list* file_acl_index_lists

(

SMB_ACL_TYPE_T

type

)

[inline, static]

acls.c の 498 行で定義されています。

参照先 _file_acl_index_lists.

参照元 receive_acl()・set_acl()・sort_file_acl_index_lists().

{
        return &_file_acl_index_lists[type != SMB_ACL_TYPE_ACCESS];
}

static void expand_file_acl_index_list

(

file_acl_index_list *

flst

)

[static]

acls.c の 503 行で定義されています。

参照先 file_acl_index_list::count・file_acl_index_list::fais・FINFO・file_acl_index_list::malloced・out_of_memory()・rprintf()・verbose.

参照元 receive_acl().

{
        /* 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");
        }
}

static smb_acl_list* smb_acl_lists

(

SMB_ACL_TYPE_T

type

)

[inline, static]

acls.c の 542 行で定義されています。

参照先 _smb_acl_lists.

参照元 receive_acl()・set_acl().

{
        return &_smb_acl_lists[type != SMB_ACL_TYPE_ACCESS];
}

static void expand_smb_acl_list

(

smb_acl_list *

sacl_list

)

[static]

acls.c の 547 行で定義されています。

参照先 smb_acl_list::count・FINFO・smb_acl_list::malloced・out_of_memory()・rprintf()・smb_acl_list::sacls・verbose.

参照元 receive_acl().

{
        /* 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");
        }
}

static int store_access_in_entry	(	uchar	access,
		SMB_ACL_ENTRY_T	entry
	)			[static]

acls.c の 583 行で定義されています。

参照先 errno・FERROR・rprintf()・sys_acl_add_perm()・sys_acl_clear_perms()・sys_acl_get_permset()・sys_acl_set_permset().

参照元 change_sacl_perms()・pack_smb_acl().

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

static BOOL pack_smb_acl	(	SMB_ACL_T *	smb_acl,
		const rsync_acl *	racl
	)			[static]

acls.c の 607 行で定義されています。

参照先 id_access::access・calc_sacl_entries()・ida_list::count・errno・FERROR・FINFO・rsync_acl::group_obj・rsync_acl::groups・id_access::id・ida_list::idas・rsync_acl::mask・rsync_acl::other・rprintf()・store_access_in_entry()・sys_acl_create_entry()・sys_acl_free_acl()・sys_acl_init()・sys_acl_set_qualifier()・sys_acl_set_tag_type()・sys_acl_valid()・rsync_acl::user_obj・rsync_acl::users.

参照元 set_acl().

{
        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
	)			[static]

acls.c の 673 行で定義されています。

参照先 errno・FERROR・rsync_acl::group_obj・rsync_acl::mask・rprintf()・store_access_in_entry()・sys_acl_get_entry()・sys_acl_get_tag_type().

参照元 set_acl().

{
        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
	)			[static]

acls.c の 749 行で定義されています。

参照先 id_access::access・ida_list::count・expand_ida_list()・FERROR・rsync_acl::group_obj・rsync_acl::groups・id_access::id・ida_list::idas・rsync_acl::mask・rsync_acl::other・read_byte()・read_int()・rprintf()・rsync_acl_initializer・rsync_acl::user_obj・rsync_acl::users.

参照元 receive_acl().

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

void receive_acl	(	struct file_struct *	file,
		int	f
	)

acls.c の 841 行で定義されています。

参照先 file_acl_index::aclidx・smb_acl_list::count・rsync_acl_list::count・file_acl_index_list::count・expand_file_acl_index_list()・expand_rsync_acl_list()・expand_smb_acl_list()・f_name()・file_acl_index_list::fais・FERROR・file_acl_index::file・file_acl_index_lists()・file_struct::mode・rsync_acl_list::racls・read_byte()・read_int()・receive_rsync_acl()・rprintf()・rsync_acl_lists()・smb_acl_list::sacls・smb_acl_lists()・str_acl_type().

参照元 recv_file_list().

{
        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
	)			[static]

acls.c の 902 行で定義されています。

参照先 file_acl_index::file.

参照元 sort_file_acl_index_lists().

{
        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

(

)

acls.c の 910 行で定義されています。

参照先 file_acl_index_list::count・file_acl_index_list::fais・file_acl_index_list_sorter()・file_acl_index_lists().

参照元 recv_file_list().

{
        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
	)			[static]

acls.c の 926 行で定義されています。

参照先 file_acl_index::aclidx・file_acl_index_list::count・file_acl_index_list::fais・FERROR・file_acl_index::file・rprintf().

参照元 set_acl().

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

int dup_acl	(	const char *	orig,
		const char *	bak,
		mode_t	mode
	)

acls.c の 956 行で定義されています。

参照先 errno・FERROR・rprintf()・rsync_acl_free()・rsync_acls_equal()・str_acl_type()・sys_acl_delete_def_file()・sys_acl_free_acl()・sys_acl_get_file()・sys_acl_set_file()・unpack_smb_acl()・rsync_acl::user_obj.

参照元 make_bak_dir().

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

void push_keep_backup_acl	(	const struct file_struct *	file,
		const char *	orig,
		const char *	dest
	)

acls.c の 1027 行で定義されています。

参照先 _backup_sacl・backup_dest_fname・backup_orig_file・backup_orig_fname・errno・FERROR・file_struct::mode・rprintf()・str_acl_type()・sys_acl_get_file().

参照元 keep_backup().

{
        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

(

)

[static]

acls.c の 1053 行で定義されています。

参照先 _backup_sacl・backup_dest_fname・errno・FERROR・rprintf()・str_acl_type()・sys_acl_set_file().

参照元 set_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

(

)

acls.c の 1076 行で定義されています。

参照先 _backup_sacl・backup_dest_fname・backup_orig_file・backup_orig_fname・null_string・sys_acl_free_acl().

参照元 keep_backup().

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

int set_acl	(	const char *	fname,
		const struct file_struct *	file,
		mode_t *	mode_p
	)

acls.c の 1103 行で定義されています。

参照先 backup_dest_fname・backup_orig_file・change_sacl_perms()・dry_run・errno・FERROR・file_acl_index_lists()・find_file_acl_index()・file_struct::mode・pack_smb_acl()・rsync_acl_list::racls・rprintf()・rsync_acl_extended_parts_equal()・rsync_acl_free()・rsync_acl_lists()・rsync_acls_equal()・smb_acl_list::sacls・set_keep_backup_acl()・smb_acl_lists()・str_acl_type()・sys_acl_delete_def_file()・sys_acl_free_acl()・sys_acl_get_file()・sys_acl_set_file()・file_struct::u・unpack_smb_acl()・rsync_acl::user_obj.

参照元 set_file_attrs().

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

static id_t* next_ace_id	(	SMB_ACL_TAG_T	tag_type,
		const rsync_acl *	racl
	)			[static]

acls.c の 1198 行で定義されています。

参照先 enum_ida_index・rsync_acl::groups・id_access::id・ida_list::idas・rsync_acl::users.

参照元 next_acl_id().

{
        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
	)			[static]

acls.c の 1209 行で定義されています。

参照先 rsync_acl_list::count・enum_racl_index・next_ace_id()・rsync_acl_list::racls.

参照元 next_acl_list_id().

{
        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

)

[static]

acls.c の 1221 行で定義されています。

参照先 _enum_racl_lists・enum_racl_list・next_acl_id().

参照元 next_acl_gid()・next_acl_uid().

{
        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

(

)

acls.c の 1232 行で定義されています。

参照先 next_acl_list_id().

参照元 recv_uid_list().

{
        return next_acl_list_id(SMB_ACL_USER);
}

id_t* next_acl_gid

(

)

acls.c の 1237 行で定義されています。

参照先 next_acl_list_id().

参照元 recv_uid_list().

{
        return next_acl_list_id(SMB_ACL_GROUP);
}

int default_perms_for_dir

(

const char *

dir

)

acls.c の 1242 行で定義されています。

参照先 dry_run・errno・FERROR・FINFO・orig_umask・rprintf()・rsync_acl_free()・rsync_acl_get_perms()・str_acl_type()・sys_acl_free_acl()・sys_acl_get_file()・unpack_smb_acl()・rsync_acl::user_obj・verbose.

参照元 recv_files()・recv_generator().

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

---

変数

int am_root

options.c の 74 行で定義されています。

参照元 generate_files()・itemize()・keep_backup()・lp_load()・main()・output_flist()・recv_add_gid()・recv_generator()・recv_uid_list()・rsync_module()・server_options()・set_file_attrs()・unchanged_attrs().

int dry_run

options.c の 60 行で定義されています。

参照元 default_perms_for_dir()・delete_item()・do_chmod()・do_delete_pass()・do_lchown()・do_link()・do_mkdir()・do_mknod()・do_mkstemp()・do_open()・do_rename()・do_rmdir()・do_symlink()・do_unlink()・generate_files()・get_local_name()・log_delete()・main()・maybe_log_item()・parse_arguments()・recv_generator()・set_acl()・set_file_attrs()・set_modtime()・set_xattr()・try_dests_non()・try_dests_reg().

int orig_umask

main.c の 65 行で定義されています。

参照元 create_directory_path()・daemon_main()・default_perms_for_dir()・generate_files()・logfile_open()・main()・mkdir_defmode()・parse_chmod()・piped_child()・recv_files()・rsync_module().

int preserve_acls

options.c の 48 行で定義されています。

参照元 keep_backup()・make_acl()・make_bak_dir()・parse_arguments()・recv_file_list()・recv_uid_list()・send_file_name()・send_uid_list()・server_options()・set_file_attrs().

const rsync_acl rsync_acl_initializer [static]

初期値:

 {
        {0, 0, NULL}, {0, 0, NULL},
        ACL_NO_ENTRY, ACL_NO_ENTRY, ACL_NO_ENTRY, ACL_NO_ENTRY
}

acls.c の 56 行で定義されています。

参照元 make_acl()・receive_rsync_acl()・unpack_smb_acl().

rsync_acl_list _rsync_acl_lists[] [static]

初期値:

 {
        { 0, 0, NULL }, 
        { 0, 0, NULL }  
}

acls.c の 284 行で定義されています。

参照元 rsync_acl_lists().

rsync_acl _curr_rsync_acls[2] [static]

acls.c の 391 行で定義されています。

参照元 make_acl()・send_acl().

file_acl_index_list _file_acl_index_lists[] [static]

初期値:

 {
        {0, 0, NULL }, 
        {0, 0, NULL }  
}

acls.c の 493 行で定義されています。

参照元 file_acl_index_lists().

smb_acl_list _smb_acl_lists[] [static]

初期値:

 {
        { 0, 0, NULL }, 
        { 0, 0, NULL }  
}

acls.c の 537 行で定義されています。

参照元 smb_acl_lists().

struct file_struct* backup_orig_file = NULL [static]

acls.c の 1021 行で定義されています。

参照元 cleanup_keep_backup_acl()・cleanup_keep_backup_xattr()・push_keep_backup_acl()・push_keep_backup_xattr()・set_acl()・set_xattr().

const char null_string[] = "" [static]

acls.c の 1022 行で定義されています。

参照元 cleanup_keep_backup_acl()・cleanup_keep_backup_xattr().

const char* backup_orig_fname = null_string [static]

acls.c の 1023 行で定義されています。

参照元 cleanup_keep_backup_acl()・cleanup_keep_backup_xattr()・push_keep_backup_acl()・push_keep_backup_xattr().

const char* backup_dest_fname = null_string [static]

acls.c の 1024 行で定義されています。

参照元 cleanup_keep_backup_acl()・cleanup_keep_backup_xattr()・push_keep_backup_acl()・push_keep_backup_xattr()・set_acl()・set_keep_backup_acl()・set_keep_backup_xal()・set_xattr().

SMB_ACL_T _backup_sacl[] = { NULL, NULL } [static]

acls.c の 1025 行で定義されています。

参照元 cleanup_keep_backup_acl()・push_keep_backup_acl()・set_keep_backup_acl().

rsync_acl_list* _enum_racl_lists[] [static]

初期値:

 {
        &_rsync_acl_lists[0], &_rsync_acl_lists[1], NULL
}

acls.c の 1188 行で定義されています。

参照元 next_acl_list_id().

rsync_acl_list** enum_racl_list = &_enum_racl_lists[0] [static]

acls.c の 1192 行で定義されています。

参照元 next_acl_list_id().

size_t enum_racl_index = 0 [static]

acls.c の 1193 行で定義されています。

参照元 next_acl_id().

size_t enum_ida_index = 0 [static]

acls.c の 1194 行で定義されています。

参照元 next_ace_id().

---