freebsd-dev/tests/sys/audit/file-attribute-access.c
Alex Richardson 40407d3998 tests/sys/audit: Skip extattr tests if extattrs are not supported
In the CheriBSD CI, we run the testsuite with /tmp as tmpfs. This causes
the extattr audit tests to fail since tmpfs does not (yet) support
extattrs. Skip those tests if the target path is on a file system that
does not support extended file attributes.

While touching these two files also convert the ATF_REQUIRE_EQ(-1, ...)
checks to use ATF_REQURIE_ERRNO().

Reviewed By:	asomers
Differential Revision: https://reviews.freebsd.org/D28392
2021-02-02 09:55:19 +00:00

1257 lines
31 KiB
C

/*-
* Copyright (c) 2018 Aniket Pandey
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <sys/extattr.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/ucred.h>
#include <atf-c.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include "utils.h"
static struct pollfd fds[1];
static mode_t mode = 0777;
static pid_t pid;
static fhandle_t fht;
static int filedesc, fhdesc;
static char extregex[80];
static char buff[] = "ezio";
static struct stat statbuff;
static struct statfs statfsbuff;
static const char *auclass = "fa";
static const char *name = "authorname";
static const char *path = "fileforaudit";
static const char *errpath = "dirdoesnotexist/fileforaudit";
static const char *successreg = "fileforaudit.*return,success";
static const char *failurereg = "fileforaudit.*return,failure";
ATF_TC_WITH_CLEANUP(stat_success);
ATF_TC_HEAD(stat_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"stat(2) call");
}
ATF_TC_BODY(stat_success, tc)
{
/* File needs to exist to call stat(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, stat(path, &statbuff));
check_audit(fds, successreg, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(stat_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(stat_failure);
ATF_TC_HEAD(stat_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"stat(2) call");
}
ATF_TC_BODY(stat_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
/* Failure reason: file does not exist */
ATF_REQUIRE_ERRNO(ENOENT, stat(errpath, &statbuff) == -1);
check_audit(fds, failurereg, pipefd);
}
ATF_TC_CLEANUP(stat_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(lstat_success);
ATF_TC_HEAD(lstat_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"lstat(2) call");
}
ATF_TC_BODY(lstat_success, tc)
{
/* Symbolic link needs to exist to call lstat(2) */
ATF_REQUIRE_EQ(0, symlink("symlink", path));
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, lstat(path, &statbuff));
check_audit(fds, successreg, pipefd);
}
ATF_TC_CLEANUP(lstat_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(lstat_failure);
ATF_TC_HEAD(lstat_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"lstat(2) call");
}
ATF_TC_BODY(lstat_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
/* Failure reason: symbolic link does not exist */
ATF_REQUIRE_ERRNO(ENOENT, lstat(errpath, &statbuff) == -1);
check_audit(fds, failurereg, pipefd);
}
ATF_TC_CLEANUP(lstat_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fstat_success);
ATF_TC_HEAD(fstat_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"fstat(2) call");
}
ATF_TC_BODY(fstat_success, tc)
{
/* File needs to exist to call fstat(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT | O_RDWR, mode)) != -1);
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, fstat(filedesc, &statbuff));
snprintf(extregex, sizeof(extregex),
"fstat.*%jd.*return,success", (intmax_t)statbuff.st_ino);
check_audit(fds, extregex, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(fstat_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fstat_failure);
ATF_TC_HEAD(fstat_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"fstat(2) call");
}
ATF_TC_BODY(fstat_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
const char *regex = "fstat.*return,failure : Bad file descriptor";
/* Failure reason: bad file descriptor */
ATF_REQUIRE_ERRNO(EBADF, fstat(-1, &statbuff) == -1);
check_audit(fds, regex, pipefd);
}
ATF_TC_CLEANUP(fstat_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fstatat_success);
ATF_TC_HEAD(fstatat_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"fstatat(2) call");
}
ATF_TC_BODY(fstatat_success, tc)
{
/* File or Symbolic link needs to exist to call lstat(2) */
ATF_REQUIRE_EQ(0, symlink("symlink", path));
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, fstatat(AT_FDCWD, path, &statbuff,
AT_SYMLINK_NOFOLLOW));
check_audit(fds, successreg, pipefd);
}
ATF_TC_CLEANUP(fstatat_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fstatat_failure);
ATF_TC_HEAD(fstatat_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"fstatat(2) call");
}
ATF_TC_BODY(fstatat_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
/* Failure reason: symbolic link does not exist */
ATF_REQUIRE_ERRNO(ENOENT,
fstatat(AT_FDCWD, path, &statbuff, AT_SYMLINK_NOFOLLOW) == -1);
check_audit(fds, failurereg, pipefd);
}
ATF_TC_CLEANUP(fstatat_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(statfs_success);
ATF_TC_HEAD(statfs_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"statfs(2) call");
}
ATF_TC_BODY(statfs_success, tc)
{
/* File needs to exist to call statfs(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, statfs(path, &statfsbuff));
check_audit(fds, successreg, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(statfs_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(statfs_failure);
ATF_TC_HEAD(statfs_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"statfs(2) call");
}
ATF_TC_BODY(statfs_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
/* Failure reason: file does not exist */
ATF_REQUIRE_ERRNO(ENOENT, statfs(errpath, &statfsbuff) == -1);
check_audit(fds, failurereg, pipefd);
}
ATF_TC_CLEANUP(statfs_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fstatfs_success);
ATF_TC_HEAD(fstatfs_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"fstatfs(2) call");
}
ATF_TC_BODY(fstatfs_success, tc)
{
/* File needs to exist to call fstat(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT | O_RDWR, mode)) != -1);
/* Call stat(2) to store the Inode number of 'path' */
ATF_REQUIRE_EQ(0, stat(path, &statbuff));
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, fstatfs(filedesc, &statfsbuff));
snprintf(extregex, sizeof(extregex), "fstatfs.*%jd.*return,success",
(intmax_t)statbuff.st_ino);
check_audit(fds, extregex, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(fstatfs_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fstatfs_failure);
ATF_TC_HEAD(fstatfs_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"fstatfs(2) call");
}
ATF_TC_BODY(fstatfs_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
const char *regex = "fstatfs.*return,failure : Bad file descriptor";
/* Failure reason: bad file descriptor */
ATF_REQUIRE_ERRNO(EBADF, fstatfs(-1, &statfsbuff) == -1);
check_audit(fds, regex, pipefd);
}
ATF_TC_CLEANUP(fstatfs_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(getfsstat_success);
ATF_TC_HEAD(getfsstat_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"getfsstat(2) call");
}
ATF_TC_BODY(getfsstat_success, tc)
{
pid = getpid();
snprintf(extregex, sizeof(extregex), "getfsstat.*%d.*success", pid);
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE(getfsstat(NULL, 0, MNT_NOWAIT) != -1);
check_audit(fds, extregex, pipefd);
}
ATF_TC_CLEANUP(getfsstat_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(getfsstat_failure);
ATF_TC_HEAD(getfsstat_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"getfsstat(2) call");
}
ATF_TC_BODY(getfsstat_failure, tc)
{
const char *regex = "getfsstat.*return,failure : Invalid argument";
FILE *pipefd = setup(fds, auclass);
/* Failure reason: Invalid value for mode */
ATF_REQUIRE_ERRNO(EINVAL, getfsstat(NULL, 0, -1) == -1);
check_audit(fds, regex, pipefd);
}
ATF_TC_CLEANUP(getfsstat_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(lgetfh_success);
ATF_TC_HEAD(lgetfh_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"lgetfh(2) call");
}
ATF_TC_BODY(lgetfh_success, tc)
{
/* Symbolic link needs to exist to get a file-handle */
ATF_REQUIRE_EQ(0, symlink("symlink", path));
const char *regex = "lgetfh.*return,success";
FILE *pipefd = setup(fds, "fa");
ATF_REQUIRE_EQ(0, lgetfh(path, &fht));
check_audit(fds, regex, pipefd);
}
ATF_TC_CLEANUP(lgetfh_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(lgetfh_failure);
ATF_TC_HEAD(lgetfh_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"lgetfh(2) call");
}
ATF_TC_BODY(lgetfh_failure, tc)
{
const char *regex = "lgetfh.*return,failure";
FILE *pipefd = setup(fds, "fa");
/* Failure reason: symbolic link does not exist */
ATF_REQUIRE_ERRNO(ENOENT, lgetfh(errpath, &fht) == -1);
check_audit(fds, regex, pipefd);
}
ATF_TC_CLEANUP(lgetfh_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fhopen_success);
ATF_TC_HEAD(fhopen_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"fhopen(2) call");
}
ATF_TC_BODY(fhopen_success, tc)
{
pid = getpid();
snprintf(extregex, sizeof(extregex), "fhopen.*%d.*return,success", pid);
/* File needs to exist to get a file-handle */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
/* Get the file handle to be passed to fhopen(2) */
ATF_REQUIRE_EQ(0, getfh(path, &fht));
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE((fhdesc = fhopen(&fht, O_RDWR)) != -1);
check_audit(fds, extregex, pipefd);
close(fhdesc);
close(filedesc);
}
ATF_TC_CLEANUP(fhopen_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fhopen_failure);
ATF_TC_HEAD(fhopen_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"fhopen(2) call");
}
ATF_TC_BODY(fhopen_failure, tc)
{
const char *regex = "fhopen.*return,failure : Invalid argument";
FILE *pipefd = setup(fds, auclass);
/*
* Failure reason: NULL does not represent any file handle
* and O_CREAT is not allowed as the flag for fhopen(2)
*/
ATF_REQUIRE_ERRNO(EINVAL, fhopen(NULL, O_CREAT) == -1);
check_audit(fds, regex, pipefd);
}
ATF_TC_CLEANUP(fhopen_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fhstat_success);
ATF_TC_HEAD(fhstat_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"fstat(2) call");
}
ATF_TC_BODY(fhstat_success, tc)
{
pid = getpid();
snprintf(extregex, sizeof(extregex), "fhstat.*%d.*return,success", pid);
/* File needs to exist to get a file-handle */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
/* Get the file handle to be passed to fhstat(2) */
ATF_REQUIRE_EQ(0, getfh(path, &fht));
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, fhstat(&fht, &statbuff));
check_audit(fds, extregex, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(fhstat_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fhstat_failure);
ATF_TC_HEAD(fhstat_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"fhstat(2) call");
}
ATF_TC_BODY(fhstat_failure, tc)
{
const char *regex = "fhstat.*return,failure : Bad address";
FILE *pipefd = setup(fds, auclass);
/* Failure reason: NULL does not represent any file handle */
ATF_REQUIRE_ERRNO(EFAULT, fhstat(NULL, NULL) == -1);
check_audit(fds, regex, pipefd);
}
ATF_TC_CLEANUP(fhstat_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fhstatfs_success);
ATF_TC_HEAD(fhstatfs_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"fstatfs(2) call");
}
ATF_TC_BODY(fhstatfs_success, tc)
{
pid = getpid();
snprintf(extregex, sizeof(extregex), "fhstatfs.*%d.*success", pid);
/* File needs to exist to get a file-handle */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
/* Get the file handle to be passed to fhstatfs(2) */
ATF_REQUIRE_EQ(0, getfh(path, &fht));
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, fhstatfs(&fht, &statfsbuff));
check_audit(fds, extregex, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(fhstatfs_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fhstatfs_failure);
ATF_TC_HEAD(fhstatfs_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"fhstatfs(2) call");
}
ATF_TC_BODY(fhstatfs_failure, tc)
{
const char *regex = "fhstatfs.*return,failure : Bad address";
FILE *pipefd = setup(fds, auclass);
/* Failure reason: NULL does not represent any file handle */
ATF_REQUIRE_ERRNO(EFAULT, fhstatfs(NULL, NULL) == -1);
check_audit(fds, regex, pipefd);
}
ATF_TC_CLEANUP(fhstatfs_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(access_success);
ATF_TC_HEAD(access_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"access(2) call");
}
ATF_TC_BODY(access_success, tc)
{
/* File needs to exist to call access(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, access(path, F_OK));
check_audit(fds, successreg, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(access_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(access_failure);
ATF_TC_HEAD(access_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"access(2) call");
}
ATF_TC_BODY(access_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
/* Failure reason: file does not exist */
ATF_REQUIRE_ERRNO(ENOENT, access(errpath, F_OK) == -1);
check_audit(fds, failurereg, pipefd);
}
ATF_TC_CLEANUP(access_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(eaccess_success);
ATF_TC_HEAD(eaccess_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"eaccess(2) call");
}
ATF_TC_BODY(eaccess_success, tc)
{
/* File needs to exist to call eaccess(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, eaccess(path, F_OK));
check_audit(fds, successreg, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(eaccess_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(eaccess_failure);
ATF_TC_HEAD(eaccess_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"eaccess(2) call");
}
ATF_TC_BODY(eaccess_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
/* Failure reason: file does not exist */
ATF_REQUIRE_ERRNO(ENOENT, eaccess(errpath, F_OK) == -1);
check_audit(fds, failurereg, pipefd);
}
ATF_TC_CLEANUP(eaccess_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(faccessat_success);
ATF_TC_HEAD(faccessat_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"faccessat(2) call");
}
ATF_TC_BODY(faccessat_success, tc)
{
/* File needs to exist to call faccessat(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
FILE *pipefd = setup(fds, auclass);
ATF_REQUIRE_EQ(0, faccessat(AT_FDCWD, path, F_OK, AT_EACCESS));
check_audit(fds, successreg, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(faccessat_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(faccessat_failure);
ATF_TC_HEAD(faccessat_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"faccessat(2) call");
}
ATF_TC_BODY(faccessat_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
/* Failure reason: file does not exist */
ATF_REQUIRE_ERRNO(ENOENT,
faccessat(AT_FDCWD, errpath, F_OK, AT_EACCESS) == -1);
check_audit(fds, failurereg, pipefd);
}
ATF_TC_CLEANUP(faccessat_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(pathconf_success);
ATF_TC_HEAD(pathconf_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"pathconf(2) call");
}
ATF_TC_BODY(pathconf_success, tc)
{
/* File needs to exist to call pathconf(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
FILE *pipefd = setup(fds, auclass);
/* Get the maximum number of bytes of filename */
ATF_REQUIRE(pathconf(path, _PC_NAME_MAX) != -1);
check_audit(fds, successreg, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(pathconf_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(pathconf_failure);
ATF_TC_HEAD(pathconf_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"pathconf(2) call");
}
ATF_TC_BODY(pathconf_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
/* Failure reason: file does not exist */
ATF_REQUIRE_ERRNO(ENOENT, pathconf(errpath, _PC_NAME_MAX) == -1);
check_audit(fds, failurereg, pipefd);
}
ATF_TC_CLEANUP(pathconf_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(lpathconf_success);
ATF_TC_HEAD(lpathconf_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"lpathconf(2) call");
}
ATF_TC_BODY(lpathconf_success, tc)
{
/* Symbolic link needs to exist to call lpathconf(2) */
ATF_REQUIRE_EQ(0, symlink("symlink", path));
FILE *pipefd = setup(fds, auclass);
/* Get the maximum number of bytes of symlink's name */
ATF_REQUIRE(lpathconf(path, _PC_SYMLINK_MAX) != -1);
check_audit(fds, successreg, pipefd);
}
ATF_TC_CLEANUP(lpathconf_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(lpathconf_failure);
ATF_TC_HEAD(lpathconf_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"lpathconf(2) call");
}
ATF_TC_BODY(lpathconf_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
/* Failure reason: symbolic link does not exist */
ATF_REQUIRE_ERRNO(ENOENT, lpathconf(errpath, _PC_SYMLINK_MAX) == -1);
check_audit(fds, failurereg, pipefd);
}
ATF_TC_CLEANUP(lpathconf_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fpathconf_success);
ATF_TC_HEAD(fpathconf_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"fpathconf(2) call");
}
ATF_TC_BODY(fpathconf_success, tc)
{
pid = getpid();
snprintf(extregex, sizeof(extregex), "fpathconf.*%d.*success", pid);
/* File needs to exist to call fpathconf(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
FILE *pipefd = setup(fds, auclass);
/* Get the maximum number of bytes of filename */
ATF_REQUIRE(fpathconf(filedesc, _PC_NAME_MAX) != -1);
check_audit(fds, extregex, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(fpathconf_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(fpathconf_failure);
ATF_TC_HEAD(fpathconf_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"fpathconf(2) call");
}
ATF_TC_BODY(fpathconf_failure, tc)
{
FILE *pipefd = setup(fds, auclass);
const char *regex = "fpathconf.*return,failure : Bad file descriptor";
/* Failure reason: Bad file descriptor */
ATF_REQUIRE_ERRNO(EBADF, fpathconf(-1, _PC_NAME_MAX) == -1);
check_audit(fds, regex, pipefd);
}
ATF_TC_CLEANUP(fpathconf_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_get_file_success);
ATF_TC_HEAD(extattr_get_file_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"extattr_get_file(2) call");
}
ATF_TC_BODY(extattr_get_file_success, tc)
{
/* File needs to exist to call extattr_get_file(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
skip_if_extattr_not_supported(path);
/* Set an extended attribute to be retrieved later on */
REQUIRE_EXTATTR_RESULT(sizeof(buff),
extattr_set_file(path, EXTATTR_NAMESPACE_USER, name, buff,
sizeof(buff)));
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_get_file.*%s.*%s.*return,success", path, name);
FILE *pipefd = setup(fds, auclass);
REQUIRE_EXTATTR_RESULT(sizeof(buff),
extattr_get_file(path, EXTATTR_NAMESPACE_USER, name, NULL, 0));
check_audit(fds, extregex, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(extattr_get_file_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_get_file_failure);
ATF_TC_HEAD(extattr_get_file_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"extattr_get_file(2) call");
}
ATF_TC_BODY(extattr_get_file_failure, tc)
{
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_get_file.*%s.*%s.*failure", path, name);
FILE *pipefd = setup(fds, auclass);
/* Failure reason: file does not exist */
ATF_REQUIRE_ERRNO(ENOENT,
extattr_get_file(path, EXTATTR_NAMESPACE_USER, name, NULL, 0) ==
-1);
check_audit(fds, extregex, pipefd);
}
ATF_TC_CLEANUP(extattr_get_file_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_get_fd_success);
ATF_TC_HEAD(extattr_get_fd_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"extattr_get_fd(2) call");
}
ATF_TC_BODY(extattr_get_fd_success, tc)
{
/* File needs to exist to call extattr_get_fd(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
skip_if_extattr_not_supported(path);
/* Set an extended attribute to be retrieved later on */
REQUIRE_EXTATTR_RESULT(sizeof(buff),
extattr_set_file(path, EXTATTR_NAMESPACE_USER, name, buff,
sizeof(buff)));
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_get_fd.*%s.*return,success", name);
FILE *pipefd = setup(fds, auclass);
REQUIRE_EXTATTR_RESULT(sizeof(buff),
extattr_get_fd(filedesc, EXTATTR_NAMESPACE_USER, name, NULL, 0));
check_audit(fds, extregex, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(extattr_get_fd_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_get_fd_failure);
ATF_TC_HEAD(extattr_get_fd_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"extattr_get_fd(2) call");
}
ATF_TC_BODY(extattr_get_fd_failure, tc)
{
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_get_fd.*%s.*return,failure : Bad file descriptor", name);
FILE *pipefd = setup(fds, auclass);
/* Failure reason: Invalid file descriptor */
ATF_REQUIRE_ERRNO(EBADF,
extattr_get_fd(-1, EXTATTR_NAMESPACE_USER, name, NULL, 0) == -1);
check_audit(fds, extregex, pipefd);
}
ATF_TC_CLEANUP(extattr_get_fd_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_get_link_success);
ATF_TC_HEAD(extattr_get_link_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"extattr_get_link(2) call");
}
ATF_TC_BODY(extattr_get_link_success, tc)
{
/* Symbolic link needs to exist to call extattr_get_link(2) */
ATF_REQUIRE_EQ(0, symlink("symlink", path));
skip_if_extattr_not_supported(".");
/* Set an extended attribute to be retrieved later on */
REQUIRE_EXTATTR_RESULT(sizeof(buff),
extattr_set_link(path, EXTATTR_NAMESPACE_USER, name, buff,
sizeof(buff)));
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_get_link.*%s.*%s.*return,success", path, name);
FILE *pipefd = setup(fds, auclass);
REQUIRE_EXTATTR_RESULT(sizeof(buff),
extattr_get_link(path, EXTATTR_NAMESPACE_USER, name, NULL, 0));
check_audit(fds, extregex, pipefd);
}
ATF_TC_CLEANUP(extattr_get_link_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_get_link_failure);
ATF_TC_HEAD(extattr_get_link_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"extattr_get_link(2) call");
}
ATF_TC_BODY(extattr_get_link_failure, tc)
{
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_get_link.*%s.*%s.*failure", path, name);
FILE *pipefd = setup(fds, auclass);
/* Failure reason: symbolic link does not exist */
ATF_REQUIRE_ERRNO(ENOENT,
extattr_get_link(path, EXTATTR_NAMESPACE_USER, name, NULL, 0));
check_audit(fds, extregex, pipefd);
}
ATF_TC_CLEANUP(extattr_get_link_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_list_file_success);
ATF_TC_HEAD(extattr_list_file_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"extattr_list_file(2) call");
}
ATF_TC_BODY(extattr_list_file_success, tc)
{
ssize_t readbuff;
/* File needs to exist to call extattr_list_file(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
skip_if_extattr_not_supported(path);
FILE *pipefd = setup(fds, auclass);
readbuff = REQUIRE_EXTATTR_SUCCESS(
extattr_list_file(path, EXTATTR_NAMESPACE_USER, NULL, 0));
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_list_file.*%s.*return,success,%zd", path, readbuff);
check_audit(fds, extregex, pipefd);
}
ATF_TC_CLEANUP(extattr_list_file_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_list_file_failure);
ATF_TC_HEAD(extattr_list_file_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"extattr_list_file(2) call");
}
ATF_TC_BODY(extattr_list_file_failure, tc)
{
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_list_file.*%s.*return,failure", path);
FILE *pipefd = setup(fds, auclass);
/* Failure reason: file does not exist */
ATF_REQUIRE_ERRNO(ENOENT,
extattr_list_file(path, EXTATTR_NAMESPACE_USER, NULL, 0));
check_audit(fds, extregex, pipefd);
}
ATF_TC_CLEANUP(extattr_list_file_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_list_fd_success);
ATF_TC_HEAD(extattr_list_fd_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"extattr_list_fd(2) call");
}
ATF_TC_BODY(extattr_list_fd_success, tc)
{
ssize_t readbuff;
/* File needs to exist to call extattr_list_fd(2) */
ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
skip_if_extattr_not_supported(path);
FILE *pipefd = setup(fds, auclass);
readbuff = REQUIRE_EXTATTR_SUCCESS(
extattr_list_fd(filedesc, EXTATTR_NAMESPACE_USER, NULL, 0));
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_list_fd.*return,success,%zd", readbuff);
check_audit(fds, extregex, pipefd);
close(filedesc);
}
ATF_TC_CLEANUP(extattr_list_fd_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_list_fd_failure);
ATF_TC_HEAD(extattr_list_fd_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"extattr_list_fd(2) call");
}
ATF_TC_BODY(extattr_list_fd_failure, tc)
{
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_list_fd.*return,failure : Bad file descriptor");
FILE *pipefd = setup(fds, auclass);
/* Failure reason: Invalid file descriptor */
ATF_REQUIRE_ERRNO(EBADF,
extattr_list_fd(-1, EXTATTR_NAMESPACE_USER, NULL, 0) == -1);
check_audit(fds, extregex, pipefd);
}
ATF_TC_CLEANUP(extattr_list_fd_failure, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_list_link_success);
ATF_TC_HEAD(extattr_list_link_success, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
"extattr_list_link(2) call");
}
ATF_TC_BODY(extattr_list_link_success, tc)
{
ssize_t readbuff;
/* Symbolic link needs to exist to call extattr_list_link(2) */
ATF_REQUIRE_EQ(0, symlink("symlink", path));
skip_if_extattr_not_supported(".");
FILE *pipefd = setup(fds, auclass);
readbuff = REQUIRE_EXTATTR_SUCCESS(
extattr_list_link(path, EXTATTR_NAMESPACE_USER, NULL, 0));
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_list_link.*%s.*return,success,%zd", path, readbuff);
check_audit(fds, extregex, pipefd);
}
ATF_TC_CLEANUP(extattr_list_link_success, tc)
{
cleanup();
}
ATF_TC_WITH_CLEANUP(extattr_list_link_failure);
ATF_TC_HEAD(extattr_list_link_failure, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
"extattr_list_link(2) call");
}
ATF_TC_BODY(extattr_list_link_failure, tc)
{
/* Prepare the regex to be checked in the audit record */
snprintf(extregex, sizeof(extregex),
"extattr_list_link.*%s.*failure", path);
FILE *pipefd = setup(fds, auclass);
/* Failure reason: symbolic link does not exist */
ATF_REQUIRE_ERRNO(ENOENT,
extattr_list_link(path, EXTATTR_NAMESPACE_USER, NULL, 0) == -1);
check_audit(fds, extregex, pipefd);
}
ATF_TC_CLEANUP(extattr_list_link_failure, tc)
{
cleanup();
}
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, stat_success);
ATF_TP_ADD_TC(tp, stat_failure);
ATF_TP_ADD_TC(tp, lstat_success);
ATF_TP_ADD_TC(tp, lstat_failure);
ATF_TP_ADD_TC(tp, fstat_success);
ATF_TP_ADD_TC(tp, fstat_failure);
ATF_TP_ADD_TC(tp, fstatat_success);
ATF_TP_ADD_TC(tp, fstatat_failure);
ATF_TP_ADD_TC(tp, statfs_success);
ATF_TP_ADD_TC(tp, statfs_failure);
ATF_TP_ADD_TC(tp, fstatfs_success);
ATF_TP_ADD_TC(tp, fstatfs_failure);
ATF_TP_ADD_TC(tp, getfsstat_success);
ATF_TP_ADD_TC(tp, getfsstat_failure);
ATF_TP_ADD_TC(tp, lgetfh_success);
ATF_TP_ADD_TC(tp, lgetfh_failure);
ATF_TP_ADD_TC(tp, fhopen_success);
ATF_TP_ADD_TC(tp, fhopen_failure);
ATF_TP_ADD_TC(tp, fhstat_success);
ATF_TP_ADD_TC(tp, fhstat_failure);
ATF_TP_ADD_TC(tp, fhstatfs_success);
ATF_TP_ADD_TC(tp, fhstatfs_failure);
ATF_TP_ADD_TC(tp, access_success);
ATF_TP_ADD_TC(tp, access_failure);
ATF_TP_ADD_TC(tp, eaccess_success);
ATF_TP_ADD_TC(tp, eaccess_failure);
ATF_TP_ADD_TC(tp, faccessat_success);
ATF_TP_ADD_TC(tp, faccessat_failure);
ATF_TP_ADD_TC(tp, pathconf_success);
ATF_TP_ADD_TC(tp, pathconf_failure);
ATF_TP_ADD_TC(tp, lpathconf_success);
ATF_TP_ADD_TC(tp, lpathconf_failure);
ATF_TP_ADD_TC(tp, fpathconf_success);
ATF_TP_ADD_TC(tp, fpathconf_failure);
ATF_TP_ADD_TC(tp, extattr_get_file_success);
ATF_TP_ADD_TC(tp, extattr_get_file_failure);
ATF_TP_ADD_TC(tp, extattr_get_fd_success);
ATF_TP_ADD_TC(tp, extattr_get_fd_failure);
ATF_TP_ADD_TC(tp, extattr_get_link_success);
ATF_TP_ADD_TC(tp, extattr_get_link_failure);
ATF_TP_ADD_TC(tp, extattr_list_file_success);
ATF_TP_ADD_TC(tp, extattr_list_file_failure);
ATF_TP_ADD_TC(tp, extattr_list_fd_success);
ATF_TP_ADD_TC(tp, extattr_list_fd_failure);
ATF_TP_ADD_TC(tp, extattr_list_link_success);
ATF_TP_ADD_TC(tp, extattr_list_link_failure);
return (atf_no_error());
}