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