*
*/
-/* Enables get_current_dir_name() in unistd.h */
+/* Enables get_current_dir_name() in unistd.h and the O_PATH flag. */
#define _GNU_SOURCE
-#include <errno.h> /* ELOOP, EINVAL, etc. */
+#include <errno.h> /* EINVAL, ELOOP, ENOTDIR, etc. */
#include <fcntl.h> /* openat() */
#include <libgen.h> /* basename(), dirname() */
#include <limits.h> /* PATH_MAX */
* open a file descriptor in a symlink-safe way when combined with
* the @c O_NOFOLLOW flag.
*
- * The @c O_PATH flag is not used because we want to fail upon
- * encountering any symlinks.
- *
* @param at_fd
* A file descriptor relative to which @c pathname will be opened.
*
* and @c OPEN_ERROR if not.
*/
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;
+ if (pathname == NULL) {
+ errno = EINVAL;
+ perror("safe_open_ex (args)");
+ return OPEN_ERROR;
}
char* firstslash = strchr(pathname, '/');
if (firstslash == NULL) {
/* No more slashes, this is the base case. */
- int r = openat(at_fd, pathname, flags);
- return r;
+ return openat(at_fd, pathname, flags);
+ }
+ else if (firstslash[1] == '\0') {
+ /* The first slash is the last character; ensure that we open
+ a directory. */
+ firstslash[0] = '\0';
+ return openat(at_fd, pathname, flags | O_DIRECTORY);
}
- /* Temporarily disable the slash, so that the subsequent call to
- openat() opens only the next directory (and doesn't recurse). */
+ /* The first slash exists and isn't the last character in the path,
+ so we can split the path wherever that first slash lies and
+ recurse. */
*firstslash = '\0';
- int fd = safe_open_ex(at_fd, pathname, flags);
+ int fd = openat(at_fd, pathname, flags | O_DIRECTORY | O_PATH);
if (fd == OPEN_ERROR) {
- if (errno != ELOOP) {
+ if (errno != ENOTDIR) {
/* Don't output anything if we ignore a symlink */
perror("safe_open_ex (safe_open_ex)");
}
return OPEN_ERROR;
}
- /* 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. */
+ /* The +1 is safe because there needs to be at least one character
+ after the first slash (we checked this above). */
int result = safe_open_ex(fd, firstslash+1, flags);
if (close(fd) == CLOSE_ERROR) {
perror("safe_open_ex (close)");
return OPEN_ERROR;
}
- int fd = open("/", flags);
+ int fd = 0;
+ if (strcmp(abspath, "/") == 0) {
+ fd = open("/", flags | O_DIRECTORY);
+ }
+ else {
+ /* Use O_PATH for some added safety if "/" is not our target */
+ fd = open("/", flags | O_DIRECTORY | O_PATH);
+ }
if (fd == OPEN_ERROR) {
perror("safe_open (open)");
return OPEN_ERROR;
*
*/
int acl_set_entry(acl_t* aclp, acl_entry_t entry) {
+ if (aclp == NULL || entry == NULL) {
+ errno = EINVAL;
+ perror("acl_set_entry (args)");
+ return ACL_ERROR;
+ }
acl_tag_t entry_tag;
if (acl_get_tag_type(entry, &entry_tag) == ACL_ERROR) {
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;
* - @c ACL_ERROR - Unexpected library error
*/
int acl_is_minimal(acl_t acl) {
+ if (acl == NULL) {
+ errno = EINVAL;
+ perror("acl_is_minimal (args)");
+ return ACL_ERROR;
+ }
int ec = acl_entry_count(acl);
* - @c ACL_ERROR - Unexpected library error.
*/
int acl_execute_masked(acl_t acl) {
+ if (acl == NULL) {
+ errno = EINVAL;
+ perror("acl_execute_masked (args)");
+ return ACL_ERROR;
+ }
acl_entry_t entry;
int ge_result = acl_get_entry(acl, ACL_FIRST_ENTRY, &entry);
* - @c ACL_ERROR - Unexpected library error.
*/
int any_can_execute(int fd, const struct stat* sp) {
+ if (sp == NULL) {
+ errno = EINVAL;
+ perror("any_can_execute (args)");
+ return ACL_ERROR;
+ }
+
acl_t acl = acl_get_fd(fd);
if (acl == (acl_t)NULL) {
* - @c ACL_ERROR - Unexpected library error.
*/
int assign_default_acl(const char* path, acl_t acl) {
-
- if (path == NULL) {
+ if (path == NULL || acl == NULL) {
errno = EINVAL;
perror("assign_default_acl (args)");
return ACL_ERROR;
fd = safe_open(path, O_NOFOLLOW);
if (fd == OPEN_ERROR) {
- if (errno == ELOOP) {
- result = ACL_FAILURE; /* hit a symlink */
+ if (errno == ELOOP || errno == ENOTDIR) {
+ /* We hit a symlink, either in the last path component (ELOOP)
+ or higher up (ENOTDIR). */
+ result = ACL_FAILURE;
goto cleanup;
}
else {