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                         path = prefix_roota(root, path);
 693         }
 694
 695         r = path_make_absolute_cwd(path, &buffer);
 696         if (r < 0)
 697                 return r;
 698
 699         fd = open("/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 700         if (fd < 0)
 701                 return -errno;
 702
 703         if (flags & CHASE_SAFE) {
 704                 if (fstat(fd, &previous_stat) < 0)
 705                         return -errno;
 706         }
 707
 708         todo = buffer;
 709         for (;;) {
 710                 _cleanup_free_ char *first = NULL;
 711                 _cleanup_close_ int child = -1;
 712                 struct stat st;
 713                 size_t n, m;
 714
 715                 /* Determine length of first component in the path */
 716                 n = strspn(todo, "/");                  /* The slashes */
 717                 m = n + strcspn(todo + n, "/");         /* The entire length of the component */
 718
 719                 /* Extract the first component. */
 720                 first = strndup(todo, m);
 721                 if (!first)
 722                         return -ENOMEM;
 723
 724                 todo += m;
 725
 726                 /* Empty? Then we reached the end. */
 727                 if (isempty(first))
 728                         break;
 729
 730                 /* Just a single slash? Then we reached the end. */
 731                 if (path_equal(first, "/")) {
 732                         /* Preserve the trailing slash */
 733                         if (!strextend(&done, "/", NULL))
 734                                 return -ENOMEM;
 735
 736                         break;
 737                 }
 738
 739                 /* Just a dot? Then let's eat this up. */
 740                 if (path_equal(first, "/."))
 741                         continue;
 742
 743                 /* Two dots? Then chop off the last bit of what we already found out. */
 744                 if (path_equal(first, "/..")) {
 745                         _cleanup_free_ char *parent = NULL;
 746                         int fd_parent = -1;
 747
 748                         /* If we already are at the top, then going up will not change anything. This is in-line with
 749                          * how the kernel handles this. */
 750                         if (isempty(done) || path_equal(done, "/"))
 751                                 continue;
 752
 753                         parent = dirname_malloc(done);
 754                         if (!parent)
 755                                 return -ENOMEM;
 756
 757                         /* Don't allow this to leave the root dir.  */
 758                         if (root &&
 759                             path_startswith(done, root) &&
 760                             !path_startswith(parent, root))
 761                                 continue;
 762
 763                         free_and_replace(done, parent);
 764
 765                         fd_parent = openat(fd, "..", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 766                         if (fd_parent < 0)
 767                                 return -errno;
 768
 769                         if (flags & CHASE_SAFE) {
 770                                 if (fstat(fd_parent, &st) < 0)
 771                                         return -errno;
 772
 773                                 if (!safe_transition(&previous_stat, &st))
 774                                         return -EPERM;
 775
 776                                 previous_stat = st;
 777                         }
 778
 779                         safe_close(fd);
 780                         fd = fd_parent;
 781
 782                         continue;
 783                 }
 784
 785                 /* Otherwise let's see what this is. */
 786                 child = openat(fd, first + n, O_CLOEXEC|O_NOFOLLOW|O_PATH);
 787                 if (child < 0) {
 788
 789                         if (errno == ENOENT &&
 790                             (flags & CHASE_NONEXISTENT) &&
 791                             (isempty(todo) || path_is_normalized(todo))) {
 792
 793                                 /* If CHASE_NONEXISTENT is set, and the path does not exist, then that's OK, return
 794                                  * what we got so far. But don't allow this if the remaining path contains "../ or "./"
 795                                  * or something else weird. */
 796
 797                                 /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 798                                 if (streq_ptr(done, "/"))
 799                                         *done = '\0';
 800
 801                                 if (!strextend(&done, first, todo, NULL))
 802                                         return -ENOMEM;
 803
 804                                 exists = false;
 805                                 break;
 806                         }
 807
 808                         return -errno;
 809                 }
 810
 811                 if (fstat(child, &st) < 0)
 812                         return -errno;
 813                 if ((flags & CHASE_SAFE) &&
 814                     !safe_transition(&previous_stat, &st))
 815                         return -EPERM;
 816
 817                 previous_stat = st;
 818
 819                 if ((flags & CHASE_NO_AUTOFS) &&
 820                     fd_is_fs_type(child, AUTOFS_SUPER_MAGIC) > 0)
 821                         return -EREMOTE;
 822
 823                 if (S_ISLNK(st.st_mode)) {
 824                         char *joined;
 825
 826                         _cleanup_free_ char *destination = NULL;
 827
 828                         /* This is a symlink, in this case read the destination. But let's make sure we don't follow
 829                          * symlinks without bounds. */
 830                         if (--max_follow <= 0)
 831                                 return -ELOOP;
 832
 833                         r = readlinkat_malloc(fd, first + n, &destination);
 834                         if (r < 0)
 835                                 return r;
 836                         if (isempty(destination))
 837                                 return -EINVAL;
 838
 839                         if (path_is_absolute(destination)) {
 840
 841                                 /* An absolute destination. Start the loop from the beginning, but use the root
 842                                  * directory as base. */
 843
 844                                 safe_close(fd);
 845                                 fd = open(root ?: "/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 846                                 if (fd < 0)
 847                                         return -errno;
 848
 849                                 free(done);
 850
 851                                 if (flags & CHASE_SAFE) {
 852                                         if (fstat(fd, &st) < 0)
 853                                                 return -errno;
 854
 855                                         if (!safe_transition(&previous_stat, &st))
 856                                                 return -EPERM;
 857
 858                                         previous_stat = st;
 859                                 }
 860
 861                                 /* Note that we do not revalidate the root, we take it as is. */
 862                                 if (isempty(root))
 863                                         done = NULL;
 864                                 else {
 865                                         done = strdup(root);
 866                                         if (!done)
 867                                                 return -ENOMEM;
 868                                 }
 869
 870                                 /* Prefix what's left to do with what we just read, and start the loop again, but
 871                                  * remain in the current directory. */
 872                                 joined = strjoin(destination, todo);
 873                         } else
 874                                 joined = strjoin("/", destination, todo);
 875                         if (!joined)
 876                                 return -ENOMEM;
 877
 878                         free(buffer);
 879                         todo = buffer = joined;
 880
 881                         continue;
 882                 }
 883
 884                 /* If this is not a symlink, then let's just add the name we read to what we already verified. */
 885                 if (!done) {
 886                         done = first;
 887                         first = NULL;
 888                 } else {
 889                         /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 890                         if (streq(done, "/"))
 891                                 *done = '\0';
 892
 893                         if (!strextend(&done, first, NULL))
 894                                 return -ENOMEM;
 895                 }
 896
 897                 /* And iterate again, but go one directory further down. */
 898                 safe_close(fd);
 899                 fd = child;
 900                 child = -1;
 901         }
 902
 903         if (!done) {
 904                 /* Special case, turn the empty string into "/", to indicate the root directory. */
 905                 done = strdup("/");
 906                 if (!done)
 907                         return -ENOMEM;
 908         }
 909
 910         if (ret) {
 911                 *ret = done;
 912                 done = NULL;
 913         }
 914
 915         if (flags & CHASE_OPEN) {
 916                 int q;
 917
 918                 /* Return the O_PATH fd we currently are looking to the caller. It can translate it to a proper fd by
 919                  * opening /proc/self/fd/xyz. */
 920
 921                 assert(fd >= 0);
 922                 q = fd;
 923                 fd = -1;
 924
 925                 return q;
 926         }
 927
 928         return exists;
 929 }
 930
 931 int access_fd(int fd, int mode) {
 932         char p[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(fd) + 1];
 933         int r;
 934
 935         /* Like access() but operates on an already open fd */
 936
 937         xsprintf(p, "/proc/self/fd/%i", fd);
 938
 939         r = access(p, mode);
 940         if (r < 0)
 941                 r = -errno;
 942
 943         return r;
 944 }