X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=src%2Fapply-default-acl.c;h=7989c985ab8bbf4a8329a64bedab1b7330336f71;hb=HEAD;hp=c4d0c3b9b4871094edf9f08a5053c0bf083cf653;hpb=df929bebddb9852c8e50481169e2fd1b5a01faf6;p=apply-default-acl.git diff --git a/src/apply-default-acl.c b/src/apply-default-acl.c index c4d0c3b..7989c98 100644 --- a/src/apply-default-acl.c +++ b/src/apply-default-acl.c @@ -1,38 +1,27 @@ /** * @file apply-default-acl.c * - * @brief The entire implementation. + * @brief The command-line interface. * */ -/* On Linux, ftw.h needs this special voodoo to work. */ -#define _XOPEN_SOURCE 500 -#define _GNU_SOURCE +#include /* EINVAL */ +#include /* AT_FOO constants */ +#include /* getopt_long() */ +#include /* the "bool" type */ +#include /* perror() */ +#include /* EXIT_FAILURE, EXIT_SUCCESS */ +#include /* faccessat() */ -#include -#include /* AT_FOO constants */ -#include /* nftw() et al. */ -#include -#include /* basename(), dirname() */ -#include -#include -#include -#include -#include -#include - -/* ACLs */ -#include /* acl_get_perm, not portable */ -#include -#include - -/* Most of the libacl functions return 1 for success, 0 for failure, - and -1 on error */ -#define ACL_ERROR -1 -#define ACL_FAILURE 0 -#define ACL_SUCCESS 1 +#include "libadacl.h" +/* We exit with EXIT_FAILURE for small errors, but we need something + * else for big ones. */ +#define EXIT_ERROR 2 +/* Prototypes */ +bool path_accessible(const char* path); +void usage(const char* program_name); /** @@ -68,710 +57,6 @@ bool path_accessible(const char* path) { } - -/** - * @brief Determine whether or not the given path is a directory. - * - * @param path - * The path to test. - * - * @return true if @c path is a directory, false otherwise. - */ -bool is_path_directory(const char* path) { - if (path == NULL) { - return false; - } - - struct stat s; - if (lstat(path, &s) == 0) { - return S_ISDIR(s.st_mode); - } - else { - return false; - } -} - - - - -/** - * @brief Update (or create) an entry in an @b minimal ACL. - * - * This function will not work if @c aclp contains extended - * entries. This is fine for our purposes, since we call @c wipe_acls - * on each path before applying the default to it. - * - * The assumption that there are no extended entries makes things much - * simpler. For example, we only have to update the @c ACL_USER_OBJ, - * @c ACL_GROUP_OBJ, and @c ACL_OTHER entries -- all others can simply - * be created anew. This means we don't have to fool around comparing - * named-user/group entries. - * - * @param aclp - * A pointer to the acl_t structure whose entry we want to modify. - * - * @param entry - * The new entry. If @c entry contains a user/group/other entry, we - * update the existing one. Otherwise we create a new entry. - * - * @return If there is an unexpected library error, @c ACL_ERROR is - * returned. Otherwise, @c ACL_SUCCESS. - * - */ -int acl_set_entry(acl_t* aclp, acl_entry_t entry) { - - acl_tag_t entry_tag; - if (acl_get_tag_type(entry, &entry_tag) == ACL_ERROR) { - perror("acl_set_entry (acl_get_tag_type)"); - return ACL_ERROR; - } - - acl_permset_t entry_permset; - if (acl_get_permset(entry, &entry_permset) == ACL_ERROR) { - perror("acl_set_entry (acl_get_permset)"); - return ACL_ERROR; - } - - acl_entry_t existing_entry; - /* Loop through the given ACL looking for matching entries. */ - int result = acl_get_entry(*aclp, ACL_FIRST_ENTRY, &existing_entry); - - while (result == ACL_SUCCESS) { - acl_tag_t existing_tag = ACL_UNDEFINED_TAG; - - if (acl_get_tag_type(existing_entry, &existing_tag) == ACL_ERROR) { - perror("set_acl_tag_permset (acl_get_tag_type)"); - return ACL_ERROR; - } - - if (existing_tag == entry_tag) { - if (entry_tag == ACL_USER_OBJ || - entry_tag == ACL_GROUP_OBJ || - entry_tag == ACL_OTHER) { - /* Only update for these three since all other tags will have - been wiped. These three are guaranteed to exist, so if we - match one of them, we're allowed to return ACL_SUCCESS - below and bypass the rest of the function. */ - acl_permset_t existing_permset; - if (acl_get_permset(existing_entry, &existing_permset) == ACL_ERROR) { - perror("acl_set_entry (acl_get_permset)"); - return ACL_ERROR; - } - - if (acl_set_permset(existing_entry, entry_permset) == ACL_ERROR) { - perror("acl_set_entry (acl_set_permset)"); - return ACL_ERROR; - } - - return ACL_SUCCESS; - } - - } - - result = acl_get_entry(*aclp, ACL_NEXT_ENTRY, &existing_entry); - } - - /* This catches both the initial acl_get_entry and the ones at the - end of the loop. */ - if (result == ACL_ERROR) { - perror("acl_set_entry (acl_get_entry)"); - return ACL_ERROR; - } - - /* If we've made it this far, we need to add a new entry to the - ACL. */ - acl_entry_t new_entry; - - /* The acl_create_entry() function can allocate new memory and/or - * change the location of the ACL structure entirely. When that - * happens, the value pointed to by aclp is updated, which means - * that a new acl_t gets "passed out" to our caller, eventually to - * be fed to acl_free(). In other words, we should still be freeing - * the right thing, even if the value pointed to by aclp changes. - */ - if (acl_create_entry(aclp, &new_entry) == ACL_ERROR) { - perror("acl_set_entry (acl_create_entry)"); - return ACL_ERROR; - } - - if (acl_set_tag_type(new_entry, entry_tag) == ACL_ERROR) { - perror("acl_set_entry (acl_set_tag_type)"); - return ACL_ERROR; - } - - if (acl_set_permset(new_entry, entry_permset) == ACL_ERROR) { - perror("acl_set_entry (acl_set_permset)"); - return ACL_ERROR; - } - - if (entry_tag == ACL_USER || entry_tag == ACL_GROUP) { - /* We need to set the qualifier too. */ - void* entry_qual = acl_get_qualifier(entry); - if (entry_qual == (void*)NULL) { - perror("acl_set_entry (acl_get_qualifier)"); - return ACL_ERROR; - } - - if (acl_set_qualifier(new_entry, entry_qual) == ACL_ERROR) { - perror("acl_set_entry (acl_set_qualifier)"); - return ACL_ERROR; - } - } - - return ACL_SUCCESS; -} - - - -/** - * @brief Determine the number of entries in the given ACL. - * - * @param acl - * The ACL to inspect. - * - * @return Either the non-negative number of entries in @c acl, or - * @c ACL_ERROR on error. - */ -int acl_entry_count(acl_t acl) { - - acl_entry_t entry; - int entry_count = 0; - int result = acl_get_entry(acl, ACL_FIRST_ENTRY, &entry); - - while (result == ACL_SUCCESS) { - entry_count++; - result = acl_get_entry(acl, ACL_NEXT_ENTRY, &entry); - } - - if (result == ACL_ERROR) { - perror("acl_entry_count (acl_get_entry)"); - return ACL_ERROR; - } - - return entry_count; -} - - - -/** - * @brief Determine whether or not the given ACL is minimal. - * - * An ACL is minimal if it has fewer than four entries. - * - * @param acl - * The ACL whose minimality is in question. - * - * @return - * - @c ACL_SUCCESS - @c acl is minimal - * - @c ACL_FAILURE - @c acl is not minimal - * - @c ACL_ERROR - Unexpected library error - */ -int acl_is_minimal(acl_t acl) { - - int ec = acl_entry_count(acl); - - if (ec == ACL_ERROR) { - perror("acl_is_minimal (acl_entry_count)"); - return ACL_ERROR; - } - - if (ec < 4) { - return ACL_SUCCESS; - } - else { - return ACL_FAILURE; - } -} - - - -/** - * @brief Determine whether the given ACL's mask denies execute. - * - * @param acl - * The ACL whose mask we want to check. - * - * @return - * - @c ACL_SUCCESS - The @c acl has a mask which denies execute. - * - @c ACL_FAILURE - The @c acl has a mask which does not deny execute. - * - @c ACL_ERROR - Unexpected library error. - */ -int acl_execute_masked(acl_t acl) { - - acl_entry_t entry; - int ge_result = acl_get_entry(acl, ACL_FIRST_ENTRY, &entry); - - while (ge_result == ACL_SUCCESS) { - acl_tag_t tag = ACL_UNDEFINED_TAG; - - if (acl_get_tag_type(entry, &tag) == ACL_ERROR) { - perror("acl_execute_masked (acl_get_tag_type)"); - return ACL_ERROR; - } - - if (tag == ACL_MASK) { - /* This is the mask entry, get its permissions, and see if - execute is specified. */ - acl_permset_t permset; - - if (acl_get_permset(entry, &permset) == ACL_ERROR) { - perror("acl_execute_masked (acl_get_permset)"); - return ACL_ERROR; - } - - int gp_result = acl_get_perm(permset, ACL_EXECUTE); - if (gp_result == ACL_ERROR) { - perror("acl_execute_masked (acl_get_perm)"); - return ACL_ERROR; - } - - if (gp_result == ACL_FAILURE) { - /* No execute bit set in the mask; execute not allowed. */ - return ACL_SUCCESS; - } - } - - ge_result = acl_get_entry(acl, ACL_NEXT_ENTRY, &entry); - } - - return ACL_FAILURE; -} - - - -/** - * @brief Determine whether @c fd is executable by anyone. - * - * - * This is used as part of the heuristic to determine whether or not - * we should mask the execute bit when inheriting an ACL. If @c fd - * describes a file, we check the @a effective permissions, contrary - * to what setfacl does. - * - * @param fd - * The file descriptor to check. - * - * @return - * - @c ACL_SUCCESS - Someone has effective execute permissions on @c fd. - * - @c ACL_FAILURE - Nobody can execute @c fd. - * - @c ACL_ERROR - Unexpected library error. - */ -int any_can_execute(int fd) { - acl_t acl = acl_get_fd(fd); - - if (acl == (acl_t)NULL) { - perror("any_can_execute (acl_get_file)"); - return ACL_ERROR; - } - - /* Our return value. */ - int result = ACL_FAILURE; - - if (acl_is_minimal(acl)) { - struct stat s; - if (fstat(fd, &s) == -1) { - perror("any_can_execute (fstat)"); - result = ACL_ERROR; - goto cleanup; - } - if (s.st_mode & (S_IXUSR | S_IXOTH | S_IXGRP)) { - result = ACL_SUCCESS; - goto cleanup; - } - else { - result = ACL_FAILURE; - goto cleanup; - } - } - - acl_entry_t entry; - int ge_result = acl_get_entry(acl, ACL_FIRST_ENTRY, &entry); - - while (ge_result == ACL_SUCCESS) { - /* The first thing we do is check to see if this is a mask - entry. If it is, we skip it entirely. */ - acl_tag_t tag = ACL_UNDEFINED_TAG; - - if (acl_get_tag_type(entry, &tag) == ACL_ERROR) { - perror("any_can_execute_or (acl_get_tag_type)"); - result = ACL_ERROR; - goto cleanup; - } - - if (tag == ACL_MASK) { - ge_result = acl_get_entry(acl, ACL_NEXT_ENTRY, &entry); - continue; - } - - /* Ok, so it's not a mask entry. Check the execute perms. */ - acl_permset_t permset; - - if (acl_get_permset(entry, &permset) == ACL_ERROR) { - perror("any_can_execute_or (acl_get_permset)"); - result = ACL_ERROR; - goto cleanup; - } - - int gp_result = acl_get_perm(permset, ACL_EXECUTE); - if (gp_result == ACL_ERROR) { - perror("any_can_execute (acl_get_perm)"); - result = ACL_ERROR; - goto cleanup; - } - - if (gp_result == ACL_SUCCESS) { - /* Only return ACL_SUCCESS if this execute bit is not masked. */ - if (acl_execute_masked(acl) != ACL_SUCCESS) { - result = ACL_SUCCESS; - goto cleanup; - } - } - - ge_result = acl_get_entry(acl, ACL_NEXT_ENTRY, &entry); - } - - if (ge_result == ACL_ERROR) { - perror("any_can_execute (acl_get_entry)"); - result = ACL_ERROR; - goto cleanup; - } - - cleanup: - acl_free(acl); - return result; -} - - - -/** - * @brief Set @c acl as the default ACL on @c path if it's a directory. - * - * This overwrites any existing default ACL on @c path. If no default - * ACL exists, then one is created. If @c path is not a directory, we - * return ACL_FAILURE but no error is raised. - * - * @param path - * The target directory whose ACL we wish to replace or create. - * - * @param acl - * The ACL to set as default on @c path. - * - * @return - * - @c ACL_SUCCESS - The default ACL was assigned successfully. - * - @c ACL_FAILURE - If @c path is not a directory. - * - @c ACL_ERROR - Unexpected library error. - */ -int assign_default_acl(const char* path, acl_t acl) { - - if (path == NULL) { - errno = EINVAL; - perror("assign_default_acl (args)"); - return ACL_ERROR; - } - - if (!is_path_directory(path)) { - return ACL_FAILURE; - } - - /* Our return value; success unless something bad happens. */ - int result = ACL_SUCCESS; - acl_t path_acl = acl_dup(acl); - - if (path_acl == (acl_t)NULL) { - perror("assign_default_acl (acl_dup)"); - return ACL_ERROR; /* Nothing to clean up in this case. */ - } - - if (acl_set_file(path, ACL_TYPE_DEFAULT, path_acl) == ACL_ERROR) { - perror("assign_default_acl (acl_set_file)"); - result = ACL_ERROR; - } - - acl_free(path_acl); - return result; -} - - - -/** - * @brief Remove all @c ACL_TYPE_ACCESS entries from the given file - * descriptor, leaving the UNIX permission bits. - * - * @param fd - * The file descriptor whose ACLs we want to wipe. - * - * @return - * - @c ACL_SUCCESS - The ACLs were wiped successfully, or none - * existed in the first place. - * - @c ACL_ERROR - Unexpected library error. - */ -int wipe_acls(int fd) { - /* Initialize an empty ACL, and then overwrite the one on "fd" with it. */ - acl_t empty_acl = acl_init(0); - - if (empty_acl == (acl_t)NULL) { - perror("wipe_acls (acl_init)"); - return ACL_ERROR; - } - - if (acl_set_fd(fd, empty_acl) == ACL_ERROR) { - perror("wipe_acls (acl_set_fd)"); - acl_free(empty_acl); - return ACL_ERROR; - } - - acl_free(empty_acl); - return ACL_SUCCESS; -} - - - -/** - * @brief Apply parent default ACL to a path. - * - * This overwrites any existing ACLs on @c path. - * - * @param path - * The path whose ACL we would like to reset to its default. - * - * @param sp - * A pointer to a stat structure for @c path, or @c NULL if you don't - * have one handy. - * - * @param no_exec_mask - * The value (either true or false) of the --no-exec-mask flag. - * - * @return - * - @c ACL_SUCCESS - The parent default ACL was inherited successfully. - * - @c ACL_FAILURE - The target path is not a regular file/directory, - * or the parent of @c path is not a directory. - * - @c ACL_ERROR - Unexpected library error. - */ -int apply_default_acl(const char* path, - const struct stat* sp, - bool no_exec_mask) { - - if (path == NULL) { - errno = EINVAL; - perror("apply_default_acl (args)"); - return ACL_ERROR; - } - - /* Define these next three variables here because we may have to - * jump to the cleanup routine which expects them to exist. - */ - - /* Our return value. */ - int result = ACL_SUCCESS; - - /* The default ACL on path's parent directory */ - acl_t defacl = (acl_t)NULL; - - /* The file descriptor corresponding to "path" */ - int fd = 0; - - /* Split "path" into base/dirname parts to be used with openat(). - * We duplicate the strings involved because dirname/basename mangle - * their arguments. - */ - char* path_copy = strdup(path); - if (path_copy == NULL) { - perror("apply_default_acl (strdup)"); - return ACL_ERROR; - } - char* parent = dirname(path_copy); - - fd = open(path, O_NOFOLLOW); - if (fd == -1) { - if (errno == ELOOP) { - result = ACL_FAILURE; /* hit a symlink */ - goto cleanup; - } - else { - perror("apply_default_acl (open fd)"); - result = ACL_ERROR; - goto cleanup; - } - } - - - /* Refuse to operate on hard links, which can be abused by an - * attacker to trick us into changing the ACL on a file we didn't - * intend to; namely the "target" of the hard link. There is TOCTOU - * race condition here, but the window is as small as possible - * between when we open the file descriptor (look above) and when we - * fstat it. - * - * Note: we only need to call fstat ourselves if we weren't passed a - * valid pointer to a stat structure (nftw does that). - */ - if (sp == NULL) { - struct stat s; - if (fstat(fd, &s) == -1) { - perror("apply_default_acl (fstat)"); - goto cleanup; - } - - sp = &s; - } - - if (!S_ISDIR(sp->st_mode)) { - /* If it's not a directory, make sure it's a regular, - non-hard-linked file. */ - if (!S_ISREG(sp->st_mode) || sp->st_nlink != 1) { - result = ACL_FAILURE; - goto cleanup; - } - } - - - /* Default to not masking the exec bit; i.e. applying the default - ACL literally. If --no-exec-mask was not specified, then we try - to "guess" whether or not to mask the exec bit. This behavior - is modeled after the capital 'X' perms of setfacl. */ - bool allow_exec = true; - - if (!no_exec_mask) { - /* Never mask the execute bit on directories. */ - int ace_result = any_can_execute(fd) || S_ISDIR(sp->st_mode); - - if (ace_result == ACL_ERROR) { - perror("apply_default_acl (any_can_execute)"); - result = ACL_ERROR; - goto cleanup; - } - - allow_exec = (bool)ace_result; - } - - defacl = acl_get_file(parent, ACL_TYPE_DEFAULT); - - if (defacl == (acl_t)NULL) { - perror("apply_default_acl (acl_get_file)"); - result = ACL_ERROR; - goto cleanup; - } - - if (wipe_acls(fd) == ACL_ERROR) { - perror("apply_default_acl (wipe_acls)"); - result = ACL_ERROR; - goto cleanup; - } - - /* Do this after wipe_acls(), otherwise we'll overwrite the wiped - ACL with this one. */ - acl_t acl = acl_get_fd(fd); - if (acl == (acl_t)NULL) { - perror("apply_default_acl (acl_get_fd)"); - result = ACL_ERROR; - goto cleanup; - } - - /* If it's a directory, inherit the parent's default. */ - if (assign_default_acl(path, defacl) == ACL_ERROR) { - perror("apply_default_acl (assign_default_acl)"); - result = ACL_ERROR; - goto cleanup; - } - - acl_entry_t entry; - int ge_result = acl_get_entry(defacl, ACL_FIRST_ENTRY, &entry); - - while (ge_result == ACL_SUCCESS) { - acl_tag_t tag = ACL_UNDEFINED_TAG; - - if (acl_get_tag_type(entry, &tag) == ACL_ERROR) { - perror("apply_default_acl (acl_get_tag_type)"); - result = ACL_ERROR; - goto cleanup; - } - - - /* We've got an entry/tag from the default ACL. Get its permset. */ - acl_permset_t permset; - if (acl_get_permset(entry, &permset) == ACL_ERROR) { - perror("apply_default_acl (acl_get_permset)"); - result = ACL_ERROR; - goto cleanup; - } - - /* If this is a default mask, fix it up. */ - if (tag == ACL_MASK || - tag == ACL_USER_OBJ || - tag == ACL_GROUP_OBJ || - tag == ACL_OTHER) { - - if (!allow_exec) { - /* The mask doesn't affect acl_user_obj, acl_group_obj (in - minimal ACLs) or acl_other entries, so if execute should be - masked, we have to do it manually. */ - if (acl_delete_perm(permset, ACL_EXECUTE) == ACL_ERROR) { - perror("apply_default_acl (acl_delete_perm)"); - result = ACL_ERROR; - goto cleanup; - } - - if (acl_set_permset(entry, permset) == ACL_ERROR) { - perror("apply_default_acl (acl_set_permset)"); - result = ACL_ERROR; - goto cleanup; - } - } - } - - /* Finally, add the permset to the access ACL. It's actually - * important that we pass in the address of "acl" here, and not - * "acl" itself. Why? The call to acl_create_entry() within - * acl_set_entry() can allocate new memory for the entry. - * Sometimes that can be done in-place, in which case everything - * is cool and the new memory gets released when we call - * acl_free(acl). - * - * But occasionally, the whole ACL structure will have to be moved - * in order to allocate the extra space. When that happens, - * acl_create_entry() modifies the pointer it was passed (in this - * case, &acl) to point to the new location. We want to call - * acl_free() on the new location, and since acl_free() gets - * called right here, we need acl_create_entry() to update the - * value of "acl". To do that, it needs the address of "acl". - */ - if (acl_set_entry(&acl, entry) == ACL_ERROR) { - perror("apply_default_acl (acl_set_entry)"); - result = ACL_ERROR; - goto cleanup; - } - - ge_result = acl_get_entry(defacl, ACL_NEXT_ENTRY, &entry); - } - - /* Catches the first acl_get_entry as well as the ones at the end of - the loop. */ - if (ge_result == ACL_ERROR) { - perror("apply_default_acl (acl_get_entry)"); - result = ACL_ERROR; - goto cleanup; - } - - if (acl_set_fd(fd, acl) == ACL_ERROR) { - perror("apply_default_acl (acl_set_fd)"); - result = ACL_ERROR; - goto cleanup; - } - - cleanup: - free(path_copy); - if (defacl != (acl_t)NULL) { - acl_free(defacl); - } - if (fd >= 0 && close(fd) == -1) { - perror("apply_default_acl (close)"); - result = ACL_ERROR; - } - return result; -} - - - /** * @brief Display program usage information. * @@ -780,126 +65,23 @@ int apply_default_acl(const char* path, * */ void usage(const char* program_name) { + if (program_name == NULL) { + /* ??? */ + return; + } + printf("Apply any applicable default ACLs to the given files or " - "directories.\n\n"); + "directories.\n\n"); printf("Usage: %s [flags] [ [ ...]]\n\n", - program_name); + program_name); printf("Flags:\n"); printf(" -h, --help Print this help message\n"); printf(" -r, --recursive Act on any given directories recursively\n"); - printf(" -x, --no-exec-mask Apply execute permissions unconditionally\n"); return; } -/** - * @brief Wrapper around @c apply_default_acl() for use with @c nftw(). - * - * For parameter information, see the @c nftw man page. - * - * @return If the ACL was applied to @c target successfully, we return - * @c FTW_CONTINUE to signal to @ nftw() that we should proceed onto - * the next file or directory. Otherwise, we return @c FTW_STOP to - * signal failure. - * - */ -int apply_default_acl_nftw(const char *target, - const struct stat *sp, - int info, - struct FTW *ftw) { - - if (apply_default_acl(target, sp, false)) { - return FTW_CONTINUE; - } - else { - return FTW_STOP; - } -} - - - -/** - * @brief Wrapper around @c apply_default_acl() for use with @c nftw(). - * - * This is identical to @c apply_default_acl_nftw(), except it passes - * @c true to @c apply_default_acl() as its no_exec_mask argument. - * - */ -int apply_default_acl_nftw_x(const char *target, - const struct stat *sp, - int info, - struct FTW *ftw) { - - if (apply_default_acl(target, sp, true)) { - return FTW_CONTINUE; - } - else { - return FTW_STOP; - } -} - - - -/** - * @brief Recursive version of @c apply_default_acl(). - * - * If @c target is a directory, we use @c nftw() to call @c - * apply_default_acl() recursively on all of its children. Otherwise, - * we just delegate to @c apply_default_acl(). - * - * We ignore symlinks for consistency with chmod -r. - * - * @param target - * The root (path) of the recursive application. - * - * @param no_exec_mask - * The value (either true or false) of the --no-exec-mask flag. - * - * @return - * If @c target is not a directory, we return the result of - * calling @c apply_default_acl() on @c target. Otherwise, we convert - * the return value of @c nftw(). If @c nftw() succeeds (returns 0), - * then we return @c true. Otherwise, we return @c false. - * \n\n - * If there is an error, it will be reported via @c perror, but - * we still return @c false. - */ -bool apply_default_acl_recursive(const char *target, bool no_exec_mask) { - - if (!is_path_directory(target)) { - return apply_default_acl(target, NULL, no_exec_mask); - } - - int max_levels = 256; - int flags = FTW_PHYS; /* Don't follow links. */ - - /* There are two separate functions that could be passed to - nftw(). One passes no_exec_mask = true to apply_default_acl(), - and the other passes no_exec_mask = false. Since the function we - pass to nftw() cannot have parameters, we have to create separate - options and make the decision here. */ - int (*fn)(const char *, const struct stat *, int, struct FTW *) = NULL; - fn = no_exec_mask ? apply_default_acl_nftw_x : apply_default_acl_nftw; - - int nftw_result = nftw(target, fn, max_levels, flags); - - if (nftw_result == 0) { - /* Success */ - return true; - } - - /* nftw will return -1 on error, or if the supplied function - * (apply_default_acl_nftw) returns a non-zero result, nftw will - * return that. - */ - if (nftw_result == -1) { - perror("apply_default_acl_recursive (nftw)"); - } - - return false; -} - /** @@ -918,13 +100,11 @@ int main(int argc, char* argv[]) { } bool recursive = false; - bool no_exec_mask = false; struct option long_options[] = { /* These options set a flag. */ {"help", no_argument, NULL, 'h'}, {"recursive", no_argument, NULL, 'r'}, - {"no-exec-mask", no_argument, NULL, 'x'}, {NULL, 0, NULL, 0} }; @@ -938,9 +118,6 @@ int main(int argc, char* argv[]) { case 'r': recursive = true; break; - case 'x': - no_exec_mask = true; - break; default: usage(argv[0]); return EXIT_FAILURE; @@ -950,9 +127,9 @@ int main(int argc, char* argv[]) { int result = EXIT_SUCCESS; int arg_index = 1; + int reapp_result = ACL_SUCCESS; for (arg_index = optind; arg_index < argc; arg_index++) { const char* target = argv[arg_index]; - bool reapp_result = false; /* Make sure we can access the given path before we go out of our * way to please it. Doing this check outside of @@ -960,22 +137,21 @@ int main(int argc, char* argv[]) { * typos, too. */ if (!path_accessible(target)) { - fprintf(stderr, "%s: %s: No such file or directory\n", argv[0], target); + perror(target); result = EXIT_FAILURE; continue; } - if (recursive) { - reapp_result = apply_default_acl_recursive(target, no_exec_mask); - } - else { - /* It's either a normal file, or we're not operating recursively. */ - reapp_result = apply_default_acl(target, NULL, no_exec_mask); - } + reapp_result = apply_default_acl(target, recursive); - if (!reapp_result) { + if (result == EXIT_SUCCESS && reapp_result == ACL_FAILURE) { + /* We don't want to turn an error into a (less-severe) failure. */ result = EXIT_FAILURE; } + if (reapp_result == ACL_ERROR) { + /* Turn both success and failure into an error, if we encounter one. */ + result = EXIT_ERROR; + } } return result;