autotools: replace my busted header checks with something that works.

My existing AC_CHECK_HEADERS checks were failing silently. Oops. I've
now defined my own macro in m4/ac_header_required.m4 that successfully
fails when a required header is missing.

configure.ac: fix header name sys/libacl.h -> acl/libacl.h.

configure.ac: use AC_HEADER_DIRENT to check for dirent.h.

configure.ac: remove check for the (not used) sys/types.h header.

configure.ac: remove the check for the (not used) ftw.h header.

configure.ac: drop AC_TYPE_MODE_T since we don't use mode_t anywhere.

autotools: bump the package and library versions to v0.3.0 and v2.0.0.

The apply_default_acl() function now takes a third "recursive"
parameter, so the library gets a new version.

Replace nftw() with manual recursion in apply_default_acl().

The nftw() tree walk worked well for a while; in particular, before we
handled symlinks safely, it was empirically faster than a hand-written
recursive descent. But recently, the very slow safe_open() function
was being called on the path that was passed to apply_default_acl(),
and nftw() fed that function a whole bunch of paths.

The apply_default_acl() function now takes a third "recusive"
parameter, and implements the recursion on its own. This lets us pass
down the old child file descriptor as the new parent file descriptor,
and avoid calling safe_open() more than once when we're operating
recursively. The result is a big speed improvement with --recursive,
tested for example on the Linux kernel source tree.

The hand-written recursion also allows us to fix a lingering exit code
bug. Now --recursive acts as if all of the targets were passed (in the
right order) on the command-line.

The new parameter affects the public API, so in the next release the
library will get a new version. The upside to this is that now it's
easy for other programs to operate recursively, simply by passing
"true" as the third parameter to apply_default_acl().

Update docs and tests for the --recursive exit code.

With the nftw() implementation, there was some bugginess in our exit
code that was both documented and tested. Well now I plan on fixing
that, so the documentation has been updated to state what the exit
code _should_ be, and the tests now check for the correct behavior
(meaning that they fail, for the moment).

run-tests.sh: ensure that we descend into directories with no ACLs.

src/libadacl.c: delete an outdated comment.

autotools: bump the package and library versions to v0.2.0 and v1.0.0.

Since the apply_default_acl_ex() function has been removed from the
public API, a new libadacl.so.1 is needed.

Eliminate the apply_default_acl_ex() function.

The apply_default_acl_ex() function was an "extended" version of the
apply_default_acl() function that, in addition, took a stat structure
pointer to the target path. The extended function was used by nftw(),
which usually has such a stat structure handy. However, the provenance
of that stat structure is not clear: does nftw() obtain it in a safe
way?

Since I don't know the answer to that question, I would rather stat()
the descriptor that I know was obtained safely. Thus there's no reason
to take the pointer as an argument, and then no reason to keep the
extended function around at all.

src/libadacl.c: remove two NULL checks around acl_free() calls.

The acl_free() function will return ACL_ERROR and set errno to EINVAL
if we pass it a null pointer; but aside from that, nothing bad
happens, and removing the checks makes the code marginally cleaner.

src/libadacl.c: fix two comment typos.

apply_default_acl_ex: avoid second call to safe_open() to speed things up.

src/libadacl.c: minor code simplification in safe_open().

src/libadacl.c: fix return type of fgetxattr in acl_copy_xattr().

run-tests.sh: add two tests to ensure a no-op without default ACLs.

run-tests.sh: add a test for the "Not a directory" error message.

run-tests.sh: whitespace cleanup.

src/libadacl.c: rewrite acl_set_entry() as acl_update_entry().

It turns out we only need to update existing entries in our ACLs, to
mask the execute permissions. Since we never need to create new
entries, the name "acl_set_entry" was not quite right. The
new-entry-creation code has been removed from the bottom half of the
function, and it has been renamed to "acl_update_entry".

Eliminate the wipe_acls() function that is apparently not needed.

src/libadacl.c: remove redundant empty pathname checks from safe_open().

src/libadacl.c: kill a pointless "else if" after an "if" that returns.

apply_default_acl_ex: don't loop through the ACL unless we're masking exec.

Improve the error message for most types of inaccessible paths.

Bail out of apply_default_acl_ex() early if the parent has no default ACL.

src/libadacl.c: don't try to close file descriptor zero.

configure.ac: bump to version 0.1.5.

Replace all tabs with spaces. We're not animals.

Eliminate the last bit of pathname usage.

A lot of work has been done recently to make apply-default-acl safe
from symlink and hardlink attacks. A big part of that work was the
recent switch to using file descriptors instead of pathnames; but,
pathnames still lingered in a few places due to a shortcoming in
libacl. Through the use of a new function, acl_copy_xattr(), I've
finally eliminated those last few bits.

The apply_default_acl_ex() function now uses path names only as
arguments to safe_open(), which hopefully is safe. Afterwards, the
file descriptors obtained from safe_open() are used. Thus the hard and
symlink attacks should finally be fixed, modulo a tiny race condition
between safe_open() and fstat() that has no known solution.

These changes rely on the Linux xattr implementation and kill our
portability, but I don't think we ever had any to begin with.

src/libadacl.c: fix a function name inside perror output.

libadacl.c: remove unused acl_get_permset() call in acl_set_entry().

configure.ac: bump to version 0.1.4.

configure.ac: check for the O_PATH flag in fcntl.h.

src/libadacl.c: mention the O_PATH flag in a comment.

configure.ac: check for the O_DIRECTORY flag in fcntl.h.

libadacl.c: use O_PATH in safe_open() for added safety.

configure.ac: bump to version 0.1.3.

Add various NULL pointer checks for good measure.

safe_open_ex: remove redundant (pathname == NULL) check.

safe_open_ex: add a comment about why O_PATH doesn't work.

run-tests.sh: add more tests for exit codes.

src/apply-default-acl.c: update the CLI to match documented exit codes.

man/apply-default-acl.1: add a note about the --recursive exit codes.

run-tests.sh: add two tests for regular file and symlink exit codes.

man/apply-default-acl.1: document the way exit codes are SUPPOSED to work.

doc/man/apply-default-acl.1: remove superfluous line breaks.

configure.ac: bump to version 0.1.2.

src/libadacl.h: add missing includes for "bool" and "struct stat" types.

configure.ac: use xz for distfiles.

configure.ac: bump to version 0.1.1.

libadacl: add error checking when we open() the filesystem root.

configure.ac: bump to version 0.1.0.

configure.ac: remove pointless comment at the top of the file.

configure.ac: add checks for openat() and O_NOFOLLOW.

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.