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 int chase_symlinks(const char *path, const char *original_root, unsigned flags, char **ret) {
 630         _cleanup_free_ char *buffer = NULL, *done = NULL, *root = NULL;
 631         _cleanup_close_ int fd = -1;
 632         unsigned max_follow = 32; /* how many symlinks to follow before giving up and returning ELOOP */
 633         bool exists = true;
 634         char *todo;
 635         int r;
 636
 637         assert(path);
 638
 639         /* This is a lot like canonicalize_file_name(), but takes an additional "root" parameter, that allows following
 640          * symlinks relative to a root directory, instead of the root of the host.
 641          *
 642          * Note that "root" primarily matters if we encounter an absolute symlink. It is also used when following
 643          * relative symlinks to ensure they cannot be used to "escape" the root directory. The path parameter passed is
 644          * assumed to be already prefixed by it, except if the CHASE_PREFIX_ROOT flag is set, in which case it is first
 645          * prefixed accordingly.
 646          *
 647          * Algorithmically this operates on two path buffers: "done" are the components of the path we already
 648          * processed and resolved symlinks, "." and ".." of. "todo" are the components of the path we still need to
 649          * process. On each iteration, we move one component from "todo" to "done", processing it's special meaning
 650          * each time. The "todo" path always starts with at least one slash, the "done" path always ends in no
 651          * slash. We always keep an O_PATH fd to the component we are currently processing, thus keeping lookup races
 652          * at a minimum.
 653          *
 654          * Suggested usage: whenever you want to canonicalize a path, use this function. Pass the absolute path you got
 655          * as-is: fully qualified and relative to your host's root. Optionally, specify the root parameter to tell this
 656          * function what to do when encountering a symlink with an absolute path as directory: prefix it by the
 657          * specified path. */
 658
 659         if (original_root) {
 660                 r = path_make_absolute_cwd(original_root, &root);
 661                 if (r < 0)
 662                         return r;
 663
 664                 if (flags & CHASE_PREFIX_ROOT)
 665                         path = prefix_roota(root, path);
 666         }
 667
 668         r = path_make_absolute_cwd(path, &buffer);
 669         if (r < 0)
 670                 return r;
 671
 672         fd = open("/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 673         if (fd < 0)
 674                 return -errno;
 675
 676         todo = buffer;
 677         for (;;) {
 678                 _cleanup_free_ char *first = NULL;
 679                 _cleanup_close_ int child = -1;
 680                 struct stat st;
 681                 size_t n, m;
 682
 683                 /* Determine length of first component in the path */
 684                 n = strspn(todo, "/");                  /* The slashes */
 685                 m = n + strcspn(todo + n, "/");         /* The entire length of the component */
 686
 687                 /* Extract the first component. */
 688                 first = strndup(todo, m);
 689                 if (!first)
 690                         return -ENOMEM;
 691
 692                 todo += m;
 693
 694                 /* Empty? Then we reached the end. */
 695                 if (isempty(first))
 696                         break;
 697
 698                 /* Just a single slash? Then we reached the end. */
 699                 if (path_equal(first, "/")) {
 700                         /* Preserve the trailing slash */
 701                         if (!strextend(&done, "/", NULL))
 702                                 return -ENOMEM;
 703
 704                         break;
 705                 }
 706
 707                 /* Just a dot? Then let's eat this up. */
 708                 if (path_equal(first, "/."))
 709                         continue;
 710
 711                 /* Two dots? Then chop off the last bit of what we already found out. */
 712                 if (path_equal(first, "/..")) {
 713                         _cleanup_free_ char *parent = NULL;
 714                         int fd_parent = -1;
 715
 716                         /* If we already are at the top, then going up will not change anything. This is in-line with
 717                          * how the kernel handles this. */
 718                         if (isempty(done) || path_equal(done, "/"))
 719                                 continue;
 720
 721                         parent = dirname_malloc(done);
 722                         if (!parent)
 723                                 return -ENOMEM;
 724
 725                         /* Don't allow this to leave the root dir.  */
 726                         if (root &&
 727                             path_startswith(done, root) &&
 728                             !path_startswith(parent, root))
 729                                 continue;
 730
 731                         free_and_replace(done, parent);
 732
 733                         fd_parent = openat(fd, "..", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 734                         if (fd_parent < 0)
 735                                 return -errno;
 736
 737                         safe_close(fd);
 738                         fd = fd_parent;
 739
 740                         continue;
 741                 }
 742
 743                 /* Otherwise let's see what this is. */
 744                 child = openat(fd, first + n, O_CLOEXEC|O_NOFOLLOW|O_PATH);
 745                 if (child < 0) {
 746
 747                         if (errno == ENOENT &&
 748                             (flags & CHASE_NONEXISTENT) &&
 749                             (isempty(todo) || path_is_normalized(todo))) {
 750
 751                                 /* If CHASE_NONEXISTENT is set, and the path does not exist, then that's OK, return
 752                                  * what we got so far. But don't allow this if the remaining path contains "../ or "./"
 753                                  * or something else weird. */
 754
 755                                 /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 756                                 if (streq_ptr(done, "/"))
 757                                         *done = '\0';
 758
 759                                 if (!strextend(&done, first, todo, NULL))
 760                                         return -ENOMEM;
 761
 762                                 exists = false;
 763                                 break;
 764                         }
 765
 766                         return -errno;
 767                 }
 768
 769                 if (fstat(child, &st) < 0)
 770                         return -errno;
 771                 if ((flags & CHASE_NO_AUTOFS) &&
 772                     fd_is_fs_type(child, AUTOFS_SUPER_MAGIC) > 0)
 773                         return -EREMOTE;
 774
 775                 if (S_ISLNK(st.st_mode)) {
 776                         char *joined;
 777
 778                         _cleanup_free_ char *destination = NULL;
 779
 780                         /* This is a symlink, in this case read the destination. But let's make sure we don't follow
 781                          * symlinks without bounds. */
 782                         if (--max_follow <= 0)
 783                                 return -ELOOP;
 784
 785                         r = readlinkat_malloc(fd, first + n, &destination);
 786                         if (r < 0)
 787                                 return r;
 788                         if (isempty(destination))
 789                                 return -EINVAL;
 790
 791                         if (path_is_absolute(destination)) {
 792
 793                                 /* An absolute destination. Start the loop from the beginning, but use the root
 794                                  * directory as base. */
 795
 796                                 safe_close(fd);
 797                                 fd = open(root ?: "/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 798                                 if (fd < 0)
 799                                         return -errno;
 800
 801                                 free(done);
 802
 803                                 /* Note that we do not revalidate the root, we take it as is. */
 804                                 if (isempty(root))
 805                                         done = NULL;
 806                                 else {
 807                                         done = strdup(root);
 808                                         if (!done)
 809                                                 return -ENOMEM;
 810                                 }
 811
 812                                 /* Prefix what's left to do with what we just read, and start the loop again, but
 813                                  * remain in the current directory. */
 814                                 joined = strjoin(destination, todo);
 815                         } else
 816                                 joined = strjoin("/", destination, todo);
 817                         if (!joined)
 818                                 return -ENOMEM;
 819
 820                         free(buffer);
 821                         todo = buffer = joined;
 822
 823                         continue;
 824                 }
 825
 826                 /* If this is not a symlink, then let's just add the name we read to what we already verified. */
 827                 if (!done) {
 828                         done = first;
 829                         first = NULL;
 830                 } else {
 831                         /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 832                         if (streq(done, "/"))
 833                                 *done = '\0';
 834
 835                         if (!strextend(&done, first, NULL))
 836                                 return -ENOMEM;
 837                 }
 838
 839                 /* And iterate again, but go one directory further down. */
 840                 safe_close(fd);
 841                 fd = child;
 842                 child = -1;
 843         }
 844
 845         if (!done) {
 846                 /* Special case, turn the empty string into "/", to indicate the root directory. */
 847                 done = strdup("/");
 848                 if (!done)
 849                         return -ENOMEM;
 850         }
 851
 852         if (ret) {
 853                 *ret = done;
 854                 done = NULL;
 855         }
 856
 857         return exists;
 858 }
 859
 860 int access_fd(int fd, int mode) {
 861         char p[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(fd) + 1];
 862         int r;
 863
 864         /* Like access() but operates on an already open fd */
 865
 866         xsprintf(p, "/proc/self/fd/%i", fd);
 867
 868         r = access(p, mode);
 869         if (r < 0)
 870                 r = -errno;
 871
 872         return r;
 873 }