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