configure.ac: add limits.h to the AC_CHECK_HEADERS list.

Add missing "flags" parameter documentation to the safe_open() functions.

Upgrade our Doxyfile automatically with doxygen -u.

Move a few constants out of the libadacl.h header to where they are used.

libadacl: update failure return value docs for apply_default_acl().

Rename apply_default_acl() to apply_default_acl_ex() and add a wrapper.

The old apply_default_acl() function has a weird second argument that
will usually be NULL for other users of the library. Instead of making
them deal with that design choice, the old apply_default_acl()
function was renamed t apply_default_acl_ex(), and a new
apply_default_acl() was added with no second argument to wrap the
former.

libadacl: improve safe_open() error message when given bad args.

Clean up a few "include" statements, and document them.

Split most functions off into a separate shared library.

Update the man page to say that symlinks are ignored in all path components.

Add documentation for the safe_open() and safe_open_ex() functions.

Define a few more error constants to make the code more readable.

Don't output anything in safe_open_ex when we ignore a symlink.

Add a test to ensure that non-terminal symlinks are not followed.

Add a test to ensure that symlinks in the CWD don't cause problems.

Add safe_open() function to fix symlink traversal in non-terminal components.

The standard library provides lots of ways to avoid symlinks in the
"baz" component of "foo/bar/baz", but very few (i.e. zero) ways to
avoid them in the "bar" component. Of course, they're just as
dangerous in either place, so it would be cool if we could ignore
symlinks entirely.

This commit adds a safe_open() function, which looks just like open()
to the caller, but which starts at the root and calls openat() one
component at-a-time. Thus if you use O_NOFOLLOW, nobody can trick you
with an intermediate component: there are no intermediate components;
it works one at-a-time. This slows things down a bit, but not fatally.

Fix an old comment about dirname/basename handling in apply_default_acl().

Eliminate the is_path_directory() function.

The is_path_directory() function was only used in two places:

  1. To avoid involving nftw when the target is a file.
  2. To avoid setting (or trying to) a default ACL on a file.

The first one doesn't really matter, and the correct behavior is
tested, so the additional "is it a directory?" check has been
dropped. In the second case, we still don't want to try to set default
ACLs on files, but now the "is it a directory?" check is done at the
call site, where a stat structure is already available.

With those two uses gone, the function has been removed.

Pass a stat structure pointer to any_can_execute() to avoid a re-stat.

Allow apply_default_acl() to take a stat pointer for its path argument.

When operating recursively, nftw has already called stat() on the path
that it feeds to apply_default_acl(). Rather than re-stat it, we can
now pass a stat struct pointer in as the second argument to
apply_default_acl(). When not operating recursively, you just pass it
NULL instead, and apply_default_acl() will do the fstat as before.

Improve the error message when assign_default_acl() is fed a NULL path.

Eliminate the one remaining use of is_directory().

The is_directory() function was called once, in a place where we
already had access to its argument's stat structure. Instead, we now
just use S_ISDIR, and the is_directory() function has met its end.

Move the "or_dir" out of any_can_execute_or_dir().

The any_can_execute_or_dir() function checked two things; whether or
not anyone could execute something, and whether or not that thing was
a directory. It's cleaner to have the "is it directory?" check outside
these days, so this commit renames that function to any_can_execute()
and the one place it's used now checks whether or not the argument is
a directory itself.

Inline the is_hardlink_safe() and is_regular_file() functions.

These two functions were only called in one place, and they were
called right after one another. Both functions merely peek the stat
structure for a file descriptor, so it's easier to stat the thing once
and then just inline the two checks rather than setup/teardown
everything twice.

Improve the error message when apply_default_acl() is fed a NULL path.

Eliminate pointless newline in the signature of acl_set_entry().

Inline the one call to the get_mode() function.

The get_mode() function was only called in one place, and its
implementation was about three lines. The overhead of checking its
arguments and figuring out its return value was not worth the
absolutely tiny improvement in readability that the function afforded,
so the whole thing has been inlined at its one call site.

Eliminate unnecessary intermediate result variables.

Before this commit, most library calls looked something like...

  int result = foo(x,y);
  if (result == whatever) {
    ...
  }

and then the "result" variable was never used again. There's no need
to introduce the new name, and it probably only increases
confusion. So, this commit eliminates them all.

Simplify wipe_acls() by having it unconditionally write a new, empty ACL.

Replace most path usage with file descriptors.

Before this commit, we were passing around paths everywhere to specify
the targets of operations. This is not optimal from a security
standpoint: the best we can do to avoid following hard links is to
check whether or not a given file has more than one name. There is a
race condition inherent in that approach -- between when you stat the
file and when you use it, the number of names may change -- but using
paths makes that window larger than it has to be. There's no guarantee
that a path used at the bottom of apply_default_acl() will refer to
the same file that we called stat() on at the top of the function.

To work around that, most of the path handling functions have been
replaced with versions that use file descriptors. Now we are able to
stat() our file descriptor immediately after opening it, and the
descriptor itself will always refer to the same file. There's still
the smallest of windows for an exploit, but this makes it much safer
to call apply_default_acl() when there may be hard links present.

Rename is_directory() to is_path_directory() in preparation for other stuff.

Add missing jump-to-cleanup in one error scenario.

Add comments explainining the acl_create_entry() gymnastics.

Remove pointless indirection in acl_entry_count() and acl_is_minimal().

The acl_t type is already a pointer to a structure, so there's no
reason to be passing around pointers to acl_t in acl_entry_count() and
acl_is_minimal(). This commit changes their signatures and call sites.

Have acl_execute_masked() take an acl_t rather than a path as its argument.

We only call acl_execute_masked() in one place; and in that place, the
ACL of the path in question is already available. So, there's no
reason for us to re-retrieve it. Instead, the function has been
updated to take an acl_t (and not a path), simplifing the logic a bit.

Rename inherit_default_acl() to assign_default_acl().

The inherit_default_acl() function was called with two path names, and
the default ACL of the second path was retrieved and applied to the
first path. However, the only situation in which the function was used
was when the default ACL of the parent path was already available -- so
we were wasting time re-retrieving it.

This commit changes the name of the function to assign_default_acl(),
and it now takes an acl_t as its second parameter rather than a
path. The one place it is used now passes it the (already-known)
parent's default ACL rather than that parent's path.

Naively ignore hard links to avoid security mishaps.

If an attacker can introduce a hard link into a directory with a
default ACL, then he may be able to trick the user into applying that
default ACL to the target of the hard link which lives somewhere else
entirely. That can be exploited to gain access to the user's files,
and is hard to detect.

To avoid that problem entirely, great care must be taken. For now, a
naive check of the target path is implemented to ensure that (at the
start of the routine) it has only one name on the filesystem. This
still admits a race condition, but is an improvement.

The new behavior is now documented in the man page, and a test has
been added to ensure that pre-existing hard links are ignored.

Fix capitalization of "No such..." in the expected output of some tests.

Add one more test for recursive symlink handling.

Fix symlink handling and update to version 0.0.6.

There was kind of a big bug in previous versions: symlinks were
followed and they weren't supposed to be. This came down to a few
"stat" calls that should have been "lstat" calls. Those changes have
been made, and there's now a test for the correct behavior.

Unrelated: I capitalized the 'n' in the "No such file..." error.

Add three tests for the new "no such file..." error output.

Use $() for subshells instead of backticks in run-tests.sh.

Print an error if any targets do not exist.

This commit fixes the last known bug, that apply-default-acl can be
called on a file that does not exist and no error is output.

A new function, path_accessible(), was added and it uses the
faccessat() POSIX call to check whether or not the current effective
user/group can access a path. We then call the new path_accessible()
on every target given on the command line. If any do not exist, an
error is printed:

  $ ./apply-default-acl derp
  ./apply-default-acl: derp: no such file or directory

Along with this change comes a version bump to v0.0.5 in configure.ac.
Some minor reorganization was done in configure.ac as well.

Fix a typo in a comment.

Make the usage() function argument program_name const.

Output an error message when a test user is missing.
Add two tests for multiple command-line arguments.

Bump configure.ac to version 0.0.4.
Add -Wall -Werror to the automake command line.
Add the test suite to Makefile.am (will generate a `make check` target).

Fix the bug from the latest test case.

Add a test for a newly-discovered bug.

Replace the global no_exec_mask variable with a slightly less-awful solution.

Whitespace fix.

Add a manpage and update Makefile.am to install it.

Finish Doxygen documentation.

Document more functions with Doxygen.
Replace magic exit codes with defined constants.
Replace a few failure codes with errors.

Begin using Doxygen-style comments.
Add a Doxyfile.

Store the test users in a bash array.
Use separate exit codes for test failure and missing users.

Use (bin,daemon) users instead of (mail,news).

Add a new command-line option, --no-exec-mask, that disables the exec bit masking heuristics.
Add tests for the new command-line option.

Add the acl_execute_masked() function.
Rename any_can_execute to any_can_execute_or_dir().
Don't mask the execute bit if the target is a directory (more-closely follows setfacl's "X" behavior).

Add more tests in preparation for the -x fix.

Set permissions on $TESTDIR in acl_reset.
Use equal signs to delimit expected/actual output.

Add two new tests for repeated application on a directory.

Rename the project to apply-default-acl.

Add a short -r flag example in the README.

Add missing '$' in README.

Update the install docs and usage info in the README.
Add the docs and test script to EXTRA_DIST.
Fix the binary path in the test script.

Add an autogen.sh.

Add a configure.ac, and replace the old makefile with two Makefile.am files.

Use getopt for option parsing.

Add tests for --recursive mode.

Add a --recursive option.
Update the usage() and option parsing for the new flag.

Fix a function name in some error messages.

Add a 'dist' makefile target.

Add LICENSE and README files.
Rename 'aclq' to 'reapply_default_acl' everywhere.

Fix command-line error handling.
Add a few comments.

Add one more test for the default mask execute bit.

Fix an error string.

Whitespace cleanup.

Fix memory leaks.

Remove the TODO (it's done).

Add another test.
Settle on the new reapplication algorithm.
Remove a ton of dead code.

Add a TODO.

Unfix one of those.

Fix two deps in the makefile.

Complicate the shit out of everything to pass the new tests.

Add a few more tricky tests.

Add a 'test' makefile target.
Fix the group execute removal so that the last test passes.
Add a new test.

Generalize a few functions to non-default ACLs.

Add another test and fool around with the logic trying to get it to pass.

Add a test suite.

Fix the logic so that it removes user/other read/write perms not specified in the default ACL.
Don't print "Success."

Change all return types to int.
Add the has_minimal_default_acl() function.
Make group bits correct in the presence of minimal ACLs.
Begin fixing group execute with extended ACLs.

Add -Wall and fix warnings.

Implement the reapply_default_acl function.

Add some non-working junk.

Initial commit, just exploring at the moment.