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/mount.h> 31 #include <sys/stat.h> 32 #include <sys/syscall.h> 33 #include <sys/ucred.h> 34 35 #include <atf-c.h> 36 #include <errno.h> 37 #include <fcntl.h> 38 #include <string.h> 39 #include <unistd.h> 40 41 #include "utils.h" 42 43 static struct pollfd fds[1]; 44 static mode_t mode = 0777; 45 static pid_t pid; 46 static fhandle_t fht; 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"; 58 59 60 ATF_TC_WITH_CLEANUP(stat_success); 61 ATF_TC_HEAD(stat_success, tc) 62 { 63 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 64 "stat(2) call"); 65 } 66 67 ATF_TC_BODY(stat_success, tc) 68 { 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); 74 close(filedesc); 75 } 76 77 ATF_TC_CLEANUP(stat_success, tc) 78 { 79 cleanup(); 80 } 81 82 83 ATF_TC_WITH_CLEANUP(stat_failure); 84 ATF_TC_HEAD(stat_failure, tc) 85 { 86 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 87 "stat(2) call"); 88 } 89 90 ATF_TC_BODY(stat_failure, tc) 91 { 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); 96 } 97 98 ATF_TC_CLEANUP(stat_failure, tc) 99 { 100 cleanup(); 101 } 102 103 104 ATF_TC_WITH_CLEANUP(lstat_success); 105 ATF_TC_HEAD(lstat_success, tc) 106 { 107 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 108 "lstat(2) call"); 109 } 110 111 ATF_TC_BODY(lstat_success, tc) 112 { 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); 118 } 119 120 ATF_TC_CLEANUP(lstat_success, tc) 121 { 122 cleanup(); 123 } 124 125 126 ATF_TC_WITH_CLEANUP(lstat_failure); 127 ATF_TC_HEAD(lstat_failure, tc) 128 { 129 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 130 "lstat(2) call"); 131 } 132 133 ATF_TC_BODY(lstat_failure, tc) 134 { 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); 139 } 140 141 ATF_TC_CLEANUP(lstat_failure, tc) 142 { 143 cleanup(); 144 } 145 146 147 ATF_TC_WITH_CLEANUP(fstat_success); 148 ATF_TC_HEAD(fstat_success, tc) 149 { 150 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 151 "fstat(2) call"); 152 } 153 154 ATF_TC_BODY(fstat_success, tc) 155 { 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)); 160 161 snprintf(extregex, sizeof(extregex), 162 "fstat.*%jd.*return,success", (intmax_t)statbuff.st_ino); 163 check_audit(fds, extregex, pipefd); 164 close(filedesc); 165 } 166 167 ATF_TC_CLEANUP(fstat_success, tc) 168 { 169 cleanup(); 170 } 171 172 173 ATF_TC_WITH_CLEANUP(fstat_failure); 174 ATF_TC_HEAD(fstat_failure, tc) 175 { 176 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 177 "fstat(2) call"); 178 } 179 180 ATF_TC_BODY(fstat_failure, tc) 181 { 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); 187 } 188 189 ATF_TC_CLEANUP(fstat_failure, tc) 190 { 191 cleanup(); 192 } 193 194 195 ATF_TC_WITH_CLEANUP(fstatat_success); 196 ATF_TC_HEAD(fstatat_success, tc) 197 { 198 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 199 "fstatat(2) call"); 200 } 201 202 ATF_TC_BODY(fstatat_success, tc) 203 { 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); 210 } 211 212 ATF_TC_CLEANUP(fstatat_success, tc) 213 { 214 cleanup(); 215 } 216 217 218 ATF_TC_WITH_CLEANUP(fstatat_failure); 219 ATF_TC_HEAD(fstatat_failure, tc) 220 { 221 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 222 "fstatat(2) call"); 223 } 224 225 ATF_TC_BODY(fstatat_failure, tc) 226 { 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); 232 } 233 234 ATF_TC_CLEANUP(fstatat_failure, tc) 235 { 236 cleanup(); 237 } 238 239 240 ATF_TC_WITH_CLEANUP(statfs_success); 241 ATF_TC_HEAD(statfs_success, tc) 242 { 243 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 244 "statfs(2) call"); 245 } 246 247 ATF_TC_BODY(statfs_success, tc) 248 { 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); 254 close(filedesc); 255 } 256 257 ATF_TC_CLEANUP(statfs_success, tc) 258 { 259 cleanup(); 260 } 261 262 263 ATF_TC_WITH_CLEANUP(statfs_failure); 264 ATF_TC_HEAD(statfs_failure, tc) 265 { 266 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 267 "statfs(2) call"); 268 } 269 270 ATF_TC_BODY(statfs_failure, tc) 271 { 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); 276 } 277 278 ATF_TC_CLEANUP(statfs_failure, tc) 279 { 280 cleanup(); 281 } 282 283 284 ATF_TC_WITH_CLEANUP(fstatfs_success); 285 ATF_TC_HEAD(fstatfs_success, tc) 286 { 287 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 288 "fstatfs(2) call"); 289 } 290 291 ATF_TC_BODY(fstatfs_success, tc) 292 { 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)); 299 300 snprintf(extregex, sizeof(extregex), "fstatfs.*%jd.*return,success", 301 (intmax_t)statbuff.st_ino); 302 check_audit(fds, extregex, pipefd); 303 close(filedesc); 304 } 305 306 ATF_TC_CLEANUP(fstatfs_success, tc) 307 { 308 cleanup(); 309 } 310 311 312 ATF_TC_WITH_CLEANUP(fstatfs_failure); 313 ATF_TC_HEAD(fstatfs_failure, tc) 314 { 315 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 316 "fstatfs(2) call"); 317 } 318 319 ATF_TC_BODY(fstatfs_failure, tc) 320 { 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); 326 } 327 328 ATF_TC_CLEANUP(fstatfs_failure, tc) 329 { 330 cleanup(); 331 } 332 333 334 ATF_TC_WITH_CLEANUP(getfsstat_success); 335 ATF_TC_HEAD(getfsstat_success, tc) 336 { 337 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 338 "getfsstat(2) call"); 339 } 340 341 ATF_TC_BODY(getfsstat_success, tc) 342 { 343 pid = getpid(); 344 snprintf(extregex, sizeof(extregex), "getfsstat.*%d.*success", pid); 345 346 FILE *pipefd = setup(fds, auclass); 347 ATF_REQUIRE(getfsstat(NULL, 0, MNT_NOWAIT) != -1); 348 check_audit(fds, extregex, pipefd); 349 } 350 351 ATF_TC_CLEANUP(getfsstat_success, tc) 352 { 353 cleanup(); 354 } 355 356 357 ATF_TC_WITH_CLEANUP(getfsstat_failure); 358 ATF_TC_HEAD(getfsstat_failure, tc) 359 { 360 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 361 "getfsstat(2) call"); 362 } 363 364 ATF_TC_BODY(getfsstat_failure, tc) 365 { 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); 371 } 372 373 ATF_TC_CLEANUP(getfsstat_failure, tc) 374 { 375 cleanup(); 376 } 377 378 379 ATF_TC_WITH_CLEANUP(lgetfh_success); 380 ATF_TC_HEAD(lgetfh_success, tc) 381 { 382 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 383 "lgetfh(2) call"); 384 } 385 386 ATF_TC_BODY(lgetfh_success, tc) 387 { 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); 394 } 395 396 ATF_TC_CLEANUP(lgetfh_success, tc) 397 { 398 cleanup(); 399 } 400 401 402 ATF_TC_WITH_CLEANUP(lgetfh_failure); 403 ATF_TC_HEAD(lgetfh_failure, tc) 404 { 405 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 406 "lgetfh(2) call"); 407 } 408 409 ATF_TC_BODY(lgetfh_failure, tc) 410 { 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); 416 } 417 418 ATF_TC_CLEANUP(lgetfh_failure, tc) 419 { 420 cleanup(); 421 } 422 423 424 ATF_TC_WITH_CLEANUP(fhopen_success); 425 ATF_TC_HEAD(fhopen_success, tc) 426 { 427 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 428 "fhopen(2) call"); 429 } 430 431 ATF_TC_BODY(fhopen_success, tc) 432 { 433 pid = getpid(); 434 snprintf(extregex, sizeof(extregex), "fhopen.*%d.*return,success", pid); 435 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)); 440 441 FILE *pipefd = setup(fds, auclass); 442 ATF_REQUIRE((fhdesc = fhopen(&fht, O_RDWR)) != -1); 443 check_audit(fds, extregex, pipefd); 444 445 close(fhdesc); 446 close(filedesc); 447 } 448 449 ATF_TC_CLEANUP(fhopen_success, tc) 450 { 451 cleanup(); 452 } 453 454 455 ATF_TC_WITH_CLEANUP(fhopen_failure); 456 ATF_TC_HEAD(fhopen_failure, tc) 457 { 458 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 459 "fhopen(2) call"); 460 } 461 462 ATF_TC_BODY(fhopen_failure, tc) 463 { 464 const char *regex = "fhopen.*return,failure : Invalid argument"; 465 FILE *pipefd = setup(fds, auclass); 466 /* 467 * Failure reason: NULL does not represent any file handle 468 * and O_CREAT is not allowed as the flag for fhopen(2) 469 */ 470 ATF_REQUIRE_ERRNO(EINVAL, fhopen(NULL, O_CREAT) == -1); 471 check_audit(fds, regex, pipefd); 472 } 473 474 ATF_TC_CLEANUP(fhopen_failure, tc) 475 { 476 cleanup(); 477 } 478 479 480 ATF_TC_WITH_CLEANUP(fhstat_success); 481 ATF_TC_HEAD(fhstat_success, tc) 482 { 483 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 484 "fstat(2) call"); 485 } 486 487 ATF_TC_BODY(fhstat_success, tc) 488 { 489 pid = getpid(); 490 snprintf(extregex, sizeof(extregex), "fhstat.*%d.*return,success", pid); 491 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)); 496 497 FILE *pipefd = setup(fds, auclass); 498 ATF_REQUIRE_EQ(0, fhstat(&fht, &statbuff)); 499 check_audit(fds, extregex, pipefd); 500 close(filedesc); 501 } 502 503 ATF_TC_CLEANUP(fhstat_success, tc) 504 { 505 cleanup(); 506 } 507 508 509 ATF_TC_WITH_CLEANUP(fhstat_failure); 510 ATF_TC_HEAD(fhstat_failure, tc) 511 { 512 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 513 "fhstat(2) call"); 514 } 515 516 ATF_TC_BODY(fhstat_failure, tc) 517 { 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); 523 } 524 525 ATF_TC_CLEANUP(fhstat_failure, tc) 526 { 527 cleanup(); 528 } 529 530 531 ATF_TC_WITH_CLEANUP(fhstatfs_success); 532 ATF_TC_HEAD(fhstatfs_success, tc) 533 { 534 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 535 "fstatfs(2) call"); 536 } 537 538 ATF_TC_BODY(fhstatfs_success, tc) 539 { 540 pid = getpid(); 541 snprintf(extregex, sizeof(extregex), "fhstatfs.*%d.*success", pid); 542 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)); 547 548 FILE *pipefd = setup(fds, auclass); 549 ATF_REQUIRE_EQ(0, fhstatfs(&fht, &statfsbuff)); 550 check_audit(fds, extregex, pipefd); 551 close(filedesc); 552 } 553 554 ATF_TC_CLEANUP(fhstatfs_success, tc) 555 { 556 cleanup(); 557 } 558 559 560 ATF_TC_WITH_CLEANUP(fhstatfs_failure); 561 ATF_TC_HEAD(fhstatfs_failure, tc) 562 { 563 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 564 "fhstatfs(2) call"); 565 } 566 567 ATF_TC_BODY(fhstatfs_failure, tc) 568 { 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); 574 } 575 576 ATF_TC_CLEANUP(fhstatfs_failure, tc) 577 { 578 cleanup(); 579 } 580 581 582 ATF_TC_WITH_CLEANUP(access_success); 583 ATF_TC_HEAD(access_success, tc) 584 { 585 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 586 "access(2) call"); 587 } 588 589 ATF_TC_BODY(access_success, tc) 590 { 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); 596 close(filedesc); 597 } 598 599 ATF_TC_CLEANUP(access_success, tc) 600 { 601 cleanup(); 602 } 603 604 605 ATF_TC_WITH_CLEANUP(access_failure); 606 ATF_TC_HEAD(access_failure, tc) 607 { 608 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 609 "access(2) call"); 610 } 611 612 ATF_TC_BODY(access_failure, tc) 613 { 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); 618 } 619 620 ATF_TC_CLEANUP(access_failure, tc) 621 { 622 cleanup(); 623 } 624 625 626 ATF_TC_WITH_CLEANUP(eaccess_success); 627 ATF_TC_HEAD(eaccess_success, tc) 628 { 629 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 630 "eaccess(2) call"); 631 } 632 633 ATF_TC_BODY(eaccess_success, tc) 634 { 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); 640 close(filedesc); 641 } 642 643 ATF_TC_CLEANUP(eaccess_success, tc) 644 { 645 cleanup(); 646 } 647 648 649 ATF_TC_WITH_CLEANUP(eaccess_failure); 650 ATF_TC_HEAD(eaccess_failure, tc) 651 { 652 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 653 "eaccess(2) call"); 654 } 655 656 ATF_TC_BODY(eaccess_failure, tc) 657 { 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); 662 } 663 664 ATF_TC_CLEANUP(eaccess_failure, tc) 665 { 666 cleanup(); 667 } 668 669 670 ATF_TC_WITH_CLEANUP(faccessat_success); 671 ATF_TC_HEAD(faccessat_success, tc) 672 { 673 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 674 "faccessat(2) call"); 675 } 676 677 ATF_TC_BODY(faccessat_success, tc) 678 { 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); 684 close(filedesc); 685 } 686 687 ATF_TC_CLEANUP(faccessat_success, tc) 688 { 689 cleanup(); 690 } 691 692 693 ATF_TC_WITH_CLEANUP(faccessat_failure); 694 ATF_TC_HEAD(faccessat_failure, tc) 695 { 696 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 697 "faccessat(2) call"); 698 } 699 700 ATF_TC_BODY(faccessat_failure, tc) 701 { 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); 707 } 708 709 ATF_TC_CLEANUP(faccessat_failure, tc) 710 { 711 cleanup(); 712 } 713 714 715 ATF_TC_WITH_CLEANUP(pathconf_success); 716 ATF_TC_HEAD(pathconf_success, tc) 717 { 718 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 719 "pathconf(2) call"); 720 } 721 722 ATF_TC_BODY(pathconf_success, tc) 723 { 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); 730 close(filedesc); 731 } 732 733 ATF_TC_CLEANUP(pathconf_success, tc) 734 { 735 cleanup(); 736 } 737 738 739 ATF_TC_WITH_CLEANUP(pathconf_failure); 740 ATF_TC_HEAD(pathconf_failure, tc) 741 { 742 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 743 "pathconf(2) call"); 744 } 745 746 ATF_TC_BODY(pathconf_failure, tc) 747 { 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); 752 } 753 754 ATF_TC_CLEANUP(pathconf_failure, tc) 755 { 756 cleanup(); 757 } 758 759 760 ATF_TC_WITH_CLEANUP(lpathconf_success); 761 ATF_TC_HEAD(lpathconf_success, tc) 762 { 763 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 764 "lpathconf(2) call"); 765 } 766 767 ATF_TC_BODY(lpathconf_success, tc) 768 { 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); 775 } 776 777 ATF_TC_CLEANUP(lpathconf_success, tc) 778 { 779 cleanup(); 780 } 781 782 783 ATF_TC_WITH_CLEANUP(lpathconf_failure); 784 ATF_TC_HEAD(lpathconf_failure, tc) 785 { 786 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 787 "lpathconf(2) call"); 788 } 789 790 ATF_TC_BODY(lpathconf_failure, tc) 791 { 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); 796 } 797 798 ATF_TC_CLEANUP(lpathconf_failure, tc) 799 { 800 cleanup(); 801 } 802 803 804 ATF_TC_WITH_CLEANUP(fpathconf_success); 805 ATF_TC_HEAD(fpathconf_success, tc) 806 { 807 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 808 "fpathconf(2) call"); 809 } 810 811 ATF_TC_BODY(fpathconf_success, tc) 812 { 813 pid = getpid(); 814 snprintf(extregex, sizeof(extregex), "fpathconf.*%d.*success", pid); 815 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); 822 close(filedesc); 823 } 824 825 ATF_TC_CLEANUP(fpathconf_success, tc) 826 { 827 cleanup(); 828 } 829 830 831 ATF_TC_WITH_CLEANUP(fpathconf_failure); 832 ATF_TC_HEAD(fpathconf_failure, tc) 833 { 834 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 835 "fpathconf(2) call"); 836 } 837 838 ATF_TC_BODY(fpathconf_failure, tc) 839 { 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); 845 } 846 847 ATF_TC_CLEANUP(fpathconf_failure, tc) 848 { 849 cleanup(); 850 } 851 852 853 ATF_TC_WITH_CLEANUP(extattr_get_file_success); 854 ATF_TC_HEAD(extattr_get_file_success, tc) 855 { 856 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 857 "extattr_get_file(2) call"); 858 } 859 860 ATF_TC_BODY(extattr_get_file_success, tc) 861 { 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); 865 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, 869 sizeof(buff))); 870 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); 874 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); 879 close(filedesc); 880 } 881 882 ATF_TC_CLEANUP(extattr_get_file_success, tc) 883 { 884 cleanup(); 885 } 886 887 888 ATF_TC_WITH_CLEANUP(extattr_get_file_failure); 889 ATF_TC_HEAD(extattr_get_file_failure, tc) 890 { 891 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 892 "extattr_get_file(2) call"); 893 } 894 895 ATF_TC_BODY(extattr_get_file_failure, tc) 896 { 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); 900 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) == 905 -1); 906 check_audit(fds, extregex, pipefd); 907 } 908 909 ATF_TC_CLEANUP(extattr_get_file_failure, tc) 910 { 911 cleanup(); 912 } 913 914 915 ATF_TC_WITH_CLEANUP(extattr_get_fd_success); 916 ATF_TC_HEAD(extattr_get_fd_success, tc) 917 { 918 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 919 "extattr_get_fd(2) call"); 920 } 921 922 ATF_TC_BODY(extattr_get_fd_success, tc) 923 { 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); 927 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, 931 sizeof(buff))); 932 933 /* Prepare the regex to be checked in the audit record */ 934 snprintf(extregex, sizeof(extregex), 935 "extattr_get_fd.*%s.*return,success", name); 936 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); 941 close(filedesc); 942 } 943 944 ATF_TC_CLEANUP(extattr_get_fd_success, tc) 945 { 946 cleanup(); 947 } 948 949 950 ATF_TC_WITH_CLEANUP(extattr_get_fd_failure); 951 ATF_TC_HEAD(extattr_get_fd_failure, tc) 952 { 953 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 954 "extattr_get_fd(2) call"); 955 } 956 957 ATF_TC_BODY(extattr_get_fd_failure, tc) 958 { 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); 962 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); 968 } 969 970 ATF_TC_CLEANUP(extattr_get_fd_failure, tc) 971 { 972 cleanup(); 973 } 974 975 976 ATF_TC_WITH_CLEANUP(extattr_get_link_success); 977 ATF_TC_HEAD(extattr_get_link_success, tc) 978 { 979 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 980 "extattr_get_link(2) call"); 981 } 982 983 ATF_TC_BODY(extattr_get_link_success, tc) 984 { 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("."); 988 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, 992 sizeof(buff))); 993 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); 997 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); 1002 } 1003 1004 ATF_TC_CLEANUP(extattr_get_link_success, tc) 1005 { 1006 cleanup(); 1007 } 1008 1009 1010 ATF_TC_WITH_CLEANUP(extattr_get_link_failure); 1011 ATF_TC_HEAD(extattr_get_link_failure, tc) 1012 { 1013 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 1014 "extattr_get_link(2) call"); 1015 } 1016 1017 ATF_TC_BODY(extattr_get_link_failure, tc) 1018 { 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); 1027 } 1028 1029 ATF_TC_CLEANUP(extattr_get_link_failure, tc) 1030 { 1031 cleanup(); 1032 } 1033 1034 1035 ATF_TC_WITH_CLEANUP(extattr_list_file_success); 1036 ATF_TC_HEAD(extattr_list_file_success, tc) 1037 { 1038 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 1039 "extattr_list_file(2) call"); 1040 } 1041 1042 ATF_TC_BODY(extattr_list_file_success, tc) 1043 { 1044 ssize_t readbuff; 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); 1048 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); 1056 } 1057 1058 ATF_TC_CLEANUP(extattr_list_file_success, tc) 1059 { 1060 cleanup(); 1061 } 1062 1063 1064 ATF_TC_WITH_CLEANUP(extattr_list_file_failure); 1065 ATF_TC_HEAD(extattr_list_file_failure, tc) 1066 { 1067 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 1068 "extattr_list_file(2) call"); 1069 } 1070 1071 ATF_TC_BODY(extattr_list_file_failure, tc) 1072 { 1073 /* Prepare the regex to be checked in the audit record */ 1074 snprintf(extregex, sizeof(extregex), 1075 "extattr_list_file.*%s.*return,failure", path); 1076 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); 1082 } 1083 1084 ATF_TC_CLEANUP(extattr_list_file_failure, tc) 1085 { 1086 cleanup(); 1087 } 1088 1089 1090 ATF_TC_WITH_CLEANUP(extattr_list_fd_success); 1091 ATF_TC_HEAD(extattr_list_fd_success, tc) 1092 { 1093 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 1094 "extattr_list_fd(2) call"); 1095 } 1096 1097 ATF_TC_BODY(extattr_list_fd_success, tc) 1098 { 1099 ssize_t readbuff; 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); 1103 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); 1111 close(filedesc); 1112 } 1113 1114 ATF_TC_CLEANUP(extattr_list_fd_success, tc) 1115 { 1116 cleanup(); 1117 } 1118 1119 1120 ATF_TC_WITH_CLEANUP(extattr_list_fd_failure); 1121 ATF_TC_HEAD(extattr_list_fd_failure, tc) 1122 { 1123 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 1124 "extattr_list_fd(2) call"); 1125 } 1126 1127 ATF_TC_BODY(extattr_list_fd_failure, tc) 1128 { 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"); 1132 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); 1138 } 1139 1140 ATF_TC_CLEANUP(extattr_list_fd_failure, tc) 1141 { 1142 cleanup(); 1143 } 1144 1145 1146 ATF_TC_WITH_CLEANUP(extattr_list_link_success); 1147 ATF_TC_HEAD(extattr_list_link_success, tc) 1148 { 1149 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " 1150 "extattr_list_link(2) call"); 1151 } 1152 1153 ATF_TC_BODY(extattr_list_link_success, tc) 1154 { 1155 ssize_t readbuff; 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("."); 1159 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); 1167 } 1168 1169 ATF_TC_CLEANUP(extattr_list_link_success, tc) 1170 { 1171 cleanup(); 1172 } 1173 1174 1175 ATF_TC_WITH_CLEANUP(extattr_list_link_failure); 1176 ATF_TC_HEAD(extattr_list_link_failure, tc) 1177 { 1178 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " 1179 "extattr_list_link(2) call"); 1180 } 1181 1182 ATF_TC_BODY(extattr_list_link_failure, tc) 1183 { 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); 1192 } 1193 1194 ATF_TC_CLEANUP(extattr_list_link_failure, tc) 1195 { 1196 cleanup(); 1197 } 1198 1199 1200 ATF_TP_ADD_TCS(tp) 1201 { 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); 1210 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); 1215 1216 ATF_TP_ADD_TC(tp, getfsstat_success); 1217 ATF_TP_ADD_TC(tp, getfsstat_failure); 1218 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); 1227 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); 1234 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); 1241 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); 1248 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()); 1256 } 1257