X-Git-Url: https://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=src%2Fapply-default-acl.c;h=45dfa56fecfdf2a160673cb412eda9690bef2f29;hb=86257934b1ac9a26a9582544801528bc4b50fcb3;hp=0030431f481f5ec6acf8790ac923de4178a064eb;hpb=354d04860687e5d3dd42550ce3ef634b067bc2f0;p=apply-default-acl.git diff --git a/src/apply-default-acl.c b/src/apply-default-acl.c index 0030431..45dfa56 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,99 @@ #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); + if (fd == -1) { + if (errno != ELOOP) { + /* Don't output anything if we ignore a symlink */ + perror("safe_open_ex (safe_open_ex)"); + } + return -1; + } + + /* 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 +163,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. * @@ -441,11 +510,10 @@ int any_can_execute(int fd, const struct stat* sp) { /** - * @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. @@ -455,7 +523,6 @@ int any_can_execute(int fd, const struct stat* sp) { * * @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) { @@ -466,11 +533,7 @@ int assign_default_acl(const char* path, acl_t acl) { 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); @@ -567,9 +630,8 @@ int apply_default_acl(const char* path, /* 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) { @@ -578,7 +640,7 @@ int apply_default_acl(const char* path, } 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 */ @@ -664,8 +726,13 @@ int apply_default_acl(const char* path, 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; @@ -863,11 +930,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, NULL, no_exec_mask); - } - int max_levels = 256; int flags = FTW_PHYS; /* Don't follow links. */