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 int readlink_and_canonicalize(const char *p, const char *root, char **ret) {
 237         char *t, *s;
 238         int r;
 239
 240         assert(p);
 241         assert(ret);
 242
 243         r = readlink_and_make_absolute(p, &t);
 244         if (r < 0)
 245                 return r;
 246
 247         r = chase_symlinks(t, root, 0, &s);
 248         if (r < 0)
 249                 /* If we can't follow up, then let's return the original string, slightly cleaned up. */
 250                 *ret = path_kill_slashes(t);
 251         else {
 252                 *ret = s;
 253                 free(t);
 254         }
 255
 256         return 0;
 257 }
 258
 259 int readlink_and_make_absolute_root(const char *root, const char *path, char **ret) {
 260         _cleanup_free_ char *target = NULL, *t = NULL;
 261         const char *full;
 262         int r;
 263
 264         full = prefix_roota(root, path);
 265         r = readlink_malloc(full, &target);
 266         if (r < 0)
 267                 return r;
 268
 269         t = file_in_same_dir(path, target);
 270         if (!t)
 271                 return -ENOMEM;
 272
 273         *ret = t;
 274         t = NULL;
 275
 276         return 0;
 277 }
 278 #endif // 0
 279
 280 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
 281         assert(path);
 282
 283         /* Under the assumption that we are running privileged we
 284          * first change the access mode and only then hand out
 285          * ownership to avoid a window where access is too open. */
 286
 287         if (mode != MODE_INVALID)
 288                 if (chmod(path, mode) < 0)
 289                         return -errno;
 290
 291         if (uid != UID_INVALID || gid != GID_INVALID)
 292                 if (chown(path, uid, gid) < 0)
 293                         return -errno;
 294
 295         return 0;
 296 }
 297
 298 int fchmod_umask(int fd, mode_t m) {
 299         mode_t u;
 300         int r;
 301
 302         u = umask(0777);
 303         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 304         umask(u);
 305
 306         return r;
 307 }
 308
 309 int fd_warn_permissions(const char *path, int fd) {
 310         struct stat st;
 311
 312         if (fstat(fd, &st) < 0)
 313                 return -errno;
 314
 315         if (st.st_mode & 0111)
 316                 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
 317
 318         if (st.st_mode & 0002)
 319                 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
 320
 321         if (getpid_cached() == 1 && (st.st_mode & 0044) != 0044)
 322                 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);
 323
 324         return 0;
 325 }
 326
 327 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
 328         char fdpath[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
 329         _cleanup_close_ int fd = -1;
 330         int r, ret = 0;
 331
 332         assert(path);
 333
 334         /* Note that touch_file() does not follow symlinks: if invoked on an existing symlink, then it is the symlink
 335          * itself which is updated, not its target
 336          *
 337          * Returns the first error we encounter, but tries to apply as much as possible. */
 338
 339         if (parents)
 340                 (void) mkdir_parents(path, 0755);
 341
 342         /* Initially, we try to open the node with O_PATH, so that we get a reference to the node. This is useful in
 343          * case the path refers to an existing device or socket node, as we can open it successfully in all cases, and
 344          * won't trigger any driver magic or so. */
 345         fd = open(path, O_PATH|O_CLOEXEC|O_NOFOLLOW);
 346         if (fd < 0) {
 347                 if (errno != ENOENT)
 348                         return -errno;
 349
 350                 /* if the node doesn't exist yet, we create it, but with O_EXCL, so that we only create a regular file
 351                  * here, and nothing else */
 352                 fd = open(path, O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC, IN_SET(mode, 0, MODE_INVALID) ? 0644 : mode);
 353                 if (fd < 0)
 354                         return -errno;
 355         }
 356
 357         /* Let's make a path from the fd, and operate on that. With this logic, we can adjust the access mode,
 358          * ownership and time of the file node in all cases, even if the fd refers to an O_PATH object — which is
 359          * something fchown(), fchmod(), futimensat() don't allow. */
 360         xsprintf(fdpath, "/proc/self/fd/%i", fd);
 361
 362         if (mode != MODE_INVALID)
 363                 if (chmod(fdpath, mode) < 0)
 364                         ret = -errno;
 365
 366         if (uid_is_valid(uid) || gid_is_valid(gid))
 367                 if (chown(fdpath, uid, gid) < 0 && ret >= 0)
 368                         ret = -errno;
 369
 370         if (stamp != USEC_INFINITY) {
 371                 struct timespec ts[2];
 372
 373                 timespec_store(&ts[0], stamp);
 374                 ts[1] = ts[0];
 375                 r = utimensat(AT_FDCWD, fdpath, ts, 0);
 376         } else
 377                 r = utimensat(AT_FDCWD, fdpath, NULL, 0);
 378         if (r < 0 && ret >= 0)
 379                 return -errno;
 380
 381         return ret;
 382 }
 383
 384 int touch(const char *path) {
 385         return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, MODE_INVALID);
 386 }
 387
 388 #if 0 /// UNNEEDED by elogind
 389 int symlink_idempotent(const char *from, const char *to) {
 390         int r;
 391
 392         assert(from);
 393         assert(to);
 394
 395         if (symlink(from, to) < 0) {
 396                 _cleanup_free_ char *p = NULL;
 397
 398                 if (errno != EEXIST)
 399                         return -errno;
 400
 401                 r = readlink_malloc(to, &p);
 402                 if (r == -EINVAL) /* Not a symlink? In that case return the original error we encountered: -EEXIST */
 403                         return -EEXIST;
 404                 if (r < 0) /* Any other error? In that case propagate it as is */
 405                         return r;
 406
 407                 if (!streq(p, from)) /* Not the symlink we want it to be? In that case, propagate the original -EEXIST */
 408                         return -EEXIST;
 409         }
 410
 411         return 0;
 412 }
 413
 414 int symlink_atomic(const char *from, const char *to) {
 415         _cleanup_free_ char *t = NULL;
 416         int r;
 417
 418         assert(from);
 419         assert(to);
 420
 421         r = tempfn_random(to, NULL, &t);
 422         if (r < 0)
 423                 return r;
 424
 425         if (symlink(from, t) < 0)
 426                 return -errno;
 427
 428         if (rename(t, to) < 0) {
 429                 unlink_noerrno(t);
 430                 return -errno;
 431         }
 432
 433         return 0;
 434 }
 435
 436 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
 437         _cleanup_free_ char *t = NULL;
 438         int r;
 439
 440         assert(path);
 441
 442         r = tempfn_random(path, NULL, &t);
 443         if (r < 0)
 444                 return r;
 445
 446         if (mknod(t, mode, dev) < 0)
 447                 return -errno;
 448
 449         if (rename(t, path) < 0) {
 450                 unlink_noerrno(t);
 451                 return -errno;
 452         }
 453
 454         return 0;
 455 }
 456
 457 int mkfifo_atomic(const char *path, mode_t mode) {
 458         _cleanup_free_ char *t = NULL;
 459         int r;
 460
 461         assert(path);
 462
 463         r = tempfn_random(path, NULL, &t);
 464         if (r < 0)
 465                 return r;
 466
 467         if (mkfifo(t, mode) < 0)
 468                 return -errno;
 469
 470         if (rename(t, path) < 0) {
 471                 unlink_noerrno(t);
 472                 return -errno;
 473         }
 474
 475         return 0;
 476 }
 477 #endif // 0
 478
 479 int get_files_in_directory(const char *path, char ***list) {
 480         _cleanup_closedir_ DIR *d = NULL;
 481         struct dirent *de;
 482         size_t bufsize = 0, n = 0;
 483         _cleanup_strv_free_ char **l = NULL;
 484
 485         assert(path);
 486
 487         /* Returns all files in a directory in *list, and the number
 488          * of files as return value. If list is NULL returns only the
 489          * number. */
 490
 491         d = opendir(path);
 492         if (!d)
 493                 return -errno;
 494
 495         FOREACH_DIRENT_ALL(de, d, return -errno) {
 496                 dirent_ensure_type(d, de);
 497
 498                 if (!dirent_is_file(de))
 499                         continue;
 500
 501                 if (list) {
 502                         /* one extra slot is needed for the terminating NULL */
 503                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
 504                                 return -ENOMEM;
 505
 506                         l[n] = strdup(de->d_name);
 507                         if (!l[n])
 508                                 return -ENOMEM;
 509
 510                         l[++n] = NULL;
 511                 } else
 512                         n++;
 513         }
 514
 515         if (list) {
 516                 *list = l;
 517                 l = NULL; /* avoid freeing */
 518         }
 519
 520         return n;
 521 }
 522
 523 static int getenv_tmp_dir(const char **ret_path) {
 524         const char *n;
 525         int r, ret = 0;
 526
 527         assert(ret_path);
 528
 529         /* We use the same order of environment variables python uses in tempfile.gettempdir():
 530          * https://docs.python.org/3/library/tempfile.html#tempfile.gettempdir */
 531         FOREACH_STRING(n, "TMPDIR", "TEMP", "TMP") {
 532                 const char *e;
 533
 534                 e = secure_getenv(n);
 535                 if (!e)
 536                         continue;
 537                 if (!path_is_absolute(e)) {
 538                         r = -ENOTDIR;
 539                         goto next;
 540                 }
 541                 if (!path_is_normalized(e)) {
 542                         r = -EPERM;
 543                         goto next;
 544                 }
 545
 546                 r = is_dir(e, true);
 547                 if (r < 0)
 548                         goto next;
 549                 if (r == 0) {
 550                         r = -ENOTDIR;
 551                         goto next;
 552                 }
 553
 554                 *ret_path = e;
 555                 return 1;
 556
 557         next:
 558                 /* Remember first error, to make this more debuggable */
 559                 if (ret >= 0)
 560                         ret = r;
 561         }
 562
 563         if (ret < 0)
 564                 return ret;
 565
 566         *ret_path = NULL;
 567         return ret;
 568 }
 569
 570 static int tmp_dir_internal(const char *def, const char **ret) {
 571         const char *e;
 572         int r, k;
 573
 574         assert(def);
 575         assert(ret);
 576
 577         r = getenv_tmp_dir(&e);
 578         if (r > 0) {
 579                 *ret = e;
 580                 return 0;
 581         }
 582
 583         k = is_dir(def, true);
 584         if (k == 0)
 585                 k = -ENOTDIR;
 586         if (k < 0)
 587                 return r < 0 ? r : k;
 588
 589         *ret = def;
 590         return 0;
 591 }
 592
 593 #if 0 /// UNNEEDED by elogind
 594 int var_tmp_dir(const char **ret) {
 595
 596         /* Returns the location for "larger" temporary files, that is backed by physical storage if available, and thus
 597          * even might survive a boot: /var/tmp. If $TMPDIR (or related environment variables) are set, its value is
 598          * returned preferably however. Note that both this function and tmp_dir() below are affected by $TMPDIR,
 599          * making it a variable that overrides all temporary file storage locations. */
 600
 601         return tmp_dir_internal("/var/tmp", ret);
 602 }
 603 #endif // 0
 604
 605 int tmp_dir(const char **ret) {
 606
 607         /* Similar to var_tmp_dir() above, but returns the location for "smaller" temporary files, which is usually
 608          * backed by an in-memory file system: /tmp. */
 609
 610         return tmp_dir_internal("/tmp", ret);
 611 }
 612
 613 #if 0 /// UNNEEDED by elogind
 614 int inotify_add_watch_fd(int fd, int what, uint32_t mask) {
 615         char path[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int) + 1];
 616         int r;
 617
 618         /* This is like inotify_add_watch(), except that the file to watch is not referenced by a path, but by an fd */
 619         xsprintf(path, "/proc/self/fd/%i", what);
 620
 621         r = inotify_add_watch(fd, path, mask);
 622         if (r < 0)
 623                 return -errno;
 624
 625         return r;
 626 }
 627 #endif // 0
 628
 629 static bool safe_transition(const struct stat *a, const struct stat *b) {
 630         /* Returns true if the transition from a to b is safe, i.e. that we never transition from unprivileged to
 631          * privileged files or directories. Why bother? So that unprivileged code can't symlink to privileged files
 632          * making us believe we read something safe even though it isn't safe in the specific context we open it in. */
 633
 634         if (a->st_uid == 0) /* Transitioning from privileged to unprivileged is always fine */
 635                 return true;
 636
 637         return a->st_uid == b->st_uid; /* Otherwise we need to stay within the same UID */
 638 }
 639
 640 int chase_symlinks(const char *path, const char *original_root, unsigned flags, char **ret) {
 641         _cleanup_free_ char *buffer = NULL, *done = NULL, *root = NULL;
 642         _cleanup_close_ int fd = -1;
 643         unsigned max_follow = 32; /* how many symlinks to follow before giving up and returning ELOOP */
 644         struct stat previous_stat;
 645         bool exists = true;
 646         char *todo;
 647         int r;
 648
 649         assert(path);
 650
 651         /* Either the file may be missing, or we return an fd to the final object, but both make no sense */
 652         if ((flags & (CHASE_NONEXISTENT|CHASE_OPEN)) == (CHASE_NONEXISTENT|CHASE_OPEN))
 653                 return -EINVAL;
 654
 655         if (isempty(path))
 656                 return -EINVAL;
 657
 658         /* This is a lot like canonicalize_file_name(), but takes an additional "root" parameter, that allows following
 659          * symlinks relative to a root directory, instead of the root of the host.
 660          *
 661          * Note that "root" primarily matters if we encounter an absolute symlink. It is also used when following
 662          * relative symlinks to ensure they cannot be used to "escape" the root directory. The path parameter passed is
 663          * assumed to be already prefixed by it, except if the CHASE_PREFIX_ROOT flag is set, in which case it is first
 664          * prefixed accordingly.
 665          *
 666          * Algorithmically this operates on two path buffers: "done" are the components of the path we already
 667          * processed and resolved symlinks, "." and ".." of. "todo" are the components of the path we still need to
 668          * process. On each iteration, we move one component from "todo" to "done", processing it's special meaning
 669          * each time. The "todo" path always starts with at least one slash, the "done" path always ends in no
 670          * slash. We always keep an O_PATH fd to the component we are currently processing, thus keeping lookup races
 671          * at a minimum.
 672          *
 673          * Suggested usage: whenever you want to canonicalize a path, use this function. Pass the absolute path you got
 674          * as-is: fully qualified and relative to your host's root. Optionally, specify the root parameter to tell this
 675          * function what to do when encountering a symlink with an absolute path as directory: prefix it by the
 676          * specified path. */
 677
 678         if (original_root) {
 679                 if (isempty(original_root)) /* What's this even supposed to mean? */
 680                         return -EINVAL;
 681
 682                 if (path_equal(original_root, "/")) /* A root directory of "/" is identical to none */
 683                         original_root = NULL;
 684         }
 685
 686         if (original_root) {
 687                 r = path_make_absolute_cwd(original_root, &root);
 688                 if (r < 0)
 689                         return r;
 690
 691                 if (flags & CHASE_PREFIX_ROOT) {
 692
 693                         /* We don't support relative paths in combination with a root directory */
 694                         if (!path_is_absolute(path))
 695                                 return -EINVAL;
 696
 697                         path = prefix_roota(root, path);
 698                 }
 699         }
 700
 701         r = path_make_absolute_cwd(path, &buffer);
 702         if (r < 0)
 703                 return r;
 704
 705         fd = open("/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 706         if (fd < 0)
 707                 return -errno;
 708
 709         if (flags & CHASE_SAFE) {
 710                 if (fstat(fd, &previous_stat) < 0)
 711                         return -errno;
 712         }
 713
 714         todo = buffer;
 715         for (;;) {
 716                 _cleanup_free_ char *first = NULL;
 717                 _cleanup_close_ int child = -1;
 718                 struct stat st;
 719                 size_t n, m;
 720
 721                 /* Determine length of first component in the path */
 722                 n = strspn(todo, "/");                  /* The slashes */
 723                 m = n + strcspn(todo + n, "/");         /* The entire length of the component */
 724
 725                 /* Extract the first component. */
 726                 first = strndup(todo, m);
 727                 if (!first)
 728                         return -ENOMEM;
 729
 730                 todo += m;
 731
 732                 /* Empty? Then we reached the end. */
 733                 if (isempty(first))
 734                         break;
 735
 736                 /* Just a single slash? Then we reached the end. */
 737                 if (path_equal(first, "/")) {
 738                         /* Preserve the trailing slash */
 739                         if (!strextend(&done, "/", NULL))
 740                                 return -ENOMEM;
 741
 742                         break;
 743                 }
 744
 745                 /* Just a dot? Then let's eat this up. */
 746                 if (path_equal(first, "/."))
 747                         continue;
 748
 749                 /* Two dots? Then chop off the last bit of what we already found out. */
 750                 if (path_equal(first, "/..")) {
 751                         _cleanup_free_ char *parent = NULL;
 752                         int fd_parent = -1;
 753
 754                         /* If we already are at the top, then going up will not change anything. This is in-line with
 755                          * how the kernel handles this. */
 756                         if (isempty(done) || path_equal(done, "/"))
 757                                 continue;
 758
 759                         parent = dirname_malloc(done);
 760                         if (!parent)
 761                                 return -ENOMEM;
 762
 763                         /* Don't allow this to leave the root dir.  */
 764                         if (root &&
 765                             path_startswith(done, root) &&
 766                             !path_startswith(parent, root))
 767                                 continue;
 768
 769                         free_and_replace(done, parent);
 770
 771                         fd_parent = openat(fd, "..", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 772                         if (fd_parent < 0)
 773                                 return -errno;
 774
 775                         if (flags & CHASE_SAFE) {
 776                                 if (fstat(fd_parent, &st) < 0)
 777                                         return -errno;
 778
 779                                 if (!safe_transition(&previous_stat, &st))
 780                                         return -EPERM;
 781
 782                                 previous_stat = st;
 783                         }
 784
 785                         safe_close(fd);
 786                         fd = fd_parent;
 787
 788                         continue;
 789                 }
 790
 791                 /* Otherwise let's see what this is. */
 792                 child = openat(fd, first + n, O_CLOEXEC|O_NOFOLLOW|O_PATH);
 793                 if (child < 0) {
 794
 795                         if (errno == ENOENT &&
 796                             (flags & CHASE_NONEXISTENT) &&
 797                             (isempty(todo) || path_is_normalized(todo))) {
 798
 799                                 /* If CHASE_NONEXISTENT is set, and the path does not exist, then that's OK, return
 800                                  * what we got so far. But don't allow this if the remaining path contains "../ or "./"
 801                                  * or something else weird. */
 802
 803                                 /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 804                                 if (streq_ptr(done, "/"))
 805                                         *done = '\0';
 806
 807                                 if (!strextend(&done, first, todo, NULL))
 808                                         return -ENOMEM;
 809
 810                                 exists = false;
 811                                 break;
 812                         }
 813
 814                         return -errno;
 815                 }
 816
 817                 if (fstat(child, &st) < 0)
 818                         return -errno;
 819                 if ((flags & CHASE_SAFE) &&
 820                     !safe_transition(&previous_stat, &st))
 821                         return -EPERM;
 822
 823                 previous_stat = st;
 824
 825                 if ((flags & CHASE_NO_AUTOFS) &&
 826                     fd_is_fs_type(child, AUTOFS_SUPER_MAGIC) > 0)
 827                         return -EREMOTE;
 828
 829                 if (S_ISLNK(st.st_mode)) {
 830                         char *joined;
 831
 832                         _cleanup_free_ char *destination = NULL;
 833
 834                         /* This is a symlink, in this case read the destination. But let's make sure we don't follow
 835                          * symlinks without bounds. */
 836                         if (--max_follow <= 0)
 837                                 return -ELOOP;
 838
 839                         r = readlinkat_malloc(fd, first + n, &destination);
 840                         if (r < 0)
 841                                 return r;
 842                         if (isempty(destination))
 843                                 return -EINVAL;
 844
 845                         if (path_is_absolute(destination)) {
 846
 847                                 /* An absolute destination. Start the loop from the beginning, but use the root
 848                                  * directory as base. */
 849
 850                                 safe_close(fd);
 851                                 fd = open(root ?: "/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 852                                 if (fd < 0)
 853                                         return -errno;
 854
 855                                 free(done);
 856
 857                                 if (flags & CHASE_SAFE) {
 858                                         if (fstat(fd, &st) < 0)
 859                                                 return -errno;
 860
 861                                         if (!safe_transition(&previous_stat, &st))
 862                                                 return -EPERM;
 863
 864                                         previous_stat = st;
 865                                 }
 866
 867                                 /* Note that we do not revalidate the root, we take it as is. */
 868                                 if (isempty(root))
 869                                         done = NULL;
 870                                 else {
 871                                         done = strdup(root);
 872                                         if (!done)
 873                                                 return -ENOMEM;
 874                                 }
 875
 876                                 /* Prefix what's left to do with what we just read, and start the loop again, but
 877                                  * remain in the current directory. */
 878                                 joined = strjoin(destination, todo);
 879                         } else
 880                                 joined = strjoin("/", destination, todo);
 881                         if (!joined)
 882                                 return -ENOMEM;
 883
 884                         free(buffer);
 885                         todo = buffer = joined;
 886
 887                         continue;
 888                 }
 889
 890                 /* If this is not a symlink, then let's just add the name we read to what we already verified. */
 891                 if (!done) {
 892                         done = first;
 893                         first = NULL;
 894                 } else {
 895                         /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 896                         if (streq(done, "/"))
 897                                 *done = '\0';
 898
 899                         if (!strextend(&done, first, NULL))
 900                                 return -ENOMEM;
 901                 }
 902
 903                 /* And iterate again, but go one directory further down. */
 904                 safe_close(fd);
 905                 fd = child;
 906                 child = -1;
 907         }
 908
 909         if (!done) {
 910                 /* Special case, turn the empty string into "/", to indicate the root directory. */
 911                 done = strdup("/");
 912                 if (!done)
 913                         return -ENOMEM;
 914         }
 915
 916         if (ret) {
 917                 *ret = done;
 918                 done = NULL;
 919         }
 920
 921         if (flags & CHASE_OPEN) {
 922                 int q;
 923
 924                 /* Return the O_PATH fd we currently are looking to the caller. It can translate it to a proper fd by
 925                  * opening /proc/self/fd/xyz. */
 926
 927                 assert(fd >= 0);
 928                 q = fd;
 929                 fd = -1;
 930
 931                 return q;
 932         }
 933
 934         return exists;
 935 }
 936
 937 int access_fd(int fd, int mode) {
 938         char p[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(fd) + 1];
 939         int r;
 940
 941         /* Like access() but operates on an already open fd */
 942
 943         xsprintf(p, "/proc/self/fd/%i", fd);
 944
 945         r = access(p, mode);
 946         if (r < 0)
 947                 r = -errno;
 948
 949         return r;
 950 }