xref: /freebsd/tests/sys/audit/file-attribute-access.c (revision cfd6422a5217410fbd66f7a7a8a64d9d85e61229)
1 /*-
2  * Copyright (c) 2018 Aniket Pandey
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
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.
12  *
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
23  * SUCH DAMAGE.
24  *
25  * $FreeBSD$
26  */
27 
28 #include <sys/param.h>
29 #include <sys/extattr.h>
30 #include <sys/ucred.h>
31 #include <sys/mount.h>
32 #include <sys/stat.h>
33 #include <sys/syscall.h>
34 
35 #include <atf-c.h>
36 #include <fcntl.h>
37 #include <unistd.h>
38 
39 #include "utils.h"
40 
41 static struct pollfd fds[1];
42 static mode_t mode = 0777;
43 static pid_t pid;
44 static fhandle_t fht;
45 static int filedesc, fhdesc;
46 static char extregex[80];
47 static char buff[] = "ezio";
48 static struct stat statbuff;
49 static struct statfs statfsbuff;
50 static const char *auclass = "fa";
51 static const char *name = "authorname";
52 static const char *path = "fileforaudit";
53 static const char *errpath = "dirdoesnotexist/fileforaudit";
54 static const char *successreg = "fileforaudit.*return,success";
55 static const char *failurereg = "fileforaudit.*return,failure";
56 
57 
58 ATF_TC_WITH_CLEANUP(stat_success);
59 ATF_TC_HEAD(stat_success, tc)
60 {
61 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
62 					"stat(2) call");
63 }
64 
65 ATF_TC_BODY(stat_success, tc)
66 {
67 	/* File needs to exist to call stat(2) */
68 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
69 	FILE *pipefd = setup(fds, auclass);
70 	ATF_REQUIRE_EQ(0, stat(path, &statbuff));
71 	check_audit(fds, successreg, pipefd);
72 	close(filedesc);
73 }
74 
75 ATF_TC_CLEANUP(stat_success, tc)
76 {
77 	cleanup();
78 }
79 
80 
81 ATF_TC_WITH_CLEANUP(stat_failure);
82 ATF_TC_HEAD(stat_failure, tc)
83 {
84 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
85 					"stat(2) call");
86 }
87 
88 ATF_TC_BODY(stat_failure, tc)
89 {
90 	FILE *pipefd = setup(fds, auclass);
91 	/* Failure reason: file does not exist */
92 	ATF_REQUIRE_EQ(-1, stat(errpath, &statbuff));
93 	check_audit(fds, failurereg, pipefd);
94 }
95 
96 ATF_TC_CLEANUP(stat_failure, tc)
97 {
98 	cleanup();
99 }
100 
101 
102 ATF_TC_WITH_CLEANUP(lstat_success);
103 ATF_TC_HEAD(lstat_success, tc)
104 {
105 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
106 					"lstat(2) call");
107 }
108 
109 ATF_TC_BODY(lstat_success, tc)
110 {
111 	/* Symbolic link needs to exist to call lstat(2) */
112 	ATF_REQUIRE_EQ(0, symlink("symlink", path));
113 	FILE *pipefd = setup(fds, auclass);
114 	ATF_REQUIRE_EQ(0, lstat(path, &statbuff));
115 	check_audit(fds, successreg, pipefd);
116 }
117 
118 ATF_TC_CLEANUP(lstat_success, tc)
119 {
120 	cleanup();
121 }
122 
123 
124 ATF_TC_WITH_CLEANUP(lstat_failure);
125 ATF_TC_HEAD(lstat_failure, tc)
126 {
127 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
128 					"lstat(2) call");
129 }
130 
131 ATF_TC_BODY(lstat_failure, tc)
132 {
133 	FILE *pipefd = setup(fds, auclass);
134 	/* Failure reason: symbolic link does not exist */
135 	ATF_REQUIRE_EQ(-1, lstat(errpath, &statbuff));
136 	check_audit(fds, failurereg, pipefd);
137 }
138 
139 ATF_TC_CLEANUP(lstat_failure, tc)
140 {
141 	cleanup();
142 }
143 
144 
145 ATF_TC_WITH_CLEANUP(fstat_success);
146 ATF_TC_HEAD(fstat_success, tc)
147 {
148 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
149 					"fstat(2) call");
150 }
151 
152 ATF_TC_BODY(fstat_success, tc)
153 {
154 	/* File needs to exist to call fstat(2) */
155 	ATF_REQUIRE((filedesc = open(path, O_CREAT | O_RDWR, mode)) != -1);
156 	FILE *pipefd = setup(fds, auclass);
157 	ATF_REQUIRE_EQ(0, fstat(filedesc, &statbuff));
158 
159 	snprintf(extregex, sizeof(extregex),
160 		"fstat.*%jd.*return,success", (intmax_t)statbuff.st_ino);
161 	check_audit(fds, extregex, pipefd);
162 	close(filedesc);
163 }
164 
165 ATF_TC_CLEANUP(fstat_success, tc)
166 {
167 	cleanup();
168 }
169 
170 
171 ATF_TC_WITH_CLEANUP(fstat_failure);
172 ATF_TC_HEAD(fstat_failure, tc)
173 {
174 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
175 					"fstat(2) call");
176 }
177 
178 ATF_TC_BODY(fstat_failure, tc)
179 {
180 	FILE *pipefd = setup(fds, auclass);
181 	const char *regex = "fstat.*return,failure : Bad file descriptor";
182 	/* Failure reason: bad file descriptor */
183 	ATF_REQUIRE_EQ(-1, fstat(-1, &statbuff));
184 	check_audit(fds, regex, pipefd);
185 }
186 
187 ATF_TC_CLEANUP(fstat_failure, tc)
188 {
189 	cleanup();
190 }
191 
192 
193 ATF_TC_WITH_CLEANUP(fstatat_success);
194 ATF_TC_HEAD(fstatat_success, tc)
195 {
196 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
197 					"fstatat(2) call");
198 }
199 
200 ATF_TC_BODY(fstatat_success, tc)
201 {
202 	/* File or Symbolic link needs to exist to call lstat(2) */
203 	ATF_REQUIRE_EQ(0, symlink("symlink", path));
204 	FILE *pipefd = setup(fds, auclass);
205 	ATF_REQUIRE_EQ(0, fstatat(AT_FDCWD, path, &statbuff,
206 		AT_SYMLINK_NOFOLLOW));
207 	check_audit(fds, successreg, pipefd);
208 }
209 
210 ATF_TC_CLEANUP(fstatat_success, tc)
211 {
212 	cleanup();
213 }
214 
215 
216 ATF_TC_WITH_CLEANUP(fstatat_failure);
217 ATF_TC_HEAD(fstatat_failure, tc)
218 {
219 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
220 					"fstatat(2) call");
221 }
222 
223 ATF_TC_BODY(fstatat_failure, tc)
224 {
225 	FILE *pipefd = setup(fds, auclass);
226 	/* Failure reason: symbolic link does not exist */
227 	ATF_REQUIRE_EQ(-1, fstatat(AT_FDCWD, path, &statbuff,
228 		AT_SYMLINK_NOFOLLOW));
229 	check_audit(fds, failurereg, pipefd);
230 }
231 
232 ATF_TC_CLEANUP(fstatat_failure, tc)
233 {
234 	cleanup();
235 }
236 
237 
238 ATF_TC_WITH_CLEANUP(statfs_success);
239 ATF_TC_HEAD(statfs_success, tc)
240 {
241 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
242 					"statfs(2) call");
243 }
244 
245 ATF_TC_BODY(statfs_success, tc)
246 {
247 	/* File needs to exist to call statfs(2) */
248 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
249 	FILE *pipefd = setup(fds, auclass);
250 	ATF_REQUIRE_EQ(0, statfs(path, &statfsbuff));
251 	check_audit(fds, successreg, pipefd);
252 	close(filedesc);
253 }
254 
255 ATF_TC_CLEANUP(statfs_success, tc)
256 {
257 	cleanup();
258 }
259 
260 
261 ATF_TC_WITH_CLEANUP(statfs_failure);
262 ATF_TC_HEAD(statfs_failure, tc)
263 {
264 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
265 					"statfs(2) call");
266 }
267 
268 ATF_TC_BODY(statfs_failure, tc)
269 {
270 	FILE *pipefd = setup(fds, auclass);
271 	/* Failure reason: file does not exist */
272 	ATF_REQUIRE_EQ(-1, statfs(errpath, &statfsbuff));
273 	check_audit(fds, failurereg, pipefd);
274 }
275 
276 ATF_TC_CLEANUP(statfs_failure, tc)
277 {
278 	cleanup();
279 }
280 
281 
282 ATF_TC_WITH_CLEANUP(fstatfs_success);
283 ATF_TC_HEAD(fstatfs_success, tc)
284 {
285 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
286 					"fstatfs(2) call");
287 }
288 
289 ATF_TC_BODY(fstatfs_success, tc)
290 {
291 	/* File needs to exist to call fstat(2) */
292 	ATF_REQUIRE((filedesc = open(path, O_CREAT | O_RDWR, mode)) != -1);
293 	/* Call stat(2) to store the Inode number of 'path' */
294 	ATF_REQUIRE_EQ(0, stat(path, &statbuff));
295 	FILE *pipefd = setup(fds, auclass);
296 	ATF_REQUIRE_EQ(0, fstatfs(filedesc, &statfsbuff));
297 
298 	snprintf(extregex, sizeof(extregex), "fstatfs.*%jd.*return,success",
299 			(intmax_t)statbuff.st_ino);
300 	check_audit(fds, extregex, pipefd);
301 	close(filedesc);
302 }
303 
304 ATF_TC_CLEANUP(fstatfs_success, tc)
305 {
306 	cleanup();
307 }
308 
309 
310 ATF_TC_WITH_CLEANUP(fstatfs_failure);
311 ATF_TC_HEAD(fstatfs_failure, tc)
312 {
313 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
314 					"fstatfs(2) call");
315 }
316 
317 ATF_TC_BODY(fstatfs_failure, tc)
318 {
319 	FILE *pipefd = setup(fds, auclass);
320 	const char *regex = "fstatfs.*return,failure : Bad file descriptor";
321 	/* Failure reason: bad file descriptor */
322 	ATF_REQUIRE_EQ(-1, fstatfs(-1, &statfsbuff));
323 	check_audit(fds, regex, pipefd);
324 }
325 
326 ATF_TC_CLEANUP(fstatfs_failure, tc)
327 {
328 	cleanup();
329 }
330 
331 
332 ATF_TC_WITH_CLEANUP(getfsstat_success);
333 ATF_TC_HEAD(getfsstat_success, tc)
334 {
335 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
336 					"getfsstat(2) call");
337 }
338 
339 ATF_TC_BODY(getfsstat_success, tc)
340 {
341 	pid = getpid();
342 	snprintf(extregex, sizeof(extregex), "getfsstat.*%d.*success", pid);
343 
344 	FILE *pipefd = setup(fds, auclass);
345 	ATF_REQUIRE(getfsstat(NULL, 0, MNT_NOWAIT) != -1);
346 	check_audit(fds, extregex, pipefd);
347 }
348 
349 ATF_TC_CLEANUP(getfsstat_success, tc)
350 {
351 	cleanup();
352 }
353 
354 
355 ATF_TC_WITH_CLEANUP(getfsstat_failure);
356 ATF_TC_HEAD(getfsstat_failure, tc)
357 {
358 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
359 					"getfsstat(2) call");
360 }
361 
362 ATF_TC_BODY(getfsstat_failure, tc)
363 {
364 	const char *regex = "getfsstat.*return,failure : Invalid argument";
365 	FILE *pipefd = setup(fds, auclass);
366 	/* Failure reason: Invalid value for mode */
367 	ATF_REQUIRE_EQ(-1, getfsstat(NULL, 0, -1));
368 	check_audit(fds, regex, pipefd);
369 }
370 
371 ATF_TC_CLEANUP(getfsstat_failure, tc)
372 {
373 	cleanup();
374 }
375 
376 
377 ATF_TC_WITH_CLEANUP(lgetfh_success);
378 ATF_TC_HEAD(lgetfh_success, tc)
379 {
380 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
381 					"lgetfh(2) call");
382 }
383 
384 ATF_TC_BODY(lgetfh_success, tc)
385 {
386 	/* Symbolic link needs to exist to get a file-handle */
387 	ATF_REQUIRE_EQ(0, symlink("symlink", path));
388 	const char *regex = "lgetfh.*return,success";
389 	FILE *pipefd = setup(fds, "fa");
390 	ATF_REQUIRE_EQ(0, lgetfh(path, &fht));
391 	check_audit(fds, regex, pipefd);
392 }
393 
394 ATF_TC_CLEANUP(lgetfh_success, tc)
395 {
396 	cleanup();
397 }
398 
399 
400 ATF_TC_WITH_CLEANUP(lgetfh_failure);
401 ATF_TC_HEAD(lgetfh_failure, tc)
402 {
403 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
404 					"lgetfh(2) call");
405 }
406 
407 ATF_TC_BODY(lgetfh_failure, tc)
408 {
409 	const char *regex = "lgetfh.*return,failure";
410 	FILE *pipefd = setup(fds, "fa");
411 	/* Failure reason: symbolic link does not exist */
412 	ATF_REQUIRE_EQ(-1, lgetfh(errpath, &fht));
413 	check_audit(fds, regex, pipefd);
414 }
415 
416 ATF_TC_CLEANUP(lgetfh_failure, tc)
417 {
418 	cleanup();
419 }
420 
421 
422 ATF_TC_WITH_CLEANUP(fhopen_success);
423 ATF_TC_HEAD(fhopen_success, tc)
424 {
425 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
426 					"fhopen(2) call");
427 }
428 
429 ATF_TC_BODY(fhopen_success, tc)
430 {
431 	pid = getpid();
432 	snprintf(extregex, sizeof(extregex), "fhopen.*%d.*return,success", pid);
433 
434 	/* File needs to exist to get a file-handle */
435 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
436 	/* Get the file handle to be passed to fhopen(2) */
437 	ATF_REQUIRE_EQ(0, getfh(path, &fht));
438 
439 	FILE *pipefd = setup(fds, auclass);
440 	ATF_REQUIRE((fhdesc = fhopen(&fht, O_RDWR)) != -1);
441 	check_audit(fds, extregex, pipefd);
442 
443 	close(fhdesc);
444 	close(filedesc);
445 }
446 
447 ATF_TC_CLEANUP(fhopen_success, tc)
448 {
449 	cleanup();
450 }
451 
452 
453 ATF_TC_WITH_CLEANUP(fhopen_failure);
454 ATF_TC_HEAD(fhopen_failure, tc)
455 {
456 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
457 					"fhopen(2) call");
458 }
459 
460 ATF_TC_BODY(fhopen_failure, tc)
461 {
462 	const char *regex = "fhopen.*return,failure : Invalid argument";
463 	FILE *pipefd = setup(fds, auclass);
464 	/*
465 	 * Failure reason: NULL does not represent any file handle
466 	 * and O_CREAT is not allowed as the flag for fhopen(2)
467 	 */
468 	ATF_REQUIRE_EQ(-1, fhopen(NULL, O_CREAT));
469 	check_audit(fds, regex, pipefd);
470 }
471 
472 ATF_TC_CLEANUP(fhopen_failure, tc)
473 {
474 	cleanup();
475 }
476 
477 
478 ATF_TC_WITH_CLEANUP(fhstat_success);
479 ATF_TC_HEAD(fhstat_success, tc)
480 {
481 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
482 					"fstat(2) call");
483 }
484 
485 ATF_TC_BODY(fhstat_success, tc)
486 {
487 	pid = getpid();
488 	snprintf(extregex, sizeof(extregex), "fhstat.*%d.*return,success", pid);
489 
490 	/* File needs to exist to get a file-handle */
491 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
492 	/* Get the file handle to be passed to fhstat(2) */
493 	ATF_REQUIRE_EQ(0, getfh(path, &fht));
494 
495 	FILE *pipefd = setup(fds, auclass);
496 	ATF_REQUIRE_EQ(0, fhstat(&fht, &statbuff));
497 	check_audit(fds, extregex, pipefd);
498 	close(filedesc);
499 }
500 
501 ATF_TC_CLEANUP(fhstat_success, tc)
502 {
503 	cleanup();
504 }
505 
506 
507 ATF_TC_WITH_CLEANUP(fhstat_failure);
508 ATF_TC_HEAD(fhstat_failure, tc)
509 {
510 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
511 					"fhstat(2) call");
512 }
513 
514 ATF_TC_BODY(fhstat_failure, tc)
515 {
516 	const char *regex = "fhstat.*return,failure : Bad address";
517 	FILE *pipefd = setup(fds, auclass);
518 	/* Failure reason: NULL does not represent any file handle */
519 	ATF_REQUIRE_EQ(-1, fhstat(NULL, NULL));
520 	check_audit(fds, regex, pipefd);
521 }
522 
523 ATF_TC_CLEANUP(fhstat_failure, tc)
524 {
525 	cleanup();
526 }
527 
528 
529 ATF_TC_WITH_CLEANUP(fhstatfs_success);
530 ATF_TC_HEAD(fhstatfs_success, tc)
531 {
532 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
533 					"fstatfs(2) call");
534 }
535 
536 ATF_TC_BODY(fhstatfs_success, tc)
537 {
538 	pid = getpid();
539 	snprintf(extregex, sizeof(extregex), "fhstatfs.*%d.*success", pid);
540 
541 	/* File needs to exist to get a file-handle */
542 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
543 	/* Get the file handle to be passed to fhstatfs(2) */
544 	ATF_REQUIRE_EQ(0, getfh(path, &fht));
545 
546 	FILE *pipefd = setup(fds, auclass);
547 	ATF_REQUIRE_EQ(0, fhstatfs(&fht, &statfsbuff));
548 	check_audit(fds, extregex, pipefd);
549 	close(filedesc);
550 }
551 
552 ATF_TC_CLEANUP(fhstatfs_success, tc)
553 {
554 	cleanup();
555 }
556 
557 
558 ATF_TC_WITH_CLEANUP(fhstatfs_failure);
559 ATF_TC_HEAD(fhstatfs_failure, tc)
560 {
561 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
562 					"fhstatfs(2) call");
563 }
564 
565 ATF_TC_BODY(fhstatfs_failure, tc)
566 {
567 	const char *regex = "fhstatfs.*return,failure : Bad address";
568 	FILE *pipefd = setup(fds, auclass);
569 	/* Failure reason: NULL does not represent any file handle */
570 	ATF_REQUIRE_EQ(-1, fhstatfs(NULL, NULL));
571 	check_audit(fds, regex, pipefd);
572 }
573 
574 ATF_TC_CLEANUP(fhstatfs_failure, tc)
575 {
576 	cleanup();
577 }
578 
579 
580 ATF_TC_WITH_CLEANUP(access_success);
581 ATF_TC_HEAD(access_success, tc)
582 {
583 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
584 					"access(2) call");
585 }
586 
587 ATF_TC_BODY(access_success, tc)
588 {
589 	/* File needs to exist to call access(2) */
590 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
591 	FILE *pipefd = setup(fds, auclass);
592 	ATF_REQUIRE_EQ(0, access(path, F_OK));
593 	check_audit(fds, successreg, pipefd);
594 	close(filedesc);
595 }
596 
597 ATF_TC_CLEANUP(access_success, tc)
598 {
599 	cleanup();
600 }
601 
602 
603 ATF_TC_WITH_CLEANUP(access_failure);
604 ATF_TC_HEAD(access_failure, tc)
605 {
606 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
607 					"access(2) call");
608 }
609 
610 ATF_TC_BODY(access_failure, tc)
611 {
612 	FILE *pipefd = setup(fds, auclass);
613 	/* Failure reason: file does not exist */
614 	ATF_REQUIRE_EQ(-1, access(errpath, F_OK));
615 	check_audit(fds, failurereg, pipefd);
616 }
617 
618 ATF_TC_CLEANUP(access_failure, tc)
619 {
620 	cleanup();
621 }
622 
623 
624 ATF_TC_WITH_CLEANUP(eaccess_success);
625 ATF_TC_HEAD(eaccess_success, tc)
626 {
627 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
628 					"eaccess(2) call");
629 }
630 
631 ATF_TC_BODY(eaccess_success, tc)
632 {
633 	/* File needs to exist to call eaccess(2) */
634 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
635 	FILE *pipefd = setup(fds, auclass);
636 	ATF_REQUIRE_EQ(0, eaccess(path, F_OK));
637 	check_audit(fds, successreg, pipefd);
638 	close(filedesc);
639 }
640 
641 ATF_TC_CLEANUP(eaccess_success, tc)
642 {
643 	cleanup();
644 }
645 
646 
647 ATF_TC_WITH_CLEANUP(eaccess_failure);
648 ATF_TC_HEAD(eaccess_failure, tc)
649 {
650 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
651 					"eaccess(2) call");
652 }
653 
654 ATF_TC_BODY(eaccess_failure, tc)
655 {
656 	FILE *pipefd = setup(fds, auclass);
657 	/* Failure reason: file does not exist */
658 	ATF_REQUIRE_EQ(-1, eaccess(errpath, F_OK));
659 	check_audit(fds, failurereg, pipefd);
660 }
661 
662 ATF_TC_CLEANUP(eaccess_failure, tc)
663 {
664 	cleanup();
665 }
666 
667 
668 ATF_TC_WITH_CLEANUP(faccessat_success);
669 ATF_TC_HEAD(faccessat_success, tc)
670 {
671 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
672 					"faccessat(2) call");
673 }
674 
675 ATF_TC_BODY(faccessat_success, tc)
676 {
677 	/* File needs to exist to call faccessat(2) */
678 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
679 	FILE *pipefd = setup(fds, auclass);
680 	ATF_REQUIRE_EQ(0, faccessat(AT_FDCWD, path, F_OK, AT_EACCESS));
681 	check_audit(fds, successreg, pipefd);
682 	close(filedesc);
683 }
684 
685 ATF_TC_CLEANUP(faccessat_success, tc)
686 {
687 	cleanup();
688 }
689 
690 
691 ATF_TC_WITH_CLEANUP(faccessat_failure);
692 ATF_TC_HEAD(faccessat_failure, tc)
693 {
694 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
695 					"faccessat(2) call");
696 }
697 
698 ATF_TC_BODY(faccessat_failure, tc)
699 {
700 	FILE *pipefd = setup(fds, auclass);
701 	/* Failure reason: file does not exist */
702 	ATF_REQUIRE_EQ(-1, faccessat(AT_FDCWD, errpath, F_OK, AT_EACCESS));
703 	check_audit(fds, failurereg, pipefd);
704 }
705 
706 ATF_TC_CLEANUP(faccessat_failure, tc)
707 {
708 	cleanup();
709 }
710 
711 
712 ATF_TC_WITH_CLEANUP(pathconf_success);
713 ATF_TC_HEAD(pathconf_success, tc)
714 {
715 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
716 					"pathconf(2) call");
717 }
718 
719 ATF_TC_BODY(pathconf_success, tc)
720 {
721 	/* File needs to exist to call pathconf(2) */
722 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
723 	FILE *pipefd = setup(fds, auclass);
724 	/* Get the maximum number of bytes of filename */
725 	ATF_REQUIRE(pathconf(path, _PC_NAME_MAX) != -1);
726 	check_audit(fds, successreg, pipefd);
727 	close(filedesc);
728 }
729 
730 ATF_TC_CLEANUP(pathconf_success, tc)
731 {
732 	cleanup();
733 }
734 
735 
736 ATF_TC_WITH_CLEANUP(pathconf_failure);
737 ATF_TC_HEAD(pathconf_failure, tc)
738 {
739 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
740 					"pathconf(2) call");
741 }
742 
743 ATF_TC_BODY(pathconf_failure, tc)
744 {
745 	FILE *pipefd = setup(fds, auclass);
746 	/* Failure reason: file does not exist */
747 	ATF_REQUIRE_EQ(-1, pathconf(errpath, _PC_NAME_MAX));
748 	check_audit(fds, failurereg, pipefd);
749 }
750 
751 ATF_TC_CLEANUP(pathconf_failure, tc)
752 {
753 	cleanup();
754 }
755 
756 
757 ATF_TC_WITH_CLEANUP(lpathconf_success);
758 ATF_TC_HEAD(lpathconf_success, tc)
759 {
760 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
761 					"lpathconf(2) call");
762 }
763 
764 ATF_TC_BODY(lpathconf_success, tc)
765 {
766 	/* Symbolic link needs to exist to call lpathconf(2) */
767 	ATF_REQUIRE_EQ(0, symlink("symlink", path));
768 	FILE *pipefd = setup(fds, auclass);
769 	/* Get the maximum number of bytes of symlink's name */
770 	ATF_REQUIRE(lpathconf(path, _PC_SYMLINK_MAX) != -1);
771 	check_audit(fds, successreg, pipefd);
772 }
773 
774 ATF_TC_CLEANUP(lpathconf_success, tc)
775 {
776 	cleanup();
777 }
778 
779 
780 ATF_TC_WITH_CLEANUP(lpathconf_failure);
781 ATF_TC_HEAD(lpathconf_failure, tc)
782 {
783 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
784 					"lpathconf(2) call");
785 }
786 
787 ATF_TC_BODY(lpathconf_failure, tc)
788 {
789 	FILE *pipefd = setup(fds, auclass);
790 	/* Failure reason: symbolic link does not exist */
791 	ATF_REQUIRE_EQ(-1, lpathconf(errpath, _PC_SYMLINK_MAX));
792 	check_audit(fds, failurereg, pipefd);
793 }
794 
795 ATF_TC_CLEANUP(lpathconf_failure, tc)
796 {
797 	cleanup();
798 }
799 
800 
801 ATF_TC_WITH_CLEANUP(fpathconf_success);
802 ATF_TC_HEAD(fpathconf_success, tc)
803 {
804 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
805 					"fpathconf(2) call");
806 }
807 
808 ATF_TC_BODY(fpathconf_success, tc)
809 {
810 	pid = getpid();
811 	snprintf(extregex, sizeof(extregex), "fpathconf.*%d.*success", pid);
812 
813 	/* File needs to exist to call fpathconf(2) */
814 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
815 	FILE *pipefd = setup(fds, auclass);
816 	/* Get the maximum number of bytes of filename */
817 	ATF_REQUIRE(fpathconf(filedesc, _PC_NAME_MAX) != -1);
818 	check_audit(fds, extregex, pipefd);
819 	close(filedesc);
820 }
821 
822 ATF_TC_CLEANUP(fpathconf_success, tc)
823 {
824 	cleanup();
825 }
826 
827 
828 ATF_TC_WITH_CLEANUP(fpathconf_failure);
829 ATF_TC_HEAD(fpathconf_failure, tc)
830 {
831 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
832 					"fpathconf(2) call");
833 }
834 
835 ATF_TC_BODY(fpathconf_failure, tc)
836 {
837 	FILE *pipefd = setup(fds, auclass);
838 	const char *regex = "fpathconf.*return,failure : Bad file descriptor";
839 	/* Failure reason: Bad file descriptor */
840 	ATF_REQUIRE_EQ(-1, fpathconf(-1, _PC_NAME_MAX));
841 	check_audit(fds, regex, pipefd);
842 }
843 
844 ATF_TC_CLEANUP(fpathconf_failure, tc)
845 {
846 	cleanup();
847 }
848 
849 
850 ATF_TC_WITH_CLEANUP(extattr_get_file_success);
851 ATF_TC_HEAD(extattr_get_file_success, tc)
852 {
853 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
854 					"extattr_get_file(2) call");
855 }
856 
857 ATF_TC_BODY(extattr_get_file_success, tc)
858 {
859 	/* File needs to exist to call extattr_get_file(2) */
860 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
861 	/* Set an extended attribute to be retrieved later on */
862 	ATF_REQUIRE_EQ(sizeof(buff), extattr_set_file(path,
863 		EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
864 
865 	/* Prepare the regex to be checked in the audit record */
866 	snprintf(extregex, sizeof(extregex),
867 		"extattr_get_file.*%s.*%s.*return,success", path, name);
868 
869 	FILE *pipefd = setup(fds, auclass);
870 	ATF_REQUIRE_EQ(sizeof(buff), extattr_get_file(path,
871 		EXTATTR_NAMESPACE_USER, name, NULL, 0));
872 	check_audit(fds, extregex, pipefd);
873 	close(filedesc);
874 }
875 
876 ATF_TC_CLEANUP(extattr_get_file_success, tc)
877 {
878 	cleanup();
879 }
880 
881 
882 ATF_TC_WITH_CLEANUP(extattr_get_file_failure);
883 ATF_TC_HEAD(extattr_get_file_failure, tc)
884 {
885 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
886 					"extattr_get_file(2) call");
887 }
888 
889 ATF_TC_BODY(extattr_get_file_failure, tc)
890 {
891 	/* Prepare the regex to be checked in the audit record */
892 	snprintf(extregex, sizeof(extregex),
893 		"extattr_get_file.*%s.*%s.*failure", path, name);
894 
895 	FILE *pipefd = setup(fds, auclass);
896 	/* Failure reason: file does not exist */
897 	ATF_REQUIRE_EQ(-1, extattr_get_file(path,
898 		EXTATTR_NAMESPACE_USER, name, NULL, 0));
899 	check_audit(fds, extregex, pipefd);
900 }
901 
902 ATF_TC_CLEANUP(extattr_get_file_failure, tc)
903 {
904 	cleanup();
905 }
906 
907 
908 ATF_TC_WITH_CLEANUP(extattr_get_fd_success);
909 ATF_TC_HEAD(extattr_get_fd_success, tc)
910 {
911 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
912 					"extattr_get_fd(2) call");
913 }
914 
915 ATF_TC_BODY(extattr_get_fd_success, tc)
916 {
917 	/* File needs to exist to call extattr_get_fd(2) */
918 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
919 	/* Set an extended attribute to be retrieved later on */
920 	ATF_REQUIRE_EQ(sizeof(buff), extattr_set_file(path,
921 		EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
922 
923 	/* Prepare the regex to be checked in the audit record */
924 	snprintf(extregex, sizeof(extregex),
925 		"extattr_get_fd.*%s.*return,success", name);
926 
927 	FILE *pipefd = setup(fds, auclass);
928 	ATF_REQUIRE_EQ(sizeof(buff), extattr_get_fd(filedesc,
929 		EXTATTR_NAMESPACE_USER, name, NULL, 0));
930 	check_audit(fds, extregex, pipefd);
931 	close(filedesc);
932 }
933 
934 ATF_TC_CLEANUP(extattr_get_fd_success, tc)
935 {
936 	cleanup();
937 }
938 
939 
940 ATF_TC_WITH_CLEANUP(extattr_get_fd_failure);
941 ATF_TC_HEAD(extattr_get_fd_failure, tc)
942 {
943 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
944 					"extattr_get_fd(2) call");
945 }
946 
947 ATF_TC_BODY(extattr_get_fd_failure, tc)
948 {
949 	/* Prepare the regex to be checked in the audit record */
950 	snprintf(extregex, sizeof(extregex),
951 	"extattr_get_fd.*%s.*return,failure : Bad file descriptor", name);
952 
953 	FILE *pipefd = setup(fds, auclass);
954 	/* Failure reason: Invalid file descriptor */
955 	ATF_REQUIRE_EQ(-1, extattr_get_fd(-1,
956 		EXTATTR_NAMESPACE_USER, name, NULL, 0));
957 	check_audit(fds, extregex, pipefd);
958 }
959 
960 ATF_TC_CLEANUP(extattr_get_fd_failure, tc)
961 {
962 	cleanup();
963 }
964 
965 
966 ATF_TC_WITH_CLEANUP(extattr_get_link_success);
967 ATF_TC_HEAD(extattr_get_link_success, tc)
968 {
969 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
970 					"extattr_get_link(2) call");
971 }
972 
973 ATF_TC_BODY(extattr_get_link_success, tc)
974 {
975 	/* Symbolic link needs to exist to call extattr_get_link(2) */
976 	ATF_REQUIRE_EQ(0, symlink("symlink", path));
977 	/* Set an extended attribute to be retrieved later on */
978 	ATF_REQUIRE_EQ(sizeof(buff), extattr_set_link(path,
979 		EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
980 
981 	/* Prepare the regex to be checked in the audit record */
982 	snprintf(extregex, sizeof(extregex),
983 		"extattr_get_link.*%s.*%s.*return,success", path, name);
984 
985 	FILE *pipefd = setup(fds, auclass);
986 	ATF_REQUIRE_EQ(sizeof(buff), extattr_get_link(path,
987 		EXTATTR_NAMESPACE_USER, name, NULL, 0));
988 	check_audit(fds, extregex, pipefd);
989 }
990 
991 ATF_TC_CLEANUP(extattr_get_link_success, tc)
992 {
993 	cleanup();
994 }
995 
996 
997 ATF_TC_WITH_CLEANUP(extattr_get_link_failure);
998 ATF_TC_HEAD(extattr_get_link_failure, tc)
999 {
1000 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1001 					"extattr_get_link(2) call");
1002 }
1003 
1004 ATF_TC_BODY(extattr_get_link_failure, tc)
1005 {
1006 	/* Prepare the regex to be checked in the audit record */
1007 	snprintf(extregex, sizeof(extregex),
1008 		"extattr_get_link.*%s.*%s.*failure", path, name);
1009 	FILE *pipefd = setup(fds, auclass);
1010 	/* Failure reason: symbolic link does not exist */
1011 	ATF_REQUIRE_EQ(-1, extattr_get_link(path,
1012 		EXTATTR_NAMESPACE_USER, name, NULL, 0));
1013 	check_audit(fds, extregex, pipefd);
1014 }
1015 
1016 ATF_TC_CLEANUP(extattr_get_link_failure, tc)
1017 {
1018 	cleanup();
1019 }
1020 
1021 
1022 ATF_TC_WITH_CLEANUP(extattr_list_file_success);
1023 ATF_TC_HEAD(extattr_list_file_success, tc)
1024 {
1025 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1026 					"extattr_list_file(2) call");
1027 }
1028 
1029 ATF_TC_BODY(extattr_list_file_success, tc)
1030 {
1031 	int readbuff;
1032 	/* File needs to exist to call extattr_list_file(2) */
1033 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
1034 
1035 	FILE *pipefd = setup(fds, auclass);
1036 	ATF_REQUIRE((readbuff = extattr_list_file(path,
1037 		EXTATTR_NAMESPACE_USER, NULL, 0)) != -1);
1038 	/* Prepare the regex to be checked in the audit record */
1039 	snprintf(extregex, sizeof(extregex),
1040 		"extattr_list_file.*%s.*return,success,%d", path, readbuff);
1041 	check_audit(fds, extregex, pipefd);
1042 }
1043 
1044 ATF_TC_CLEANUP(extattr_list_file_success, tc)
1045 {
1046 	cleanup();
1047 }
1048 
1049 
1050 ATF_TC_WITH_CLEANUP(extattr_list_file_failure);
1051 ATF_TC_HEAD(extattr_list_file_failure, tc)
1052 {
1053 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1054 					"extattr_list_file(2) call");
1055 }
1056 
1057 ATF_TC_BODY(extattr_list_file_failure, tc)
1058 {
1059 	/* Prepare the regex to be checked in the audit record */
1060 	snprintf(extregex, sizeof(extregex),
1061 		"extattr_list_file.*%s.*return,failure", path);
1062 
1063 	FILE *pipefd = setup(fds, auclass);
1064 	/* Failure reason: file does not exist */
1065 	ATF_REQUIRE_EQ(-1, extattr_list_file(path,
1066 		EXTATTR_NAMESPACE_USER, NULL, 0));
1067 	check_audit(fds, extregex, pipefd);
1068 }
1069 
1070 ATF_TC_CLEANUP(extattr_list_file_failure, tc)
1071 {
1072 	cleanup();
1073 }
1074 
1075 
1076 ATF_TC_WITH_CLEANUP(extattr_list_fd_success);
1077 ATF_TC_HEAD(extattr_list_fd_success, tc)
1078 {
1079 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1080 					"extattr_list_fd(2) call");
1081 }
1082 
1083 ATF_TC_BODY(extattr_list_fd_success, tc)
1084 {
1085 	int readbuff;
1086 	/* File needs to exist to call extattr_list_fd(2) */
1087 	ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1);
1088 
1089 	FILE *pipefd = setup(fds, auclass);
1090 	ATF_REQUIRE((readbuff = extattr_list_fd(filedesc,
1091 		EXTATTR_NAMESPACE_USER, NULL, 0)) != -1);
1092 	/* Prepare the regex to be checked in the audit record */
1093 	snprintf(extregex, sizeof(extregex),
1094 		"extattr_list_fd.*return,success,%d", readbuff);
1095 	check_audit(fds, extregex, pipefd);
1096 	close(filedesc);
1097 }
1098 
1099 ATF_TC_CLEANUP(extattr_list_fd_success, tc)
1100 {
1101 	cleanup();
1102 }
1103 
1104 
1105 ATF_TC_WITH_CLEANUP(extattr_list_fd_failure);
1106 ATF_TC_HEAD(extattr_list_fd_failure, tc)
1107 {
1108 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1109 					"extattr_list_fd(2) call");
1110 }
1111 
1112 ATF_TC_BODY(extattr_list_fd_failure, tc)
1113 {
1114 	/* Prepare the regex to be checked in the audit record */
1115 	snprintf(extregex, sizeof(extregex),
1116 		"extattr_list_fd.*return,failure : Bad file descriptor");
1117 
1118 	FILE *pipefd = setup(fds, auclass);
1119 	/* Failure reason: Invalid file descriptor */
1120 	ATF_REQUIRE_EQ(-1,
1121 		extattr_list_fd(-1, EXTATTR_NAMESPACE_USER, NULL, 0));
1122 	check_audit(fds, extregex, pipefd);
1123 }
1124 
1125 ATF_TC_CLEANUP(extattr_list_fd_failure, tc)
1126 {
1127 	cleanup();
1128 }
1129 
1130 
1131 ATF_TC_WITH_CLEANUP(extattr_list_link_success);
1132 ATF_TC_HEAD(extattr_list_link_success, tc)
1133 {
1134 	atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1135 					"extattr_list_link(2) call");
1136 }
1137 
1138 ATF_TC_BODY(extattr_list_link_success, tc)
1139 {
1140 	int readbuff;
1141 	/* Symbolic link needs to exist to call extattr_list_link(2) */
1142 	ATF_REQUIRE_EQ(0, symlink("symlink", path));
1143 	FILE *pipefd = setup(fds, auclass);
1144 
1145 	ATF_REQUIRE((readbuff = extattr_list_link(path,
1146 		EXTATTR_NAMESPACE_USER, NULL, 0)) != -1);
1147 	/* Prepare the regex to be checked in the audit record */
1148 	snprintf(extregex, sizeof(extregex),
1149 		"extattr_list_link.*%s.*return,success,%d", path, readbuff);
1150 	check_audit(fds, extregex, pipefd);
1151 }
1152 
1153 ATF_TC_CLEANUP(extattr_list_link_success, tc)
1154 {
1155 	cleanup();
1156 }
1157 
1158 
1159 ATF_TC_WITH_CLEANUP(extattr_list_link_failure);
1160 ATF_TC_HEAD(extattr_list_link_failure, tc)
1161 {
1162 	atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1163 					"extattr_list_link(2) call");
1164 }
1165 
1166 ATF_TC_BODY(extattr_list_link_failure, tc)
1167 {
1168 	/* Prepare the regex to be checked in the audit record */
1169 	snprintf(extregex, sizeof(extregex),
1170 		"extattr_list_link.*%s.*failure", path);
1171 	FILE *pipefd = setup(fds, auclass);
1172 	/* Failure reason: symbolic link does not exist */
1173 	ATF_REQUIRE_EQ(-1, extattr_list_link(path,
1174 		EXTATTR_NAMESPACE_USER, NULL, 0));
1175 	check_audit(fds, extregex, pipefd);
1176 }
1177 
1178 ATF_TC_CLEANUP(extattr_list_link_failure, tc)
1179 {
1180 	cleanup();
1181 }
1182 
1183 
1184 ATF_TP_ADD_TCS(tp)
1185 {
1186 	ATF_TP_ADD_TC(tp, stat_success);
1187 	ATF_TP_ADD_TC(tp, stat_failure);
1188 	ATF_TP_ADD_TC(tp, lstat_success);
1189 	ATF_TP_ADD_TC(tp, lstat_failure);
1190 	ATF_TP_ADD_TC(tp, fstat_success);
1191 	ATF_TP_ADD_TC(tp, fstat_failure);
1192 	ATF_TP_ADD_TC(tp, fstatat_success);
1193 	ATF_TP_ADD_TC(tp, fstatat_failure);
1194 
1195 	ATF_TP_ADD_TC(tp, statfs_success);
1196 	ATF_TP_ADD_TC(tp, statfs_failure);
1197 	ATF_TP_ADD_TC(tp, fstatfs_success);
1198 	ATF_TP_ADD_TC(tp, fstatfs_failure);
1199 
1200 	ATF_TP_ADD_TC(tp, getfsstat_success);
1201 	ATF_TP_ADD_TC(tp, getfsstat_failure);
1202 
1203 	ATF_TP_ADD_TC(tp, lgetfh_success);
1204 	ATF_TP_ADD_TC(tp, lgetfh_failure);
1205 	ATF_TP_ADD_TC(tp, fhopen_success);
1206 	ATF_TP_ADD_TC(tp, fhopen_failure);
1207 	ATF_TP_ADD_TC(tp, fhstat_success);
1208 	ATF_TP_ADD_TC(tp, fhstat_failure);
1209 	ATF_TP_ADD_TC(tp, fhstatfs_success);
1210 	ATF_TP_ADD_TC(tp, fhstatfs_failure);
1211 
1212 	ATF_TP_ADD_TC(tp, access_success);
1213 	ATF_TP_ADD_TC(tp, access_failure);
1214 	ATF_TP_ADD_TC(tp, eaccess_success);
1215 	ATF_TP_ADD_TC(tp, eaccess_failure);
1216 	ATF_TP_ADD_TC(tp, faccessat_success);
1217 	ATF_TP_ADD_TC(tp, faccessat_failure);
1218 
1219 	ATF_TP_ADD_TC(tp, pathconf_success);
1220 	ATF_TP_ADD_TC(tp, pathconf_failure);
1221 	ATF_TP_ADD_TC(tp, lpathconf_success);
1222 	ATF_TP_ADD_TC(tp, lpathconf_failure);
1223 	ATF_TP_ADD_TC(tp, fpathconf_success);
1224 	ATF_TP_ADD_TC(tp, fpathconf_failure);
1225 
1226 	ATF_TP_ADD_TC(tp, extattr_get_file_success);
1227 	ATF_TP_ADD_TC(tp, extattr_get_file_failure);
1228 	ATF_TP_ADD_TC(tp, extattr_get_fd_success);
1229 	ATF_TP_ADD_TC(tp, extattr_get_fd_failure);
1230 	ATF_TP_ADD_TC(tp, extattr_get_link_success);
1231 	ATF_TP_ADD_TC(tp, extattr_get_link_failure);
1232 
1233 	ATF_TP_ADD_TC(tp, extattr_list_file_success);
1234 	ATF_TP_ADD_TC(tp, extattr_list_file_failure);
1235 	ATF_TP_ADD_TC(tp, extattr_list_fd_success);
1236 	ATF_TP_ADD_TC(tp, extattr_list_fd_failure);
1237 	ATF_TP_ADD_TC(tp, extattr_list_link_success);
1238 	ATF_TP_ADD_TC(tp, extattr_list_link_failure);
1239 
1240 	return (atf_no_error());
1241 }
1242