src/basic/fs-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <errno.h>
  22 #include <stddef.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sys/stat.h>
  27 #include <linux/magic.h>
  28 #include <time.h>
  29 #include <unistd.h>
  30
  31 #include "alloc-util.h"
  32 #include "dirent-util.h"
  33 #include "fd-util.h"
  34 #include "fileio.h"
  35 #include "fs-util.h"
  36 //#include "log.h"
  37 //#include "macro.h"
  38 //#include "missing.h"
  39 #include "mkdir.h"
  40 #include "parse-util.h"
  41 #include "path-util.h"
  42 //#include "process-util.h"
  43 #include "stat-util.h"
  44 #include "stdio-util.h"
  45 #include "string-util.h"
  46 #include "strv.h"
  47 //#include "time-util.h"
  48 #include "user-util.h"
  49 #include "util.h"
  50
  51 /// Additional includes needed by elogind
  52 #include "process-util.h"
  53
  54 int unlink_noerrno(const char *path) {
  55         PROTECT_ERRNO;
  56         int r;
  57
  58         r = unlink(path);
  59         if (r < 0)
  60                 return -errno;
  61
  62         return 0;
  63 }
  64
  65 #if 0 /// UNNEEDED by elogind
  66 int rmdir_parents(const char *path, const char *stop) {
  67         size_t l;
  68         int r = 0;
  69
  70         assert(path);
  71         assert(stop);
  72
  73         l = strlen(path);
  74
  75         /* Skip trailing slashes */
  76         while (l > 0 && path[l-1] == '/')
  77                 l--;
  78
  79         while (l > 0) {
  80                 char *t;
  81
  82                 /* Skip last component */
  83                 while (l > 0 && path[l-1] != '/')
  84                         l--;
  85
  86                 /* Skip trailing slashes */
  87                 while (l > 0 && path[l-1] == '/')
  88                         l--;
  89
  90                 if (l <= 0)
  91                         break;
  92
  93                 t = strndup(path, l);
  94                 if (!t)
  95                         return -ENOMEM;
  96
  97                 if (path_startswith(stop, t)) {
  98                         free(t);
  99                         return 0;
 100                 }
 101
 102                 r = rmdir(t);
 103                 free(t);
 104
 105                 if (r < 0)
 106                         if (errno != ENOENT)
 107                                 return -errno;
 108         }
 109
 110         return 0;
 111 }
 112
 113 int rename_noreplace(int olddirfd, const char *oldpath, int newdirfd, const char *newpath) {
 114         struct stat buf;
 115         int ret;
 116
 117         ret = renameat2(olddirfd, oldpath, newdirfd, newpath, RENAME_NOREPLACE);
 118         if (ret >= 0)
 119                 return 0;
 120
 121         /* renameat2() exists since Linux 3.15, btrfs added support for it later.
 122          * If it is not implemented, fallback to another method. */
 123         if (!IN_SET(errno, EINVAL, ENOSYS))
 124                 return -errno;
 125
 126         /* The link()/unlink() fallback does not work on directories. But
 127          * renameat() without RENAME_NOREPLACE gives the same semantics on
 128          * directories, except when newpath is an *empty* directory. This is
 129          * good enough. */
 130         ret = fstatat(olddirfd, oldpath, &buf, AT_SYMLINK_NOFOLLOW);
 131         if (ret >= 0 && S_ISDIR(buf.st_mode)) {
 132                 ret = renameat(olddirfd, oldpath, newdirfd, newpath);
 133                 return ret >= 0 ? 0 : -errno;
 134         }
 135
 136         /* If it is not a directory, use the link()/unlink() fallback. */
 137         ret = linkat(olddirfd, oldpath, newdirfd, newpath, 0);
 138         if (ret < 0)
 139                 return -errno;
 140
 141         ret = unlinkat(olddirfd, oldpath, 0);
 142         if (ret < 0) {
 143                 /* backup errno before the following unlinkat() alters it */
 144                 ret = errno;
 145                 (void) unlinkat(newdirfd, newpath, 0);
 146                 errno = ret;
 147                 return -errno;
 148         }
 149
 150         return 0;
 151 }
 152 #endif // 0
 153
 154 int readlinkat_malloc(int fd, const char *p, char **ret) {
 155         size_t l = 100;
 156         int r;
 157
 158         assert(p);
 159         assert(ret);
 160
 161         for (;;) {
 162                 char *c;
 163                 ssize_t n;
 164
 165                 c = new(char, l);
 166                 if (!c)
 167                         return -ENOMEM;
 168
 169                 n = readlinkat(fd, p, c, l-1);
 170                 if (n < 0) {
 171                         r = -errno;
 172                         free(c);
 173                         return r;
 174                 }
 175
 176                 if ((size_t) n < l-1) {
 177                         c[n] = 0;
 178                         *ret = c;
 179                         return 0;
 180                 }
 181
 182                 free(c);
 183                 l *= 2;
 184         }
 185 }
 186
 187 int readlink_malloc(const char *p, char **ret) {
 188         return readlinkat_malloc(AT_FDCWD, p, ret);
 189 }
 190
 191 #if 0 /// UNNEEDED by elogind
 192 int readlink_value(const char *p, char **ret) {
 193         _cleanup_free_ char *link = NULL;
 194         char *value;
 195         int r;
 196
 197         r = readlink_malloc(p, &link);
 198         if (r < 0)
 199                 return r;
 200
 201         value = basename(link);
 202         if (!value)
 203                 return -ENOENT;
 204
 205         value = strdup(value);
 206         if (!value)
 207                 return -ENOMEM;
 208
 209         *ret = value;
 210
 211         return 0;
 212 }
 213 #endif // 0
 214
 215 int readlink_and_make_absolute(const char *p, char **r) {
 216         _cleanup_free_ char *target = NULL;
 217         char *k;
 218         int j;
 219
 220         assert(p);
 221         assert(r);
 222
 223         j = readlink_malloc(p, &target);
 224         if (j < 0)
 225                 return j;
 226
 227         k = file_in_same_dir(p, target);
 228         if (!k)
 229                 return -ENOMEM;
 230
 231         *r = k;
 232         return 0;
 233 }
 234
 235 #if 0 /// UNNEEDED by elogind
 236 #endif // 0
 237 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
 238         assert(path);
 239
 240         /* Under the assumption that we are running privileged we
 241          * first change the access mode and only then hand out
 242          * ownership to avoid a window where access is too open. */
 243
 244         if (mode != MODE_INVALID)
 245                 if (chmod(path, mode) < 0)
 246                         return -errno;
 247
 248         if (uid != UID_INVALID || gid != GID_INVALID)
 249                 if (chown(path, uid, gid) < 0)
 250                         return -errno;
 251
 252         return 0;
 253 }
 254
 255 int fchmod_umask(int fd, mode_t m) {
 256         mode_t u;
 257         int r;
 258
 259         u = umask(0777);
 260         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 261         umask(u);
 262
 263         return r;
 264 }
 265
 266 int fd_warn_permissions(const char *path, int fd) {
 267         struct stat st;
 268
 269         if (fstat(fd, &st) < 0)
 270                 return -errno;
 271
 272         if (st.st_mode & 0111)
 273                 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
 274
 275         if (st.st_mode & 0002)
 276                 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
 277
 278         if (getpid_cached() == 1 && (st.st_mode & 0044) != 0044)
 279                 log_warning("Configuration file %s is marked world-inaccessible. This has no effect as configuration data is accessible via APIs without restrictions. Proceeding anyway.", path);
 280
 281         return 0;
 282 }
 283
 284 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
 285         char fdpath[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
 286         _cleanup_close_ int fd = -1;
 287         int r, ret = 0;
 288
 289         assert(path);
 290
 291         /* Note that touch_file() does not follow symlinks: if invoked on an existing symlink, then it is the symlink
 292          * itself which is updated, not its target
 293          *
 294          * Returns the first error we encounter, but tries to apply as much as possible. */
 295
 296         if (parents)
 297                 (void) mkdir_parents(path, 0755);
 298
 299         /* Initially, we try to open the node with O_PATH, so that we get a reference to the node. This is useful in
 300          * case the path refers to an existing device or socket node, as we can open it successfully in all cases, and
 301          * won't trigger any driver magic or so. */
 302         fd = open(path, O_PATH|O_CLOEXEC|O_NOFOLLOW);
 303         if (fd < 0) {
 304                 if (errno != ENOENT)
 305                         return -errno;
 306
 307                 /* if the node doesn't exist yet, we create it, but with O_EXCL, so that we only create a regular file
 308                  * here, and nothing else */
 309                 fd = open(path, O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC, IN_SET(mode, 0, MODE_INVALID) ? 0644 : mode);
 310                 if (fd < 0)
 311                         return -errno;
 312         }
 313
 314         /* Let's make a path from the fd, and operate on that. With this logic, we can adjust the access mode,
 315          * ownership and time of the file node in all cases, even if the fd refers to an O_PATH object — which is
 316          * something fchown(), fchmod(), futimensat() don't allow. */
 317         xsprintf(fdpath, "/proc/self/fd/%i", fd);
 318
 319         if (mode != MODE_INVALID)
 320                 if (chmod(fdpath, mode) < 0)
 321                         ret = -errno;
 322
 323         if (uid_is_valid(uid) || gid_is_valid(gid))
 324                 if (chown(fdpath, uid, gid) < 0 && ret >= 0)
 325                         ret = -errno;
 326
 327         if (stamp != USEC_INFINITY) {
 328                 struct timespec ts[2];
 329
 330                 timespec_store(&ts[0], stamp);
 331                 ts[1] = ts[0];
 332                 r = utimensat(AT_FDCWD, fdpath, ts, 0);
 333         } else
 334                 r = utimensat(AT_FDCWD, fdpath, NULL, 0);
 335         if (r < 0 && ret >= 0)
 336                 return -errno;
 337
 338         return ret;
 339 }
 340
 341 int touch(const char *path) {
 342         return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, MODE_INVALID);
 343 }
 344
 345 #if 0 /// UNNEEDED by elogind
 346 int symlink_idempotent(const char *from, const char *to) {
 347         int r;
 348
 349         assert(from);
 350         assert(to);
 351
 352         if (symlink(from, to) < 0) {
 353                 _cleanup_free_ char *p = NULL;
 354
 355                 if (errno != EEXIST)
 356                         return -errno;
 357
 358                 r = readlink_malloc(to, &p);
 359                 if (r == -EINVAL) /* Not a symlink? In that case return the original error we encountered: -EEXIST */
 360                         return -EEXIST;
 361                 if (r < 0) /* Any other error? In that case propagate it as is */
 362                         return r;
 363
 364                 if (!streq(p, from)) /* Not the symlink we want it to be? In that case, propagate the original -EEXIST */
 365                         return -EEXIST;
 366         }
 367
 368         return 0;
 369 }
 370
 371 int symlink_atomic(const char *from, const char *to) {
 372         _cleanup_free_ char *t = NULL;
 373         int r;
 374
 375         assert(from);
 376         assert(to);
 377
 378         r = tempfn_random(to, NULL, &t);
 379         if (r < 0)
 380                 return r;
 381
 382         if (symlink(from, t) < 0)
 383                 return -errno;
 384
 385         if (rename(t, to) < 0) {
 386                 unlink_noerrno(t);
 387                 return -errno;
 388         }
 389
 390         return 0;
 391 }
 392
 393 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
 394         _cleanup_free_ char *t = NULL;
 395         int r;
 396
 397         assert(path);
 398
 399         r = tempfn_random(path, NULL, &t);
 400         if (r < 0)
 401                 return r;
 402
 403         if (mknod(t, mode, dev) < 0)
 404                 return -errno;
 405
 406         if (rename(t, path) < 0) {
 407                 unlink_noerrno(t);
 408                 return -errno;
 409         }
 410
 411         return 0;
 412 }
 413
 414 int mkfifo_atomic(const char *path, mode_t mode) {
 415         _cleanup_free_ char *t = NULL;
 416         int r;
 417
 418         assert(path);
 419
 420         r = tempfn_random(path, NULL, &t);
 421         if (r < 0)
 422                 return r;
 423
 424         if (mkfifo(t, mode) < 0)
 425                 return -errno;
 426
 427         if (rename(t, path) < 0) {
 428                 unlink_noerrno(t);
 429                 return -errno;
 430         }
 431
 432         return 0;
 433 }
 434 #endif // 0
 435
 436 int get_files_in_directory(const char *path, char ***list) {
 437         _cleanup_closedir_ DIR *d = NULL;
 438         struct dirent *de;
 439         size_t bufsize = 0, n = 0;
 440         _cleanup_strv_free_ char **l = NULL;
 441
 442         assert(path);
 443
 444         /* Returns all files in a directory in *list, and the number
 445          * of files as return value. If list is NULL returns only the
 446          * number. */
 447
 448         d = opendir(path);
 449         if (!d)
 450                 return -errno;
 451
 452         FOREACH_DIRENT_ALL(de, d, return -errno) {
 453                 dirent_ensure_type(d, de);
 454
 455                 if (!dirent_is_file(de))
 456                         continue;
 457
 458                 if (list) {
 459                         /* one extra slot is needed for the terminating NULL */
 460                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
 461                                 return -ENOMEM;
 462
 463                         l[n] = strdup(de->d_name);
 464                         if (!l[n])
 465                                 return -ENOMEM;
 466
 467                         l[++n] = NULL;
 468                 } else
 469                         n++;
 470         }
 471
 472         if (list) {
 473                 *list = l;
 474                 l = NULL; /* avoid freeing */
 475         }
 476
 477         return n;
 478 }
 479
 480 static int getenv_tmp_dir(const char **ret_path) {
 481         const char *n;
 482         int r, ret = 0;
 483
 484         assert(ret_path);
 485
 486         /* We use the same order of environment variables python uses in tempfile.gettempdir():
 487          * https://docs.python.org/3/library/tempfile.html#tempfile.gettempdir */
 488         FOREACH_STRING(n, "TMPDIR", "TEMP", "TMP") {
 489                 const char *e;
 490
 491                 e = secure_getenv(n);
 492                 if (!e)
 493                         continue;
 494                 if (!path_is_absolute(e)) {
 495                         r = -ENOTDIR;
 496                         goto next;
 497                 }
 498                 if (!path_is_normalized(e)) {
 499                         r = -EPERM;
 500                         goto next;
 501                 }
 502
 503                 r = is_dir(e, true);
 504                 if (r < 0)
 505                         goto next;
 506                 if (r == 0) {
 507                         r = -ENOTDIR;
 508                         goto next;
 509                 }
 510
 511                 *ret_path = e;
 512                 return 1;
 513
 514         next:
 515                 /* Remember first error, to make this more debuggable */
 516                 if (ret >= 0)
 517                         ret = r;
 518         }
 519
 520         if (ret < 0)
 521                 return ret;
 522
 523         *ret_path = NULL;
 524         return ret;
 525 }
 526
 527 static int tmp_dir_internal(const char *def, const char **ret) {
 528         const char *e;
 529         int r, k;
 530
 531         assert(def);
 532         assert(ret);
 533
 534         r = getenv_tmp_dir(&e);
 535         if (r > 0) {
 536                 *ret = e;
 537                 return 0;
 538         }
 539
 540         k = is_dir(def, true);
 541         if (k == 0)
 542                 k = -ENOTDIR;
 543         if (k < 0)
 544                 return r < 0 ? r : k;
 545
 546         *ret = def;
 547         return 0;
 548 }
 549
 550 #if 0 /// UNNEEDED by elogind
 551 int var_tmp_dir(const char **ret) {
 552
 553         /* Returns the location for "larger" temporary files, that is backed by physical storage if available, and thus
 554          * even might survive a boot: /var/tmp. If $TMPDIR (or related environment variables) are set, its value is
 555          * returned preferably however. Note that both this function and tmp_dir() below are affected by $TMPDIR,
 556          * making it a variable that overrides all temporary file storage locations. */
 557
 558         return tmp_dir_internal("/var/tmp", ret);
 559 }
 560 #endif // 0
 561
 562 int tmp_dir(const char **ret) {
 563
 564         /* Similar to var_tmp_dir() above, but returns the location for "smaller" temporary files, which is usually
 565          * backed by an in-memory file system: /tmp. */
 566
 567         return tmp_dir_internal("/tmp", ret);
 568 }
 569
 570 #if 0 /// UNNEEDED by elogind
 571 int inotify_add_watch_fd(int fd, int what, uint32_t mask) {
 572         char path[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int) + 1];
 573         int r;
 574
 575         /* This is like inotify_add_watch(), except that the file to watch is not referenced by a path, but by an fd */
 576         xsprintf(path, "/proc/self/fd/%i", what);
 577
 578         r = inotify_add_watch(fd, path, mask);
 579         if (r < 0)
 580                 return -errno;
 581
 582         return r;
 583 }
 584 #endif // 0
 585
 586 static bool safe_transition(const struct stat *a, const struct stat *b) {
 587         /* Returns true if the transition from a to b is safe, i.e. that we never transition from unprivileged to
 588          * privileged files or directories. Why bother? So that unprivileged code can't symlink to privileged files
 589          * making us believe we read something safe even though it isn't safe in the specific context we open it in. */
 590
 591         if (a->st_uid == 0) /* Transitioning from privileged to unprivileged is always fine */
 592                 return true;
 593
 594         return a->st_uid == b->st_uid; /* Otherwise we need to stay within the same UID */
 595 }
 596
 597 int chase_symlinks(const char *path, const char *original_root, unsigned flags, char **ret) {
 598         _cleanup_free_ char *buffer = NULL, *done = NULL, *root = NULL;
 599         _cleanup_close_ int fd = -1;
 600         unsigned max_follow = 32; /* how many symlinks to follow before giving up and returning ELOOP */
 601         struct stat previous_stat;
 602         bool exists = true;
 603         char *todo;
 604         int r;
 605
 606         assert(path);
 607
 608         /* Either the file may be missing, or we return an fd to the final object, but both make no sense */
 609         if ((flags & (CHASE_NONEXISTENT|CHASE_OPEN)) == (CHASE_NONEXISTENT|CHASE_OPEN))
 610                 return -EINVAL;
 611
 612         if (isempty(path))
 613                 return -EINVAL;
 614
 615         /* This is a lot like canonicalize_file_name(), but takes an additional "root" parameter, that allows following
 616          * symlinks relative to a root directory, instead of the root of the host.
 617          *
 618          * Note that "root" primarily matters if we encounter an absolute symlink. It is also used when following
 619          * relative symlinks to ensure they cannot be used to "escape" the root directory. The path parameter passed is
 620          * assumed to be already prefixed by it, except if the CHASE_PREFIX_ROOT flag is set, in which case it is first
 621          * prefixed accordingly.
 622          *
 623          * Algorithmically this operates on two path buffers: "done" are the components of the path we already
 624          * processed and resolved symlinks, "." and ".." of. "todo" are the components of the path we still need to
 625          * process. On each iteration, we move one component from "todo" to "done", processing it's special meaning
 626          * each time. The "todo" path always starts with at least one slash, the "done" path always ends in no
 627          * slash. We always keep an O_PATH fd to the component we are currently processing, thus keeping lookup races
 628          * at a minimum.
 629          *
 630          * Suggested usage: whenever you want to canonicalize a path, use this function. Pass the absolute path you got
 631          * as-is: fully qualified and relative to your host's root. Optionally, specify the root parameter to tell this
 632          * function what to do when encountering a symlink with an absolute path as directory: prefix it by the
 633          * specified path. */
 634
 635         /* A root directory of "/" or "" is identical to none */
 636         if (isempty(original_root) || path_equal(original_root, "/"))
 637                 original_root = NULL;
 638
 639         if (original_root) {
 640                 r = path_make_absolute_cwd(original_root, &root);
 641                 if (r < 0)
 642                         return r;
 643
 644                 if (flags & CHASE_PREFIX_ROOT) {
 645
 646                         /* We don't support relative paths in combination with a root directory */
 647                         if (!path_is_absolute(path))
 648                                 return -EINVAL;
 649
 650                         path = prefix_roota(root, path);
 651                 }
 652         }
 653
 654         r = path_make_absolute_cwd(path, &buffer);
 655         if (r < 0)
 656                 return r;
 657
 658         fd = open("/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 659         if (fd < 0)
 660                 return -errno;
 661
 662         if (flags & CHASE_SAFE) {
 663                 if (fstat(fd, &previous_stat) < 0)
 664                         return -errno;
 665         }
 666
 667         todo = buffer;
 668         for (;;) {
 669                 _cleanup_free_ char *first = NULL;
 670                 _cleanup_close_ int child = -1;
 671                 struct stat st;
 672                 size_t n, m;
 673
 674                 /* Determine length of first component in the path */
 675                 n = strspn(todo, "/");                  /* The slashes */
 676                 m = n + strcspn(todo + n, "/");         /* The entire length of the component */
 677
 678                 /* Extract the first component. */
 679                 first = strndup(todo, m);
 680                 if (!first)
 681                         return -ENOMEM;
 682
 683                 todo += m;
 684
 685                 /* Empty? Then we reached the end. */
 686                 if (isempty(first))
 687                         break;
 688
 689                 /* Just a single slash? Then we reached the end. */
 690                 if (path_equal(first, "/")) {
 691                         /* Preserve the trailing slash */
 692                         if (!strextend(&done, "/", NULL))
 693                                 return -ENOMEM;
 694
 695                         break;
 696                 }
 697
 698                 /* Just a dot? Then let's eat this up. */
 699                 if (path_equal(first, "/."))
 700                         continue;
 701
 702                 /* Two dots? Then chop off the last bit of what we already found out. */
 703                 if (path_equal(first, "/..")) {
 704                         _cleanup_free_ char *parent = NULL;
 705                         _cleanup_close_ int fd_parent = -1;
 706
 707                         /* If we already are at the top, then going up will not change anything. This is in-line with
 708                          * how the kernel handles this. */
 709                         if (isempty(done) || path_equal(done, "/"))
 710                                 continue;
 711
 712                         parent = dirname_malloc(done);
 713                         if (!parent)
 714                                 return -ENOMEM;
 715
 716                         /* Don't allow this to leave the root dir.  */
 717                         if (root &&
 718                             path_startswith(done, root) &&
 719                             !path_startswith(parent, root))
 720                                 continue;
 721
 722                         free_and_replace(done, parent);
 723
 724                         fd_parent = openat(fd, "..", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 725                         if (fd_parent < 0)
 726                                 return -errno;
 727
 728                         if (flags & CHASE_SAFE) {
 729                                 if (fstat(fd_parent, &st) < 0)
 730                                         return -errno;
 731
 732                                 if (!safe_transition(&previous_stat, &st))
 733                                         return -EPERM;
 734
 735                                 previous_stat = st;
 736                         }
 737
 738                         safe_close(fd);
 739                         fd = fd_parent;
 740                         fd_parent = -1;
 741
 742                         continue;
 743                 }
 744
 745                 /* Otherwise let's see what this is. */
 746                 child = openat(fd, first + n, O_CLOEXEC|O_NOFOLLOW|O_PATH);
 747                 if (child < 0) {
 748
 749                         if (errno == ENOENT &&
 750                             (flags & CHASE_NONEXISTENT) &&
 751                             (isempty(todo) || path_is_normalized(todo))) {
 752
 753                                 /* If CHASE_NONEXISTENT is set, and the path does not exist, then that's OK, return
 754                                  * what we got so far. But don't allow this if the remaining path contains "../ or "./"
 755                                  * or something else weird. */
 756
 757                                 /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 758                                 if (streq_ptr(done, "/"))
 759                                         *done = '\0';
 760
 761                                 if (!strextend(&done, first, todo, NULL))
 762                                         return -ENOMEM;
 763
 764                                 exists = false;
 765                                 break;
 766                         }
 767
 768                         return -errno;
 769                 }
 770
 771                 if (fstat(child, &st) < 0)
 772                         return -errno;
 773                 if ((flags & CHASE_SAFE) &&
 774                     !safe_transition(&previous_stat, &st))
 775                         return -EPERM;
 776
 777                 previous_stat = st;
 778
 779                 if ((flags & CHASE_NO_AUTOFS) &&
 780                     fd_is_fs_type(child, AUTOFS_SUPER_MAGIC) > 0)
 781                         return -EREMOTE;
 782
 783                 if (S_ISLNK(st.st_mode)) {
 784                         char *joined;
 785
 786                         _cleanup_free_ char *destination = NULL;
 787
 788                         /* This is a symlink, in this case read the destination. But let's make sure we don't follow
 789                          * symlinks without bounds. */
 790                         if (--max_follow <= 0)
 791                                 return -ELOOP;
 792
 793                         r = readlinkat_malloc(fd, first + n, &destination);
 794                         if (r < 0)
 795                                 return r;
 796                         if (isempty(destination))
 797                                 return -EINVAL;
 798
 799                         if (path_is_absolute(destination)) {
 800
 801                                 /* An absolute destination. Start the loop from the beginning, but use the root
 802                                  * directory as base. */
 803
 804                                 safe_close(fd);
 805                                 fd = open(root ?: "/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 806                                 if (fd < 0)
 807                                         return -errno;
 808
 809                                 if (flags & CHASE_SAFE) {
 810                                         if (fstat(fd, &st) < 0)
 811                                                 return -errno;
 812
 813                                         if (!safe_transition(&previous_stat, &st))
 814                                                 return -EPERM;
 815
 816                                         previous_stat = st;
 817                                 }
 818
 819                                 free(done);
 820
 821                                 /* Note that we do not revalidate the root, we take it as is. */
 822                                 if (isempty(root))
 823                                         done = NULL;
 824                                 else {
 825                                         done = strdup(root);
 826                                         if (!done)
 827                                                 return -ENOMEM;
 828                                 }
 829
 830                                 /* Prefix what's left to do with what we just read, and start the loop again, but
 831                                  * remain in the current directory. */
 832                                 joined = strjoin(destination, todo);
 833                         } else
 834                                 joined = strjoin("/", destination, todo);
 835                         if (!joined)
 836                                 return -ENOMEM;
 837
 838                         free(buffer);
 839                         todo = buffer = joined;
 840
 841                         continue;
 842                 }
 843
 844                 /* If this is not a symlink, then let's just add the name we read to what we already verified. */
 845                 if (!done) {
 846                         done = first;
 847                         first = NULL;
 848                 } else {
 849                         /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 850                         if (streq(done, "/"))
 851                                 *done = '\0';
 852
 853                         if (!strextend(&done, first, NULL))
 854                                 return -ENOMEM;
 855                 }
 856
 857                 /* And iterate again, but go one directory further down. */
 858                 safe_close(fd);
 859                 fd = child;
 860                 child = -1;
 861         }
 862
 863         if (!done) {
 864                 /* Special case, turn the empty string into "/", to indicate the root directory. */
 865                 done = strdup("/");
 866                 if (!done)
 867                         return -ENOMEM;
 868         }
 869
 870         if (ret) {
 871                 *ret = done;
 872                 done = NULL;
 873         }
 874
 875         if (flags & CHASE_OPEN) {
 876                 int q;
 877
 878                 /* Return the O_PATH fd we currently are looking to the caller. It can translate it to a proper fd by
 879                  * opening /proc/self/fd/xyz. */
 880
 881                 assert(fd >= 0);
 882                 q = fd;
 883                 fd = -1;
 884
 885                 return q;
 886         }
 887
 888         return exists;
 889 }
 890
 891 int access_fd(int fd, int mode) {
 892         char p[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(fd) + 1];
 893         int r;
 894
 895         /* Like access() but operates on an already open fd */
 896
 897         xsprintf(p, "/proc/self/fd/%i", fd);
 898
 899         r = access(p, mode);
 900         if (r < 0)
 901                 r = -errno;
 902
 903         return r;
 904 }
 905
 906 int unlinkat_deallocate(int fd, const char *name, int flags) {
 907         _cleanup_close_ int truncate_fd = -1;
 908         struct stat st;
 909         off_t l, bs;
 910
 911         /* Operates like unlinkat() but also deallocates the file contents if it is a regular file and there's no other
 912          * link to it. This is useful to ensure that other processes that might have the file open for reading won't be
 913          * able to keep the data pinned on disk forever. This call is particular useful whenever we execute clean-up
 914          * jobs ("vacuuming"), where we want to make sure the data is really gone and the disk space released and
 915          * returned to the free pool.
 916          *
 917          * Deallocation is preferably done by FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE (👊) if supported, which means
 918          * the file won't change size. That's a good thing since we shouldn't needlessly trigger SIGBUS in other
 919          * programs that have mmap()ed the file. (The assumption here is that changing file contents to all zeroes
 920          * underneath those programs is the better choice than simply triggering SIGBUS in them which truncation does.)
 921          * However if hole punching is not implemented in the kernel or file system we'll fall back to normal file
 922          * truncation (🔪), as our goal of deallocating the data space trumps our goal of being nice to readers (💐).
 923          *
 924          * Note that we attempt deallocation, but failure to succeed with that is not considered fatal, as long as the
 925          * primary job – to delete the file – is accomplished. */
 926
 927         if ((flags & AT_REMOVEDIR) == 0) {
 928                 truncate_fd = openat(fd, name, O_WRONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW|O_NONBLOCK);
 929                 if (truncate_fd < 0) {
 930
 931                         /* If this failed because the file doesn't exist propagate the error right-away. Also,
 932                          * AT_REMOVEDIR wasn't set, and we tried to open the file for writing, which means EISDIR is
 933                          * returned when this is a directory but we are not supposed to delete those, hence propagate
 934                          * the error right-away too. */
 935                         if (IN_SET(errno, ENOENT, EISDIR))
 936                                 return -errno;
 937
 938                         if (errno != ELOOP) /* don't complain if this is a symlink */
 939                                 log_debug_errno(errno, "Failed to open file '%s' for deallocation, ignoring: %m", name);
 940                 }
 941         }
 942
 943         if (unlinkat(fd, name, flags) < 0)
 944                 return -errno;
 945
 946         if (truncate_fd < 0) /* Don't have a file handle, can't do more ☹️ */
 947                 return 0;
 948
 949         if (fstat(truncate_fd, &st) < 0) {
 950                 log_debug_errno(errno, "Failed to stat file '%s' for deallocation, ignoring.", name);
 951                 return 0;
 952         }
 953
 954         if (!S_ISREG(st.st_mode) || st.st_blocks == 0 || st.st_nlink > 0)
 955                 return 0;
 956
 957         /* If this is a regular file, it actually took up space on disk and there are no other links it's time to
 958          * punch-hole/truncate this to release the disk space. */
 959
 960         bs = MAX(st.st_blksize, 512);
 961         l = DIV_ROUND_UP(st.st_size, bs) * bs; /* Round up to next block size */
 962
 963         if (fallocate(truncate_fd, FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE, 0, l) >= 0)
 964                 return 0; /* Successfully punched a hole! 😊 */
 965
 966         /* Fall back to truncation */
 967         if (ftruncate(truncate_fd, 0) < 0) {
 968                 log_debug_errno(errno, "Failed to truncate file to 0, ignoring: %m");
 969                 return 0;
 970         }
 971
 972         return 0;
 973 }