2 * Copyright (c) 2018 Aniket Pandey
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 #include <sys/param.h>
29 #include <sys/extattr.h>
30 #include <sys/mount.h>
32 #include <sys/syscall.h>
33 #include <sys/ucred.h>
43 static struct pollfd fds[1];
44 static mode_t mode = 0777;
47 static int filedesc, fhdesc;
48 static char extregex[80];
49 static char buff[] = "ezio";
50 static struct stat statbuff;
51 static struct statfs statfsbuff;
52 static const char *auclass = "fa";
53 static const char *name = "authorname";
54 static const char *path = "fileforaudit";
55 static const char *errpath = "dirdoesnotexist/fileforaudit";
56 static const char *successreg = "fileforaudit.*return,success";
57 static const char *failurereg = "fileforaudit.*return,failure";
60 ATF_TC_WITH_CLEANUP(stat_success);
61 ATF_TC_HEAD(stat_success, tc)
63 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
67 ATF_TC_BODY(stat_success, tc)
69 /* File needs to exist to call stat(2) */
70 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
71 FILE *pipefd = setup(fds, auclass);
72 ATF_REQUIRE_EQ(0, stat(path, &statbuff));
73 check_audit(fds, successreg, pipefd);
77 ATF_TC_CLEANUP(stat_success, tc)
83 ATF_TC_WITH_CLEANUP(stat_failure);
84 ATF_TC_HEAD(stat_failure, tc)
86 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
90 ATF_TC_BODY(stat_failure, tc)
92 FILE *pipefd = setup(fds, auclass);
93 /* Failure reason: file does not exist */
94 ATF_REQUIRE_ERRNO(ENOENT, stat(errpath, &statbuff) == -1);
95 check_audit(fds, failurereg, pipefd);
98 ATF_TC_CLEANUP(stat_failure, tc)
104 ATF_TC_WITH_CLEANUP(lstat_success);
105 ATF_TC_HEAD(lstat_success, tc)
107 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
111 ATF_TC_BODY(lstat_success, tc)
113 /* Symbolic link needs to exist to call lstat(2) */
114 ATF_REQUIRE_EQ(0, symlink("symlink", path));
115 FILE *pipefd = setup(fds, auclass);
116 ATF_REQUIRE_EQ(0, lstat(path, &statbuff));
117 check_audit(fds, successreg, pipefd);
120 ATF_TC_CLEANUP(lstat_success, tc)
126 ATF_TC_WITH_CLEANUP(lstat_failure);
127 ATF_TC_HEAD(lstat_failure, tc)
129 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
133 ATF_TC_BODY(lstat_failure, tc)
135 FILE *pipefd = setup(fds, auclass);
136 /* Failure reason: symbolic link does not exist */
137 ATF_REQUIRE_ERRNO(ENOENT, lstat(errpath, &statbuff) == -1);
138 check_audit(fds, failurereg, pipefd);
141 ATF_TC_CLEANUP(lstat_failure, tc)
147 ATF_TC_WITH_CLEANUP(fstat_success);
148 ATF_TC_HEAD(fstat_success, tc)
150 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
154 ATF_TC_BODY(fstat_success, tc)
156 /* File needs to exist to call fstat(2) */
157 ATF_REQUIRE((filedesc = open(path, O_CREAT | O_RDWR, mode)) != -1);
158 FILE *pipefd = setup(fds, auclass);
159 ATF_REQUIRE_EQ(0, fstat(filedesc, &statbuff));
161 snprintf(extregex, sizeof(extregex),
162 "fstat.*%jd.*return,success", (intmax_t)statbuff.st_ino);
163 check_audit(fds, extregex, pipefd);
167 ATF_TC_CLEANUP(fstat_success, tc)
173 ATF_TC_WITH_CLEANUP(fstat_failure);
174 ATF_TC_HEAD(fstat_failure, tc)
176 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
180 ATF_TC_BODY(fstat_failure, tc)
182 FILE *pipefd = setup(fds, auclass);
183 const char *regex = "fstat.*return,failure : Bad file descriptor";
184 /* Failure reason: bad file descriptor */
185 ATF_REQUIRE_ERRNO(EBADF, fstat(-1, &statbuff) == -1);
186 check_audit(fds, regex, pipefd);
189 ATF_TC_CLEANUP(fstat_failure, tc)
195 ATF_TC_WITH_CLEANUP(fstatat_success);
196 ATF_TC_HEAD(fstatat_success, tc)
198 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
202 ATF_TC_BODY(fstatat_success, tc)
204 /* File or Symbolic link needs to exist to call lstat(2) */
205 ATF_REQUIRE_EQ(0, symlink("symlink", path));
206 FILE *pipefd = setup(fds, auclass);
207 ATF_REQUIRE_EQ(0, fstatat(AT_FDCWD, path, &statbuff,
208 AT_SYMLINK_NOFOLLOW));
209 check_audit(fds, successreg, pipefd);
212 ATF_TC_CLEANUP(fstatat_success, tc)
218 ATF_TC_WITH_CLEANUP(fstatat_failure);
219 ATF_TC_HEAD(fstatat_failure, tc)
221 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
225 ATF_TC_BODY(fstatat_failure, tc)
227 FILE *pipefd = setup(fds, auclass);
228 /* Failure reason: symbolic link does not exist */
229 ATF_REQUIRE_ERRNO(ENOENT,
230 fstatat(AT_FDCWD, path, &statbuff, AT_SYMLINK_NOFOLLOW) == -1);
231 check_audit(fds, failurereg, pipefd);
234 ATF_TC_CLEANUP(fstatat_failure, tc)
240 ATF_TC_WITH_CLEANUP(statfs_success);
241 ATF_TC_HEAD(statfs_success, tc)
243 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
247 ATF_TC_BODY(statfs_success, tc)
249 /* File needs to exist to call statfs(2) */
250 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
251 FILE *pipefd = setup(fds, auclass);
252 ATF_REQUIRE_EQ(0, statfs(path, &statfsbuff));
253 check_audit(fds, successreg, pipefd);
257 ATF_TC_CLEANUP(statfs_success, tc)
263 ATF_TC_WITH_CLEANUP(statfs_failure);
264 ATF_TC_HEAD(statfs_failure, tc)
266 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
270 ATF_TC_BODY(statfs_failure, tc)
272 FILE *pipefd = setup(fds, auclass);
273 /* Failure reason: file does not exist */
274 ATF_REQUIRE_ERRNO(ENOENT, statfs(errpath, &statfsbuff) == -1);
275 check_audit(fds, failurereg, pipefd);
278 ATF_TC_CLEANUP(statfs_failure, tc)
284 ATF_TC_WITH_CLEANUP(fstatfs_success);
285 ATF_TC_HEAD(fstatfs_success, tc)
287 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
291 ATF_TC_BODY(fstatfs_success, tc)
293 /* File needs to exist to call fstat(2) */
294 ATF_REQUIRE((filedesc = open(path, O_CREAT | O_RDWR, mode)) != -1);
295 /* Call stat(2) to store the Inode number of 'path' */
296 ATF_REQUIRE_EQ(0, stat(path, &statbuff));
297 FILE *pipefd = setup(fds, auclass);
298 ATF_REQUIRE_EQ(0, fstatfs(filedesc, &statfsbuff));
300 snprintf(extregex, sizeof(extregex), "fstatfs.*%jd.*return,success",
301 (intmax_t)statbuff.st_ino);
302 check_audit(fds, extregex, pipefd);
306 ATF_TC_CLEANUP(fstatfs_success, tc)
312 ATF_TC_WITH_CLEANUP(fstatfs_failure);
313 ATF_TC_HEAD(fstatfs_failure, tc)
315 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
319 ATF_TC_BODY(fstatfs_failure, tc)
321 FILE *pipefd = setup(fds, auclass);
322 const char *regex = "fstatfs.*return,failure : Bad file descriptor";
323 /* Failure reason: bad file descriptor */
324 ATF_REQUIRE_ERRNO(EBADF, fstatfs(-1, &statfsbuff) == -1);
325 check_audit(fds, regex, pipefd);
328 ATF_TC_CLEANUP(fstatfs_failure, tc)
334 ATF_TC_WITH_CLEANUP(getfsstat_success);
335 ATF_TC_HEAD(getfsstat_success, tc)
337 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
338 "getfsstat(2) call");
341 ATF_TC_BODY(getfsstat_success, tc)
344 snprintf(extregex, sizeof(extregex), "getfsstat.*%d.*success", pid);
346 FILE *pipefd = setup(fds, auclass);
347 ATF_REQUIRE(getfsstat(NULL, 0, MNT_NOWAIT) != -1);
348 check_audit(fds, extregex, pipefd);
351 ATF_TC_CLEANUP(getfsstat_success, tc)
357 ATF_TC_WITH_CLEANUP(getfsstat_failure);
358 ATF_TC_HEAD(getfsstat_failure, tc)
360 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
361 "getfsstat(2) call");
364 ATF_TC_BODY(getfsstat_failure, tc)
366 const char *regex = "getfsstat.*return,failure : Invalid argument";
367 FILE *pipefd = setup(fds, auclass);
368 /* Failure reason: Invalid value for mode */
369 ATF_REQUIRE_ERRNO(EINVAL, getfsstat(NULL, 0, -1) == -1);
370 check_audit(fds, regex, pipefd);
373 ATF_TC_CLEANUP(getfsstat_failure, tc)
379 ATF_TC_WITH_CLEANUP(lgetfh_success);
380 ATF_TC_HEAD(lgetfh_success, tc)
382 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
386 ATF_TC_BODY(lgetfh_success, tc)
388 /* Symbolic link needs to exist to get a file-handle */
389 ATF_REQUIRE_EQ(0, symlink("symlink", path));
390 const char *regex = "lgetfh.*return,success";
391 FILE *pipefd = setup(fds, "fa");
392 ATF_REQUIRE_EQ(0, lgetfh(path, &fht));
393 check_audit(fds, regex, pipefd);
396 ATF_TC_CLEANUP(lgetfh_success, tc)
402 ATF_TC_WITH_CLEANUP(lgetfh_failure);
403 ATF_TC_HEAD(lgetfh_failure, tc)
405 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
409 ATF_TC_BODY(lgetfh_failure, tc)
411 const char *regex = "lgetfh.*return,failure";
412 FILE *pipefd = setup(fds, "fa");
413 /* Failure reason: symbolic link does not exist */
414 ATF_REQUIRE_ERRNO(ENOENT, lgetfh(errpath, &fht) == -1);
415 check_audit(fds, regex, pipefd);
418 ATF_TC_CLEANUP(lgetfh_failure, tc)
424 ATF_TC_WITH_CLEANUP(fhopen_success);
425 ATF_TC_HEAD(fhopen_success, tc)
427 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
431 ATF_TC_BODY(fhopen_success, tc)
434 snprintf(extregex, sizeof(extregex), "fhopen.*%d.*return,success", pid);
436 /* File needs to exist to get a file-handle */
437 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
438 /* Get the file handle to be passed to fhopen(2) */
439 ATF_REQUIRE_EQ(0, getfh(path, &fht));
441 FILE *pipefd = setup(fds, auclass);
442 ATF_REQUIRE((fhdesc = fhopen(&fht, O_RDWR)) != -1);
443 check_audit(fds, extregex, pipefd);
449 ATF_TC_CLEANUP(fhopen_success, tc)
455 ATF_TC_WITH_CLEANUP(fhopen_failure);
456 ATF_TC_HEAD(fhopen_failure, tc)
458 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
462 ATF_TC_BODY(fhopen_failure, tc)
464 const char *regex = "fhopen.*return,failure : Invalid argument";
465 FILE *pipefd = setup(fds, auclass);
467 * Failure reason: NULL does not represent any file handle
468 * and O_CREAT is not allowed as the flag for fhopen(2)
470 ATF_REQUIRE_ERRNO(EINVAL, fhopen(NULL, O_CREAT) == -1);
471 check_audit(fds, regex, pipefd);
474 ATF_TC_CLEANUP(fhopen_failure, tc)
480 ATF_TC_WITH_CLEANUP(fhstat_success);
481 ATF_TC_HEAD(fhstat_success, tc)
483 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
487 ATF_TC_BODY(fhstat_success, tc)
490 snprintf(extregex, sizeof(extregex), "fhstat.*%d.*return,success", pid);
492 /* File needs to exist to get a file-handle */
493 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
494 /* Get the file handle to be passed to fhstat(2) */
495 ATF_REQUIRE_EQ(0, getfh(path, &fht));
497 FILE *pipefd = setup(fds, auclass);
498 ATF_REQUIRE_EQ(0, fhstat(&fht, &statbuff));
499 check_audit(fds, extregex, pipefd);
503 ATF_TC_CLEANUP(fhstat_success, tc)
509 ATF_TC_WITH_CLEANUP(fhstat_failure);
510 ATF_TC_HEAD(fhstat_failure, tc)
512 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
516 ATF_TC_BODY(fhstat_failure, tc)
518 const char *regex = "fhstat.*return,failure : Bad address";
519 FILE *pipefd = setup(fds, auclass);
520 /* Failure reason: NULL does not represent any file handle */
521 ATF_REQUIRE_ERRNO(EFAULT, fhstat(NULL, NULL) == -1);
522 check_audit(fds, regex, pipefd);
525 ATF_TC_CLEANUP(fhstat_failure, tc)
531 ATF_TC_WITH_CLEANUP(fhstatfs_success);
532 ATF_TC_HEAD(fhstatfs_success, tc)
534 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
538 ATF_TC_BODY(fhstatfs_success, tc)
541 snprintf(extregex, sizeof(extregex), "fhstatfs.*%d.*success", pid);
543 /* File needs to exist to get a file-handle */
544 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
545 /* Get the file handle to be passed to fhstatfs(2) */
546 ATF_REQUIRE_EQ(0, getfh(path, &fht));
548 FILE *pipefd = setup(fds, auclass);
549 ATF_REQUIRE_EQ(0, fhstatfs(&fht, &statfsbuff));
550 check_audit(fds, extregex, pipefd);
554 ATF_TC_CLEANUP(fhstatfs_success, tc)
560 ATF_TC_WITH_CLEANUP(fhstatfs_failure);
561 ATF_TC_HEAD(fhstatfs_failure, tc)
563 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
567 ATF_TC_BODY(fhstatfs_failure, tc)
569 const char *regex = "fhstatfs.*return,failure : Bad address";
570 FILE *pipefd = setup(fds, auclass);
571 /* Failure reason: NULL does not represent any file handle */
572 ATF_REQUIRE_ERRNO(EFAULT, fhstatfs(NULL, NULL) == -1);
573 check_audit(fds, regex, pipefd);
576 ATF_TC_CLEANUP(fhstatfs_failure, tc)
582 ATF_TC_WITH_CLEANUP(access_success);
583 ATF_TC_HEAD(access_success, tc)
585 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
589 ATF_TC_BODY(access_success, tc)
591 /* File needs to exist to call access(2) */
592 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
593 FILE *pipefd = setup(fds, auclass);
594 ATF_REQUIRE_EQ(0, access(path, F_OK));
595 check_audit(fds, successreg, pipefd);
599 ATF_TC_CLEANUP(access_success, tc)
605 ATF_TC_WITH_CLEANUP(access_failure);
606 ATF_TC_HEAD(access_failure, tc)
608 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
612 ATF_TC_BODY(access_failure, tc)
614 FILE *pipefd = setup(fds, auclass);
615 /* Failure reason: file does not exist */
616 ATF_REQUIRE_ERRNO(ENOENT, access(errpath, F_OK) == -1);
617 check_audit(fds, failurereg, pipefd);
620 ATF_TC_CLEANUP(access_failure, tc)
626 ATF_TC_WITH_CLEANUP(eaccess_success);
627 ATF_TC_HEAD(eaccess_success, tc)
629 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
633 ATF_TC_BODY(eaccess_success, tc)
635 /* File needs to exist to call eaccess(2) */
636 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
637 FILE *pipefd = setup(fds, auclass);
638 ATF_REQUIRE_EQ(0, eaccess(path, F_OK));
639 check_audit(fds, successreg, pipefd);
643 ATF_TC_CLEANUP(eaccess_success, tc)
649 ATF_TC_WITH_CLEANUP(eaccess_failure);
650 ATF_TC_HEAD(eaccess_failure, tc)
652 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
656 ATF_TC_BODY(eaccess_failure, tc)
658 FILE *pipefd = setup(fds, auclass);
659 /* Failure reason: file does not exist */
660 ATF_REQUIRE_ERRNO(ENOENT, eaccess(errpath, F_OK) == -1);
661 check_audit(fds, failurereg, pipefd);
664 ATF_TC_CLEANUP(eaccess_failure, tc)
670 ATF_TC_WITH_CLEANUP(faccessat_success);
671 ATF_TC_HEAD(faccessat_success, tc)
673 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
674 "faccessat(2) call");
677 ATF_TC_BODY(faccessat_success, tc)
679 /* File needs to exist to call faccessat(2) */
680 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
681 FILE *pipefd = setup(fds, auclass);
682 ATF_REQUIRE_EQ(0, faccessat(AT_FDCWD, path, F_OK, AT_EACCESS));
683 check_audit(fds, successreg, pipefd);
687 ATF_TC_CLEANUP(faccessat_success, tc)
693 ATF_TC_WITH_CLEANUP(faccessat_failure);
694 ATF_TC_HEAD(faccessat_failure, tc)
696 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
697 "faccessat(2) call");
700 ATF_TC_BODY(faccessat_failure, tc)
702 FILE *pipefd = setup(fds, auclass);
703 /* Failure reason: file does not exist */
704 ATF_REQUIRE_ERRNO(ENOENT,
705 faccessat(AT_FDCWD, errpath, F_OK, AT_EACCESS) == -1);
706 check_audit(fds, failurereg, pipefd);
709 ATF_TC_CLEANUP(faccessat_failure, tc)
715 ATF_TC_WITH_CLEANUP(pathconf_success);
716 ATF_TC_HEAD(pathconf_success, tc)
718 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
722 ATF_TC_BODY(pathconf_success, tc)
724 /* File needs to exist to call pathconf(2) */
725 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
726 FILE *pipefd = setup(fds, auclass);
727 /* Get the maximum number of bytes of filename */
728 ATF_REQUIRE(pathconf(path, _PC_NAME_MAX) != -1);
729 check_audit(fds, successreg, pipefd);
733 ATF_TC_CLEANUP(pathconf_success, tc)
739 ATF_TC_WITH_CLEANUP(pathconf_failure);
740 ATF_TC_HEAD(pathconf_failure, tc)
742 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
746 ATF_TC_BODY(pathconf_failure, tc)
748 FILE *pipefd = setup(fds, auclass);
749 /* Failure reason: file does not exist */
750 ATF_REQUIRE_ERRNO(ENOENT, pathconf(errpath, _PC_NAME_MAX) == -1);
751 check_audit(fds, failurereg, pipefd);
754 ATF_TC_CLEANUP(pathconf_failure, tc)
760 ATF_TC_WITH_CLEANUP(lpathconf_success);
761 ATF_TC_HEAD(lpathconf_success, tc)
763 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
764 "lpathconf(2) call");
767 ATF_TC_BODY(lpathconf_success, tc)
769 /* Symbolic link needs to exist to call lpathconf(2) */
770 ATF_REQUIRE_EQ(0, symlink("symlink", path));
771 FILE *pipefd = setup(fds, auclass);
772 /* Get the maximum number of bytes of symlink's name */
773 ATF_REQUIRE(lpathconf(path, _PC_SYMLINK_MAX) != -1);
774 check_audit(fds, successreg, pipefd);
777 ATF_TC_CLEANUP(lpathconf_success, tc)
783 ATF_TC_WITH_CLEANUP(lpathconf_failure);
784 ATF_TC_HEAD(lpathconf_failure, tc)
786 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
787 "lpathconf(2) call");
790 ATF_TC_BODY(lpathconf_failure, tc)
792 FILE *pipefd = setup(fds, auclass);
793 /* Failure reason: symbolic link does not exist */
794 ATF_REQUIRE_ERRNO(ENOENT, lpathconf(errpath, _PC_SYMLINK_MAX) == -1);
795 check_audit(fds, failurereg, pipefd);
798 ATF_TC_CLEANUP(lpathconf_failure, tc)
804 ATF_TC_WITH_CLEANUP(fpathconf_success);
805 ATF_TC_HEAD(fpathconf_success, tc)
807 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
808 "fpathconf(2) call");
811 ATF_TC_BODY(fpathconf_success, tc)
814 snprintf(extregex, sizeof(extregex), "fpathconf.*%d.*success", pid);
816 /* File needs to exist to call fpathconf(2) */
817 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
818 FILE *pipefd = setup(fds, auclass);
819 /* Get the maximum number of bytes of filename */
820 ATF_REQUIRE(fpathconf(filedesc, _PC_NAME_MAX) != -1);
821 check_audit(fds, extregex, pipefd);
825 ATF_TC_CLEANUP(fpathconf_success, tc)
831 ATF_TC_WITH_CLEANUP(fpathconf_failure);
832 ATF_TC_HEAD(fpathconf_failure, tc)
834 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
835 "fpathconf(2) call");
838 ATF_TC_BODY(fpathconf_failure, tc)
840 FILE *pipefd = setup(fds, auclass);
841 const char *regex = "fpathconf.*return,failure : Bad file descriptor";
842 /* Failure reason: Bad file descriptor */
843 ATF_REQUIRE_ERRNO(EBADF, fpathconf(-1, _PC_NAME_MAX) == -1);
844 check_audit(fds, regex, pipefd);
847 ATF_TC_CLEANUP(fpathconf_failure, tc)
853 ATF_TC_WITH_CLEANUP(extattr_get_file_success);
854 ATF_TC_HEAD(extattr_get_file_success, tc)
856 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
857 "extattr_get_file(2) call");
860 ATF_TC_BODY(extattr_get_file_success, tc)
862 /* File needs to exist to call extattr_get_file(2) */
863 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
864 skip_if_extattr_not_supported(path);
866 /* Set an extended attribute to be retrieved later on */
867 REQUIRE_EXTATTR_RESULT(sizeof(buff),
868 extattr_set_file(path, EXTATTR_NAMESPACE_USER, name, buff,
871 /* Prepare the regex to be checked in the audit record */
872 snprintf(extregex, sizeof(extregex),
873 "extattr_get_file.*%s.*%s.*return,success", path, name);
875 FILE *pipefd = setup(fds, auclass);
876 REQUIRE_EXTATTR_RESULT(sizeof(buff),
877 extattr_get_file(path, EXTATTR_NAMESPACE_USER, name, NULL, 0));
878 check_audit(fds, extregex, pipefd);
882 ATF_TC_CLEANUP(extattr_get_file_success, tc)
888 ATF_TC_WITH_CLEANUP(extattr_get_file_failure);
889 ATF_TC_HEAD(extattr_get_file_failure, tc)
891 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
892 "extattr_get_file(2) call");
895 ATF_TC_BODY(extattr_get_file_failure, tc)
897 /* Prepare the regex to be checked in the audit record */
898 snprintf(extregex, sizeof(extregex),
899 "extattr_get_file.*%s.*%s.*failure", path, name);
901 FILE *pipefd = setup(fds, auclass);
902 /* Failure reason: file does not exist */
903 ATF_REQUIRE_ERRNO(ENOENT,
904 extattr_get_file(path, EXTATTR_NAMESPACE_USER, name, NULL, 0) ==
906 check_audit(fds, extregex, pipefd);
909 ATF_TC_CLEANUP(extattr_get_file_failure, tc)
915 ATF_TC_WITH_CLEANUP(extattr_get_fd_success);
916 ATF_TC_HEAD(extattr_get_fd_success, tc)
918 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
919 "extattr_get_fd(2) call");
922 ATF_TC_BODY(extattr_get_fd_success, tc)
924 /* File needs to exist to call extattr_get_fd(2) */
925 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
926 skip_if_extattr_not_supported(path);
928 /* Set an extended attribute to be retrieved later on */
929 REQUIRE_EXTATTR_RESULT(sizeof(buff),
930 extattr_set_file(path, EXTATTR_NAMESPACE_USER, name, buff,
933 /* Prepare the regex to be checked in the audit record */
934 snprintf(extregex, sizeof(extregex),
935 "extattr_get_fd.*%s.*return,success", name);
937 FILE *pipefd = setup(fds, auclass);
938 REQUIRE_EXTATTR_RESULT(sizeof(buff),
939 extattr_get_fd(filedesc, EXTATTR_NAMESPACE_USER, name, NULL, 0));
940 check_audit(fds, extregex, pipefd);
944 ATF_TC_CLEANUP(extattr_get_fd_success, tc)
950 ATF_TC_WITH_CLEANUP(extattr_get_fd_failure);
951 ATF_TC_HEAD(extattr_get_fd_failure, tc)
953 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
954 "extattr_get_fd(2) call");
957 ATF_TC_BODY(extattr_get_fd_failure, tc)
959 /* Prepare the regex to be checked in the audit record */
960 snprintf(extregex, sizeof(extregex),
961 "extattr_get_fd.*%s.*return,failure : Bad file descriptor", name);
963 FILE *pipefd = setup(fds, auclass);
964 /* Failure reason: Invalid file descriptor */
965 ATF_REQUIRE_ERRNO(EBADF,
966 extattr_get_fd(-1, EXTATTR_NAMESPACE_USER, name, NULL, 0) == -1);
967 check_audit(fds, extregex, pipefd);
970 ATF_TC_CLEANUP(extattr_get_fd_failure, tc)
976 ATF_TC_WITH_CLEANUP(extattr_get_link_success);
977 ATF_TC_HEAD(extattr_get_link_success, tc)
979 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
980 "extattr_get_link(2) call");
983 ATF_TC_BODY(extattr_get_link_success, tc)
985 /* Symbolic link needs to exist to call extattr_get_link(2) */
986 ATF_REQUIRE_EQ(0, symlink("symlink", path));
987 skip_if_extattr_not_supported(".");
989 /* Set an extended attribute to be retrieved later on */
990 REQUIRE_EXTATTR_RESULT(sizeof(buff),
991 extattr_set_link(path, EXTATTR_NAMESPACE_USER, name, buff,
994 /* Prepare the regex to be checked in the audit record */
995 snprintf(extregex, sizeof(extregex),
996 "extattr_get_link.*%s.*%s.*return,success", path, name);
998 FILE *pipefd = setup(fds, auclass);
999 REQUIRE_EXTATTR_RESULT(sizeof(buff),
1000 extattr_get_link(path, EXTATTR_NAMESPACE_USER, name, NULL, 0));
1001 check_audit(fds, extregex, pipefd);
1004 ATF_TC_CLEANUP(extattr_get_link_success, tc)
1010 ATF_TC_WITH_CLEANUP(extattr_get_link_failure);
1011 ATF_TC_HEAD(extattr_get_link_failure, tc)
1013 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1014 "extattr_get_link(2) call");
1017 ATF_TC_BODY(extattr_get_link_failure, tc)
1019 /* Prepare the regex to be checked in the audit record */
1020 snprintf(extregex, sizeof(extregex),
1021 "extattr_get_link.*%s.*%s.*failure", path, name);
1022 FILE *pipefd = setup(fds, auclass);
1023 /* Failure reason: symbolic link does not exist */
1024 ATF_REQUIRE_ERRNO(ENOENT,
1025 extattr_get_link(path, EXTATTR_NAMESPACE_USER, name, NULL, 0));
1026 check_audit(fds, extregex, pipefd);
1029 ATF_TC_CLEANUP(extattr_get_link_failure, tc)
1035 ATF_TC_WITH_CLEANUP(extattr_list_file_success);
1036 ATF_TC_HEAD(extattr_list_file_success, tc)
1038 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1039 "extattr_list_file(2) call");
1042 ATF_TC_BODY(extattr_list_file_success, tc)
1045 /* File needs to exist to call extattr_list_file(2) */
1046 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
1047 skip_if_extattr_not_supported(path);
1049 FILE *pipefd = setup(fds, auclass);
1050 readbuff = REQUIRE_EXTATTR_SUCCESS(
1051 extattr_list_file(path, EXTATTR_NAMESPACE_USER, NULL, 0));
1052 /* Prepare the regex to be checked in the audit record */
1053 snprintf(extregex, sizeof(extregex),
1054 "extattr_list_file.*%s.*return,success,%zd", path, readbuff);
1055 check_audit(fds, extregex, pipefd);
1058 ATF_TC_CLEANUP(extattr_list_file_success, tc)
1064 ATF_TC_WITH_CLEANUP(extattr_list_file_failure);
1065 ATF_TC_HEAD(extattr_list_file_failure, tc)
1067 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1068 "extattr_list_file(2) call");
1071 ATF_TC_BODY(extattr_list_file_failure, tc)
1073 /* Prepare the regex to be checked in the audit record */
1074 snprintf(extregex, sizeof(extregex),
1075 "extattr_list_file.*%s.*return,failure", path);
1077 FILE *pipefd = setup(fds, auclass);
1078 /* Failure reason: file does not exist */
1079 ATF_REQUIRE_ERRNO(ENOENT,
1080 extattr_list_file(path, EXTATTR_NAMESPACE_USER, NULL, 0));
1081 check_audit(fds, extregex, pipefd);
1084 ATF_TC_CLEANUP(extattr_list_file_failure, tc)
1090 ATF_TC_WITH_CLEANUP(extattr_list_fd_success);
1091 ATF_TC_HEAD(extattr_list_fd_success, tc)
1093 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1094 "extattr_list_fd(2) call");
1097 ATF_TC_BODY(extattr_list_fd_success, tc)
1100 /* File needs to exist to call extattr_list_fd(2) */
1101 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
1102 skip_if_extattr_not_supported(path);
1104 FILE *pipefd = setup(fds, auclass);
1105 readbuff = REQUIRE_EXTATTR_SUCCESS(
1106 extattr_list_fd(filedesc, EXTATTR_NAMESPACE_USER, NULL, 0));
1107 /* Prepare the regex to be checked in the audit record */
1108 snprintf(extregex, sizeof(extregex),
1109 "extattr_list_fd.*return,success,%zd", readbuff);
1110 check_audit(fds, extregex, pipefd);
1114 ATF_TC_CLEANUP(extattr_list_fd_success, tc)
1120 ATF_TC_WITH_CLEANUP(extattr_list_fd_failure);
1121 ATF_TC_HEAD(extattr_list_fd_failure, tc)
1123 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1124 "extattr_list_fd(2) call");
1127 ATF_TC_BODY(extattr_list_fd_failure, tc)
1129 /* Prepare the regex to be checked in the audit record */
1130 snprintf(extregex, sizeof(extregex),
1131 "extattr_list_fd.*return,failure : Bad file descriptor");
1133 FILE *pipefd = setup(fds, auclass);
1134 /* Failure reason: Invalid file descriptor */
1135 ATF_REQUIRE_ERRNO(EBADF,
1136 extattr_list_fd(-1, EXTATTR_NAMESPACE_USER, NULL, 0) == -1);
1137 check_audit(fds, extregex, pipefd);
1140 ATF_TC_CLEANUP(extattr_list_fd_failure, tc)
1146 ATF_TC_WITH_CLEANUP(extattr_list_link_success);
1147 ATF_TC_HEAD(extattr_list_link_success, tc)
1149 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1150 "extattr_list_link(2) call");
1153 ATF_TC_BODY(extattr_list_link_success, tc)
1156 /* Symbolic link needs to exist to call extattr_list_link(2) */
1157 ATF_REQUIRE_EQ(0, symlink("symlink", path));
1158 skip_if_extattr_not_supported(".");
1160 FILE *pipefd = setup(fds, auclass);
1161 readbuff = REQUIRE_EXTATTR_SUCCESS(
1162 extattr_list_link(path, EXTATTR_NAMESPACE_USER, NULL, 0));
1163 /* Prepare the regex to be checked in the audit record */
1164 snprintf(extregex, sizeof(extregex),
1165 "extattr_list_link.*%s.*return,success,%zd", path, readbuff);
1166 check_audit(fds, extregex, pipefd);
1169 ATF_TC_CLEANUP(extattr_list_link_success, tc)
1175 ATF_TC_WITH_CLEANUP(extattr_list_link_failure);
1176 ATF_TC_HEAD(extattr_list_link_failure, tc)
1178 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1179 "extattr_list_link(2) call");
1182 ATF_TC_BODY(extattr_list_link_failure, tc)
1184 /* Prepare the regex to be checked in the audit record */
1185 snprintf(extregex, sizeof(extregex),
1186 "extattr_list_link.*%s.*failure", path);
1187 FILE *pipefd = setup(fds, auclass);
1188 /* Failure reason: symbolic link does not exist */
1189 ATF_REQUIRE_ERRNO(ENOENT,
1190 extattr_list_link(path, EXTATTR_NAMESPACE_USER, NULL, 0) == -1);
1191 check_audit(fds, extregex, pipefd);
1194 ATF_TC_CLEANUP(extattr_list_link_failure, tc)
1202 ATF_TP_ADD_TC(tp, stat_success);
1203 ATF_TP_ADD_TC(tp, stat_failure);
1204 ATF_TP_ADD_TC(tp, lstat_success);
1205 ATF_TP_ADD_TC(tp, lstat_failure);
1206 ATF_TP_ADD_TC(tp, fstat_success);
1207 ATF_TP_ADD_TC(tp, fstat_failure);
1208 ATF_TP_ADD_TC(tp, fstatat_success);
1209 ATF_TP_ADD_TC(tp, fstatat_failure);
1211 ATF_TP_ADD_TC(tp, statfs_success);
1212 ATF_TP_ADD_TC(tp, statfs_failure);
1213 ATF_TP_ADD_TC(tp, fstatfs_success);
1214 ATF_TP_ADD_TC(tp, fstatfs_failure);
1216 ATF_TP_ADD_TC(tp, getfsstat_success);
1217 ATF_TP_ADD_TC(tp, getfsstat_failure);
1219 ATF_TP_ADD_TC(tp, lgetfh_success);
1220 ATF_TP_ADD_TC(tp, lgetfh_failure);
1221 ATF_TP_ADD_TC(tp, fhopen_success);
1222 ATF_TP_ADD_TC(tp, fhopen_failure);
1223 ATF_TP_ADD_TC(tp, fhstat_success);
1224 ATF_TP_ADD_TC(tp, fhstat_failure);
1225 ATF_TP_ADD_TC(tp, fhstatfs_success);
1226 ATF_TP_ADD_TC(tp, fhstatfs_failure);
1228 ATF_TP_ADD_TC(tp, access_success);
1229 ATF_TP_ADD_TC(tp, access_failure);
1230 ATF_TP_ADD_TC(tp, eaccess_success);
1231 ATF_TP_ADD_TC(tp, eaccess_failure);
1232 ATF_TP_ADD_TC(tp, faccessat_success);
1233 ATF_TP_ADD_TC(tp, faccessat_failure);
1235 ATF_TP_ADD_TC(tp, pathconf_success);
1236 ATF_TP_ADD_TC(tp, pathconf_failure);
1237 ATF_TP_ADD_TC(tp, lpathconf_success);
1238 ATF_TP_ADD_TC(tp, lpathconf_failure);
1239 ATF_TP_ADD_TC(tp, fpathconf_success);
1240 ATF_TP_ADD_TC(tp, fpathconf_failure);
1242 ATF_TP_ADD_TC(tp, extattr_get_file_success);
1243 ATF_TP_ADD_TC(tp, extattr_get_file_failure);
1244 ATF_TP_ADD_TC(tp, extattr_get_fd_success);
1245 ATF_TP_ADD_TC(tp, extattr_get_fd_failure);
1246 ATF_TP_ADD_TC(tp, extattr_get_link_success);
1247 ATF_TP_ADD_TC(tp, extattr_get_link_failure);
1249 ATF_TP_ADD_TC(tp, extattr_list_file_success);
1250 ATF_TP_ADD_TC(tp, extattr_list_file_failure);
1251 ATF_TP_ADD_TC(tp, extattr_list_fd_success);
1252 ATF_TP_ADD_TC(tp, extattr_list_fd_failure);
1253 ATF_TP_ADD_TC(tp, extattr_list_link_success);
1254 ATF_TP_ADD_TC(tp, extattr_list_link_failure);
1255 return (atf_no_error());