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/types.h>
29 #include <sys/extattr.h>
44 static uid_t uid = -1;
45 static gid_t gid = -1;
46 static int filedesc, retval;
47 static struct pollfd fds[1];
48 static mode_t mode = 0777;
49 static char extregex[80];
50 static char buff[] = "ezio";
51 static const char *auclass = "fm";
52 static const char *name = "authorname";
53 static const char *path = "fileforaudit";
54 static const char *errpath = "adirhasnoname/fileforaudit";
55 static const char *successreg = "fileforaudit.*return,success";
56 static const char *failurereg = "fileforaudit.*return,failure";
59 ATF_TC_WITH_CLEANUP(flock_success);
60 ATF_TC_HEAD(flock_success, tc)
62 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
66 ATF_TC_BODY(flock_success, tc)
69 snprintf(extregex, sizeof(extregex), "flock.*%d.*return,success", pid);
71 /* File needs to exist to call flock(2) */
72 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
73 FILE *pipefd = setup(fds, auclass);
74 ATF_REQUIRE_EQ(0, flock(filedesc, LOCK_SH));
75 check_audit(fds, extregex, pipefd);
79 ATF_TC_CLEANUP(flock_success, tc)
85 ATF_TC_WITH_CLEANUP(flock_failure);
86 ATF_TC_HEAD(flock_failure, tc)
88 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
92 ATF_TC_BODY(flock_failure, tc)
94 const char *regex = "flock.*return,failure : Bad file descriptor";
95 FILE *pipefd = setup(fds, auclass);
96 ATF_REQUIRE_ERRNO(EBADF, flock(-1, LOCK_SH) == -1);
97 check_audit(fds, regex, pipefd);
100 ATF_TC_CLEANUP(flock_failure, tc)
106 ATF_TC_WITH_CLEANUP(fcntl_success);
107 ATF_TC_HEAD(fcntl_success, tc)
109 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
113 ATF_TC_BODY(fcntl_success, tc)
116 /* File needs to exist to call fcntl(2) */
117 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
118 FILE *pipefd = setup(fds, auclass);
120 /* Retrieve the status flags of 'filedesc' and store it in flagstatus */
121 ATF_REQUIRE((flagstatus = fcntl(filedesc, F_GETFL, 0)) != -1);
122 snprintf(extregex, sizeof(extregex),
123 "fcntl.*return,success,%d", flagstatus);
124 check_audit(fds, extregex, pipefd);
128 ATF_TC_CLEANUP(fcntl_success, tc)
134 ATF_TC_WITH_CLEANUP(fcntl_failure);
135 ATF_TC_HEAD(fcntl_failure, tc)
137 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
141 ATF_TC_BODY(fcntl_failure, tc)
143 const char *regex = "fcntl.*return,failure : Bad file descriptor";
144 FILE *pipefd = setup(fds, auclass);
145 ATF_REQUIRE_ERRNO(EBADF, fcntl(-1, F_GETFL, 0) == -1);
146 check_audit(fds, regex, pipefd);
149 ATF_TC_CLEANUP(fcntl_failure, tc)
155 ATF_TC_WITH_CLEANUP(fsync_success);
156 ATF_TC_HEAD(fsync_success, tc)
158 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
162 ATF_TC_BODY(fsync_success, tc)
165 snprintf(extregex, sizeof(extregex), "fsync.*%d.*return,success", pid);
167 /* File needs to exist to call fsync(2) */
168 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
169 FILE *pipefd = setup(fds, auclass);
170 ATF_REQUIRE_EQ(0, fsync(filedesc));
171 check_audit(fds, extregex, pipefd);
175 ATF_TC_CLEANUP(fsync_success, tc)
181 ATF_TC_WITH_CLEANUP(fsync_failure);
182 ATF_TC_HEAD(fsync_failure, tc)
184 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
188 ATF_TC_BODY(fsync_failure, tc)
190 const char *regex = "fsync.*return,failure : Bad file descriptor";
191 FILE *pipefd = setup(fds, auclass);
192 /* Failure reason: Invalid file descriptor */
193 ATF_REQUIRE_ERRNO(EBADF, fsync(-1) == -1);
194 check_audit(fds, regex, pipefd);
197 ATF_TC_CLEANUP(fsync_failure, tc)
203 ATF_TC_WITH_CLEANUP(chmod_success);
204 ATF_TC_HEAD(chmod_success, tc)
206 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
210 ATF_TC_BODY(chmod_success, tc)
212 /* File needs to exist to call chmod(2) */
213 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
214 FILE *pipefd = setup(fds, auclass);
215 ATF_REQUIRE_EQ(0, chmod(path, mode));
216 check_audit(fds, successreg, pipefd);
220 ATF_TC_CLEANUP(chmod_success, tc)
226 ATF_TC_WITH_CLEANUP(chmod_failure);
227 ATF_TC_HEAD(chmod_failure, tc)
229 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
233 ATF_TC_BODY(chmod_failure, tc)
235 FILE *pipefd = setup(fds, auclass);
236 /* Failure reason: file does not exist */
237 ATF_REQUIRE_ERRNO(ENOENT, chmod(errpath, mode) == -1);
238 check_audit(fds, failurereg, pipefd);
241 ATF_TC_CLEANUP(chmod_failure, tc)
247 ATF_TC_WITH_CLEANUP(fchmod_success);
248 ATF_TC_HEAD(fchmod_success, tc)
250 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
254 ATF_TC_BODY(fchmod_success, tc)
257 snprintf(extregex, sizeof(extregex), "fchmod.*%d.*return,success", pid);
259 /* File needs to exist to call fchmod(2) */
260 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
261 FILE *pipefd = setup(fds, auclass);
262 ATF_REQUIRE_EQ(0, fchmod(filedesc, mode));
263 check_audit(fds, extregex, pipefd);
267 ATF_TC_CLEANUP(fchmod_success, tc)
273 ATF_TC_WITH_CLEANUP(fchmod_failure);
274 ATF_TC_HEAD(fchmod_failure, tc)
276 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
280 ATF_TC_BODY(fchmod_failure, tc)
282 const char *regex = "fchmod.*return,failure : Bad file descriptor";
283 FILE *pipefd = setup(fds, auclass);
284 /* Failure reason: Invalid file descriptor */
285 ATF_REQUIRE_ERRNO(EBADF, fchmod(-1, mode) == -1);
286 check_audit(fds, regex, pipefd);
289 ATF_TC_CLEANUP(fchmod_failure, tc)
295 ATF_TC_WITH_CLEANUP(lchmod_success);
296 ATF_TC_HEAD(lchmod_success, tc)
298 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
302 ATF_TC_BODY(lchmod_success, tc)
304 /* Symbolic link needs to exist to call lchmod(2) */
305 ATF_REQUIRE_EQ(0, symlink("symlink", path));
306 FILE *pipefd = setup(fds, auclass);
307 ATF_REQUIRE_EQ(0, lchmod(path, mode));
308 check_audit(fds, successreg, pipefd);
311 ATF_TC_CLEANUP(lchmod_success, tc)
317 ATF_TC_WITH_CLEANUP(lchmod_failure);
318 ATF_TC_HEAD(lchmod_failure, tc)
320 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
324 ATF_TC_BODY(lchmod_failure, tc)
326 FILE *pipefd = setup(fds, auclass);
327 /* Failure reason: file does not exist */
328 ATF_REQUIRE_ERRNO(ENOENT, lchmod(errpath, mode) == -1);
329 check_audit(fds, failurereg, pipefd);
332 ATF_TC_CLEANUP(lchmod_failure, tc)
338 ATF_TC_WITH_CLEANUP(fchmodat_success);
339 ATF_TC_HEAD(fchmodat_success, tc)
341 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
345 ATF_TC_BODY(fchmodat_success, tc)
347 /* File needs to exist to call fchmodat(2) */
348 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
349 FILE *pipefd = setup(fds, auclass);
350 ATF_REQUIRE_EQ(0, fchmodat(AT_FDCWD, path, mode, 0));
351 check_audit(fds, successreg, pipefd);
355 ATF_TC_CLEANUP(fchmodat_success, tc)
361 ATF_TC_WITH_CLEANUP(fchmodat_failure);
362 ATF_TC_HEAD(fchmodat_failure, tc)
364 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
368 ATF_TC_BODY(fchmodat_failure, tc)
370 FILE *pipefd = setup(fds, auclass);
371 /* Failure reason: file does not exist */
372 ATF_REQUIRE_ERRNO(ENOENT, fchmodat(AT_FDCWD, errpath, mode, 0) == -1);
373 check_audit(fds, failurereg, pipefd);
376 ATF_TC_CLEANUP(fchmodat_failure, tc)
382 ATF_TC_WITH_CLEANUP(chown_success);
383 ATF_TC_HEAD(chown_success, tc)
385 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
389 ATF_TC_BODY(chown_success, tc)
391 /* File needs to exist to call chown(2) */
392 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
393 FILE *pipefd = setup(fds, auclass);
394 ATF_REQUIRE_EQ(0, chown(path, uid, gid));
395 check_audit(fds, successreg, pipefd);
399 ATF_TC_CLEANUP(chown_success, tc)
405 ATF_TC_WITH_CLEANUP(chown_failure);
406 ATF_TC_HEAD(chown_failure, tc)
408 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
412 ATF_TC_BODY(chown_failure, tc)
414 FILE *pipefd = setup(fds, auclass);
415 /* Failure reason: file does not exist */
416 ATF_REQUIRE_ERRNO(ENOENT, chown(errpath, uid, gid) == -1);
417 check_audit(fds, failurereg, pipefd);
420 ATF_TC_CLEANUP(chown_failure, tc)
426 ATF_TC_WITH_CLEANUP(fchown_success);
427 ATF_TC_HEAD(fchown_success, tc)
429 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
433 ATF_TC_BODY(fchown_success, tc)
436 snprintf(extregex, sizeof(extregex), "fchown.*%d.*return,success", pid);
438 /* File needs to exist to call fchown(2) */
439 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
440 FILE *pipefd = setup(fds, auclass);
441 ATF_REQUIRE_EQ(0, fchown(filedesc, uid, gid));
442 check_audit(fds, extregex, pipefd);
446 ATF_TC_CLEANUP(fchown_success, tc)
452 ATF_TC_WITH_CLEANUP(fchown_failure);
453 ATF_TC_HEAD(fchown_failure, tc)
455 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
459 ATF_TC_BODY(fchown_failure, tc)
461 const char *regex = "fchown.*return,failure : Bad file descriptor";
462 FILE *pipefd = setup(fds, auclass);
463 /* Failure reason: Invalid file descriptor */
464 ATF_REQUIRE_ERRNO(EBADF, fchown(-1, uid, gid) == -1);
465 check_audit(fds, regex, pipefd);
468 ATF_TC_CLEANUP(fchown_failure, tc)
474 ATF_TC_WITH_CLEANUP(lchown_success);
475 ATF_TC_HEAD(lchown_success, tc)
477 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
481 ATF_TC_BODY(lchown_success, tc)
483 /* Symbolic link needs to exist to call lchown(2) */
484 ATF_REQUIRE_EQ(0, symlink("symlink", path));
485 FILE *pipefd = setup(fds, auclass);
486 ATF_REQUIRE_EQ(0, lchown(path, uid, gid));
487 check_audit(fds, successreg, pipefd);
490 ATF_TC_CLEANUP(lchown_success, tc)
496 ATF_TC_WITH_CLEANUP(lchown_failure);
497 ATF_TC_HEAD(lchown_failure, tc)
499 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
503 ATF_TC_BODY(lchown_failure, tc)
505 FILE *pipefd = setup(fds, auclass);
506 /* Failure reason: Symbolic link does not exist */
507 ATF_REQUIRE_ERRNO(ENOENT, lchown(errpath, uid, gid) == -1);
508 check_audit(fds, failurereg, pipefd);
511 ATF_TC_CLEANUP(lchown_failure, tc)
517 ATF_TC_WITH_CLEANUP(fchownat_success);
518 ATF_TC_HEAD(fchownat_success, tc)
520 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
524 ATF_TC_BODY(fchownat_success, tc)
526 /* File needs to exist to call fchownat(2) */
527 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
528 FILE *pipefd = setup(fds, auclass);
529 ATF_REQUIRE_EQ(0, fchownat(AT_FDCWD, path, uid, gid, 0));
530 check_audit(fds, successreg, pipefd);
534 ATF_TC_CLEANUP(fchownat_success, tc)
540 ATF_TC_WITH_CLEANUP(fchownat_failure);
541 ATF_TC_HEAD(fchownat_failure, tc)
543 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
547 ATF_TC_BODY(fchownat_failure, tc)
549 FILE *pipefd = setup(fds, auclass);
550 /* Failure reason: file does not exist */
551 ATF_REQUIRE_ERRNO(ENOENT,
552 fchownat(AT_FDCWD, errpath, uid, gid, 0) == -1);
553 check_audit(fds, failurereg, pipefd);
556 ATF_TC_CLEANUP(fchownat_failure, tc)
562 ATF_TC_WITH_CLEANUP(chflags_success);
563 ATF_TC_HEAD(chflags_success, tc)
565 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
569 ATF_TC_BODY(chflags_success, tc)
571 /* File needs to exist to call chflags(2) */
572 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
573 FILE *pipefd = setup(fds, auclass);
574 ATF_REQUIRE_EQ(0, chflags(path, UF_OFFLINE));
575 check_audit(fds, successreg, pipefd);
579 ATF_TC_CLEANUP(chflags_success, tc)
585 ATF_TC_WITH_CLEANUP(chflags_failure);
586 ATF_TC_HEAD(chflags_failure, tc)
588 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
592 ATF_TC_BODY(chflags_failure, tc)
594 FILE *pipefd = setup(fds, auclass);
595 /* Failure reason: file does not exist */
596 ATF_REQUIRE_ERRNO(ENOENT, chflags(errpath, UF_OFFLINE) == -1);
597 check_audit(fds, failurereg, pipefd);
600 ATF_TC_CLEANUP(chflags_failure, tc)
606 ATF_TC_WITH_CLEANUP(fchflags_success);
607 ATF_TC_HEAD(fchflags_success, tc)
609 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
613 ATF_TC_BODY(fchflags_success, tc)
616 snprintf(extregex, sizeof(extregex), "fchflags.*%d.*ret.*success", pid);
617 /* File needs to exist to call fchflags(2) */
618 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
620 FILE *pipefd = setup(fds, auclass);
621 ATF_REQUIRE_EQ(0, fchflags(filedesc, UF_OFFLINE));
622 check_audit(fds, extregex, pipefd);
626 ATF_TC_CLEANUP(fchflags_success, tc)
632 ATF_TC_WITH_CLEANUP(fchflags_failure);
633 ATF_TC_HEAD(fchflags_failure, tc)
635 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
639 ATF_TC_BODY(fchflags_failure, tc)
641 const char *regex = "fchflags.*return,failure : Bad file descriptor";
642 FILE *pipefd = setup(fds, auclass);
643 /* Failure reason: Invalid file descriptor */
644 ATF_REQUIRE_ERRNO(EBADF, fchflags(-1, UF_OFFLINE) == -1);
645 check_audit(fds, regex, pipefd);
648 ATF_TC_CLEANUP(fchflags_failure, tc)
654 ATF_TC_WITH_CLEANUP(lchflags_success);
655 ATF_TC_HEAD(lchflags_success, tc)
657 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
661 ATF_TC_BODY(lchflags_success, tc)
663 /* Symbolic link needs to exist to call lchflags(2) */
664 ATF_REQUIRE_EQ(0, symlink("symlink", path));
665 FILE *pipefd = setup(fds, auclass);
666 ATF_REQUIRE_EQ(0, lchflags(path, UF_OFFLINE));
667 check_audit(fds, successreg, pipefd);
670 ATF_TC_CLEANUP(lchflags_success, tc)
676 ATF_TC_WITH_CLEANUP(lchflags_failure);
677 ATF_TC_HEAD(lchflags_failure, tc)
679 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
683 ATF_TC_BODY(lchflags_failure, tc)
685 FILE *pipefd = setup(fds, auclass);
686 /* Failure reason: Symbolic link does not exist */
687 ATF_REQUIRE_ERRNO(ENOENT, lchflags(errpath, UF_OFFLINE) == -1);
688 check_audit(fds, failurereg, pipefd);
691 ATF_TC_CLEANUP(lchflags_failure, tc)
697 ATF_TC_WITH_CLEANUP(chflagsat_success);
698 ATF_TC_HEAD(chflagsat_success, tc)
700 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
701 "chflagsat(2) call");
704 ATF_TC_BODY(chflagsat_success, tc)
706 /* File needs to exist to call chflagsat(2) */
707 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
708 FILE *pipefd = setup(fds, auclass);
709 ATF_REQUIRE_EQ(0, chflagsat(AT_FDCWD, path, UF_OFFLINE, 0));
710 check_audit(fds, successreg, pipefd);
714 ATF_TC_CLEANUP(chflagsat_success, tc)
720 ATF_TC_WITH_CLEANUP(chflagsat_failure);
721 ATF_TC_HEAD(chflagsat_failure, tc)
723 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
724 "chflagsat(2) call");
727 ATF_TC_BODY(chflagsat_failure, tc)
729 FILE *pipefd = setup(fds, auclass);
730 /* Failure reason: file does not exist */
731 ATF_REQUIRE_ERRNO(ENOENT,
732 chflagsat(AT_FDCWD, errpath, UF_OFFLINE, 0) == -1);
733 check_audit(fds, failurereg, pipefd);
736 ATF_TC_CLEANUP(chflagsat_failure, tc)
742 ATF_TC_WITH_CLEANUP(utimes_success);
743 ATF_TC_HEAD(utimes_success, tc)
745 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
749 ATF_TC_BODY(utimes_success, tc)
751 /* File needs to exist to call utimes(2) */
752 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
753 FILE *pipefd = setup(fds, auclass);
754 ATF_REQUIRE_EQ(0, utimes(path, NULL));
755 check_audit(fds, successreg, pipefd);
759 ATF_TC_CLEANUP(utimes_success, tc)
765 ATF_TC_WITH_CLEANUP(utimes_failure);
766 ATF_TC_HEAD(utimes_failure, tc)
768 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
772 ATF_TC_BODY(utimes_failure, tc)
774 FILE *pipefd = setup(fds, auclass);
775 /* Failure reason: file does not exist */
776 ATF_REQUIRE_ERRNO(ENOENT, utimes(errpath, NULL) == -1);
777 check_audit(fds, failurereg, pipefd);
780 ATF_TC_CLEANUP(utimes_failure, tc)
786 ATF_TC_WITH_CLEANUP(futimes_success);
787 ATF_TC_HEAD(futimes_success, tc)
789 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
793 ATF_TC_BODY(futimes_success, tc)
796 snprintf(extregex, sizeof(extregex), "futimes.*%d.*ret.*success", pid);
798 /* File needs to exist to call futimes(2) */
799 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
800 FILE *pipefd = setup(fds, auclass);
801 ATF_REQUIRE_EQ(0, futimes(filedesc, NULL));
802 check_audit(fds, extregex, pipefd);
806 ATF_TC_CLEANUP(futimes_success, tc)
812 ATF_TC_WITH_CLEANUP(futimes_failure);
813 ATF_TC_HEAD(futimes_failure, tc)
815 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
819 ATF_TC_BODY(futimes_failure, tc)
821 const char *regex = "futimes.*return,failure : Bad file descriptor";
822 FILE *pipefd = setup(fds, auclass);
823 /* Failure reason: Invalid file descriptor */
824 ATF_REQUIRE_ERRNO(EBADF, futimes(-1, NULL) == -1);
825 check_audit(fds, regex, pipefd);
828 ATF_TC_CLEANUP(futimes_failure, tc)
834 ATF_TC_WITH_CLEANUP(lutimes_success);
835 ATF_TC_HEAD(lutimes_success, tc)
837 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
841 ATF_TC_BODY(lutimes_success, tc)
843 /* Symbolic link needs to exist to call lutimes(2) */
844 ATF_REQUIRE_EQ(0, symlink("symlink", path));
845 FILE *pipefd = setup(fds, auclass);
846 ATF_REQUIRE_EQ(0, lutimes(path, NULL));
847 check_audit(fds, successreg, pipefd);
850 ATF_TC_CLEANUP(lutimes_success, tc)
856 ATF_TC_WITH_CLEANUP(lutimes_failure);
857 ATF_TC_HEAD(lutimes_failure, tc)
859 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
863 ATF_TC_BODY(lutimes_failure, tc)
865 FILE *pipefd = setup(fds, auclass);
866 /* Failure reason: symbolic link does not exist */
867 ATF_REQUIRE_ERRNO(ENOENT, lutimes(errpath, NULL) == -1);
868 check_audit(fds, failurereg, pipefd);
871 ATF_TC_CLEANUP(lutimes_failure, tc)
877 ATF_TC_WITH_CLEANUP(futimesat_success);
878 ATF_TC_HEAD(futimesat_success, tc)
880 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
881 "futimesat(2) call");
884 ATF_TC_BODY(futimesat_success, tc)
886 /* File needs to exist to call futimesat(2) */
887 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
888 FILE *pipefd = setup(fds, auclass);
889 ATF_REQUIRE_EQ(0, futimesat(AT_FDCWD, path, NULL));
890 check_audit(fds, successreg, pipefd);
894 ATF_TC_CLEANUP(futimesat_success, tc)
900 ATF_TC_WITH_CLEANUP(futimesat_failure);
901 ATF_TC_HEAD(futimesat_failure, tc)
903 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
904 "futimesat(2) call");
907 ATF_TC_BODY(futimesat_failure, tc)
909 FILE *pipefd = setup(fds, auclass);
910 /* Failure reason: file does not exist */
911 ATF_REQUIRE_ERRNO(ENOENT, futimesat(AT_FDCWD, errpath, NULL) == -1);
912 check_audit(fds, failurereg, pipefd);
915 ATF_TC_CLEANUP(futimesat_failure, tc)
921 ATF_TC_WITH_CLEANUP(mprotect_success);
922 ATF_TC_HEAD(mprotect_success, tc)
924 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
928 ATF_TC_BODY(mprotect_success, tc)
931 snprintf(extregex, sizeof(extregex), "mprotect.*%d.*ret.*success", pid);
933 FILE *pipefd = setup(fds, auclass);
934 ATF_REQUIRE_EQ(0, mprotect(NULL, 0, PROT_NONE));
935 check_audit(fds, extregex, pipefd);
938 ATF_TC_CLEANUP(mprotect_success, tc)
944 ATF_TC_WITH_CLEANUP(mprotect_failure);
945 ATF_TC_HEAD(mprotect_failure, tc)
947 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
951 ATF_TC_BODY(mprotect_failure, tc)
953 const char *regex = "mprotect.*return,failure : Invalid argument";
954 FILE *pipefd = setup(fds, auclass);
955 ATF_REQUIRE_ERRNO(EINVAL,
956 mprotect((void *)SIZE_MAX, -1, PROT_NONE) == -1);
957 check_audit(fds, regex, pipefd);
960 ATF_TC_CLEANUP(mprotect_failure, tc)
966 * undelete(2) only works on whiteout files in union file system. Hence, no
967 * test case for successful invocation.
970 ATF_TC_WITH_CLEANUP(undelete_failure);
971 ATF_TC_HEAD(undelete_failure, tc)
973 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
977 ATF_TC_BODY(undelete_failure, tc)
980 snprintf(extregex, sizeof(extregex), "undelete.*%d.*ret.*failure", pid);
982 FILE *pipefd = setup(fds, auclass);
983 /* Failure reason: File does not exist */
984 ATF_REQUIRE_ERRNO(ENOENT, undelete(errpath) == -1);
985 check_audit(fds, extregex, pipefd);
988 ATF_TC_CLEANUP(undelete_failure, tc)
994 ATF_TC_WITH_CLEANUP(extattr_set_file_success);
995 ATF_TC_HEAD(extattr_set_file_success, tc)
997 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
998 "extattr_set_file(2) call");
1001 ATF_TC_BODY(extattr_set_file_success, tc)
1003 /* File needs to exist to call extattr_set_file(2) */
1004 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
1005 skip_if_extattr_not_supported(path);
1007 /* Prepare the regex to be checked in the audit record */
1008 snprintf(extregex, sizeof(extregex),
1009 "extattr_set_file.*%s.*%s.*return,success", path, name);
1011 FILE *pipefd = setup(fds, auclass);
1012 REQUIRE_EXTATTR_RESULT(sizeof(buff), extattr_set_file(path,
1013 EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
1014 check_audit(fds, extregex, pipefd);
1018 ATF_TC_CLEANUP(extattr_set_file_success, tc)
1024 ATF_TC_WITH_CLEANUP(extattr_set_file_failure);
1025 ATF_TC_HEAD(extattr_set_file_failure, tc)
1027 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1028 "extattr_set_file(2) call");
1031 ATF_TC_BODY(extattr_set_file_failure, tc)
1033 /* Prepare the regex to be checked in the audit record */
1034 snprintf(extregex, sizeof(extregex),
1035 "extattr_set_file.*%s.*%s.*failure", path, name);
1037 FILE *pipefd = setup(fds, auclass);
1038 /* Failure reason: file does not exist */
1039 ATF_REQUIRE_ERRNO(ENOENT,
1040 extattr_set_file(path, EXTATTR_NAMESPACE_USER, name, NULL, 0) ==
1042 check_audit(fds, extregex, pipefd);
1045 ATF_TC_CLEANUP(extattr_set_file_failure, tc)
1051 ATF_TC_WITH_CLEANUP(extattr_set_fd_success);
1052 ATF_TC_HEAD(extattr_set_fd_success, tc)
1054 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1055 "extattr_set_fd(2) call");
1058 ATF_TC_BODY(extattr_set_fd_success, tc)
1060 /* File needs to exist to call extattr_set_fd(2) */
1061 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
1062 skip_if_extattr_not_supported(path);
1064 /* Prepare the regex to be checked in the audit record */
1065 snprintf(extregex, sizeof(extregex),
1066 "extattr_set_fd.*%s.*return,success", name);
1068 FILE *pipefd = setup(fds, auclass);
1069 REQUIRE_EXTATTR_RESULT(sizeof(buff), extattr_set_fd(filedesc,
1070 EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
1071 check_audit(fds, extregex, pipefd);
1075 ATF_TC_CLEANUP(extattr_set_fd_success, tc)
1081 ATF_TC_WITH_CLEANUP(extattr_set_fd_failure);
1082 ATF_TC_HEAD(extattr_set_fd_failure, tc)
1084 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1085 "extattr_set_fd(2) call");
1088 ATF_TC_BODY(extattr_set_fd_failure, tc)
1090 /* Prepare the regex to be checked in the audit record */
1091 snprintf(extregex, sizeof(extregex),
1092 "extattr_set_fd.*%s.*return,failure : Bad file descriptor", name);
1094 FILE *pipefd = setup(fds, auclass);
1095 /* Failure reason: Invalid file descriptor */
1096 ATF_REQUIRE_ERRNO(EBADF,
1097 extattr_set_fd(-1, EXTATTR_NAMESPACE_USER, name, NULL, 0) == -1);
1098 check_audit(fds, extregex, pipefd);
1101 ATF_TC_CLEANUP(extattr_set_fd_failure, tc)
1107 ATF_TC_WITH_CLEANUP(extattr_set_link_success);
1108 ATF_TC_HEAD(extattr_set_link_success, tc)
1110 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1111 "extattr_set_link(2) call");
1114 ATF_TC_BODY(extattr_set_link_success, tc)
1116 /* Symbolic link needs to exist to call extattr_set_link(2) */
1117 ATF_REQUIRE_EQ(0, symlink("symlink", path));
1118 skip_if_extattr_not_supported(".");
1120 /* Prepare the regex to be checked in the audit record */
1121 snprintf(extregex, sizeof(extregex),
1122 "extattr_set_link.*%s.*%s.*return,success", path, name);
1124 FILE *pipefd = setup(fds, auclass);
1125 REQUIRE_EXTATTR_RESULT(sizeof(buff), extattr_set_link(path,
1126 EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
1128 check_audit(fds, extregex, pipefd);
1131 ATF_TC_CLEANUP(extattr_set_link_success, tc)
1137 ATF_TC_WITH_CLEANUP(extattr_set_link_failure);
1138 ATF_TC_HEAD(extattr_set_link_failure, tc)
1140 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1141 "extattr_set_link(2) call");
1144 ATF_TC_BODY(extattr_set_link_failure, tc)
1146 /* Prepare the regex to be checked in the audit record */
1147 snprintf(extregex, sizeof(extregex),
1148 "extattr_set_link.*%s.*%s.*failure", path, name);
1149 FILE *pipefd = setup(fds, auclass);
1150 /* Failure reason: symbolic link does not exist */
1151 ATF_REQUIRE_ERRNO(ENOENT,
1152 extattr_set_link(path, EXTATTR_NAMESPACE_USER, name, NULL, 0) ==
1154 check_audit(fds, extregex, pipefd);
1157 ATF_TC_CLEANUP(extattr_set_link_failure, tc)
1163 ATF_TC_WITH_CLEANUP(extattr_delete_file_success);
1164 ATF_TC_HEAD(extattr_delete_file_success, tc)
1166 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1167 "extattr_delete_file(2) call");
1170 ATF_TC_BODY(extattr_delete_file_success, tc)
1172 /* File needs to exist to call extattr_delete_file(2) */
1173 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
1174 skip_if_extattr_not_supported(path);
1176 REQUIRE_EXTATTR_RESULT(sizeof(buff), extattr_set_file(path,
1177 EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
1179 FILE *pipefd = setup(fds, auclass);
1180 retval = REQUIRE_EXTATTR_SUCCESS(
1181 extattr_delete_file(path, EXTATTR_NAMESPACE_USER, name));
1182 /* Prepare the regex to be checked in the audit record */
1183 snprintf(extregex, sizeof(extregex),
1184 "extattr_delete_file.*%s.*return,success,%d", path, retval);
1185 check_audit(fds, extregex, pipefd);
1189 ATF_TC_CLEANUP(extattr_delete_file_success, tc)
1195 ATF_TC_WITH_CLEANUP(extattr_delete_file_failure);
1196 ATF_TC_HEAD(extattr_delete_file_failure, tc)
1198 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1199 "extattr_delete_file(2) call");
1202 ATF_TC_BODY(extattr_delete_file_failure, tc)
1204 /* Prepare the regex to be checked in the audit record */
1205 snprintf(extregex, sizeof(extregex),
1206 "extattr_delete_file.*%s.*return,failure", path);
1208 FILE *pipefd = setup(fds, auclass);
1209 /* Failure reason: file does not exist */
1210 ATF_REQUIRE_ERRNO(ENOENT,
1211 extattr_delete_file(path, EXTATTR_NAMESPACE_USER, name) == -1);
1212 check_audit(fds, extregex, pipefd);
1215 ATF_TC_CLEANUP(extattr_delete_file_failure, tc)
1221 ATF_TC_WITH_CLEANUP(extattr_delete_fd_success);
1222 ATF_TC_HEAD(extattr_delete_fd_success, tc)
1224 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1225 "extattr_delete_fd(2) call");
1228 ATF_TC_BODY(extattr_delete_fd_success, tc)
1230 /* File needs to exist to call extattr_delete_fd(2) */
1231 ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
1232 skip_if_extattr_not_supported(path);
1234 REQUIRE_EXTATTR_RESULT(sizeof(buff), extattr_set_file(path,
1235 EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
1237 FILE *pipefd = setup(fds, auclass);
1238 retval = REQUIRE_EXTATTR_SUCCESS(extattr_delete_fd(filedesc,
1239 EXTATTR_NAMESPACE_USER, name));
1240 /* Prepare the regex to be checked in the audit record */
1241 snprintf(extregex, sizeof(extregex),
1242 "extattr_delete_fd.*return,success,%d", retval);
1243 check_audit(fds, extregex, pipefd);
1247 ATF_TC_CLEANUP(extattr_delete_fd_success, tc)
1253 ATF_TC_WITH_CLEANUP(extattr_delete_fd_failure);
1254 ATF_TC_HEAD(extattr_delete_fd_failure, tc)
1256 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1257 "extattr_delete_fd(2) call");
1260 ATF_TC_BODY(extattr_delete_fd_failure, tc)
1262 /* Prepare the regex to be checked in the audit record */
1263 snprintf(extregex, sizeof(extregex),
1264 "extattr_delete_fd.*return,failure : Bad file descriptor");
1266 FILE *pipefd = setup(fds, auclass);
1267 /* Failure reason: Invalid file descriptor */
1268 ATF_REQUIRE_ERRNO(EBADF,
1269 extattr_delete_fd(-1, EXTATTR_NAMESPACE_USER, name) == -1);
1270 check_audit(fds, extregex, pipefd);
1273 ATF_TC_CLEANUP(extattr_delete_fd_failure, tc)
1279 ATF_TC_WITH_CLEANUP(extattr_delete_link_success);
1280 ATF_TC_HEAD(extattr_delete_link_success, tc)
1282 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1283 "extattr_delete_link(2) call");
1286 ATF_TC_BODY(extattr_delete_link_success, tc)
1288 /* Symbolic link needs to exist to call extattr_delete_link(2) */
1289 ATF_REQUIRE_EQ(0, symlink("symlink", path));
1290 skip_if_extattr_not_supported(".");
1292 REQUIRE_EXTATTR_RESULT(sizeof(buff), extattr_set_link(path,
1293 EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
1295 FILE *pipefd = setup(fds, auclass);
1296 retval = REQUIRE_EXTATTR_SUCCESS(extattr_delete_link(path,
1297 EXTATTR_NAMESPACE_USER, name));
1298 /* Prepare the regex to be checked in the audit record */
1299 snprintf(extregex, sizeof(extregex),
1300 "extattr_delete_link.*%s.*return,success,%d", path, retval);
1301 check_audit(fds, extregex, pipefd);
1304 ATF_TC_CLEANUP(extattr_delete_link_success, tc)
1310 ATF_TC_WITH_CLEANUP(extattr_delete_link_failure);
1311 ATF_TC_HEAD(extattr_delete_link_failure, tc)
1313 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1314 "extattr_delete_link(2) call");
1317 ATF_TC_BODY(extattr_delete_link_failure, tc)
1319 /* Prepare the regex to be checked in the audit record */
1320 snprintf(extregex, sizeof(extregex),
1321 "extattr_delete_link.*%s.*failure", path);
1322 FILE *pipefd = setup(fds, auclass);
1323 /* Failure reason: symbolic link does not exist */
1324 ATF_REQUIRE_ERRNO(ENOENT,
1325 extattr_delete_link(path, EXTATTR_NAMESPACE_USER, name) == -1);
1326 check_audit(fds, extregex, pipefd);
1329 ATF_TC_CLEANUP(extattr_delete_link_failure, tc)
1337 ATF_TP_ADD_TC(tp, flock_success);
1338 ATF_TP_ADD_TC(tp, flock_failure);
1339 ATF_TP_ADD_TC(tp, fcntl_success);
1340 ATF_TP_ADD_TC(tp, fcntl_failure);
1341 ATF_TP_ADD_TC(tp, fsync_success);
1342 ATF_TP_ADD_TC(tp, fsync_failure);
1344 ATF_TP_ADD_TC(tp, chmod_success);
1345 ATF_TP_ADD_TC(tp, chmod_failure);
1346 ATF_TP_ADD_TC(tp, fchmod_success);
1347 ATF_TP_ADD_TC(tp, fchmod_failure);
1348 ATF_TP_ADD_TC(tp, lchmod_success);
1349 ATF_TP_ADD_TC(tp, lchmod_failure);
1350 ATF_TP_ADD_TC(tp, fchmodat_success);
1351 ATF_TP_ADD_TC(tp, fchmodat_failure);
1353 ATF_TP_ADD_TC(tp, chown_success);
1354 ATF_TP_ADD_TC(tp, chown_failure);
1355 ATF_TP_ADD_TC(tp, fchown_success);
1356 ATF_TP_ADD_TC(tp, fchown_failure);
1357 ATF_TP_ADD_TC(tp, lchown_success);
1358 ATF_TP_ADD_TC(tp, lchown_failure);
1359 ATF_TP_ADD_TC(tp, fchownat_success);
1360 ATF_TP_ADD_TC(tp, fchownat_failure);
1362 ATF_TP_ADD_TC(tp, chflags_success);
1363 ATF_TP_ADD_TC(tp, chflags_failure);
1364 ATF_TP_ADD_TC(tp, fchflags_success);
1365 ATF_TP_ADD_TC(tp, fchflags_failure);
1366 ATF_TP_ADD_TC(tp, lchflags_success);
1367 ATF_TP_ADD_TC(tp, lchflags_failure);
1368 ATF_TP_ADD_TC(tp, chflagsat_success);
1369 ATF_TP_ADD_TC(tp, chflagsat_failure);
1371 ATF_TP_ADD_TC(tp, utimes_success);
1372 ATF_TP_ADD_TC(tp, utimes_failure);
1373 ATF_TP_ADD_TC(tp, futimes_success);
1374 ATF_TP_ADD_TC(tp, futimes_failure);
1375 ATF_TP_ADD_TC(tp, lutimes_success);
1376 ATF_TP_ADD_TC(tp, lutimes_failure);
1377 ATF_TP_ADD_TC(tp, futimesat_success);
1378 ATF_TP_ADD_TC(tp, futimesat_failure);
1380 ATF_TP_ADD_TC(tp, mprotect_success);
1381 ATF_TP_ADD_TC(tp, mprotect_failure);
1382 ATF_TP_ADD_TC(tp, undelete_failure);
1384 ATF_TP_ADD_TC(tp, extattr_set_file_success);
1385 ATF_TP_ADD_TC(tp, extattr_set_file_failure);
1386 ATF_TP_ADD_TC(tp, extattr_set_fd_success);
1387 ATF_TP_ADD_TC(tp, extattr_set_fd_failure);
1388 ATF_TP_ADD_TC(tp, extattr_set_link_success);
1389 ATF_TP_ADD_TC(tp, extattr_set_link_failure);
1391 ATF_TP_ADD_TC(tp, extattr_delete_file_success);
1392 ATF_TP_ADD_TC(tp, extattr_delete_file_failure);
1393 ATF_TP_ADD_TC(tp, extattr_delete_fd_success);
1394 ATF_TP_ADD_TC(tp, extattr_delete_fd_failure);
1395 ATF_TP_ADD_TC(tp, extattr_delete_link_success);
1396 ATF_TP_ADD_TC(tp, extattr_delete_link_failure);
1398 return (atf_no_error());