src/test/test-fs-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <unistd.h>
   4
   5 #include "alloc-util.h"
   6 #include "chase-symlinks.h"
   7 #include "copy.h"
   8 #include "fd-util.h"
   9 #include "fileio.h"
  10 #include "fs-util.h"
  11 #include "id128-util.h"
  12 #include "macro.h"
  13 #include "mkdir.h"
  14 #include "path-util.h"
  15 #include "random-util.h"
  16 #include "rm-rf.h"
  17 #include "stdio-util.h"
  18 #include "string-util.h"
  19 #include "strv.h"
  20 #include "sync-util.h"
  21 #include "tests.h"
  22 #include "tmpfile-util.h"
  23 #include "umask-util.h"
  24 #include "user-util.h"
  25 #include "virt.h"
  26
  27 static const char *arg_test_dir = NULL;
  28
  29 TEST(chase_symlinks) {
  30         _cleanup_free_ char *result = NULL, *pwd = NULL;
  31         _cleanup_close_ int pfd = -EBADF;
  32         char *temp;
  33         const char *top, *p, *pslash, *q, *qslash;
  34         struct stat st;
  35         int r;
  36
  37         temp = strjoina(arg_test_dir ?: "/tmp", "/test-chase.XXXXXX");
  38         assert_se(mkdtemp(temp));
  39
  40         top = strjoina(temp, "/top");
  41         assert_se(mkdir(top, 0700) >= 0);
  42
  43         p = strjoina(top, "/dot");
  44         if (symlink(".", p) < 0) {
  45                 assert_se(IN_SET(errno, EINVAL, ENOSYS, ENOTTY, EPERM));
  46                 log_tests_skipped_errno(errno, "symlink() not possible");
  47                 goto cleanup;
  48         };
  49
  50         p = strjoina(top, "/dotdot");
  51         assert_se(symlink("..", p) >= 0);
  52
  53         p = strjoina(top, "/dotdota");
  54         assert_se(symlink("../a", p) >= 0);
  55
  56         p = strjoina(temp, "/a");
  57         assert_se(symlink("b", p) >= 0);
  58
  59         p = strjoina(temp, "/b");
  60         assert_se(symlink("/usr", p) >= 0);
  61
  62         p = strjoina(temp, "/start");
  63         assert_se(symlink("top/dot/dotdota", p) >= 0);
  64
  65         /* Paths that use symlinks underneath the "root" */
  66
  67         r = chase_symlinks(p, NULL, 0, &result, NULL);
  68         assert_se(r > 0);
  69         assert_se(path_equal(result, "/usr"));
  70         result = mfree(result);
  71
  72         pslash = strjoina(p, "/");
  73         r = chase_symlinks(pslash, NULL, 0, &result, NULL);
  74         assert_se(r > 0);
  75         assert_se(path_equal(result, "/usr/"));
  76         result = mfree(result);
  77
  78         r = chase_symlinks(p, temp, 0, &result, NULL);
  79         assert_se(r == -ENOENT);
  80
  81         r = chase_symlinks(pslash, temp, 0, &result, NULL);
  82         assert_se(r == -ENOENT);
  83
  84         q = strjoina(temp, "/usr");
  85
  86         r = chase_symlinks(p, temp, CHASE_NONEXISTENT, &result, NULL);
  87         assert_se(r == 0);
  88         assert_se(path_equal(result, q));
  89         result = mfree(result);
  90
  91         qslash = strjoina(q, "/");
  92
  93         r = chase_symlinks(pslash, temp, CHASE_NONEXISTENT, &result, NULL);
  94         assert_se(r == 0);
  95         assert_se(path_equal(result, qslash));
  96         result = mfree(result);
  97
  98         assert_se(mkdir(q, 0700) >= 0);
  99
 100         r = chase_symlinks(p, temp, 0, &result, NULL);
 101         assert_se(r > 0);
 102         assert_se(path_equal(result, q));
 103         result = mfree(result);
 104
 105         r = chase_symlinks(pslash, temp, 0, &result, NULL);
 106         assert_se(r > 0);
 107         assert_se(path_equal(result, qslash));
 108         result = mfree(result);
 109
 110         p = strjoina(temp, "/slash");
 111         assert_se(symlink("/", p) >= 0);
 112
 113         r = chase_symlinks(p, NULL, 0, &result, NULL);
 114         assert_se(r > 0);
 115         assert_se(path_equal(result, "/"));
 116         result = mfree(result);
 117
 118         r = chase_symlinks(p, temp, 0, &result, NULL);
 119         assert_se(r > 0);
 120         assert_se(path_equal(result, temp));
 121         result = mfree(result);
 122
 123         /* Paths that would "escape" outside of the "root" */
 124
 125         p = strjoina(temp, "/6dots");
 126         assert_se(symlink("../../..", p) >= 0);
 127
 128         r = chase_symlinks(p, temp, 0, &result, NULL);
 129         assert_se(r > 0 && path_equal(result, temp));
 130         result = mfree(result);
 131
 132         p = strjoina(temp, "/6dotsusr");
 133         assert_se(symlink("../../../usr", p) >= 0);
 134
 135         r = chase_symlinks(p, temp, 0, &result, NULL);
 136         assert_se(r > 0 && path_equal(result, q));
 137         result = mfree(result);
 138
 139         p = strjoina(temp, "/top/8dotsusr");
 140         assert_se(symlink("../../../../usr", p) >= 0);
 141
 142         r = chase_symlinks(p, temp, 0, &result, NULL);
 143         assert_se(r > 0 && path_equal(result, q));
 144         result = mfree(result);
 145
 146         /* Paths that contain repeated slashes */
 147
 148         p = strjoina(temp, "/slashslash");
 149         assert_se(symlink("///usr///", p) >= 0);
 150
 151         r = chase_symlinks(p, NULL, 0, &result, NULL);
 152         assert_se(r > 0);
 153         assert_se(path_equal(result, "/usr"));
 154         assert_se(streq(result, "/usr")); /* we guarantee that we drop redundant slashes */
 155         result = mfree(result);
 156
 157         r = chase_symlinks(p, temp, 0, &result, NULL);
 158         assert_se(r > 0);
 159         assert_se(path_equal(result, q));
 160         result = mfree(result);
 161
 162         /* Paths underneath the "root" with different UIDs while using CHASE_SAFE */
 163
 164         if (geteuid() == 0) {
 165                 p = strjoina(temp, "/user");
 166                 assert_se(mkdir(p, 0755) >= 0);
 167                 assert_se(chown(p, UID_NOBODY, GID_NOBODY) >= 0);
 168
 169                 q = strjoina(temp, "/user/root");
 170                 assert_se(mkdir(q, 0755) >= 0);
 171
 172                 p = strjoina(q, "/link");
 173                 assert_se(symlink("/", p) >= 0);
 174
 175                 /* Fail when user-owned directories contain root-owned subdirectories. */
 176                 r = chase_symlinks(p, temp, CHASE_SAFE, &result, NULL);
 177                 assert_se(r == -ENOLINK);
 178                 result = mfree(result);
 179
 180                 /* Allow this when the user-owned directories are all in the "root". */
 181                 r = chase_symlinks(p, q, CHASE_SAFE, &result, NULL);
 182                 assert_se(r > 0);
 183                 result = mfree(result);
 184         }
 185
 186         /* Paths using . */
 187
 188         r = chase_symlinks("/etc/./.././", NULL, 0, &result, NULL);
 189         assert_se(r > 0);
 190         assert_se(path_equal(result, "/"));
 191         result = mfree(result);
 192
 193         r = chase_symlinks("/etc/./.././", "/etc", 0, &result, NULL);
 194         assert_se(r > 0 && path_equal(result, "/etc"));
 195         result = mfree(result);
 196
 197         r = chase_symlinks("/../.././//../../etc", NULL, 0, &result, NULL);
 198         assert_se(r > 0);
 199         assert_se(streq(result, "/etc"));
 200         result = mfree(result);
 201
 202         r = chase_symlinks("/../.././//../../test-chase.fsldajfl", NULL, CHASE_NONEXISTENT, &result, NULL);
 203         assert_se(r == 0);
 204         assert_se(streq(result, "/test-chase.fsldajfl"));
 205         result = mfree(result);
 206
 207         r = chase_symlinks("/../.././//../../etc", "/", CHASE_PREFIX_ROOT, &result, NULL);
 208         assert_se(r > 0);
 209         assert_se(streq(result, "/etc"));
 210         result = mfree(result);
 211
 212         r = chase_symlinks("/../.././//../../test-chase.fsldajfl", "/", CHASE_PREFIX_ROOT|CHASE_NONEXISTENT, &result, NULL);
 213         assert_se(r == 0);
 214         assert_se(streq(result, "/test-chase.fsldajfl"));
 215         result = mfree(result);
 216
 217         r = chase_symlinks("/etc/machine-id/foo", NULL, 0, &result, NULL);
 218         assert_se(IN_SET(r, -ENOTDIR, -ENOENT));
 219         result = mfree(result);
 220
 221         /* Path that loops back to self */
 222
 223         p = strjoina(temp, "/recursive-symlink");
 224         assert_se(symlink("recursive-symlink", p) >= 0);
 225         r = chase_symlinks(p, NULL, 0, &result, NULL);
 226         assert_se(r == -ELOOP);
 227
 228         /* Path which doesn't exist */
 229
 230         p = strjoina(temp, "/idontexist");
 231         r = chase_symlinks(p, NULL, 0, &result, NULL);
 232         assert_se(r == -ENOENT);
 233
 234         r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result, NULL);
 235         assert_se(r == 0);
 236         assert_se(path_equal(result, p));
 237         result = mfree(result);
 238
 239         p = strjoina(temp, "/idontexist/meneither");
 240         r = chase_symlinks(p, NULL, 0, &result, NULL);
 241         assert_se(r == -ENOENT);
 242
 243         r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result, NULL);
 244         assert_se(r == 0);
 245         assert_se(path_equal(result, p));
 246         result = mfree(result);
 247
 248         /* Relative paths */
 249
 250         assert_se(safe_getcwd(&pwd) >= 0);
 251
 252         assert_se(chdir(temp) >= 0);
 253
 254         p = "this/is/a/relative/path";
 255         r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result, NULL);
 256         assert_se(r == 0);
 257
 258         p = strjoina(temp, "/", p);
 259         assert_se(path_equal(result, p));
 260         result = mfree(result);
 261
 262         p = "this/is/a/relative/path";
 263         r = chase_symlinks(p, temp, CHASE_NONEXISTENT, &result, NULL);
 264         assert_se(r == 0);
 265
 266         p = strjoina(temp, "/", p);
 267         assert_se(path_equal(result, p));
 268         result = mfree(result);
 269
 270         assert_se(chdir(pwd) >= 0);
 271
 272         /* Path which doesn't exist, but contains weird stuff */
 273
 274         p = strjoina(temp, "/idontexist/..");
 275         r = chase_symlinks(p, NULL, 0, &result, NULL);
 276         assert_se(r == -ENOENT);
 277
 278         r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result, NULL);
 279         assert_se(r == -ENOENT);
 280
 281         p = strjoina(temp, "/target");
 282         q = strjoina(temp, "/top");
 283         assert_se(symlink(q, p) >= 0);
 284         p = strjoina(temp, "/target/idontexist");
 285         r = chase_symlinks(p, NULL, 0, &result, NULL);
 286         assert_se(r == -ENOENT);
 287
 288         if (geteuid() == 0) {
 289                 p = strjoina(temp, "/priv1");
 290                 assert_se(mkdir(p, 0755) >= 0);
 291
 292                 q = strjoina(p, "/priv2");
 293                 assert_se(mkdir(q, 0755) >= 0);
 294
 295                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) >= 0);
 296
 297                 assert_se(chown(q, UID_NOBODY, GID_NOBODY) >= 0);
 298                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) >= 0);
 299
 300                 assert_se(chown(p, UID_NOBODY, GID_NOBODY) >= 0);
 301                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) >= 0);
 302
 303                 assert_se(chown(q, 0, 0) >= 0);
 304                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) == -ENOLINK);
 305
 306                 assert_se(rmdir(q) >= 0);
 307                 assert_se(symlink("/etc/passwd", q) >= 0);
 308                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) == -ENOLINK);
 309
 310                 assert_se(chown(p, 0, 0) >= 0);
 311                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) >= 0);
 312         }
 313
 314         p = strjoina(temp, "/machine-id-test");
 315         assert_se(symlink("/usr/../etc/./machine-id", p) >= 0);
 316
 317         r = chase_symlinks(p, NULL, 0, NULL, &pfd);
 318         if (r != -ENOENT && sd_id128_get_machine(NULL) >= 0) {
 319                 _cleanup_close_ int fd = -EBADF;
 320                 sd_id128_t a, b;
 321
 322                 assert_se(pfd >= 0);
 323
 324                 fd = fd_reopen(pfd, O_RDONLY|O_CLOEXEC);
 325                 assert_se(fd >= 0);
 326                 safe_close(pfd);
 327
 328                 assert_se(id128_read_fd(fd, ID128_FORMAT_PLAIN, &a) >= 0);
 329                 assert_se(sd_id128_get_machine(&b) >= 0);
 330                 assert_se(sd_id128_equal(a, b));
 331         }
 332
 333         assert_se(lstat(p, &st) >= 0);
 334         r = chase_symlinks_and_unlink(p, NULL, 0, 0,  &result);
 335         assert_se(path_equal(result, p));
 336         result = mfree(result);
 337         assert_se(r == 0);
 338         assert_se(lstat(p, &st) == -1 && errno == ENOENT);
 339
 340         /* Test CHASE_NOFOLLOW */
 341
 342         p = strjoina(temp, "/target");
 343         q = strjoina(temp, "/symlink");
 344         assert_se(symlink(p, q) >= 0);
 345         r = chase_symlinks(q, NULL, CHASE_NOFOLLOW, &result, &pfd);
 346         assert_se(r >= 0);
 347         assert_se(pfd >= 0);
 348         assert_se(path_equal(result, q));
 349         assert_se(fstat(pfd, &st) >= 0);
 350         assert_se(S_ISLNK(st.st_mode));
 351         result = mfree(result);
 352         pfd = safe_close(pfd);
 353
 354         /* s1 -> s2 -> nonexistent */
 355         q = strjoina(temp, "/s1");
 356         assert_se(symlink("s2", q) >= 0);
 357         p = strjoina(temp, "/s2");
 358         assert_se(symlink("nonexistent", p) >= 0);
 359         r = chase_symlinks(q, NULL, CHASE_NOFOLLOW, &result, &pfd);
 360         assert_se(r >= 0);
 361         assert_se(pfd >= 0);
 362         assert_se(path_equal(result, q));
 363         assert_se(fstat(pfd, &st) >= 0);
 364         assert_se(S_ISLNK(st.st_mode));
 365         result = mfree(result);
 366         pfd = safe_close(pfd);
 367
 368         /* Test CHASE_STEP */
 369
 370         p = strjoina(temp, "/start");
 371         r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
 372         assert_se(r == 0);
 373         p = strjoina(temp, "/top/dot/dotdota");
 374         assert_se(streq(p, result));
 375         result = mfree(result);
 376
 377         r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
 378         assert_se(r == 0);
 379         p = strjoina(temp, "/top/dotdota");
 380         assert_se(streq(p, result));
 381         result = mfree(result);
 382
 383         r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
 384         assert_se(r == 0);
 385         p = strjoina(temp, "/top/../a");
 386         assert_se(streq(p, result));
 387         result = mfree(result);
 388
 389         r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
 390         assert_se(r == 0);
 391         p = strjoina(temp, "/a");
 392         assert_se(streq(p, result));
 393         result = mfree(result);
 394
 395         r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
 396         assert_se(r == 0);
 397         p = strjoina(temp, "/b");
 398         assert_se(streq(p, result));
 399         result = mfree(result);
 400
 401         r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
 402         assert_se(r == 0);
 403         assert_se(streq("/usr", result));
 404         result = mfree(result);
 405
 406         r = chase_symlinks("/usr", NULL, CHASE_STEP, &result, NULL);
 407         assert_se(r > 0);
 408         assert_se(streq("/usr", result));
 409         result = mfree(result);
 410
 411         /* Make sure that symlinks in the "root" path are not resolved, but those below are */
 412         p = strjoina("/etc/..", temp, "/self");
 413         assert_se(symlink(".", p) >= 0);
 414         q = strjoina(p, "/top/dot/dotdota");
 415         r = chase_symlinks(q, p, 0, &result, NULL);
 416         assert_se(r > 0);
 417         assert_se(path_equal(path_startswith(result, p), "usr"));
 418         result = mfree(result);
 419
 420         /* Test CHASE_PROHIBIT_SYMLINKS */
 421
 422         assert_se(chase_symlinks("top/dot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS, NULL, NULL) == -EREMCHG);
 423         assert_se(chase_symlinks("top/dot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS|CHASE_WARN, NULL, NULL) == -EREMCHG);
 424         assert_se(chase_symlinks("top/dotdot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS, NULL, NULL) == -EREMCHG);
 425         assert_se(chase_symlinks("top/dotdot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS|CHASE_WARN, NULL, NULL) == -EREMCHG);
 426         assert_se(chase_symlinks("top/dot/dot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS, NULL, NULL) == -EREMCHG);
 427         assert_se(chase_symlinks("top/dot/dot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS|CHASE_WARN, NULL, NULL) == -EREMCHG);
 428
 429  cleanup:
 430         assert_se(rm_rf(temp, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
 431 }
 432
 433 TEST(unlink_noerrno) {
 434         char *name;
 435         int fd;
 436
 437         name = strjoina(arg_test_dir ?: "/tmp", "/test-close_nointr.XXXXXX");
 438         fd = mkostemp_safe(name);
 439         assert_se(fd >= 0);
 440         assert_se(close_nointr(fd) >= 0);
 441
 442         {
 443                 PROTECT_ERRNO;
 444                 errno = 42;
 445                 assert_se(unlink_noerrno(name) >= 0);
 446                 assert_se(errno == 42);
 447                 assert_se(unlink_noerrno(name) < 0);
 448                 assert_se(errno == 42);
 449         }
 450 }
 451
 452 TEST(readlink_and_make_absolute) {
 453         const char *tempdir, *name, *name2, *name_alias;
 454         _cleanup_free_ char *r1 = NULL, *r2 = NULL, *pwd = NULL;
 455
 456         tempdir = strjoina(arg_test_dir ?: "/tmp", "/test-readlink_and_make_absolute");
 457         name = strjoina(tempdir, "/original");
 458         name2 = "test-readlink_and_make_absolute/original";
 459         name_alias = strjoina(arg_test_dir ?: "/tmp", "/test-readlink_and_make_absolute-alias");
 460
 461         assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid(), MKDIR_WARN_MODE) >= 0);
 462         assert_se(touch(name) >= 0);
 463
 464         if (symlink(name, name_alias) < 0) {
 465                 assert_se(IN_SET(errno, EINVAL, ENOSYS, ENOTTY, EPERM));
 466                 log_tests_skipped_errno(errno, "symlink() not possible");
 467         } else {
 468                 assert_se(readlink_and_make_absolute(name_alias, &r1) >= 0);
 469                 assert_se(streq(r1, name));
 470                 assert_se(unlink(name_alias) >= 0);
 471
 472                 assert_se(safe_getcwd(&pwd) >= 0);
 473
 474                 assert_se(chdir(tempdir) >= 0);
 475                 assert_se(symlink(name2, name_alias) >= 0);
 476                 assert_se(readlink_and_make_absolute(name_alias, &r2) >= 0);
 477                 assert_se(streq(r2, name));
 478                 assert_se(unlink(name_alias) >= 0);
 479
 480                 assert_se(chdir(pwd) >= 0);
 481         }
 482
 483         assert_se(rm_rf(tempdir, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
 484 }
 485
 486 TEST(get_files_in_directory) {
 487         _cleanup_strv_free_ char **l = NULL, **t = NULL;
 488
 489         assert_se(get_files_in_directory(arg_test_dir ?: "/tmp", &l) >= 0);
 490         assert_se(get_files_in_directory(".", &t) >= 0);
 491         assert_se(get_files_in_directory(".", NULL) >= 0);
 492 }
 493
 494 TEST(var_tmp) {
 495         _cleanup_free_ char *tmpdir_backup = NULL, *temp_backup = NULL, *tmp_backup = NULL;
 496         const char *tmp_dir = NULL, *t;
 497
 498         t = getenv("TMPDIR");
 499         if (t) {
 500                 tmpdir_backup = strdup(t);
 501                 assert_se(tmpdir_backup);
 502         }
 503
 504         t = getenv("TEMP");
 505         if (t) {
 506                 temp_backup = strdup(t);
 507                 assert_se(temp_backup);
 508         }
 509
 510         t = getenv("TMP");
 511         if (t) {
 512                 tmp_backup = strdup(t);
 513                 assert_se(tmp_backup);
 514         }
 515
 516         assert_se(unsetenv("TMPDIR") >= 0);
 517         assert_se(unsetenv("TEMP") >= 0);
 518         assert_se(unsetenv("TMP") >= 0);
 519
 520         assert_se(var_tmp_dir(&tmp_dir) >= 0);
 521         assert_se(streq(tmp_dir, "/var/tmp"));
 522
 523         assert_se(setenv("TMPDIR", "/tmp", true) >= 0);
 524         assert_se(streq(getenv("TMPDIR"), "/tmp"));
 525
 526         assert_se(var_tmp_dir(&tmp_dir) >= 0);
 527         assert_se(streq(tmp_dir, "/tmp"));
 528
 529         assert_se(setenv("TMPDIR", "/88_does_not_exist_88", true) >= 0);
 530         assert_se(streq(getenv("TMPDIR"), "/88_does_not_exist_88"));
 531
 532         assert_se(var_tmp_dir(&tmp_dir) >= 0);
 533         assert_se(streq(tmp_dir, "/var/tmp"));
 534
 535         if (tmpdir_backup)  {
 536                 assert_se(setenv("TMPDIR", tmpdir_backup, true) >= 0);
 537                 assert_se(streq(getenv("TMPDIR"), tmpdir_backup));
 538         }
 539
 540         if (temp_backup)  {
 541                 assert_se(setenv("TEMP", temp_backup, true) >= 0);
 542                 assert_se(streq(getenv("TEMP"), temp_backup));
 543         }
 544
 545         if (tmp_backup)  {
 546                 assert_se(setenv("TMP", tmp_backup, true) >= 0);
 547                 assert_se(streq(getenv("TMP"), tmp_backup));
 548         }
 549 }
 550
 551 TEST(dot_or_dot_dot) {
 552         assert_se(!dot_or_dot_dot(NULL));
 553         assert_se(!dot_or_dot_dot(""));
 554         assert_se(!dot_or_dot_dot("xxx"));
 555         assert_se(dot_or_dot_dot("."));
 556         assert_se(dot_or_dot_dot(".."));
 557         assert_se(!dot_or_dot_dot(".foo"));
 558         assert_se(!dot_or_dot_dot("..foo"));
 559 }
 560
 561 TEST(access_fd) {
 562         _cleanup_(rmdir_and_freep) char *p = NULL;
 563         _cleanup_close_ int fd = -EBADF;
 564         const char *a;
 565
 566         a = strjoina(arg_test_dir ?: "/tmp", "/access-fd.XXXXXX");
 567         assert_se(mkdtemp_malloc(a, &p) >= 0);
 568
 569         fd = open(p, O_RDONLY|O_DIRECTORY|O_CLOEXEC);
 570         assert_se(fd >= 0);
 571
 572         assert_se(access_fd(fd, R_OK) >= 0);
 573         assert_se(access_fd(fd, F_OK) >= 0);
 574         assert_se(access_fd(fd, W_OK) >= 0);
 575
 576         assert_se(fchmod(fd, 0000) >= 0);
 577
 578         assert_se(access_fd(fd, F_OK) >= 0);
 579
 580         if (geteuid() == 0) {
 581                 assert_se(access_fd(fd, R_OK) >= 0);
 582                 assert_se(access_fd(fd, W_OK) >= 0);
 583         } else {
 584                 assert_se(access_fd(fd, R_OK) == -EACCES);
 585                 assert_se(access_fd(fd, W_OK) == -EACCES);
 586         }
 587 }
 588
 589 TEST(touch_file) {
 590         uid_t test_uid, test_gid;
 591         _cleanup_(rm_rf_physical_and_freep) char *p = NULL;
 592         struct stat st;
 593         const char *a;
 594         usec_t test_mtime;
 595         int r;
 596
 597         test_uid = geteuid() == 0 ? 65534 : getuid();
 598         test_gid = geteuid() == 0 ? 65534 : getgid();
 599
 600         test_mtime = usec_sub_unsigned(now(CLOCK_REALTIME), USEC_PER_WEEK);
 601
 602         a = strjoina(arg_test_dir ?: "/dev/shm", "/touch-file-XXXXXX");
 603         assert_se(mkdtemp_malloc(a, &p) >= 0);
 604
 605         a = strjoina(p, "/regular");
 606         r = touch_file(a, false, test_mtime, test_uid, test_gid, 0640);
 607         if (r < 0) {
 608                 assert_se(IN_SET(r, -EINVAL, -ENOSYS, -ENOTTY, -EPERM));
 609                 log_tests_skipped_errno(errno, "touch_file() not possible");
 610                 return;
 611         }
 612
 613         assert_se(lstat(a, &st) >= 0);
 614         assert_se(st.st_uid == test_uid);
 615         assert_se(st.st_gid == test_gid);
 616         assert_se(S_ISREG(st.st_mode));
 617         assert_se((st.st_mode & 0777) == 0640);
 618         assert_se(timespec_load(&st.st_mtim) == test_mtime);
 619
 620         a = strjoina(p, "/dir");
 621         assert_se(mkdir(a, 0775) >= 0);
 622         assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 623         assert_se(lstat(a, &st) >= 0);
 624         assert_se(st.st_uid == test_uid);
 625         assert_se(st.st_gid == test_gid);
 626         assert_se(S_ISDIR(st.st_mode));
 627         assert_se((st.st_mode & 0777) == 0640);
 628         assert_se(timespec_load(&st.st_mtim) == test_mtime);
 629
 630         a = strjoina(p, "/fifo");
 631         assert_se(mkfifo(a, 0775) >= 0);
 632         assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 633         assert_se(lstat(a, &st) >= 0);
 634         assert_se(st.st_uid == test_uid);
 635         assert_se(st.st_gid == test_gid);
 636         assert_se(S_ISFIFO(st.st_mode));
 637         assert_se((st.st_mode & 0777) == 0640);
 638         assert_se(timespec_load(&st.st_mtim) == test_mtime);
 639
 640         a = strjoina(p, "/sock");
 641         assert_se(mknod(a, 0775 | S_IFSOCK, 0) >= 0);
 642         assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 643         assert_se(lstat(a, &st) >= 0);
 644         assert_se(st.st_uid == test_uid);
 645         assert_se(st.st_gid == test_gid);
 646         assert_se(S_ISSOCK(st.st_mode));
 647         assert_se((st.st_mode & 0777) == 0640);
 648         assert_se(timespec_load(&st.st_mtim) == test_mtime);
 649
 650         if (geteuid() == 0) {
 651                 a = strjoina(p, "/bdev");
 652                 r = mknod(a, 0775 | S_IFBLK, makedev(0, 0));
 653                 if (r < 0 && errno == EPERM && detect_container() > 0) {
 654                         log_notice("Running in unprivileged container? Skipping remaining tests in %s", __func__);
 655                         return;
 656                 }
 657                 assert_se(r >= 0);
 658                 assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 659                 assert_se(lstat(a, &st) >= 0);
 660                 assert_se(st.st_uid == test_uid);
 661                 assert_se(st.st_gid == test_gid);
 662                 assert_se(S_ISBLK(st.st_mode));
 663                 assert_se((st.st_mode & 0777) == 0640);
 664                 assert_se(timespec_load(&st.st_mtim) == test_mtime);
 665
 666                 a = strjoina(p, "/cdev");
 667                 assert_se(mknod(a, 0775 | S_IFCHR, makedev(0, 0)) >= 0);
 668                 assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 669                 assert_se(lstat(a, &st) >= 0);
 670                 assert_se(st.st_uid == test_uid);
 671                 assert_se(st.st_gid == test_gid);
 672                 assert_se(S_ISCHR(st.st_mode));
 673                 assert_se((st.st_mode & 0777) == 0640);
 674                 assert_se(timespec_load(&st.st_mtim) == test_mtime);
 675         }
 676
 677         a = strjoina(p, "/lnk");
 678         assert_se(symlink("target", a) >= 0);
 679         assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 680         assert_se(lstat(a, &st) >= 0);
 681         assert_se(st.st_uid == test_uid);
 682         assert_se(st.st_gid == test_gid);
 683         assert_se(S_ISLNK(st.st_mode));
 684         assert_se(timespec_load(&st.st_mtim) == test_mtime);
 685 }
 686
 687 TEST(unlinkat_deallocate) {
 688         _cleanup_free_ char *p = NULL;
 689         _cleanup_close_ int fd = -EBADF;
 690         struct stat st;
 691
 692         assert_se(tempfn_random_child(arg_test_dir, "unlink-deallocation", &p) >= 0);
 693
 694         fd = open(p, O_WRONLY|O_CLOEXEC|O_CREAT|O_EXCL, 0600);
 695         assert_se(fd >= 0);
 696
 697         assert_se(write(fd, "hallo\n", 6) == 6);
 698
 699         assert_se(fstat(fd, &st) >= 0);
 700         assert_se(st.st_size == 6);
 701         assert_se(st.st_blocks > 0);
 702         assert_se(st.st_nlink == 1);
 703
 704         assert_se(unlinkat_deallocate(AT_FDCWD, p, UNLINK_ERASE) >= 0);
 705
 706         assert_se(fstat(fd, &st) >= 0);
 707         assert_se(IN_SET(st.st_size, 0, 6)); /* depending on whether hole punching worked the size will be 6
 708                                                 (it worked) or 0 (we had to resort to truncation) */
 709         assert_se(st.st_blocks == 0);
 710         assert_se(st.st_nlink == 0);
 711 }
 712
 713 TEST(fsync_directory_of_file) {
 714         _cleanup_close_ int fd = -EBADF;
 715
 716         fd = open_tmpfile_unlinkable(arg_test_dir, O_RDWR);
 717         assert_se(fd >= 0);
 718
 719         assert_se(fsync_directory_of_file(fd) >= 0);
 720 }
 721
 722 TEST(rename_noreplace) {
 723         static const char* const table[] = {
 724                 "/reg",
 725                 "/dir",
 726                 "/fifo",
 727                 "/socket",
 728                 "/symlink",
 729                 NULL
 730         };
 731
 732         _cleanup_(rm_rf_physical_and_freep) char *z = NULL;
 733         const char *j = NULL;
 734
 735         if (arg_test_dir)
 736                 j = strjoina(arg_test_dir, "/testXXXXXX");
 737         assert_se(mkdtemp_malloc(j, &z) >= 0);
 738
 739         j = strjoina(z, table[0]);
 740         assert_se(touch(j) >= 0);
 741
 742         j = strjoina(z, table[1]);
 743         assert_se(mkdir(j, 0777) >= 0);
 744
 745         j = strjoina(z, table[2]);
 746         (void) mkfifo(j, 0777);
 747
 748         j = strjoina(z, table[3]);
 749         (void) mknod(j, S_IFSOCK | 0777, 0);
 750
 751         j = strjoina(z, table[4]);
 752         (void) symlink("foobar", j);
 753
 754         STRV_FOREACH(a, table) {
 755                 _cleanup_free_ char *x = NULL, *y = NULL;
 756
 757                 x = strjoin(z, *a);
 758                 assert_se(x);
 759
 760                 if (access(x, F_OK) < 0) {
 761                         assert_se(errno == ENOENT);
 762                         continue;
 763                 }
 764
 765                 STRV_FOREACH(b, table) {
 766                         _cleanup_free_ char *w = NULL;
 767
 768                         w = strjoin(z, *b);
 769                         assert_se(w);
 770
 771                         if (access(w, F_OK) < 0) {
 772                                 assert_se(errno == ENOENT);
 773                                 continue;
 774                         }
 775
 776                         assert_se(rename_noreplace(AT_FDCWD, x, AT_FDCWD, w) == -EEXIST);
 777                 }
 778
 779                 y = strjoin(z, "/somethingelse");
 780                 assert_se(y);
 781
 782                 assert_se(rename_noreplace(AT_FDCWD, x, AT_FDCWD, y) >= 0);
 783                 assert_se(rename_noreplace(AT_FDCWD, y, AT_FDCWD, x) >= 0);
 784         }
 785 }
 786
 787 TEST(chmod_and_chown) {
 788         _cleanup_(rm_rf_physical_and_freep) char *d = NULL;
 789         struct stat st;
 790         const char *p;
 791
 792         if (geteuid() != 0)
 793                 return;
 794
 795         BLOCK_WITH_UMASK(0000);
 796
 797         assert_se(mkdtemp_malloc(NULL, &d) >= 0);
 798
 799         p = strjoina(d, "/reg");
 800         assert_se(mknod(p, S_IFREG | 0123, 0) >= 0);
 801
 802         assert_se(chmod_and_chown(p, S_IFREG | 0321, 1, 2) >= 0);
 803         assert_se(chmod_and_chown(p, S_IFDIR | 0555, 3, 4) == -EINVAL);
 804
 805         assert_se(lstat(p, &st) >= 0);
 806         assert_se(S_ISREG(st.st_mode));
 807         assert_se((st.st_mode & 07777) == 0321);
 808
 809         p = strjoina(d, "/dir");
 810         assert_se(mkdir(p, 0123) >= 0);
 811
 812         assert_se(chmod_and_chown(p, S_IFDIR | 0321, 1, 2) >= 0);
 813         assert_se(chmod_and_chown(p, S_IFREG | 0555, 3, 4) == -EINVAL);
 814
 815         assert_se(lstat(p, &st) >= 0);
 816         assert_se(S_ISDIR(st.st_mode));
 817         assert_se((st.st_mode & 07777) == 0321);
 818
 819         p = strjoina(d, "/lnk");
 820         assert_se(symlink("idontexist", p) >= 0);
 821
 822         assert_se(chmod_and_chown(p, S_IFLNK | 0321, 1, 2) >= 0);
 823         assert_se(chmod_and_chown(p, S_IFREG | 0555, 3, 4) == -EINVAL);
 824         assert_se(chmod_and_chown(p, S_IFDIR | 0555, 3, 4) == -EINVAL);
 825
 826         assert_se(lstat(p, &st) >= 0);
 827         assert_se(S_ISLNK(st.st_mode));
 828 }
 829
 830 static void create_binary_file(const char *p, const void *data, size_t l) {
 831         _cleanup_close_ int fd = -EBADF;
 832
 833         fd = open(p, O_CREAT|O_WRONLY|O_EXCL|O_CLOEXEC, 0600);
 834         assert_se(fd >= 0);
 835         assert_se(write(fd, data, l) == (ssize_t) l);
 836 }
 837
 838 TEST(conservative_rename) {
 839         _cleanup_(unlink_and_freep) char *p = NULL;
 840         _cleanup_free_ char *q = NULL;
 841         size_t l = 16*1024 + random_u64() % (32 * 1024); /* some randomly sized buffer 16k…48k */
 842         uint8_t buffer[l+1];
 843
 844         random_bytes(buffer, l);
 845
 846         assert_se(tempfn_random_child(NULL, NULL, &p) >= 0);
 847         create_binary_file(p, buffer, l);
 848
 849         assert_se(tempfn_random_child(NULL, NULL, &q) >= 0);
 850
 851         /* Check that the hardlinked "copy" is detected */
 852         assert_se(link(p, q) >= 0);
 853         assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) == 0);
 854         assert_se(access(q, F_OK) < 0 && errno == ENOENT);
 855
 856         /* Check that a manual copy is detected */
 857         assert_se(copy_file(p, q, 0, MODE_INVALID, 0, 0, COPY_REFLINK) >= 0);
 858         assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) == 0);
 859         assert_se(access(q, F_OK) < 0 && errno == ENOENT);
 860
 861         /* Check that a manual new writeout is also detected */
 862         create_binary_file(q, buffer, l);
 863         assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) == 0);
 864         assert_se(access(q, F_OK) < 0 && errno == ENOENT);
 865
 866         /* Check that a minimally changed version is detected */
 867         buffer[47] = ~buffer[47];
 868         create_binary_file(q, buffer, l);
 869         assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) > 0);
 870         assert_se(access(q, F_OK) < 0 && errno == ENOENT);
 871
 872         /* Check that this really is new updated version */
 873         create_binary_file(q, buffer, l);
 874         assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) == 0);
 875         assert_se(access(q, F_OK) < 0 && errno == ENOENT);
 876
 877         /* Make sure we detect extended files */
 878         buffer[l++] = 47;
 879         create_binary_file(q, buffer, l);
 880         assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) > 0);
 881         assert_se(access(q, F_OK) < 0 && errno == ENOENT);
 882
 883         /* Make sure we detect truncated files */
 884         l--;
 885         create_binary_file(q, buffer, l);
 886         assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) > 0);
 887         assert_se(access(q, F_OK) < 0 && errno == ENOENT);
 888 }
 889
 890 static void test_rmdir_parents_one(
 891                 const char *prefix,
 892                 const char *path,
 893                 const char *stop,
 894                 int expected,
 895                 const char *test_exist,
 896                 const char *test_nonexist_subdir) {
 897
 898         const char *p, *s;
 899
 900         log_debug("/* %s(%s, %s) */", __func__, path, stop);
 901
 902         p = strjoina(prefix, path);
 903         s = strjoina(prefix, stop);
 904
 905         if (expected >= 0)
 906                 assert_se(mkdir_parents(p, 0700) >= 0);
 907
 908         assert_se(rmdir_parents(p, s) == expected);
 909
 910         if (expected >= 0) {
 911                 const char *e, *f;
 912
 913                 e = strjoina(prefix, test_exist);
 914                 f = strjoina(e, test_nonexist_subdir);
 915
 916                 assert_se(access(e, F_OK) >= 0);
 917                 assert_se(access(f, F_OK) < 0);
 918         }
 919 }
 920
 921 TEST(rmdir_parents) {
 922         char *temp;
 923
 924         temp = strjoina(arg_test_dir ?: "/tmp", "/test-rmdir.XXXXXX");
 925         assert_se(mkdtemp(temp));
 926
 927         test_rmdir_parents_one(temp, "/aaa/../hoge/foo", "/hoge/foo", -EINVAL, NULL, NULL);
 928         test_rmdir_parents_one(temp, "/aaa/bbb/ccc", "/hoge/../aaa", -EINVAL, NULL, NULL);
 929
 930         test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/aaa/bbb/ccc/ddd", 0, "/aaa/bbb/ccc/ddd", "/eee");
 931         test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/aaa/bbb/ccc", 0, "/aaa/bbb/ccc", "/ddd");
 932         test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/aaa/bbb", 0, "/aaa/bbb", "/ccc");
 933         test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/aaa", 0, "/aaa", "/bbb");
 934         test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/", 0, "/", "/aaa");
 935
 936         test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/aaa/hoge/foo", 0, "/aaa", "/bbb");
 937         test_rmdir_parents_one(temp, "/aaa////bbb/.//ccc//ddd/eee///./.", "///././aaa/.", 0, "/aaa", "/bbb");
 938
 939         assert_se(rm_rf(temp, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
 940 }
 941
 942 static void test_parse_cifs_service_one(const char *f, const char *h, const char *s, const char *d, int ret) {
 943         _cleanup_free_ char *a = NULL, *b = NULL, *c = NULL;
 944
 945         assert_se(parse_cifs_service(f, &a, &b, &c) == ret);
 946         assert_se(streq_ptr(a, h));
 947         assert_se(streq_ptr(b, s));
 948         assert_se(streq_ptr(c, d));
 949 }
 950
 951 TEST(parse_cifs_service) {
 952         test_parse_cifs_service_one("//foo/bar/baz", "foo", "bar", "baz", 0);
 953         test_parse_cifs_service_one("\\\\foo\\bar\\baz", "foo", "bar", "baz", 0);
 954         test_parse_cifs_service_one("//foo/bar", "foo", "bar", NULL, 0);
 955         test_parse_cifs_service_one("\\\\foo\\bar", "foo", "bar", NULL, 0);
 956         test_parse_cifs_service_one("//foo/bar/baz/uuu", "foo", "bar", "baz/uuu", 0);
 957         test_parse_cifs_service_one("\\\\foo\\bar\\baz\\uuu", "foo", "bar", "baz/uuu", 0);
 958
 959         test_parse_cifs_service_one(NULL, NULL, NULL, NULL, -EINVAL);
 960         test_parse_cifs_service_one("", NULL, NULL, NULL, -EINVAL);
 961         test_parse_cifs_service_one("abc", NULL, NULL, NULL, -EINVAL);
 962         test_parse_cifs_service_one("abc/cde/efg", NULL, NULL, NULL, -EINVAL);
 963         test_parse_cifs_service_one("//foo/bar/baz/..", NULL, NULL, NULL, -EINVAL);
 964         test_parse_cifs_service_one("//foo///", NULL, NULL, NULL, -EINVAL);
 965         test_parse_cifs_service_one("//foo/.", NULL, NULL, NULL, -EINVAL);
 966         test_parse_cifs_service_one("//foo/a/.", NULL, NULL, NULL, -EINVAL);
 967         test_parse_cifs_service_one("//./a", NULL, NULL, NULL, -EINVAL);
 968 }
 969
 970 TEST(open_mkdir_at) {
 971         _cleanup_close_ int fd = -EBADF, subdir_fd = -EBADF, subsubdir_fd = -EBADF;
 972         _cleanup_(rm_rf_physical_and_freep) char *t = NULL;
 973
 974         assert_se(open_mkdir_at(AT_FDCWD, "/proc", O_EXCL|O_CLOEXEC, 0) == -EEXIST);
 975
 976         fd = open_mkdir_at(AT_FDCWD, "/proc", O_CLOEXEC, 0);
 977         assert_se(fd >= 0);
 978         fd = safe_close(fd);
 979
 980         assert_se(open_mkdir_at(AT_FDCWD, "/bin/sh", O_EXCL|O_CLOEXEC, 0) == -EEXIST);
 981         assert_se(open_mkdir_at(AT_FDCWD, "/bin/sh", O_CLOEXEC, 0) == -EEXIST);
 982
 983         assert_se(mkdtemp_malloc(NULL, &t) >= 0);
 984
 985         assert_se(open_mkdir_at(AT_FDCWD, t, O_EXCL|O_CLOEXEC, 0) == -EEXIST);
 986         assert_se(open_mkdir_at(AT_FDCWD, t, O_PATH|O_EXCL|O_CLOEXEC, 0) == -EEXIST);
 987
 988         fd = open_mkdir_at(AT_FDCWD, t, O_CLOEXEC, 0000);
 989         assert_se(fd >= 0);
 990         fd = safe_close(fd);
 991
 992         fd = open_mkdir_at(AT_FDCWD, t, O_PATH|O_CLOEXEC, 0000);
 993         assert_se(fd >= 0);
 994
 995         subdir_fd = open_mkdir_at(fd, "xxx", O_PATH|O_EXCL|O_CLOEXEC, 0700);
 996         assert_se(subdir_fd >= 0);
 997
 998         assert_se(open_mkdir_at(fd, "xxx", O_PATH|O_EXCL|O_CLOEXEC, 0) == -EEXIST);
 999
1000         subsubdir_fd = open_mkdir_at(subdir_fd, "yyy", O_EXCL|O_CLOEXEC, 0700);
1001         assert_se(subsubdir_fd >= 0);
1002         subsubdir_fd = safe_close(subsubdir_fd);
1003
1004         assert_se(open_mkdir_at(subdir_fd, "yyy", O_EXCL|O_CLOEXEC, 0) == -EEXIST);
1005
1006         assert_se(open_mkdir_at(fd, "xxx/yyy", O_EXCL|O_CLOEXEC, 0) == -EEXIST);
1007
1008         subsubdir_fd = open_mkdir_at(fd, "xxx/yyy", O_CLOEXEC, 0700);
1009         assert_se(subsubdir_fd >= 0);
1010 }
1011
1012 TEST(openat_report_new) {
1013         _cleanup_free_ char *j = NULL;
1014         _cleanup_(rm_rf_physical_and_freep) char *d = NULL;
1015         _cleanup_close_ int fd = -EBADF;
1016         bool b;
1017
1018         assert_se(mkdtemp_malloc(NULL, &d) >= 0);
1019
1020         j = path_join(d, "test");
1021         assert_se(j);
1022
1023         fd = openat_report_new(AT_FDCWD, j, O_RDWR|O_CREAT, 0666, &b);
1024         assert_se(fd >= 0);
1025         fd = safe_close(fd);
1026         assert_se(b);
1027
1028         fd = openat_report_new(AT_FDCWD, j, O_RDWR|O_CREAT, 0666, &b);
1029         assert_se(fd >= 0);
1030         fd = safe_close(fd);
1031         assert_se(!b);
1032
1033         fd = openat_report_new(AT_FDCWD, j, O_RDWR|O_CREAT, 0666, &b);
1034         assert_se(fd >= 0);
1035         fd = safe_close(fd);
1036         assert_se(!b);
1037
1038         assert_se(unlink(j) >= 0);
1039
1040         fd = openat_report_new(AT_FDCWD, j, O_RDWR|O_CREAT, 0666, &b);
1041         assert_se(fd >= 0);
1042         fd = safe_close(fd);
1043         assert_se(b);
1044
1045         fd = openat_report_new(AT_FDCWD, j, O_RDWR|O_CREAT, 0666, &b);
1046         assert_se(fd >= 0);
1047         fd = safe_close(fd);
1048         assert_se(!b);
1049
1050         assert_se(unlink(j) >= 0);
1051
1052         fd = openat_report_new(AT_FDCWD, j, O_RDWR|O_CREAT, 0666, NULL);
1053         assert_se(fd >= 0);
1054         fd = safe_close(fd);
1055
1056         fd = openat_report_new(AT_FDCWD, j, O_RDWR|O_CREAT, 0666, &b);
1057         assert_se(fd >= 0);
1058         fd = safe_close(fd);
1059         assert_se(!b);
1060
1061         fd = openat_report_new(AT_FDCWD, j, O_RDWR, 0666, &b);
1062         assert_se(fd >= 0);
1063         fd = safe_close(fd);
1064         assert_se(!b);
1065
1066         fd = openat_report_new(AT_FDCWD, j, O_RDWR|O_CREAT|O_EXCL, 0666, &b);
1067         assert_se(fd == -EEXIST);
1068
1069         assert_se(unlink(j) >= 0);
1070
1071         fd = openat_report_new(AT_FDCWD, j, O_RDWR, 0666, &b);
1072         assert_se(fd == -ENOENT);
1073
1074         fd = openat_report_new(AT_FDCWD, j, O_RDWR|O_CREAT|O_EXCL, 0666, &b);
1075         assert_se(fd >= 0);
1076         fd = safe_close(fd);
1077         assert_se(b);
1078 }
1079
1080 static int intro(void) {
1081         arg_test_dir = saved_argv[1];
1082         return EXIT_SUCCESS;
1083 }
1084
1085 DEFINE_TEST_MAIN_WITH_INTRO(LOG_INFO, intro);