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 int unlink_or_warn(const char *filename) {
 571         if (unlink(filename) < 0 && errno != ENOENT)
 572                 /* If the file doesn't exist and the fs simply was read-only (in which
 573                  * case unlink() returns EROFS even if the file doesn't exist), don't
 574                  * complain */
 575                 if (errno != EROFS || access(filename, F_OK) >= 0)
 576                         return log_error_errno(errno, "Failed to remove \"%s\": %m", filename);
 577
 578         return 0;
 579 }
 580
 581 #if 0 /// UNNEEDED by elogind
 582 int inotify_add_watch_fd(int fd, int what, uint32_t mask) {
 583         char path[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int) + 1];
 584         int r;
 585
 586         /* This is like inotify_add_watch(), except that the file to watch is not referenced by a path, but by an fd */
 587         xsprintf(path, "/proc/self/fd/%i", what);
 588
 589         r = inotify_add_watch(fd, path, mask);
 590         if (r < 0)
 591                 return -errno;
 592
 593         return r;
 594 }
 595 #endif // 0
 596
 597 static bool safe_transition(const struct stat *a, const struct stat *b) {
 598         /* Returns true if the transition from a to b is safe, i.e. that we never transition from unprivileged to
 599          * privileged files or directories. Why bother? So that unprivileged code can't symlink to privileged files
 600          * making us believe we read something safe even though it isn't safe in the specific context we open it in. */
 601
 602         if (a->st_uid == 0) /* Transitioning from privileged to unprivileged is always fine */
 603                 return true;
 604
 605         return a->st_uid == b->st_uid; /* Otherwise we need to stay within the same UID */
 606 }
 607
 608 int chase_symlinks(const char *path, const char *original_root, unsigned flags, char **ret) {
 609         _cleanup_free_ char *buffer = NULL, *done = NULL, *root = NULL;
 610         _cleanup_close_ int fd = -1;
 611         unsigned max_follow = 32; /* how many symlinks to follow before giving up and returning ELOOP */
 612         struct stat previous_stat;
 613         bool exists = true;
 614         char *todo;
 615         int r;
 616
 617         assert(path);
 618
 619         /* Either the file may be missing, or we return an fd to the final object, but both make no sense */
 620         if ((flags & (CHASE_NONEXISTENT|CHASE_OPEN)) == (CHASE_NONEXISTENT|CHASE_OPEN))
 621                 return -EINVAL;
 622
 623         if (isempty(path))
 624                 return -EINVAL;
 625
 626         /* This is a lot like canonicalize_file_name(), but takes an additional "root" parameter, that allows following
 627          * symlinks relative to a root directory, instead of the root of the host.
 628          *
 629          * Note that "root" primarily matters if we encounter an absolute symlink. It is also used when following
 630          * relative symlinks to ensure they cannot be used to "escape" the root directory. The path parameter passed is
 631          * assumed to be already prefixed by it, except if the CHASE_PREFIX_ROOT flag is set, in which case it is first
 632          * prefixed accordingly.
 633          *
 634          * Algorithmically this operates on two path buffers: "done" are the components of the path we already
 635          * processed and resolved symlinks, "." and ".." of. "todo" are the components of the path we still need to
 636          * process. On each iteration, we move one component from "todo" to "done", processing it's special meaning
 637          * each time. The "todo" path always starts with at least one slash, the "done" path always ends in no
 638          * slash. We always keep an O_PATH fd to the component we are currently processing, thus keeping lookup races
 639          * at a minimum.
 640          *
 641          * Suggested usage: whenever you want to canonicalize a path, use this function. Pass the absolute path you got
 642          * as-is: fully qualified and relative to your host's root. Optionally, specify the root parameter to tell this
 643          * function what to do when encountering a symlink with an absolute path as directory: prefix it by the
 644          * specified path. */
 645
 646         /* A root directory of "/" or "" is identical to none */
 647         if (isempty(original_root) || path_equal(original_root, "/"))
 648                 original_root = NULL;
 649
 650         if (original_root) {
 651                 r = path_make_absolute_cwd(original_root, &root);
 652                 if (r < 0)
 653                         return r;
 654
 655                 if (flags & CHASE_PREFIX_ROOT) {
 656
 657                         /* We don't support relative paths in combination with a root directory */
 658                         if (!path_is_absolute(path))
 659                                 return -EINVAL;
 660
 661                         path = prefix_roota(root, path);
 662                 }
 663         }
 664
 665         r = path_make_absolute_cwd(path, &buffer);
 666         if (r < 0)
 667                 return r;
 668
 669         fd = open("/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 670         if (fd < 0)
 671                 return -errno;
 672
 673         if (flags & CHASE_SAFE) {
 674                 if (fstat(fd, &previous_stat) < 0)
 675                         return -errno;
 676         }
 677
 678         todo = buffer;
 679         for (;;) {
 680                 _cleanup_free_ char *first = NULL;
 681                 _cleanup_close_ int child = -1;
 682                 struct stat st;
 683                 size_t n, m;
 684
 685                 /* Determine length of first component in the path */
 686                 n = strspn(todo, "/");                  /* The slashes */
 687                 m = n + strcspn(todo + n, "/");         /* The entire length of the component */
 688
 689                 /* Extract the first component. */
 690                 first = strndup(todo, m);
 691                 if (!first)
 692                         return -ENOMEM;
 693
 694                 todo += m;
 695
 696                 /* Empty? Then we reached the end. */
 697                 if (isempty(first))
 698                         break;
 699
 700                 /* Just a single slash? Then we reached the end. */
 701                 if (path_equal(first, "/")) {
 702                         /* Preserve the trailing slash */
 703                         if (!strextend(&done, "/", NULL))
 704                                 return -ENOMEM;
 705
 706                         break;
 707                 }
 708
 709                 /* Just a dot? Then let's eat this up. */
 710                 if (path_equal(first, "/."))
 711                         continue;
 712
 713                 /* Two dots? Then chop off the last bit of what we already found out. */
 714                 if (path_equal(first, "/..")) {
 715                         _cleanup_free_ char *parent = NULL;
 716                         _cleanup_close_ int fd_parent = -1;
 717
 718                         /* If we already are at the top, then going up will not change anything. This is in-line with
 719                          * how the kernel handles this. */
 720                         if (isempty(done) || path_equal(done, "/"))
 721                                 continue;
 722
 723                         parent = dirname_malloc(done);
 724                         if (!parent)
 725                                 return -ENOMEM;
 726
 727                         /* Don't allow this to leave the root dir.  */
 728                         if (root &&
 729                             path_startswith(done, root) &&
 730                             !path_startswith(parent, root))
 731                                 continue;
 732
 733                         free_and_replace(done, parent);
 734
 735                         fd_parent = openat(fd, "..", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 736                         if (fd_parent < 0)
 737                                 return -errno;
 738
 739                         if (flags & CHASE_SAFE) {
 740                                 if (fstat(fd_parent, &st) < 0)
 741                                         return -errno;
 742
 743                                 if (!safe_transition(&previous_stat, &st))
 744                                         return -EPERM;
 745
 746                                 previous_stat = st;
 747                         }
 748
 749                         safe_close(fd);
 750                         fd = fd_parent;
 751                         fd_parent = -1;
 752
 753                         continue;
 754                 }
 755
 756                 /* Otherwise let's see what this is. */
 757                 child = openat(fd, first + n, O_CLOEXEC|O_NOFOLLOW|O_PATH);
 758                 if (child < 0) {
 759
 760                         if (errno == ENOENT &&
 761                             (flags & CHASE_NONEXISTENT) &&
 762                             (isempty(todo) || path_is_normalized(todo))) {
 763
 764                                 /* If CHASE_NONEXISTENT is set, and the path does not exist, then that's OK, return
 765                                  * what we got so far. But don't allow this if the remaining path contains "../ or "./"
 766                                  * or something else weird. */
 767
 768                                 /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 769                                 if (streq_ptr(done, "/"))
 770                                         *done = '\0';
 771
 772                                 if (!strextend(&done, first, todo, NULL))
 773                                         return -ENOMEM;
 774
 775                                 exists = false;
 776                                 break;
 777                         }
 778
 779                         return -errno;
 780                 }
 781
 782                 if (fstat(child, &st) < 0)
 783                         return -errno;
 784                 if ((flags & CHASE_SAFE) &&
 785                     !safe_transition(&previous_stat, &st))
 786                         return -EPERM;
 787
 788                 previous_stat = st;
 789
 790                 if ((flags & CHASE_NO_AUTOFS) &&
 791                     fd_is_fs_type(child, AUTOFS_SUPER_MAGIC) > 0)
 792                         return -EREMOTE;
 793
 794                 if (S_ISLNK(st.st_mode)) {
 795                         char *joined;
 796
 797                         _cleanup_free_ char *destination = NULL;
 798
 799                         /* This is a symlink, in this case read the destination. But let's make sure we don't follow
 800                          * symlinks without bounds. */
 801                         if (--max_follow <= 0)
 802                                 return -ELOOP;
 803
 804                         r = readlinkat_malloc(fd, first + n, &destination);
 805                         if (r < 0)
 806                                 return r;
 807                         if (isempty(destination))
 808                                 return -EINVAL;
 809
 810                         if (path_is_absolute(destination)) {
 811
 812                                 /* An absolute destination. Start the loop from the beginning, but use the root
 813                                  * directory as base. */
 814
 815                                 safe_close(fd);
 816                                 fd = open(root ?: "/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 817                                 if (fd < 0)
 818                                         return -errno;
 819
 820                                 if (flags & CHASE_SAFE) {
 821                                         if (fstat(fd, &st) < 0)
 822                                                 return -errno;
 823
 824                                         if (!safe_transition(&previous_stat, &st))
 825                                                 return -EPERM;
 826
 827                                         previous_stat = st;
 828                                 }
 829
 830                                 free(done);
 831
 832                                 /* Note that we do not revalidate the root, we take it as is. */
 833                                 if (isempty(root))
 834                                         done = NULL;
 835                                 else {
 836                                         done = strdup(root);
 837                                         if (!done)
 838                                                 return -ENOMEM;
 839                                 }
 840
 841                                 /* Prefix what's left to do with what we just read, and start the loop again, but
 842                                  * remain in the current directory. */
 843                                 joined = strjoin(destination, todo);
 844                         } else
 845                                 joined = strjoin("/", destination, todo);
 846                         if (!joined)
 847                                 return -ENOMEM;
 848
 849                         free(buffer);
 850                         todo = buffer = joined;
 851
 852                         continue;
 853                 }
 854
 855                 /* If this is not a symlink, then let's just add the name we read to what we already verified. */
 856                 if (!done) {
 857                         done = first;
 858                         first = NULL;
 859                 } else {
 860                         /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 861                         if (streq(done, "/"))
 862                                 *done = '\0';
 863
 864                         if (!strextend(&done, first, NULL))
 865                                 return -ENOMEM;
 866                 }
 867
 868                 /* And iterate again, but go one directory further down. */
 869                 safe_close(fd);
 870                 fd = child;
 871                 child = -1;
 872         }
 873
 874         if (!done) {
 875                 /* Special case, turn the empty string into "/", to indicate the root directory. */
 876                 done = strdup("/");
 877                 if (!done)
 878                         return -ENOMEM;
 879         }
 880
 881         if (ret) {
 882                 *ret = done;
 883                 done = NULL;
 884         }
 885
 886         if (flags & CHASE_OPEN) {
 887                 int q;
 888
 889                 /* Return the O_PATH fd we currently are looking to the caller. It can translate it to a proper fd by
 890                  * opening /proc/self/fd/xyz. */
 891
 892                 assert(fd >= 0);
 893                 q = fd;
 894                 fd = -1;
 895
 896                 return q;
 897         }
 898
 899         return exists;
 900 }
 901
 902 int access_fd(int fd, int mode) {
 903         char p[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(fd) + 1];
 904         int r;
 905
 906         /* Like access() but operates on an already open fd */
 907
 908         xsprintf(p, "/proc/self/fd/%i", fd);
 909
 910         r = access(p, mode);
 911         if (r < 0)
 912                 r = -errno;
 913
 914         return r;
 915 }
 916
 917 int unlinkat_deallocate(int fd, const char *name, int flags) {
 918         _cleanup_close_ int truncate_fd = -1;
 919         struct stat st;
 920         off_t l, bs;
 921
 922         /* Operates like unlinkat() but also deallocates the file contents if it is a regular file and there's no other
 923          * link to it. This is useful to ensure that other processes that might have the file open for reading won't be
 924          * able to keep the data pinned on disk forever. This call is particular useful whenever we execute clean-up
 925          * jobs ("vacuuming"), where we want to make sure the data is really gone and the disk space released and
 926          * returned to the free pool.
 927          *
 928          * Deallocation is preferably done by FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE (👊) if supported, which means
 929          * the file won't change size. That's a good thing since we shouldn't needlessly trigger SIGBUS in other
 930          * programs that have mmap()ed the file. (The assumption here is that changing file contents to all zeroes
 931          * underneath those programs is the better choice than simply triggering SIGBUS in them which truncation does.)
 932          * However if hole punching is not implemented in the kernel or file system we'll fall back to normal file
 933          * truncation (🔪), as our goal of deallocating the data space trumps our goal of being nice to readers (💐).
 934          *
 935          * Note that we attempt deallocation, but failure to succeed with that is not considered fatal, as long as the
 936          * primary job – to delete the file – is accomplished. */
 937
 938         if ((flags & AT_REMOVEDIR) == 0) {
 939                 truncate_fd = openat(fd, name, O_WRONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW|O_NONBLOCK);
 940                 if (truncate_fd < 0) {
 941
 942                         /* If this failed because the file doesn't exist propagate the error right-away. Also,
 943                          * AT_REMOVEDIR wasn't set, and we tried to open the file for writing, which means EISDIR is
 944                          * returned when this is a directory but we are not supposed to delete those, hence propagate
 945                          * the error right-away too. */
 946                         if (IN_SET(errno, ENOENT, EISDIR))
 947                                 return -errno;
 948
 949                         if (errno != ELOOP) /* don't complain if this is a symlink */
 950                                 log_debug_errno(errno, "Failed to open file '%s' for deallocation, ignoring: %m", name);
 951                 }
 952         }
 953
 954         if (unlinkat(fd, name, flags) < 0)
 955                 return -errno;
 956
 957         if (truncate_fd < 0) /* Don't have a file handle, can't do more ☹️ */
 958                 return 0;
 959
 960         if (fstat(truncate_fd, &st) < 0) {
 961                 log_debug_errno(errno, "Failed to stat file '%s' for deallocation, ignoring.", name);
 962                 return 0;
 963         }
 964
 965         if (!S_ISREG(st.st_mode) || st.st_blocks == 0 || st.st_nlink > 0)
 966                 return 0;
 967
 968         /* If this is a regular file, it actually took up space on disk and there are no other links it's time to
 969          * punch-hole/truncate this to release the disk space. */
 970
 971         bs = MAX(st.st_blksize, 512);
 972         l = DIV_ROUND_UP(st.st_size, bs) * bs; /* Round up to next block size */
 973
 974         if (fallocate(truncate_fd, FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE, 0, l) >= 0)
 975                 return 0; /* Successfully punched a hole! 😊 */
 976
 977         /* Fall back to truncation */
 978         if (ftruncate(truncate_fd, 0) < 0) {
 979                 log_debug_errno(errno, "Failed to truncate file to 0, ignoring: %m");
 980                 return 0;
 981         }
 982
 983         return 0;
 984 }
 985
 986 int fsync_directory_of_file(int fd) {
 987         _cleanup_free_ char *path = NULL, *dn = NULL;
 988         _cleanup_close_ int dfd = -1;
 989         int r;
 990
 991         r = fd_verify_regular(fd);
 992         if (r < 0)
 993                 return r;
 994
 995         r = fd_get_path(fd, &path);
 996         if (r < 0)
 997                 return r;
 998
 999         if (!path_is_absolute(path))
1000                 return -EINVAL;
1001
1002         dn = dirname_malloc(path);
1003         if (!dn)
1004                 return -ENOMEM;
1005
1006         dfd = open(dn, O_RDONLY|O_CLOEXEC|O_DIRECTORY);
1007         if (dfd < 0)
1008                 return -errno;
1009
1010         if (fsync(dfd) < 0)
1011                 return -errno;
1012
1013         return 0;
1014 }