tests/sys/audit/file-attribute-modify.c

   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/types.h>
  29 #include <sys/extattr.h>
  30 #include <sys/file.h>
  31 #include <sys/mman.h>
  32 #include <sys/stat.h>
  33 #include <sys/time.h>
  34
  35 #include <atf-c.h>
  36 #include <errno.h>
  37 #include <fcntl.h>
  38 #include <stdint.h>
  39 #include <unistd.h>
  40
  41 #include "utils.h"
  42
  43 static pid_t pid;
  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";
  57
  58
  59 ATF_TC_WITH_CLEANUP(flock_success);
  60 ATF_TC_HEAD(flock_success, tc)
  61 {
  62         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
  63                                         "flock(2) call");
  64 }
  65
  66 ATF_TC_BODY(flock_success, tc)
  67 {
  68         pid = getpid();
  69         snprintf(extregex, sizeof(extregex), "flock.*%d.*return,success", pid);
  70
  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);
  76         close(filedesc);
  77 }
  78
  79 ATF_TC_CLEANUP(flock_success, tc)
  80 {
  81         cleanup();
  82 }
  83
  84
  85 ATF_TC_WITH_CLEANUP(flock_failure);
  86 ATF_TC_HEAD(flock_failure, tc)
  87 {
  88         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
  89                                         "flock(2) call");
  90 }
  91
  92 ATF_TC_BODY(flock_failure, tc)
  93 {
  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);
  98 }
  99
 100 ATF_TC_CLEANUP(flock_failure, tc)
 101 {
 102         cleanup();
 103 }
 104
 105
 106 ATF_TC_WITH_CLEANUP(fcntl_success);
 107 ATF_TC_HEAD(fcntl_success, tc)
 108 {
 109         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 110                                         "fcntl(2) call");
 111 }
 112
 113 ATF_TC_BODY(fcntl_success, tc)
 114 {
 115         int flagstatus;
 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);
 119
 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);
 125         close(filedesc);
 126 }
 127
 128 ATF_TC_CLEANUP(fcntl_success, tc)
 129 {
 130         cleanup();
 131 }
 132
 133
 134 ATF_TC_WITH_CLEANUP(fcntl_failure);
 135 ATF_TC_HEAD(fcntl_failure, tc)
 136 {
 137         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 138                                         "fcntl(2) call");
 139 }
 140
 141 ATF_TC_BODY(fcntl_failure, tc)
 142 {
 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);
 147 }
 148
 149 ATF_TC_CLEANUP(fcntl_failure, tc)
 150 {
 151         cleanup();
 152 }
 153
 154
 155 ATF_TC_WITH_CLEANUP(fsync_success);
 156 ATF_TC_HEAD(fsync_success, tc)
 157 {
 158         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 159                                         "fsync(2) call");
 160 }
 161
 162 ATF_TC_BODY(fsync_success, tc)
 163 {
 164         pid = getpid();
 165         snprintf(extregex, sizeof(extregex), "fsync.*%d.*return,success", pid);
 166
 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);
 172         close(filedesc);
 173 }
 174
 175 ATF_TC_CLEANUP(fsync_success, tc)
 176 {
 177         cleanup();
 178 }
 179
 180
 181 ATF_TC_WITH_CLEANUP(fsync_failure);
 182 ATF_TC_HEAD(fsync_failure, tc)
 183 {
 184         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 185                                         "fsync(2) call");
 186 }
 187
 188 ATF_TC_BODY(fsync_failure, tc)
 189 {
 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);
 195 }
 196
 197 ATF_TC_CLEANUP(fsync_failure, tc)
 198 {
 199         cleanup();
 200 }
 201
 202
 203 ATF_TC_WITH_CLEANUP(chmod_success);
 204 ATF_TC_HEAD(chmod_success, tc)
 205 {
 206         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 207                                         "chmod(2) call");
 208 }
 209
 210 ATF_TC_BODY(chmod_success, tc)
 211 {
 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);
 217         close(filedesc);
 218 }
 219
 220 ATF_TC_CLEANUP(chmod_success, tc)
 221 {
 222         cleanup();
 223 }
 224
 225
 226 ATF_TC_WITH_CLEANUP(chmod_failure);
 227 ATF_TC_HEAD(chmod_failure, tc)
 228 {
 229         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 230                                         "chmod(2) call");
 231 }
 232
 233 ATF_TC_BODY(chmod_failure, tc)
 234 {
 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);
 239 }
 240
 241 ATF_TC_CLEANUP(chmod_failure, tc)
 242 {
 243         cleanup();
 244 }
 245
 246
 247 ATF_TC_WITH_CLEANUP(fchmod_success);
 248 ATF_TC_HEAD(fchmod_success, tc)
 249 {
 250         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 251                                         "fchmod(2) call");
 252 }
 253
 254 ATF_TC_BODY(fchmod_success, tc)
 255 {
 256         pid = getpid();
 257         snprintf(extregex, sizeof(extregex), "fchmod.*%d.*return,success", pid);
 258
 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);
 264         close(filedesc);
 265 }
 266
 267 ATF_TC_CLEANUP(fchmod_success, tc)
 268 {
 269         cleanup();
 270 }
 271
 272
 273 ATF_TC_WITH_CLEANUP(fchmod_failure);
 274 ATF_TC_HEAD(fchmod_failure, tc)
 275 {
 276         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 277                                         "fchmod(2) call");
 278 }
 279
 280 ATF_TC_BODY(fchmod_failure, tc)
 281 {
 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);
 287 }
 288
 289 ATF_TC_CLEANUP(fchmod_failure, tc)
 290 {
 291         cleanup();
 292 }
 293
 294
 295 ATF_TC_WITH_CLEANUP(lchmod_success);
 296 ATF_TC_HEAD(lchmod_success, tc)
 297 {
 298         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 299                                         "lchmod(2) call");
 300 }
 301
 302 ATF_TC_BODY(lchmod_success, tc)
 303 {
 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);
 309 }
 310
 311 ATF_TC_CLEANUP(lchmod_success, tc)
 312 {
 313         cleanup();
 314 }
 315
 316
 317 ATF_TC_WITH_CLEANUP(lchmod_failure);
 318 ATF_TC_HEAD(lchmod_failure, tc)
 319 {
 320         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 321                                         "lchmod(2) call");
 322 }
 323
 324 ATF_TC_BODY(lchmod_failure, tc)
 325 {
 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);
 330 }
 331
 332 ATF_TC_CLEANUP(lchmod_failure, tc)
 333 {
 334         cleanup();
 335 }
 336
 337
 338 ATF_TC_WITH_CLEANUP(fchmodat_success);
 339 ATF_TC_HEAD(fchmodat_success, tc)
 340 {
 341         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 342                                         "fchmodat(2) call");
 343 }
 344
 345 ATF_TC_BODY(fchmodat_success, tc)
 346 {
 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);
 352         close(filedesc);
 353 }
 354
 355 ATF_TC_CLEANUP(fchmodat_success, tc)
 356 {
 357         cleanup();
 358 }
 359
 360
 361 ATF_TC_WITH_CLEANUP(fchmodat_failure);
 362 ATF_TC_HEAD(fchmodat_failure, tc)
 363 {
 364         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 365                                         "fchmodat(2) call");
 366 }
 367
 368 ATF_TC_BODY(fchmodat_failure, tc)
 369 {
 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);
 374 }
 375
 376 ATF_TC_CLEANUP(fchmodat_failure, tc)
 377 {
 378         cleanup();
 379 }
 380
 381
 382 ATF_TC_WITH_CLEANUP(chown_success);
 383 ATF_TC_HEAD(chown_success, tc)
 384 {
 385         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 386                                         "chown(2) call");
 387 }
 388
 389 ATF_TC_BODY(chown_success, tc)
 390 {
 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);
 396         close(filedesc);
 397 }
 398
 399 ATF_TC_CLEANUP(chown_success, tc)
 400 {
 401         cleanup();
 402 }
 403
 404
 405 ATF_TC_WITH_CLEANUP(chown_failure);
 406 ATF_TC_HEAD(chown_failure, tc)
 407 {
 408         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 409                                         "chown(2) call");
 410 }
 411
 412 ATF_TC_BODY(chown_failure, tc)
 413 {
 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);
 418 }
 419
 420 ATF_TC_CLEANUP(chown_failure, tc)
 421 {
 422         cleanup();
 423 }
 424
 425
 426 ATF_TC_WITH_CLEANUP(fchown_success);
 427 ATF_TC_HEAD(fchown_success, tc)
 428 {
 429         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 430                                         "fchown(2) call");
 431 }
 432
 433 ATF_TC_BODY(fchown_success, tc)
 434 {
 435         pid = getpid();
 436         snprintf(extregex, sizeof(extregex), "fchown.*%d.*return,success", pid);
 437
 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);
 443         close(filedesc);
 444 }
 445
 446 ATF_TC_CLEANUP(fchown_success, tc)
 447 {
 448         cleanup();
 449 }
 450
 451
 452 ATF_TC_WITH_CLEANUP(fchown_failure);
 453 ATF_TC_HEAD(fchown_failure, tc)
 454 {
 455         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 456                                         "fchown(2) call");
 457 }
 458
 459 ATF_TC_BODY(fchown_failure, tc)
 460 {
 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);
 466 }
 467
 468 ATF_TC_CLEANUP(fchown_failure, tc)
 469 {
 470         cleanup();
 471 }
 472
 473
 474 ATF_TC_WITH_CLEANUP(lchown_success);
 475 ATF_TC_HEAD(lchown_success, tc)
 476 {
 477         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 478                                         "lchown(2) call");
 479 }
 480
 481 ATF_TC_BODY(lchown_success, tc)
 482 {
 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);
 488 }
 489
 490 ATF_TC_CLEANUP(lchown_success, tc)
 491 {
 492         cleanup();
 493 }
 494
 495
 496 ATF_TC_WITH_CLEANUP(lchown_failure);
 497 ATF_TC_HEAD(lchown_failure, tc)
 498 {
 499         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 500                                         "lchown(2) call");
 501 }
 502
 503 ATF_TC_BODY(lchown_failure, tc)
 504 {
 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);
 509 }
 510
 511 ATF_TC_CLEANUP(lchown_failure, tc)
 512 {
 513         cleanup();
 514 }
 515
 516
 517 ATF_TC_WITH_CLEANUP(fchownat_success);
 518 ATF_TC_HEAD(fchownat_success, tc)
 519 {
 520         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 521                                         "fchownat(2) call");
 522 }
 523
 524 ATF_TC_BODY(fchownat_success, tc)
 525 {
 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);
 531         close(filedesc);
 532 }
 533
 534 ATF_TC_CLEANUP(fchownat_success, tc)
 535 {
 536         cleanup();
 537 }
 538
 539
 540 ATF_TC_WITH_CLEANUP(fchownat_failure);
 541 ATF_TC_HEAD(fchownat_failure, tc)
 542 {
 543         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 544                                         "fchownat(2) call");
 545 }
 546
 547 ATF_TC_BODY(fchownat_failure, tc)
 548 {
 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);
 554 }
 555
 556 ATF_TC_CLEANUP(fchownat_failure, tc)
 557 {
 558         cleanup();
 559 }
 560
 561
 562 ATF_TC_WITH_CLEANUP(chflags_success);
 563 ATF_TC_HEAD(chflags_success, tc)
 564 {
 565         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 566                                         "chflags(2) call");
 567 }
 568
 569 ATF_TC_BODY(chflags_success, tc)
 570 {
 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);
 576         close(filedesc);
 577 }
 578
 579 ATF_TC_CLEANUP(chflags_success, tc)
 580 {
 581         cleanup();
 582 }
 583
 584
 585 ATF_TC_WITH_CLEANUP(chflags_failure);
 586 ATF_TC_HEAD(chflags_failure, tc)
 587 {
 588         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 589                                         "chflags(2) call");
 590 }
 591
 592 ATF_TC_BODY(chflags_failure, tc)
 593 {
 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);
 598 }
 599
 600 ATF_TC_CLEANUP(chflags_failure, tc)
 601 {
 602         cleanup();
 603 }
 604
 605
 606 ATF_TC_WITH_CLEANUP(fchflags_success);
 607 ATF_TC_HEAD(fchflags_success, tc)
 608 {
 609         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 610                                         "fchflags(2) call");
 611 }
 612
 613 ATF_TC_BODY(fchflags_success, tc)
 614 {
 615         pid = getpid();
 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);
 619
 620         FILE *pipefd = setup(fds, auclass);
 621         ATF_REQUIRE_EQ(0, fchflags(filedesc, UF_OFFLINE));
 622         check_audit(fds, extregex, pipefd);
 623         close(filedesc);
 624 }
 625
 626 ATF_TC_CLEANUP(fchflags_success, tc)
 627 {
 628         cleanup();
 629 }
 630
 631
 632 ATF_TC_WITH_CLEANUP(fchflags_failure);
 633 ATF_TC_HEAD(fchflags_failure, tc)
 634 {
 635         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 636                                         "fchflags(2) call");
 637 }
 638
 639 ATF_TC_BODY(fchflags_failure, tc)
 640 {
 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);
 646 }
 647
 648 ATF_TC_CLEANUP(fchflags_failure, tc)
 649 {
 650         cleanup();
 651 }
 652
 653
 654 ATF_TC_WITH_CLEANUP(lchflags_success);
 655 ATF_TC_HEAD(lchflags_success, tc)
 656 {
 657         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 658                                         "lchflags(2) call");
 659 }
 660
 661 ATF_TC_BODY(lchflags_success, tc)
 662 {
 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);
 668 }
 669
 670 ATF_TC_CLEANUP(lchflags_success, tc)
 671 {
 672         cleanup();
 673 }
 674
 675
 676 ATF_TC_WITH_CLEANUP(lchflags_failure);
 677 ATF_TC_HEAD(lchflags_failure, tc)
 678 {
 679         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 680                                         "lchflags(2) call");
 681 }
 682
 683 ATF_TC_BODY(lchflags_failure, tc)
 684 {
 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);
 689 }
 690
 691 ATF_TC_CLEANUP(lchflags_failure, tc)
 692 {
 693         cleanup();
 694 }
 695
 696
 697 ATF_TC_WITH_CLEANUP(chflagsat_success);
 698 ATF_TC_HEAD(chflagsat_success, tc)
 699 {
 700         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 701                                         "chflagsat(2) call");
 702 }
 703
 704 ATF_TC_BODY(chflagsat_success, tc)
 705 {
 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);
 711         close(filedesc);
 712 }
 713
 714 ATF_TC_CLEANUP(chflagsat_success, tc)
 715 {
 716         cleanup();
 717 }
 718
 719
 720 ATF_TC_WITH_CLEANUP(chflagsat_failure);
 721 ATF_TC_HEAD(chflagsat_failure, tc)
 722 {
 723         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 724                                         "chflagsat(2) call");
 725 }
 726
 727 ATF_TC_BODY(chflagsat_failure, tc)
 728 {
 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);
 734 }
 735
 736 ATF_TC_CLEANUP(chflagsat_failure, tc)
 737 {
 738         cleanup();
 739 }
 740
 741
 742 ATF_TC_WITH_CLEANUP(utimes_success);
 743 ATF_TC_HEAD(utimes_success, tc)
 744 {
 745         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 746                                         "utimes(2) call");
 747 }
 748
 749 ATF_TC_BODY(utimes_success, tc)
 750 {
 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);
 756         close(filedesc);
 757 }
 758
 759 ATF_TC_CLEANUP(utimes_success, tc)
 760 {
 761         cleanup();
 762 }
 763
 764
 765 ATF_TC_WITH_CLEANUP(utimes_failure);
 766 ATF_TC_HEAD(utimes_failure, tc)
 767 {
 768         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 769                                         "utimes(2) call");
 770 }
 771
 772 ATF_TC_BODY(utimes_failure, tc)
 773 {
 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);
 778 }
 779
 780 ATF_TC_CLEANUP(utimes_failure, tc)
 781 {
 782         cleanup();
 783 }
 784
 785
 786 ATF_TC_WITH_CLEANUP(futimes_success);
 787 ATF_TC_HEAD(futimes_success, tc)
 788 {
 789         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 790                                         "futimes(2) call");
 791 }
 792
 793 ATF_TC_BODY(futimes_success, tc)
 794 {
 795         pid = getpid();
 796         snprintf(extregex, sizeof(extregex), "futimes.*%d.*ret.*success", pid);
 797
 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);
 803         close(filedesc);
 804 }
 805
 806 ATF_TC_CLEANUP(futimes_success, tc)
 807 {
 808         cleanup();
 809 }
 810
 811
 812 ATF_TC_WITH_CLEANUP(futimes_failure);
 813 ATF_TC_HEAD(futimes_failure, tc)
 814 {
 815         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 816                                         "futimes(2) call");
 817 }
 818
 819 ATF_TC_BODY(futimes_failure, tc)
 820 {
 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);
 826 }
 827
 828 ATF_TC_CLEANUP(futimes_failure, tc)
 829 {
 830         cleanup();
 831 }
 832
 833
 834 ATF_TC_WITH_CLEANUP(lutimes_success);
 835 ATF_TC_HEAD(lutimes_success, tc)
 836 {
 837         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 838                                         "lutimes(2) call");
 839 }
 840
 841 ATF_TC_BODY(lutimes_success, tc)
 842 {
 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);
 848 }
 849
 850 ATF_TC_CLEANUP(lutimes_success, tc)
 851 {
 852         cleanup();
 853 }
 854
 855
 856 ATF_TC_WITH_CLEANUP(lutimes_failure);
 857 ATF_TC_HEAD(lutimes_failure, tc)
 858 {
 859         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 860                                         "lutimes(2) call");
 861 }
 862
 863 ATF_TC_BODY(lutimes_failure, tc)
 864 {
 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);
 869 }
 870
 871 ATF_TC_CLEANUP(lutimes_failure, tc)
 872 {
 873         cleanup();
 874 }
 875
 876
 877 ATF_TC_WITH_CLEANUP(futimesat_success);
 878 ATF_TC_HEAD(futimesat_success, tc)
 879 {
 880         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 881                                         "futimesat(2) call");
 882 }
 883
 884 ATF_TC_BODY(futimesat_success, tc)
 885 {
 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);
 891         close(filedesc);
 892 }
 893
 894 ATF_TC_CLEANUP(futimesat_success, tc)
 895 {
 896         cleanup();
 897 }
 898
 899
 900 ATF_TC_WITH_CLEANUP(futimesat_failure);
 901 ATF_TC_HEAD(futimesat_failure, tc)
 902 {
 903         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 904                                         "futimesat(2) call");
 905 }
 906
 907 ATF_TC_BODY(futimesat_failure, tc)
 908 {
 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);
 913 }
 914
 915 ATF_TC_CLEANUP(futimesat_failure, tc)
 916 {
 917         cleanup();
 918 }
 919
 920
 921 ATF_TC_WITH_CLEANUP(mprotect_success);
 922 ATF_TC_HEAD(mprotect_success, tc)
 923 {
 924         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 925                                         "mprotect(2) call");
 926 }
 927
 928 ATF_TC_BODY(mprotect_success, tc)
 929 {
 930         pid = getpid();
 931         snprintf(extregex, sizeof(extregex), "mprotect.*%d.*ret.*success", pid);
 932
 933         FILE *pipefd = setup(fds, auclass);
 934         ATF_REQUIRE_EQ(0, mprotect(NULL, 0, PROT_NONE));
 935         check_audit(fds, extregex, pipefd);
 936 }
 937
 938 ATF_TC_CLEANUP(mprotect_success, tc)
 939 {
 940         cleanup();
 941 }
 942
 943
 944 ATF_TC_WITH_CLEANUP(mprotect_failure);
 945 ATF_TC_HEAD(mprotect_failure, tc)
 946 {
 947         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 948                                         "mprotect(2) call");
 949 }
 950
 951 ATF_TC_BODY(mprotect_failure, tc)
 952 {
 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);
 958 }
 959
 960 ATF_TC_CLEANUP(mprotect_failure, tc)
 961 {
 962         cleanup();
 963 }
 964
 965 /*
 966  * undelete(2) only works on whiteout files in union file system. Hence, no
 967  * test case for successful invocation.
 968  */
 969
 970 ATF_TC_WITH_CLEANUP(undelete_failure);
 971 ATF_TC_HEAD(undelete_failure, tc)
 972 {
 973         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 974                                         "undelete(2) call");
 975 }
 976
 977 ATF_TC_BODY(undelete_failure, tc)
 978 {
 979         pid = getpid();
 980         snprintf(extregex, sizeof(extregex), "undelete.*%d.*ret.*failure", pid);
 981
 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);
 986 }
 987
 988 ATF_TC_CLEANUP(undelete_failure, tc)
 989 {
 990         cleanup();
 991 }
 992
 993
 994 ATF_TC_WITH_CLEANUP(extattr_set_file_success);
 995 ATF_TC_HEAD(extattr_set_file_success, tc)
 996 {
 997         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 998                                         "extattr_set_file(2) call");
 999 }
1000
1001 ATF_TC_BODY(extattr_set_file_success, tc)
1002 {
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);
1006
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);
1010
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);
1015         close(filedesc);
1016 }
1017
1018 ATF_TC_CLEANUP(extattr_set_file_success, tc)
1019 {
1020         cleanup();
1021 }
1022
1023
1024 ATF_TC_WITH_CLEANUP(extattr_set_file_failure);
1025 ATF_TC_HEAD(extattr_set_file_failure, tc)
1026 {
1027         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1028                                         "extattr_set_file(2) call");
1029 }
1030
1031 ATF_TC_BODY(extattr_set_file_failure, tc)
1032 {
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);
1036
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) ==
1041                 -1);
1042         check_audit(fds, extregex, pipefd);
1043 }
1044
1045 ATF_TC_CLEANUP(extattr_set_file_failure, tc)
1046 {
1047         cleanup();
1048 }
1049
1050
1051 ATF_TC_WITH_CLEANUP(extattr_set_fd_success);
1052 ATF_TC_HEAD(extattr_set_fd_success, tc)
1053 {
1054         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1055                                         "extattr_set_fd(2) call");
1056 }
1057
1058 ATF_TC_BODY(extattr_set_fd_success, tc)
1059 {
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);
1063
1064         /* Prepare the regex to be checked in the audit record */
1065         snprintf(extregex, sizeof(extregex),
1066                 "extattr_set_fd.*%s.*return,success", name);
1067
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);
1072         close(filedesc);
1073 }
1074
1075 ATF_TC_CLEANUP(extattr_set_fd_success, tc)
1076 {
1077         cleanup();
1078 }
1079
1080
1081 ATF_TC_WITH_CLEANUP(extattr_set_fd_failure);
1082 ATF_TC_HEAD(extattr_set_fd_failure, tc)
1083 {
1084         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1085                                         "extattr_set_fd(2) call");
1086 }
1087
1088 ATF_TC_BODY(extattr_set_fd_failure, tc)
1089 {
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);
1093
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);
1099 }
1100
1101 ATF_TC_CLEANUP(extattr_set_fd_failure, tc)
1102 {
1103         cleanup();
1104 }
1105
1106
1107 ATF_TC_WITH_CLEANUP(extattr_set_link_success);
1108 ATF_TC_HEAD(extattr_set_link_success, tc)
1109 {
1110         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1111                                         "extattr_set_link(2) call");
1112 }
1113
1114 ATF_TC_BODY(extattr_set_link_success, tc)
1115 {
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(".");
1119
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);
1123
1124         FILE *pipefd = setup(fds, auclass);
1125         REQUIRE_EXTATTR_RESULT(sizeof(buff), extattr_set_link(path,
1126                 EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
1127
1128         check_audit(fds, extregex, pipefd);
1129 }
1130
1131 ATF_TC_CLEANUP(extattr_set_link_success, tc)
1132 {
1133         cleanup();
1134 }
1135
1136
1137 ATF_TC_WITH_CLEANUP(extattr_set_link_failure);
1138 ATF_TC_HEAD(extattr_set_link_failure, tc)
1139 {
1140         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1141                                         "extattr_set_link(2) call");
1142 }
1143
1144 ATF_TC_BODY(extattr_set_link_failure, tc)
1145 {
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) ==
1153                 -1);
1154         check_audit(fds, extregex, pipefd);
1155 }
1156
1157 ATF_TC_CLEANUP(extattr_set_link_failure, tc)
1158 {
1159         cleanup();
1160 }
1161
1162
1163 ATF_TC_WITH_CLEANUP(extattr_delete_file_success);
1164 ATF_TC_HEAD(extattr_delete_file_success, tc)
1165 {
1166         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1167                                         "extattr_delete_file(2) call");
1168 }
1169
1170 ATF_TC_BODY(extattr_delete_file_success, tc)
1171 {
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);
1175
1176         REQUIRE_EXTATTR_RESULT(sizeof(buff), extattr_set_file(path,
1177                 EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
1178
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);
1186         close(filedesc);
1187 }
1188
1189 ATF_TC_CLEANUP(extattr_delete_file_success, tc)
1190 {
1191         cleanup();
1192 }
1193
1194
1195 ATF_TC_WITH_CLEANUP(extattr_delete_file_failure);
1196 ATF_TC_HEAD(extattr_delete_file_failure, tc)
1197 {
1198         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1199                                         "extattr_delete_file(2) call");
1200 }
1201
1202 ATF_TC_BODY(extattr_delete_file_failure, tc)
1203 {
1204         /* Prepare the regex to be checked in the audit record */
1205         snprintf(extregex, sizeof(extregex),
1206                 "extattr_delete_file.*%s.*return,failure", path);
1207
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);
1213 }
1214
1215 ATF_TC_CLEANUP(extattr_delete_file_failure, tc)
1216 {
1217         cleanup();
1218 }
1219
1220
1221 ATF_TC_WITH_CLEANUP(extattr_delete_fd_success);
1222 ATF_TC_HEAD(extattr_delete_fd_success, tc)
1223 {
1224         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1225                                         "extattr_delete_fd(2) call");
1226 }
1227
1228 ATF_TC_BODY(extattr_delete_fd_success, tc)
1229 {
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);
1233
1234         REQUIRE_EXTATTR_RESULT(sizeof(buff), extattr_set_file(path,
1235                 EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
1236
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);
1244         close(filedesc);
1245 }
1246
1247 ATF_TC_CLEANUP(extattr_delete_fd_success, tc)
1248 {
1249         cleanup();
1250 }
1251
1252
1253 ATF_TC_WITH_CLEANUP(extattr_delete_fd_failure);
1254 ATF_TC_HEAD(extattr_delete_fd_failure, tc)
1255 {
1256         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1257                                         "extattr_delete_fd(2) call");
1258 }
1259
1260 ATF_TC_BODY(extattr_delete_fd_failure, tc)
1261 {
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");
1265
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);
1271 }
1272
1273 ATF_TC_CLEANUP(extattr_delete_fd_failure, tc)
1274 {
1275         cleanup();
1276 }
1277
1278
1279 ATF_TC_WITH_CLEANUP(extattr_delete_link_success);
1280 ATF_TC_HEAD(extattr_delete_link_success, tc)
1281 {
1282         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1283                                         "extattr_delete_link(2) call");
1284 }
1285
1286 ATF_TC_BODY(extattr_delete_link_success, tc)
1287 {
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(".");
1291
1292         REQUIRE_EXTATTR_RESULT(sizeof(buff), extattr_set_link(path,
1293                 EXTATTR_NAMESPACE_USER, name, buff, sizeof(buff)));
1294
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);
1302 }
1303
1304 ATF_TC_CLEANUP(extattr_delete_link_success, tc)
1305 {
1306         cleanup();
1307 }
1308
1309
1310 ATF_TC_WITH_CLEANUP(extattr_delete_link_failure);
1311 ATF_TC_HEAD(extattr_delete_link_failure, tc)
1312 {
1313         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1314                                         "extattr_delete_link(2) call");
1315 }
1316
1317 ATF_TC_BODY(extattr_delete_link_failure, tc)
1318 {
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);
1327 }
1328
1329 ATF_TC_CLEANUP(extattr_delete_link_failure, tc)
1330 {
1331         cleanup();
1332 }
1333
1334
1335 ATF_TP_ADD_TCS(tp)
1336 {
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);
1343
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);
1352
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);
1361
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);
1370
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);
1379
1380         ATF_TP_ADD_TC(tp, mprotect_success);
1381         ATF_TP_ADD_TC(tp, mprotect_failure);
1382         ATF_TP_ADD_TC(tp, undelete_failure);
1383
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);
1390
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);
1397
1398         return (atf_no_error());
1399 }