src/test/test-fs-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <unistd.h>
   4
   5 #include "alloc-util.h"
   6 #include "fd-util.h"
   7 #include "fs-util.h"
   8 #include "id128-util.h"
   9 #include "macro.h"
  10 #include "mkdir.h"
  11 #include "path-util.h"
  12 #include "rm-rf.h"
  13 #include "stdio-util.h"
  14 #include "string-util.h"
  15 #include "strv.h"
  16 #include "tests.h"
  17 #include "tmpfile-util.h"
  18 #include "user-util.h"
  19 #include "util.h"
  20 #include "virt.h"
  21
  22 static const char *arg_test_dir = NULL;
  23
  24 static void test_chase_symlinks(void) {
  25         _cleanup_free_ char *result = NULL;
  26         char *temp;
  27         const char *top, *p, *pslash, *q, *qslash;
  28         struct stat st;
  29         int r, pfd;
  30
  31         log_info("/* %s */", __func__);
  32
  33         temp = strjoina(arg_test_dir ?: "/tmp", "/test-chase.XXXXXX");
  34         assert_se(mkdtemp(temp));
  35
  36         top = strjoina(temp, "/top");
  37         assert_se(mkdir(top, 0700) >= 0);
  38
  39         p = strjoina(top, "/dot");
  40         if (symlink(".", p) < 0) {
  41                 assert_se(IN_SET(errno, EINVAL, ENOSYS, ENOTTY, EPERM));
  42                 log_tests_skipped_errno(errno, "symlink() not possible");
  43                 goto cleanup;
  44         };
  45
  46         p = strjoina(top, "/dotdot");
  47         assert_se(symlink("..", p) >= 0);
  48
  49         p = strjoina(top, "/dotdota");
  50         assert_se(symlink("../a", p) >= 0);
  51
  52         p = strjoina(temp, "/a");
  53         assert_se(symlink("b", p) >= 0);
  54
  55         p = strjoina(temp, "/b");
  56         assert_se(symlink("/usr", p) >= 0);
  57
  58         p = strjoina(temp, "/start");
  59         assert_se(symlink("top/dot/dotdota", p) >= 0);
  60
  61         /* Paths that use symlinks underneath the "root" */
  62
  63         r = chase_symlinks(p, NULL, 0, &result);
  64         assert_se(r > 0);
  65         assert_se(path_equal(result, "/usr"));
  66         result = mfree(result);
  67
  68         pslash = strjoina(p, "/");
  69         r = chase_symlinks(pslash, NULL, 0, &result);
  70         assert_se(r > 0);
  71         assert_se(path_equal(result, "/usr/"));
  72         result = mfree(result);
  73
  74         r = chase_symlinks(p, temp, 0, &result);
  75         assert_se(r == -ENOENT);
  76
  77         r = chase_symlinks(pslash, temp, 0, &result);
  78         assert_se(r == -ENOENT);
  79
  80         q = strjoina(temp, "/usr");
  81
  82         r = chase_symlinks(p, temp, CHASE_NONEXISTENT, &result);
  83         assert_se(r == 0);
  84         assert_se(path_equal(result, q));
  85         result = mfree(result);
  86
  87         qslash = strjoina(q, "/");
  88
  89         r = chase_symlinks(pslash, temp, CHASE_NONEXISTENT, &result);
  90         assert_se(r == 0);
  91         assert_se(path_equal(result, qslash));
  92         result = mfree(result);
  93
  94         assert_se(mkdir(q, 0700) >= 0);
  95
  96         r = chase_symlinks(p, temp, 0, &result);
  97         assert_se(r > 0);
  98         assert_se(path_equal(result, q));
  99         result = mfree(result);
 100
 101         r = chase_symlinks(pslash, temp, 0, &result);
 102         assert_se(r > 0);
 103         assert_se(path_equal(result, qslash));
 104         result = mfree(result);
 105
 106         p = strjoina(temp, "/slash");
 107         assert_se(symlink("/", p) >= 0);
 108
 109         r = chase_symlinks(p, NULL, 0, &result);
 110         assert_se(r > 0);
 111         assert_se(path_equal(result, "/"));
 112         result = mfree(result);
 113
 114         r = chase_symlinks(p, temp, 0, &result);
 115         assert_se(r > 0);
 116         assert_se(path_equal(result, temp));
 117         result = mfree(result);
 118
 119         /* Paths that would "escape" outside of the "root" */
 120
 121         p = strjoina(temp, "/6dots");
 122         assert_se(symlink("../../..", p) >= 0);
 123
 124         r = chase_symlinks(p, temp, 0, &result);
 125         assert_se(r > 0 && path_equal(result, temp));
 126         result = mfree(result);
 127
 128         p = strjoina(temp, "/6dotsusr");
 129         assert_se(symlink("../../../usr", p) >= 0);
 130
 131         r = chase_symlinks(p, temp, 0, &result);
 132         assert_se(r > 0 && path_equal(result, q));
 133         result = mfree(result);
 134
 135         p = strjoina(temp, "/top/8dotsusr");
 136         assert_se(symlink("../../../../usr", p) >= 0);
 137
 138         r = chase_symlinks(p, temp, 0, &result);
 139         assert_se(r > 0 && path_equal(result, q));
 140         result = mfree(result);
 141
 142         /* Paths that contain repeated slashes */
 143
 144         p = strjoina(temp, "/slashslash");
 145         assert_se(symlink("///usr///", p) >= 0);
 146
 147         r = chase_symlinks(p, NULL, 0, &result);
 148         assert_se(r > 0);
 149         assert_se(path_equal(result, "/usr"));
 150         result = mfree(result);
 151
 152         r = chase_symlinks(p, temp, 0, &result);
 153         assert_se(r > 0);
 154         assert_se(path_equal(result, q));
 155         result = mfree(result);
 156
 157         /* Paths underneath the "root" with different UIDs while using CHASE_SAFE */
 158
 159         if (geteuid() == 0) {
 160                 p = strjoina(temp, "/user");
 161                 assert_se(mkdir(p, 0755) >= 0);
 162                 assert_se(chown(p, UID_NOBODY, GID_NOBODY) >= 0);
 163
 164                 q = strjoina(temp, "/user/root");
 165                 assert_se(mkdir(q, 0755) >= 0);
 166
 167                 p = strjoina(q, "/link");
 168                 assert_se(symlink("/", p) >= 0);
 169
 170                 /* Fail when user-owned directories contain root-owned subdirectories. */
 171                 r = chase_symlinks(p, temp, CHASE_SAFE, &result);
 172                 assert_se(r == -ENOLINK);
 173                 result = mfree(result);
 174
 175                 /* Allow this when the user-owned directories are all in the "root". */
 176                 r = chase_symlinks(p, q, CHASE_SAFE, &result);
 177                 assert_se(r > 0);
 178                 result = mfree(result);
 179         }
 180
 181         /* Paths using . */
 182
 183         r = chase_symlinks("/etc/./.././", NULL, 0, &result);
 184         assert_se(r > 0);
 185         assert_se(path_equal(result, "/"));
 186         result = mfree(result);
 187
 188         r = chase_symlinks("/etc/./.././", "/etc", 0, &result);
 189         assert_se(r > 0 && path_equal(result, "/etc"));
 190         result = mfree(result);
 191
 192         r = chase_symlinks("/../.././//../../etc", NULL, 0, &result);
 193         assert_se(r > 0);
 194         assert_se(streq(result, "/etc"));
 195         result = mfree(result);
 196
 197         r = chase_symlinks("/../.././//../../test-chase.fsldajfl", NULL, CHASE_NONEXISTENT, &result);
 198         assert_se(r == 0);
 199         assert_se(streq(result, "/test-chase.fsldajfl"));
 200         result = mfree(result);
 201
 202         r = chase_symlinks("/../.././//../../etc", "/", CHASE_PREFIX_ROOT, &result);
 203         assert_se(r > 0);
 204         assert_se(streq(result, "/etc"));
 205         result = mfree(result);
 206
 207         r = chase_symlinks("/../.././//../../test-chase.fsldajfl", "/", CHASE_PREFIX_ROOT|CHASE_NONEXISTENT, &result);
 208         assert_se(r == 0);
 209         assert_se(streq(result, "/test-chase.fsldajfl"));
 210         result = mfree(result);
 211
 212         r = chase_symlinks("/etc/machine-id/foo", NULL, 0, &result);
 213         assert_se(r == -ENOTDIR);
 214         result = mfree(result);
 215
 216         /* Path that loops back to self */
 217
 218         p = strjoina(temp, "/recursive-symlink");
 219         assert_se(symlink("recursive-symlink", p) >= 0);
 220         r = chase_symlinks(p, NULL, 0, &result);
 221         assert_se(r == -ELOOP);
 222
 223         /* Path which doesn't exist */
 224
 225         p = strjoina(temp, "/idontexist");
 226         r = chase_symlinks(p, NULL, 0, &result);
 227         assert_se(r == -ENOENT);
 228
 229         r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result);
 230         assert_se(r == 0);
 231         assert_se(path_equal(result, p));
 232         result = mfree(result);
 233
 234         p = strjoina(temp, "/idontexist/meneither");
 235         r = chase_symlinks(p, NULL, 0, &result);
 236         assert_se(r == -ENOENT);
 237
 238         r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result);
 239         assert_se(r == 0);
 240         assert_se(path_equal(result, p));
 241         result = mfree(result);
 242
 243         /* Path which doesn't exist, but contains weird stuff */
 244
 245         p = strjoina(temp, "/idontexist/..");
 246         r = chase_symlinks(p, NULL, 0, &result);
 247         assert_se(r == -ENOENT);
 248
 249         r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result);
 250         assert_se(r == -ENOENT);
 251
 252         p = strjoina(temp, "/target");
 253         q = strjoina(temp, "/top");
 254         assert_se(symlink(q, p) >= 0);
 255         p = strjoina(temp, "/target/idontexist");
 256         r = chase_symlinks(p, NULL, 0, &result);
 257         assert_se(r == -ENOENT);
 258
 259         if (geteuid() == 0) {
 260                 p = strjoina(temp, "/priv1");
 261                 assert_se(mkdir(p, 0755) >= 0);
 262
 263                 q = strjoina(p, "/priv2");
 264                 assert_se(mkdir(q, 0755) >= 0);
 265
 266                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) >= 0);
 267
 268                 assert_se(chown(q, UID_NOBODY, GID_NOBODY) >= 0);
 269                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) >= 0);
 270
 271                 assert_se(chown(p, UID_NOBODY, GID_NOBODY) >= 0);
 272                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) >= 0);
 273
 274                 assert_se(chown(q, 0, 0) >= 0);
 275                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) == -ENOLINK);
 276
 277                 assert_se(rmdir(q) >= 0);
 278                 assert_se(symlink("/etc/passwd", q) >= 0);
 279                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) == -ENOLINK);
 280
 281                 assert_se(chown(p, 0, 0) >= 0);
 282                 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) >= 0);
 283         }
 284
 285         p = strjoina(temp, "/machine-id-test");
 286         assert_se(symlink("/usr/../etc/./machine-id", p) >= 0);
 287
 288         pfd = chase_symlinks(p, NULL, CHASE_OPEN, NULL);
 289         if (pfd != -ENOENT) {
 290                 _cleanup_close_ int fd = -1;
 291                 sd_id128_t a, b;
 292
 293                 assert_se(pfd >= 0);
 294
 295                 fd = fd_reopen(pfd, O_RDONLY|O_CLOEXEC);
 296                 assert_se(fd >= 0);
 297                 safe_close(pfd);
 298
 299                 assert_se(id128_read_fd(fd, ID128_PLAIN, &a) >= 0);
 300                 assert_se(sd_id128_get_machine(&b) >= 0);
 301                 assert_se(sd_id128_equal(a, b));
 302         }
 303
 304         /* Test CHASE_NOFOLLOW */
 305
 306         p = strjoina(temp, "/target");
 307         q = strjoina(temp, "/symlink");
 308         assert_se(symlink(p, q) >= 0);
 309         pfd = chase_symlinks(q, NULL, CHASE_OPEN|CHASE_NOFOLLOW, &result);
 310         assert_se(pfd > 0);
 311         assert_se(path_equal(result, q));
 312         assert_se(fstat(pfd, &st) >= 0);
 313         assert_se(S_ISLNK(st.st_mode));
 314         result = mfree(result);
 315
 316         /* s1 -> s2 -> nonexistent */
 317         q = strjoina(temp, "/s1");
 318         assert_se(symlink("s2", q) >= 0);
 319         p = strjoina(temp, "/s2");
 320         assert_se(symlink("nonexistent", p) >= 0);
 321         pfd = chase_symlinks(q, NULL, CHASE_OPEN|CHASE_NOFOLLOW, &result);
 322         assert_se(pfd > 0);
 323         assert_se(path_equal(result, q));
 324         assert_se(fstat(pfd, &st) >= 0);
 325         assert_se(S_ISLNK(st.st_mode));
 326         result = mfree(result);
 327
 328         /* Test CHASE_ONE */
 329
 330         p = strjoina(temp, "/start");
 331         r = chase_symlinks(p, NULL, CHASE_STEP, &result);
 332         assert_se(r == 0);
 333         p = strjoina(temp, "/top/dot/dotdota");
 334         assert_se(streq(p, result));
 335         result = mfree(result);
 336
 337         r = chase_symlinks(p, NULL, CHASE_STEP, &result);
 338         assert_se(r == 0);
 339         p = strjoina(temp, "/top/./dotdota");
 340         assert_se(streq(p, result));
 341         result = mfree(result);
 342
 343         r = chase_symlinks(p, NULL, CHASE_STEP, &result);
 344         assert_se(r == 0);
 345         p = strjoina(temp, "/top/../a");
 346         assert_se(streq(p, result));
 347         result = mfree(result);
 348
 349         r = chase_symlinks(p, NULL, CHASE_STEP, &result);
 350         assert_se(r == 0);
 351         p = strjoina(temp, "/a");
 352         assert_se(streq(p, result));
 353         result = mfree(result);
 354
 355         r = chase_symlinks(p, NULL, CHASE_STEP, &result);
 356         assert_se(r == 0);
 357         p = strjoina(temp, "/b");
 358         assert_se(streq(p, result));
 359         result = mfree(result);
 360
 361         r = chase_symlinks(p, NULL, CHASE_STEP, &result);
 362         assert_se(r == 0);
 363         assert_se(streq("/usr", result));
 364         result = mfree(result);
 365
 366         r = chase_symlinks("/usr", NULL, CHASE_STEP, &result);
 367         assert_se(r > 0);
 368         assert_se(streq("/usr", result));
 369         result = mfree(result);
 370
 371  cleanup:
 372         assert_se(rm_rf(temp, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
 373 }
 374
 375 static void test_unlink_noerrno(void) {
 376         char *name;
 377         int fd;
 378
 379         log_info("/* %s */", __func__);
 380
 381         name = strjoina(arg_test_dir ?: "/tmp", "/test-close_nointr.XXXXXX");
 382         fd = mkostemp_safe(name);
 383         assert_se(fd >= 0);
 384         assert_se(close_nointr(fd) >= 0);
 385
 386         {
 387                 PROTECT_ERRNO;
 388                 errno = 42;
 389                 assert_se(unlink_noerrno(name) >= 0);
 390                 assert_se(errno == 42);
 391                 assert_se(unlink_noerrno(name) < 0);
 392                 assert_se(errno == 42);
 393         }
 394 }
 395
 396 static void test_readlink_and_make_absolute(void) {
 397         const char *tempdir, *name, *name2, *name_alias;
 398         _cleanup_free_ char *r1 = NULL, *r2 = NULL, *pwd = NULL;
 399
 400         log_info("/* %s */", __func__);
 401
 402         tempdir = strjoina(arg_test_dir ?: "/tmp", "/test-readlink_and_make_absolute");
 403         name = strjoina(tempdir, "/original");
 404         name2 = "test-readlink_and_make_absolute/original";
 405         name_alias = strjoina(arg_test_dir ?: "/tmp", "/test-readlink_and_make_absolute-alias");
 406
 407         assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid(), MKDIR_WARN_MODE) >= 0);
 408         assert_se(touch(name) >= 0);
 409
 410         if (symlink(name, name_alias) < 0) {
 411                 assert_se(IN_SET(errno, EINVAL, ENOSYS, ENOTTY, EPERM));
 412                 log_tests_skipped_errno(errno, "symlink() not possible");
 413         } else {
 414                 assert_se(readlink_and_make_absolute(name_alias, &r1) >= 0);
 415                 assert_se(streq(r1, name));
 416                 assert_se(unlink(name_alias) >= 0);
 417
 418                 assert_se(safe_getcwd(&pwd) >= 0);
 419
 420                 assert_se(chdir(tempdir) >= 0);
 421                 assert_se(symlink(name2, name_alias) >= 0);
 422                 assert_se(readlink_and_make_absolute(name_alias, &r2) >= 0);
 423                 assert_se(streq(r2, name));
 424                 assert_se(unlink(name_alias) >= 0);
 425
 426                 assert_se(chdir(pwd) >= 0);
 427         }
 428
 429         assert_se(rm_rf(tempdir, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
 430 }
 431
 432 static void test_get_files_in_directory(void) {
 433         _cleanup_strv_free_ char **l = NULL, **t = NULL;
 434
 435         assert_se(get_files_in_directory(arg_test_dir ?: "/tmp", &l) >= 0);
 436         assert_se(get_files_in_directory(".", &t) >= 0);
 437         assert_se(get_files_in_directory(".", NULL) >= 0);
 438 }
 439
 440 static void test_var_tmp(void) {
 441         _cleanup_free_ char *tmpdir_backup = NULL, *temp_backup = NULL, *tmp_backup = NULL;
 442         const char *tmp_dir = NULL, *t;
 443
 444         log_info("/* %s */", __func__);
 445
 446         t = getenv("TMPDIR");
 447         if (t) {
 448                 tmpdir_backup = strdup(t);
 449                 assert_se(tmpdir_backup);
 450         }
 451
 452         t = getenv("TEMP");
 453         if (t) {
 454                 temp_backup = strdup(t);
 455                 assert_se(temp_backup);
 456         }
 457
 458         t = getenv("TMP");
 459         if (t) {
 460                 tmp_backup = strdup(t);
 461                 assert_se(tmp_backup);
 462         }
 463
 464         assert_se(unsetenv("TMPDIR") >= 0);
 465         assert_se(unsetenv("TEMP") >= 0);
 466         assert_se(unsetenv("TMP") >= 0);
 467
 468         assert_se(var_tmp_dir(&tmp_dir) >= 0);
 469         assert_se(streq(tmp_dir, "/var/tmp"));
 470
 471         assert_se(setenv("TMPDIR", "/tmp", true) >= 0);
 472         assert_se(streq(getenv("TMPDIR"), "/tmp"));
 473
 474         assert_se(var_tmp_dir(&tmp_dir) >= 0);
 475         assert_se(streq(tmp_dir, "/tmp"));
 476
 477         assert_se(setenv("TMPDIR", "/88_does_not_exist_88", true) >= 0);
 478         assert_se(streq(getenv("TMPDIR"), "/88_does_not_exist_88"));
 479
 480         assert_se(var_tmp_dir(&tmp_dir) >= 0);
 481         assert_se(streq(tmp_dir, "/var/tmp"));
 482
 483         if (tmpdir_backup)  {
 484                 assert_se(setenv("TMPDIR", tmpdir_backup, true) >= 0);
 485                 assert_se(streq(getenv("TMPDIR"), tmpdir_backup));
 486         }
 487
 488         if (temp_backup)  {
 489                 assert_se(setenv("TEMP", temp_backup, true) >= 0);
 490                 assert_se(streq(getenv("TEMP"), temp_backup));
 491         }
 492
 493         if (tmp_backup)  {
 494                 assert_se(setenv("TMP", tmp_backup, true) >= 0);
 495                 assert_se(streq(getenv("TMP"), tmp_backup));
 496         }
 497 }
 498
 499 static void test_dot_or_dot_dot(void) {
 500         log_info("/* %s */", __func__);
 501
 502         assert_se(!dot_or_dot_dot(NULL));
 503         assert_se(!dot_or_dot_dot(""));
 504         assert_se(!dot_or_dot_dot("xxx"));
 505         assert_se(dot_or_dot_dot("."));
 506         assert_se(dot_or_dot_dot(".."));
 507         assert_se(!dot_or_dot_dot(".foo"));
 508         assert_se(!dot_or_dot_dot("..foo"));
 509 }
 510
 511 static void test_access_fd(void) {
 512         _cleanup_(rmdir_and_freep) char *p = NULL;
 513         _cleanup_close_ int fd = -1;
 514         const char *a;
 515
 516         log_info("/* %s */", __func__);
 517
 518         a = strjoina(arg_test_dir ?: "/tmp", "/access-fd.XXXXXX");
 519         assert_se(mkdtemp_malloc(a, &p) >= 0);
 520
 521         fd = open(p, O_RDONLY|O_DIRECTORY|O_CLOEXEC);
 522         assert_se(fd >= 0);
 523
 524         assert_se(access_fd(fd, R_OK) >= 0);
 525         assert_se(access_fd(fd, F_OK) >= 0);
 526         assert_se(access_fd(fd, W_OK) >= 0);
 527
 528         assert_se(fchmod(fd, 0000) >= 0);
 529
 530         assert_se(access_fd(fd, F_OK) >= 0);
 531
 532         if (geteuid() == 0) {
 533                 assert_se(access_fd(fd, R_OK) >= 0);
 534                 assert_se(access_fd(fd, W_OK) >= 0);
 535         } else {
 536                 assert_se(access_fd(fd, R_OK) == -EACCES);
 537                 assert_se(access_fd(fd, W_OK) == -EACCES);
 538         }
 539 }
 540
 541 static void test_touch_file(void) {
 542         uid_t test_uid, test_gid;
 543         _cleanup_(rm_rf_physical_and_freep) char *p = NULL;
 544         struct stat st;
 545         const char *a;
 546         usec_t test_mtime;
 547         int r;
 548
 549         log_info("/* %s */", __func__);
 550
 551         test_uid = geteuid() == 0 ? 65534 : getuid();
 552         test_gid = geteuid() == 0 ? 65534 : getgid();
 553
 554         test_mtime = usec_sub_unsigned(now(CLOCK_REALTIME), USEC_PER_WEEK);
 555
 556         a = strjoina(arg_test_dir ?: "/dev/shm", "/touch-file-XXXXXX");
 557         assert_se(mkdtemp_malloc(a, &p) >= 0);
 558
 559         a = strjoina(p, "/regular");
 560         r = touch_file(a, false, test_mtime, test_uid, test_gid, 0640);
 561         if (r < 0) {
 562                 assert_se(IN_SET(r, -EINVAL, -ENOSYS, -ENOTTY, -EPERM));
 563                 log_tests_skipped_errno(errno, "touch_file() not possible");
 564                 return;
 565         }
 566
 567         assert_se(lstat(a, &st) >= 0);
 568         assert_se(st.st_uid == test_uid);
 569         assert_se(st.st_gid == test_gid);
 570         assert_se(S_ISREG(st.st_mode));
 571         assert_se((st.st_mode & 0777) == 0640);
 572         assert_se(timespec_load(&st.st_mtim) == test_mtime);
 573
 574         a = strjoina(p, "/dir");
 575         assert_se(mkdir(a, 0775) >= 0);
 576         assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 577         assert_se(lstat(a, &st) >= 0);
 578         assert_se(st.st_uid == test_uid);
 579         assert_se(st.st_gid == test_gid);
 580         assert_se(S_ISDIR(st.st_mode));
 581         assert_se((st.st_mode & 0777) == 0640);
 582         assert_se(timespec_load(&st.st_mtim) == test_mtime);
 583
 584         a = strjoina(p, "/fifo");
 585         assert_se(mkfifo(a, 0775) >= 0);
 586         assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 587         assert_se(lstat(a, &st) >= 0);
 588         assert_se(st.st_uid == test_uid);
 589         assert_se(st.st_gid == test_gid);
 590         assert_se(S_ISFIFO(st.st_mode));
 591         assert_se((st.st_mode & 0777) == 0640);
 592         assert_se(timespec_load(&st.st_mtim) == test_mtime);
 593
 594         a = strjoina(p, "/sock");
 595         assert_se(mknod(a, 0775 | S_IFSOCK, 0) >= 0);
 596         assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 597         assert_se(lstat(a, &st) >= 0);
 598         assert_se(st.st_uid == test_uid);
 599         assert_se(st.st_gid == test_gid);
 600         assert_se(S_ISSOCK(st.st_mode));
 601         assert_se((st.st_mode & 0777) == 0640);
 602         assert_se(timespec_load(&st.st_mtim) == test_mtime);
 603
 604         if (geteuid() == 0) {
 605                 a = strjoina(p, "/cdev");
 606                 r = mknod(a, 0775 | S_IFCHR, makedev(0, 0));
 607                 if (r < 0 && errno == EPERM && detect_container() > 0) {
 608                         log_notice("Running in unprivileged container? Skipping remaining tests in %s", __func__);
 609                         return;
 610                 }
 611                 assert_se(r >= 0);
 612                 assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 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_ISCHR(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, "/bdev");
 621                 assert_se(mknod(a, 0775 | S_IFBLK, makedev(0, 0)) >= 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_ISBLK(st.st_mode));
 627                 assert_se((st.st_mode & 0777) == 0640);
 628                 assert_se(timespec_load(&st.st_mtim) == test_mtime);
 629         }
 630
 631         a = strjoina(p, "/lnk");
 632         assert_se(symlink("target", a) >= 0);
 633         assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
 634         assert_se(lstat(a, &st) >= 0);
 635         assert_se(st.st_uid == test_uid);
 636         assert_se(st.st_gid == test_gid);
 637         assert_se(S_ISLNK(st.st_mode));
 638         assert_se((st.st_mode & 0777) == 0640);
 639         assert_se(timespec_load(&st.st_mtim) == test_mtime);
 640 }
 641
 642 static void test_unlinkat_deallocate(void) {
 643         _cleanup_free_ char *p = NULL;
 644         _cleanup_close_ int fd = -1;
 645         struct stat st;
 646
 647         log_info("/* %s */", __func__);
 648
 649         assert_se(tempfn_random_child(arg_test_dir, "unlink-deallocation", &p) >= 0);
 650
 651         fd = open(p, O_WRONLY|O_CLOEXEC|O_CREAT|O_EXCL, 0600);
 652         assert_se(fd >= 0);
 653
 654         assert_se(write(fd, "hallo\n", 6) == 6);
 655
 656         assert_se(fstat(fd, &st) >= 0);
 657         assert_se(st.st_size == 6);
 658         assert_se(st.st_blocks > 0);
 659         assert_se(st.st_nlink == 1);
 660
 661         assert_se(unlinkat_deallocate(AT_FDCWD, p, 0) >= 0);
 662
 663         assert_se(fstat(fd, &st) >= 0);
 664         assert_se(IN_SET(st.st_size, 0, 6)); /* depending on whether hole punching worked the size will be 6
 665                                                 (it worked) or 0 (we had to resort to truncation) */
 666         assert_se(st.st_blocks == 0);
 667         assert_se(st.st_nlink == 0);
 668 }
 669
 670 static void test_fsync_directory_of_file(void) {
 671         _cleanup_close_ int fd = -1;
 672
 673         log_info("/* %s */", __func__);
 674
 675         fd = open_tmpfile_unlinkable(arg_test_dir, O_RDWR);
 676         assert_se(fd >= 0);
 677
 678         assert_se(fsync_directory_of_file(fd) >= 0);
 679 }
 680
 681 static void test_rename_noreplace(void) {
 682         static const char* const table[] = {
 683                 "/reg",
 684                 "/dir",
 685                 "/fifo",
 686                 "/socket",
 687                 "/symlink",
 688                 NULL
 689         };
 690
 691         _cleanup_(rm_rf_physical_and_freep) char *z = NULL;
 692         const char *j = NULL;
 693         char **a, **b;
 694
 695         log_info("/* %s */", __func__);
 696
 697         if (arg_test_dir)
 698                 j = strjoina(arg_test_dir, "/testXXXXXX");
 699         assert_se(mkdtemp_malloc(j, &z) >= 0);
 700
 701         j = strjoina(z, table[0]);
 702         assert_se(touch(j) >= 0);
 703
 704         j = strjoina(z, table[1]);
 705         assert_se(mkdir(j, 0777) >= 0);
 706
 707         j = strjoina(z, table[2]);
 708         (void) mkfifo(j, 0777);
 709
 710         j = strjoina(z, table[3]);
 711         (void) mknod(j, S_IFSOCK | 0777, 0);
 712
 713         j = strjoina(z, table[4]);
 714         (void) symlink("foobar", j);
 715
 716         STRV_FOREACH(a, (char**) table) {
 717                 _cleanup_free_ char *x = NULL, *y = NULL;
 718
 719                 x = strjoin(z, *a);
 720                 assert_se(x);
 721
 722                 if (access(x, F_OK) < 0) {
 723                         assert_se(errno == ENOENT);
 724                         continue;
 725                 }
 726
 727                 STRV_FOREACH(b, (char**) table) {
 728                         _cleanup_free_ char *w = NULL;
 729
 730                         w = strjoin(w, *b);
 731                         assert_se(w);
 732
 733                         if (access(w, F_OK) < 0) {
 734                                 assert_se(errno == ENOENT);
 735                                 continue;
 736                         }
 737
 738                         assert_se(rename_noreplace(AT_FDCWD, w, AT_FDCWD, y) == -EEXIST);
 739                 }
 740
 741                 y = strjoin(z, "/somethingelse");
 742                 assert_se(y);
 743
 744                 assert_se(rename_noreplace(AT_FDCWD, x, AT_FDCWD, y) >= 0);
 745                 assert_se(rename_noreplace(AT_FDCWD, y, AT_FDCWD, x) >= 0);
 746         }
 747 }
 748
 749 int main(int argc, char *argv[]) {
 750         test_setup_logging(LOG_INFO);
 751
 752         arg_test_dir = argv[1];
 753
 754         test_unlink_noerrno();
 755         test_get_files_in_directory();
 756         test_readlink_and_make_absolute();
 757         test_var_tmp();
 758         test_chase_symlinks();
 759         test_dot_or_dot_dot();
 760         test_access_fd();
 761         test_touch_file();
 762         test_unlinkat_deallocate();
 763         test_fsync_directory_of_file();
 764         test_rename_noreplace();
 765
 766         return 0;
 767 }