X-Git-Url: https://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=src%2Fapply-default-acl.c;h=8979d1c56eb1955922d4b9705de9f4876781e3d2;hb=2dee89ff5a032f896d57a353c04525c506372669;hp=d2f8f536b530fa5b63d8fe605c75ab1ac1f737af;hpb=1be99786d05f3a7a75a17badae7b42491442a17a;p=apply-default-acl.git diff --git a/src/apply-default-acl.c b/src/apply-default-acl.c index d2f8f53..8979d1c 100644 --- a/src/apply-default-acl.c +++ b/src/apply-default-acl.c @@ -14,6 +14,7 @@ #include /* nftw() et al. */ #include #include /* basename(), dirname() */ +#include /* PATH_MAX */ #include #include #include @@ -33,6 +34,92 @@ #define ACL_SUCCESS 1 +int safe_open_ex(int at_fd, char* pathname, int flags) { + if (pathname != NULL && strlen(pathname) == 0) { + /* Oops, went one level to deep with nothing to do. */ + return at_fd; + } + + char* firstslash = strchr(pathname, '/'); + if (firstslash == NULL) { + /* No more slashes, this is the base case. */ + int r = openat(at_fd, pathname, flags); + return r; + } + + /* Temporarily disable the slash, so that the subsequent call to + openat() opens only the next directory (and doesn't recurse). */ + *firstslash = '\0'; + int fd = safe_open_ex(at_fd, pathname, flags); + + /* The ++ is safe because there needs to be at least a null byte + after the first slash, even if it's the last real character in + the string. */ + int result = safe_open_ex(fd, firstslash+1, flags); + if (close(fd) == -1) { + perror("safe_open_ex (close)"); + return -1; + } + return result; +} + + +int safe_open(const char* pathname, int flags) { + if (pathname == NULL || strlen(pathname) == 0 || pathname[0] == '\0') { + /* error? */ + return -1; + } + + char abspath[PATH_MAX]; + int snprintf_result = 0; + if (strchr(pathname, '/') == pathname) { + /* pathname is already absolute; just copy it. */ + snprintf_result = snprintf(abspath, PATH_MAX, "%s", pathname); + } + else { + /* Concatenate the current working directory and pathname into an + * absolute path. We use realpath() ONLY on the cwd part, and not + * on the pathname part, because realpath() resolves symlinks. And + * the whole point of all this crap is to avoid following symlinks + * in the pathname. + * + * Using realpath() on the cwd lets us operate on relative paths + * while we're sitting in a directory that happens to have a + * symlink in it; for example: cd /var/run && apply-default-acl foo. + */ + char* cwd = get_current_dir_name(); + if (cwd == NULL) { + perror("safe_open (get_current_dir_name)"); + return -1; + } + + char abs_cwd[PATH_MAX]; + if (realpath(cwd, abs_cwd) == NULL) { + perror("safe_open (realpath)"); + free(cwd); + return -1; + } + snprintf_result = snprintf(abspath, PATH_MAX, "%s/%s", abs_cwd, pathname); + free(cwd); + } + if (snprintf_result == -1 || snprintf_result > PATH_MAX) { + perror("safe_open (snprintf)"); + return -1; + } + + int fd = open("/", flags); + if (strcmp(abspath, "/") == 0) { + return fd; + } + + int result = safe_open_ex(fd, abspath+1, flags); + if (close(fd) == -1) { + perror("safe_open (close)"); + return -1; + } + return result; +} + /** @@ -69,31 +156,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. * @@ -351,12 +413,15 @@ int acl_execute_masked(acl_t acl) { * @param fd * The file descriptor to check. * + * @param sp + * A pointer to a stat structure for @c fd. + * * @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) { +int any_can_execute(int fd, const struct stat* sp) { acl_t acl = acl_get_fd(fd); if (acl == (acl_t)NULL) { @@ -368,13 +433,7 @@ int any_can_execute(int fd) { 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)) { + if (sp->st_mode & (S_IXUSR | S_IXOTH | S_IXGRP)) { result = ACL_SUCCESS; goto cleanup; } @@ -444,11 +503,10 @@ int any_can_execute(int fd) { /** - * @brief Set @c acl as the default ACL on @c path if it's a directory. + * @brief Set @c acl as the default ACL on @c path. * - * 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. + * This overwrites any existing default ACL on @c path. If @c path is + * not a directory, we return ACL_ERROR and @c errno is set. * * @param path * The target directory whose ACL we wish to replace or create. @@ -458,21 +516,17 @@ int any_can_execute(int fd) { * * @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 = ENOENT; + 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. */ + /* Our return value; success unless something bad happens. */ int result = ACL_SUCCESS; acl_t path_acl = acl_dup(acl); @@ -533,6 +587,10 @@ int wipe_acls(int fd) { * @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. * @@ -542,7 +600,9 @@ int wipe_acls(int fd) { * or the parent of @c path is not a directory. * - @c ACL_ERROR - Unexpected library error. */ -int apply_default_acl(const char* path, bool no_exec_mask) { +int apply_default_acl(const char* path, + const struct stat* sp, + bool no_exec_mask) { if (path == NULL) { errno = EINVAL; @@ -563,9 +623,8 @@ int apply_default_acl(const char* path, bool no_exec_mask) { /* 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. + /* Get the parent directory of "path" with dirname(), which happens + * to murder its argument and necessitates a path_copy. */ char* path_copy = strdup(path); if (path_copy == NULL) { @@ -574,7 +633,7 @@ int apply_default_acl(const char* path, bool no_exec_mask) { } char* parent = dirname(path_copy); - fd = open(path, O_NOFOLLOW); + fd = safe_open(path, O_NOFOLLOW); if (fd == -1) { if (errno == ELOOP) { result = ACL_FAILURE; /* hit a symlink */ @@ -594,16 +653,24 @@ int apply_default_acl(const char* path, bool no_exec_mask) { * 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). */ - struct stat s; - if (fstat(fd, &s) == -1) { - perror("apply_default_acl (fstat)"); - goto cleanup; + if (sp == NULL) { + struct stat s; + if (fstat(fd, &s) == -1) { + perror("apply_default_acl (fstat)"); + goto cleanup; + } + + sp = &s; } - if (!S_ISDIR(s.st_mode)) { + + 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(s.st_mode) || s.st_nlink != 1) { + if (!S_ISREG(sp->st_mode) || sp->st_nlink != 1) { result = ACL_FAILURE; goto cleanup; } @@ -618,7 +685,7 @@ int apply_default_acl(const char* path, bool no_exec_mask) { if (!no_exec_mask) { /* Never mask the execute bit on directories. */ - int ace_result = any_can_execute(fd) || S_ISDIR(s.st_mode); + int ace_result = any_can_execute(fd,sp) || S_ISDIR(sp->st_mode); if (ace_result == ACL_ERROR) { perror("apply_default_acl (any_can_execute)"); @@ -652,8 +719,13 @@ int apply_default_acl(const char* path, bool no_exec_mask) { goto cleanup; } - /* If it's a directory, inherit the parent's default. */ - if (assign_default_acl(path, defacl) == ACL_ERROR) { + /* If it's a directory, inherit the parent's default. We sure hope + * that "path" still points to the same thing that "fd" and this + * "sp" describe. If not, we may wind up trying to set a default ACL + * on a file, and this will throw an error. I guess that's what we + * want to do? + */ + if (S_ISDIR(sp->st_mode) && assign_default_acl(path, defacl) == ACL_ERROR) { perror("apply_default_acl (assign_default_acl)"); result = ACL_ERROR; goto cleanup; @@ -790,11 +862,11 @@ void usage(const char* program_name) { * */ int apply_default_acl_nftw(const char *target, - const struct stat *s, + const struct stat *sp, int info, struct FTW *ftw) { - if (apply_default_acl(target, false)) { + if (apply_default_acl(target, sp, false)) { return FTW_CONTINUE; } else { @@ -812,11 +884,11 @@ int apply_default_acl_nftw(const char *target, * */ int apply_default_acl_nftw_x(const char *target, - const struct stat *s, + const struct stat *sp, int info, struct FTW *ftw) { - if (apply_default_acl(target, true)) { + if (apply_default_acl(target, sp, true)) { return FTW_CONTINUE; } else { @@ -851,11 +923,6 @@ int apply_default_acl_nftw_x(const char *target, * 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, no_exec_mask); - } - int max_levels = 256; int flags = FTW_PHYS; /* Don't follow links. */ @@ -955,7 +1022,7 @@ int main(int argc, char* argv[]) { } else { /* It's either a normal file, or we're not operating recursively. */ - reapp_result = apply_default_acl(target, no_exec_mask); + reapp_result = apply_default_acl(target, NULL, no_exec_mask); } if (!reapp_result) {