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