src/basic/fs-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright 2010 Lennart Poettering
   4 ***/
   5
   6 #include <errno.h>
   7 #include <stddef.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <sys/stat.h>
  12 #include <linux/magic.h>
  13 #include <time.h>
  14 #include <unistd.h>
  15
  16 #include "alloc-util.h"
  17 #include "dirent-util.h"
  18 #include "fd-util.h"
  19 #include "fileio.h"
  20 #include "fs-util.h"
  21 //#include "log.h"
  22 //#include "macro.h"
  23 //#include "missing.h"
  24 #include "mkdir.h"
  25 #include "parse-util.h"
  26 #include "path-util.h"
  27 //#include "process-util.h"
  28 #include "stat-util.h"
  29 #include "stdio-util.h"
  30 #include "string-util.h"
  31 #include "strv.h"
  32 //#include "time-util.h"
  33 #include "user-util.h"
  34 #include "util.h"
  35
  36 /// Additional includes needed by elogind
  37 #include "process-util.h"
  38
  39 int unlink_noerrno(const char *path) {
  40         PROTECT_ERRNO;
  41         int r;
  42
  43         r = unlink(path);
  44         if (r < 0)
  45                 return -errno;
  46
  47         return 0;
  48 }
  49
  50 #if 0 /// UNNEEDED by elogind
  51 int rmdir_parents(const char *path, const char *stop) {
  52         size_t l;
  53         int r = 0;
  54
  55         assert(path);
  56         assert(stop);
  57
  58         l = strlen(path);
  59
  60         /* Skip trailing slashes */
  61         while (l > 0 && path[l-1] == '/')
  62                 l--;
  63
  64         while (l > 0) {
  65                 char *t;
  66
  67                 /* Skip last component */
  68                 while (l > 0 && path[l-1] != '/')
  69                         l--;
  70
  71                 /* Skip trailing slashes */
  72                 while (l > 0 && path[l-1] == '/')
  73                         l--;
  74
  75                 if (l <= 0)
  76                         break;
  77
  78                 t = strndup(path, l);
  79                 if (!t)
  80                         return -ENOMEM;
  81
  82                 if (path_startswith(stop, t)) {
  83                         free(t);
  84                         return 0;
  85                 }
  86
  87                 r = rmdir(t);
  88                 free(t);
  89
  90                 if (r < 0)
  91                         if (errno != ENOENT)
  92                                 return -errno;
  93         }
  94
  95         return 0;
  96 }
  97
  98 int rename_noreplace(int olddirfd, const char *oldpath, int newdirfd, const char *newpath) {
  99         struct stat buf;
 100         int ret;
 101
 102         ret = renameat2(olddirfd, oldpath, newdirfd, newpath, RENAME_NOREPLACE);
 103         if (ret >= 0)
 104                 return 0;
 105
 106         /* renameat2() exists since Linux 3.15, btrfs added support for it later.
 107          * If it is not implemented, fallback to another method. */
 108         if (!IN_SET(errno, EINVAL, ENOSYS))
 109                 return -errno;
 110
 111         /* The link()/unlink() fallback does not work on directories. But
 112          * renameat() without RENAME_NOREPLACE gives the same semantics on
 113          * directories, except when newpath is an *empty* directory. This is
 114          * good enough. */
 115         ret = fstatat(olddirfd, oldpath, &buf, AT_SYMLINK_NOFOLLOW);
 116         if (ret >= 0 && S_ISDIR(buf.st_mode)) {
 117                 ret = renameat(olddirfd, oldpath, newdirfd, newpath);
 118                 return ret >= 0 ? 0 : -errno;
 119         }
 120
 121         /* If it is not a directory, use the link()/unlink() fallback. */
 122         ret = linkat(olddirfd, oldpath, newdirfd, newpath, 0);
 123         if (ret < 0)
 124                 return -errno;
 125
 126         ret = unlinkat(olddirfd, oldpath, 0);
 127         if (ret < 0) {
 128                 /* backup errno before the following unlinkat() alters it */
 129                 ret = errno;
 130                 (void) unlinkat(newdirfd, newpath, 0);
 131                 errno = ret;
 132                 return -errno;
 133         }
 134
 135         return 0;
 136 }
 137 #endif // 0
 138
 139 int readlinkat_malloc(int fd, const char *p, char **ret) {
 140         size_t l = 100;
 141         int r;
 142
 143         assert(p);
 144         assert(ret);
 145
 146         for (;;) {
 147                 char *c;
 148                 ssize_t n;
 149
 150                 c = new(char, l);
 151                 if (!c)
 152                         return -ENOMEM;
 153
 154                 n = readlinkat(fd, p, c, l-1);
 155                 if (n < 0) {
 156                         r = -errno;
 157                         free(c);
 158                         return r;
 159                 }
 160
 161                 if ((size_t) n < l-1) {
 162                         c[n] = 0;
 163                         *ret = c;
 164                         return 0;
 165                 }
 166
 167                 free(c);
 168                 l *= 2;
 169         }
 170 }
 171
 172 int readlink_malloc(const char *p, char **ret) {
 173         return readlinkat_malloc(AT_FDCWD, p, ret);
 174 }
 175
 176 #if 0 /// UNNEEDED by elogind
 177 int readlink_value(const char *p, char **ret) {
 178         _cleanup_free_ char *link = NULL;
 179         char *value;
 180         int r;
 181
 182         r = readlink_malloc(p, &link);
 183         if (r < 0)
 184                 return r;
 185
 186         value = basename(link);
 187         if (!value)
 188                 return -ENOENT;
 189
 190         value = strdup(value);
 191         if (!value)
 192                 return -ENOMEM;
 193
 194         *ret = value;
 195
 196         return 0;
 197 }
 198 #endif // 0
 199
 200 int readlink_and_make_absolute(const char *p, char **r) {
 201         _cleanup_free_ char *target = NULL;
 202         char *k;
 203         int j;
 204
 205         assert(p);
 206         assert(r);
 207
 208         j = readlink_malloc(p, &target);
 209         if (j < 0)
 210                 return j;
 211
 212         k = file_in_same_dir(p, target);
 213         if (!k)
 214                 return -ENOMEM;
 215
 216         *r = k;
 217         return 0;
 218 }
 219
 220 #if 0 /// UNNEEDED by elogind
 221 #endif // 0
 222 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
 223         assert(path);
 224
 225         /* Under the assumption that we are running privileged we
 226          * first change the access mode and only then hand out
 227          * ownership to avoid a window where access is too open. */
 228
 229         if (mode != MODE_INVALID)
 230                 if (chmod(path, mode) < 0)
 231                         return -errno;
 232
 233         if (uid != UID_INVALID || gid != GID_INVALID)
 234                 if (chown(path, uid, gid) < 0)
 235                         return -errno;
 236
 237         return 0;
 238 }
 239
 240 int fchmod_umask(int fd, mode_t m) {
 241         mode_t u;
 242         int r;
 243
 244         u = umask(0777);
 245         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 246         umask(u);
 247
 248         return r;
 249 }
 250
 251 int fchmod_opath(int fd, mode_t m) {
 252         char procfs_path[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
 253
 254         /* This function operates also on fd that might have been opened with
 255          * O_PATH. Indeed fchmodat() doesn't have the AT_EMPTY_PATH flag like
 256          * fchownat() does. */
 257
 258         xsprintf(procfs_path, "/proc/self/fd/%i", fd);
 259
 260         if (chmod(procfs_path, m) < 0)
 261                 return -errno;
 262
 263         return 0;
 264 }
 265
 266 int fd_warn_permissions(const char *path, int fd) {
 267         struct stat st;
 268
 269         if (fstat(fd, &st) < 0)
 270                 return -errno;
 271
 272         if (st.st_mode & 0111)
 273                 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
 274
 275         if (st.st_mode & 0002)
 276                 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
 277
 278         if (getpid_cached() == 1 && (st.st_mode & 0044) != 0044)
 279                 log_warning("Configuration file %s is marked world-inaccessible. This has no effect as configuration data is accessible via APIs without restrictions. Proceeding anyway.", path);
 280
 281         return 0;
 282 }
 283
 284 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
 285         char fdpath[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
 286         _cleanup_close_ int fd = -1;
 287         int r, ret = 0;
 288
 289         assert(path);
 290
 291         /* Note that touch_file() does not follow symlinks: if invoked on an existing symlink, then it is the symlink
 292          * itself which is updated, not its target
 293          *
 294          * Returns the first error we encounter, but tries to apply as much as possible. */
 295
 296         if (parents)
 297                 (void) mkdir_parents(path, 0755);
 298
 299         /* Initially, we try to open the node with O_PATH, so that we get a reference to the node. This is useful in
 300          * case the path refers to an existing device or socket node, as we can open it successfully in all cases, and
 301          * won't trigger any driver magic or so. */
 302         fd = open(path, O_PATH|O_CLOEXEC|O_NOFOLLOW);
 303         if (fd < 0) {
 304                 if (errno != ENOENT)
 305                         return -errno;
 306
 307                 /* if the node doesn't exist yet, we create it, but with O_EXCL, so that we only create a regular file
 308                  * here, and nothing else */
 309                 fd = open(path, O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC, IN_SET(mode, 0, MODE_INVALID) ? 0644 : mode);
 310                 if (fd < 0)
 311                         return -errno;
 312         }
 313
 314         /* Let's make a path from the fd, and operate on that. With this logic, we can adjust the access mode,
 315          * ownership and time of the file node in all cases, even if the fd refers to an O_PATH object — which is
 316          * something fchown(), fchmod(), futimensat() don't allow. */
 317         xsprintf(fdpath, "/proc/self/fd/%i", fd);
 318
 319         if (mode != MODE_INVALID)
 320                 if (chmod(fdpath, mode) < 0)
 321                         ret = -errno;
 322
 323         if (uid_is_valid(uid) || gid_is_valid(gid))
 324                 if (chown(fdpath, uid, gid) < 0 && ret >= 0)
 325                         ret = -errno;
 326
 327         if (stamp != USEC_INFINITY) {
 328                 struct timespec ts[2];
 329
 330                 timespec_store(&ts[0], stamp);
 331                 ts[1] = ts[0];
 332                 r = utimensat(AT_FDCWD, fdpath, ts, 0);
 333         } else
 334                 r = utimensat(AT_FDCWD, fdpath, NULL, 0);
 335         if (r < 0 && ret >= 0)
 336                 return -errno;
 337
 338         return ret;
 339 }
 340
 341 int touch(const char *path) {
 342         return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, MODE_INVALID);
 343 }
 344
 345 #if 0 /// UNNEEDED by elogind
 346 int symlink_idempotent(const char *from, const char *to) {
 347         int r;
 348
 349         assert(from);
 350         assert(to);
 351
 352         if (symlink(from, to) < 0) {
 353                 _cleanup_free_ char *p = NULL;
 354
 355                 if (errno != EEXIST)
 356                         return -errno;
 357
 358                 r = readlink_malloc(to, &p);
 359                 if (r == -EINVAL) /* Not a symlink? In that case return the original error we encountered: -EEXIST */
 360                         return -EEXIST;
 361                 if (r < 0) /* Any other error? In that case propagate it as is */
 362                         return r;
 363
 364                 if (!streq(p, from)) /* Not the symlink we want it to be? In that case, propagate the original -EEXIST */
 365                         return -EEXIST;
 366         }
 367
 368         return 0;
 369 }
 370
 371 int symlink_atomic(const char *from, const char *to) {
 372         _cleanup_free_ char *t = NULL;
 373         int r;
 374
 375         assert(from);
 376         assert(to);
 377
 378         r = tempfn_random(to, NULL, &t);
 379         if (r < 0)
 380                 return r;
 381
 382         if (symlink(from, t) < 0)
 383                 return -errno;
 384
 385         if (rename(t, to) < 0) {
 386                 unlink_noerrno(t);
 387                 return -errno;
 388         }
 389
 390         return 0;
 391 }
 392
 393 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
 394         _cleanup_free_ char *t = NULL;
 395         int r;
 396
 397         assert(path);
 398
 399         r = tempfn_random(path, NULL, &t);
 400         if (r < 0)
 401                 return r;
 402
 403         if (mknod(t, mode, dev) < 0)
 404                 return -errno;
 405
 406         if (rename(t, path) < 0) {
 407                 unlink_noerrno(t);
 408                 return -errno;
 409         }
 410
 411         return 0;
 412 }
 413
 414 int mkfifo_atomic(const char *path, mode_t mode) {
 415         _cleanup_free_ char *t = NULL;
 416         int r;
 417
 418         assert(path);
 419
 420         r = tempfn_random(path, NULL, &t);
 421         if (r < 0)
 422                 return r;
 423
 424         if (mkfifo(t, mode) < 0)
 425                 return -errno;
 426
 427         if (rename(t, path) < 0) {
 428                 unlink_noerrno(t);
 429                 return -errno;
 430         }
 431
 432         return 0;
 433 }
 434 #endif // 0
 435
 436 int get_files_in_directory(const char *path, char ***list) {
 437         _cleanup_closedir_ DIR *d = NULL;
 438         struct dirent *de;
 439         size_t bufsize = 0, n = 0;
 440         _cleanup_strv_free_ char **l = NULL;
 441
 442         assert(path);
 443
 444         /* Returns all files in a directory in *list, and the number
 445          * of files as return value. If list is NULL returns only the
 446          * number. */
 447
 448         d = opendir(path);
 449         if (!d)
 450                 return -errno;
 451
 452         FOREACH_DIRENT_ALL(de, d, return -errno) {
 453                 dirent_ensure_type(d, de);
 454
 455                 if (!dirent_is_file(de))
 456                         continue;
 457
 458                 if (list) {
 459                         /* one extra slot is needed for the terminating NULL */
 460                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
 461                                 return -ENOMEM;
 462
 463                         l[n] = strdup(de->d_name);
 464                         if (!l[n])
 465                                 return -ENOMEM;
 466
 467                         l[++n] = NULL;
 468                 } else
 469                         n++;
 470         }
 471
 472         if (list)
 473                 *list = TAKE_PTR(l);
 474
 475         return n;
 476 }
 477
 478 static int getenv_tmp_dir(const char **ret_path) {
 479         const char *n;
 480         int r, ret = 0;
 481
 482         assert(ret_path);
 483
 484         /* We use the same order of environment variables python uses in tempfile.gettempdir():
 485          * https://docs.python.org/3/library/tempfile.html#tempfile.gettempdir */
 486         FOREACH_STRING(n, "TMPDIR", "TEMP", "TMP") {
 487                 const char *e;
 488
 489                 e = secure_getenv(n);
 490                 if (!e)
 491                         continue;
 492                 if (!path_is_absolute(e)) {
 493                         r = -ENOTDIR;
 494                         goto next;
 495                 }
 496                 if (!path_is_normalized(e)) {
 497                         r = -EPERM;
 498                         goto next;
 499                 }
 500
 501                 r = is_dir(e, true);
 502                 if (r < 0)
 503                         goto next;
 504                 if (r == 0) {
 505                         r = -ENOTDIR;
 506                         goto next;
 507                 }
 508
 509                 *ret_path = e;
 510                 return 1;
 511
 512         next:
 513                 /* Remember first error, to make this more debuggable */
 514                 if (ret >= 0)
 515                         ret = r;
 516         }
 517
 518         if (ret < 0)
 519                 return ret;
 520
 521         *ret_path = NULL;
 522         return ret;
 523 }
 524
 525 static int tmp_dir_internal(const char *def, const char **ret) {
 526         const char *e;
 527         int r, k;
 528
 529         assert(def);
 530         assert(ret);
 531
 532         r = getenv_tmp_dir(&e);
 533         if (r > 0) {
 534                 *ret = e;
 535                 return 0;
 536         }
 537
 538         k = is_dir(def, true);
 539         if (k == 0)
 540                 k = -ENOTDIR;
 541         if (k < 0)
 542                 return r < 0 ? r : k;
 543
 544         *ret = def;
 545         return 0;
 546 }
 547
 548 #if 0 /// UNNEEDED by elogind
 549 int var_tmp_dir(const char **ret) {
 550
 551         /* Returns the location for "larger" temporary files, that is backed by physical storage if available, and thus
 552          * even might survive a boot: /var/tmp. If $TMPDIR (or related environment variables) are set, its value is
 553          * returned preferably however. Note that both this function and tmp_dir() below are affected by $TMPDIR,
 554          * making it a variable that overrides all temporary file storage locations. */
 555
 556         return tmp_dir_internal("/var/tmp", ret);
 557 }
 558 #endif // 0
 559
 560 int tmp_dir(const char **ret) {
 561
 562         /* Similar to var_tmp_dir() above, but returns the location for "smaller" temporary files, which is usually
 563          * backed by an in-memory file system: /tmp. */
 564
 565         return tmp_dir_internal("/tmp", ret);
 566 }
 567
 568 int unlink_or_warn(const char *filename) {
 569         if (unlink(filename) < 0 && errno != ENOENT)
 570                 /* If the file doesn't exist and the fs simply was read-only (in which
 571                  * case unlink() returns EROFS even if the file doesn't exist), don't
 572                  * complain */
 573                 if (errno != EROFS || access(filename, F_OK) >= 0)
 574                         return log_error_errno(errno, "Failed to remove \"%s\": %m", filename);
 575
 576         return 0;
 577 }
 578
 579 #if 0 /// UNNEEDED by elogind
 580 int inotify_add_watch_fd(int fd, int what, uint32_t mask) {
 581         char path[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int) + 1];
 582         int r;
 583
 584         /* This is like inotify_add_watch(), except that the file to watch is not referenced by a path, but by an fd */
 585         xsprintf(path, "/proc/self/fd/%i", what);
 586
 587         r = inotify_add_watch(fd, path, mask);
 588         if (r < 0)
 589                 return -errno;
 590
 591         return r;
 592 }
 593 #endif // 0
 594
 595 static bool safe_transition(const struct stat *a, const struct stat *b) {
 596         /* Returns true if the transition from a to b is safe, i.e. that we never transition from unprivileged to
 597          * privileged files or directories. Why bother? So that unprivileged code can't symlink to privileged files
 598          * making us believe we read something safe even though it isn't safe in the specific context we open it in. */
 599
 600         if (a->st_uid == 0) /* Transitioning from privileged to unprivileged is always fine */
 601                 return true;
 602
 603         return a->st_uid == b->st_uid; /* Otherwise we need to stay within the same UID */
 604 }
 605
 606 int chase_symlinks(const char *path, const char *original_root, unsigned flags, char **ret) {
 607         _cleanup_free_ char *buffer = NULL, *done = NULL, *root = NULL;
 608         _cleanup_close_ int fd = -1;
 609         unsigned max_follow = CHASE_SYMLINKS_MAX; /* how many symlinks to follow before giving up and returning ELOOP */
 610         struct stat previous_stat;
 611         bool exists = true;
 612         char *todo;
 613         int r;
 614
 615         assert(path);
 616
 617         /* Either the file may be missing, or we return an fd to the final object, but both make no sense */
 618         if (FLAGS_SET(flags, CHASE_NONEXISTENT | CHASE_OPEN))
 619                 return -EINVAL;
 620
 621         if (FLAGS_SET(flags, CHASE_STEP | CHASE_OPEN))
 622                 return -EINVAL;
 623
 624         if (isempty(path))
 625                 return -EINVAL;
 626
 627         /* This is a lot like canonicalize_file_name(), but takes an additional "root" parameter, that allows following
 628          * symlinks relative to a root directory, instead of the root of the host.
 629          *
 630          * Note that "root" primarily matters if we encounter an absolute symlink. It is also used when following
 631          * relative symlinks to ensure they cannot be used to "escape" the root directory. The path parameter passed is
 632          * assumed to be already prefixed by it, except if the CHASE_PREFIX_ROOT flag is set, in which case it is first
 633          * prefixed accordingly.
 634          *
 635          * Algorithmically this operates on two path buffers: "done" are the components of the path we already
 636          * processed and resolved symlinks, "." and ".." of. "todo" are the components of the path we still need to
 637          * process. On each iteration, we move one component from "todo" to "done", processing it's special meaning
 638          * each time. The "todo" path always starts with at least one slash, the "done" path always ends in no
 639          * slash. We always keep an O_PATH fd to the component we are currently processing, thus keeping lookup races
 640          * at a minimum.
 641          *
 642          * Suggested usage: whenever you want to canonicalize a path, use this function. Pass the absolute path you got
 643          * as-is: fully qualified and relative to your host's root. Optionally, specify the root parameter to tell this
 644          * function what to do when encountering a symlink with an absolute path as directory: prefix it by the
 645          * specified path.
 646          *
 647          * There are three ways to invoke this function:
 648          *
 649          * 1. Without CHASE_STEP or CHASE_OPEN: in this case the path is resolved and the normalized path is returned
 650          *    in `ret`. The return value is < 0 on error. If CHASE_NONEXISTENT is also set 0 is returned if the file
 651          *    doesn't exist, > 0 otherwise. If CHASE_NONEXISTENT is not set >= 0 is returned if the destination was
 652          *    found, -ENOENT if it doesn't.
 653          *
 654          * 2. With CHASE_OPEN: in this case the destination is opened after chasing it as O_PATH and this file
 655          *    descriptor is returned as return value. This is useful to open files relative to some root
 656          *    directory. Note that the returned O_PATH file descriptors must be converted into a regular one (using
 657          *    fd_reopen() or such) before it can be used for reading/writing. CHASE_OPEN may not be combined with
 658          *    CHASE_NONEXISTENT.
 659          *
 660          * 3. With CHASE_STEP: in this case only a single step of the normalization is executed, i.e. only the first
 661          *    symlink or ".." component of the path is resolved, and the resulting path is returned. This is useful if
 662          *    a caller wants to trace the a path through the file system verbosely. Returns < 0 on error, > 0 if the
 663          *    path is fully normalized, and == 0 for each normalization step. This may be combined with
 664          *    CHASE_NONEXISTENT, in which case 1 is returned when a component is not found.
 665          *
 666          * */
 667
 668         /* A root directory of "/" or "" is identical to none */
 669         if (empty_or_root(original_root))
 670                 original_root = NULL;
 671
 672         if (!original_root && !ret && (flags & (CHASE_NONEXISTENT|CHASE_NO_AUTOFS|CHASE_SAFE|CHASE_OPEN|CHASE_STEP)) == CHASE_OPEN) {
 673                 /* Shortcut the CHASE_OPEN case if the caller isn't interested in the actual path and has no root set
 674                  * and doesn't care about any of the other special features we provide either. */
 675                 r = open(path, O_PATH|O_CLOEXEC);
 676                 if (r < 0)
 677                         return -errno;
 678
 679                 return r;
 680         }
 681
 682         if (original_root) {
 683                 r = path_make_absolute_cwd(original_root, &root);
 684                 if (r < 0)
 685                         return r;
 686
 687                 if (flags & CHASE_PREFIX_ROOT) {
 688
 689                         /* We don't support relative paths in combination with a root directory */
 690                         if (!path_is_absolute(path))
 691                                 return -EINVAL;
 692
 693                         path = prefix_roota(root, path);
 694                 }
 695         }
 696
 697         r = path_make_absolute_cwd(path, &buffer);
 698         if (r < 0)
 699                 return r;
 700
 701         fd = open("/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 702         if (fd < 0)
 703                 return -errno;
 704
 705         if (flags & CHASE_SAFE) {
 706                 if (fstat(fd, &previous_stat) < 0)
 707                         return -errno;
 708         }
 709
 710         todo = buffer;
 711         for (;;) {
 712                 _cleanup_free_ char *first = NULL;
 713                 _cleanup_close_ int child = -1;
 714                 struct stat st;
 715                 size_t n, m;
 716
 717                 /* Determine length of first component in the path */
 718                 n = strspn(todo, "/");                  /* The slashes */
 719                 m = n + strcspn(todo + n, "/");         /* The entire length of the component */
 720
 721                 /* Extract the first component. */
 722                 first = strndup(todo, m);
 723                 if (!first)
 724                         return -ENOMEM;
 725
 726                 todo += m;
 727
 728                 /* Empty? Then we reached the end. */
 729                 if (isempty(first))
 730                         break;
 731
 732                 /* Just a single slash? Then we reached the end. */
 733                 if (path_equal(first, "/")) {
 734                         /* Preserve the trailing slash */
 735
 736                         if (flags & CHASE_TRAIL_SLASH)
 737                                 if (!strextend(&done, "/", NULL))
 738                                         return -ENOMEM;
 739
 740                         break;
 741                 }
 742
 743                 /* Just a dot? Then let's eat this up. */
 744                 if (path_equal(first, "/."))
 745                         continue;
 746
 747                 /* Two dots? Then chop off the last bit of what we already found out. */
 748                 if (path_equal(first, "/..")) {
 749                         _cleanup_free_ char *parent = NULL;
 750                         _cleanup_close_ int fd_parent = -1;
 751
 752                         /* If we already are at the top, then going up will not change anything. This is in-line with
 753                          * how the kernel handles this. */
 754                         if (empty_or_root(done))
 755                                 continue;
 756
 757                         parent = dirname_malloc(done);
 758                         if (!parent)
 759                                 return -ENOMEM;
 760
 761                         /* Don't allow this to leave the root dir.  */
 762                         if (root &&
 763                             path_startswith(done, root) &&
 764                             !path_startswith(parent, root))
 765                                 continue;
 766
 767                         free_and_replace(done, parent);
 768
 769                         if (flags & CHASE_STEP)
 770                                 goto chased_one;
 771
 772                         fd_parent = openat(fd, "..", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 773                         if (fd_parent < 0)
 774                                 return -errno;
 775
 776                         if (flags & CHASE_SAFE) {
 777                                 if (fstat(fd_parent, &st) < 0)
 778                                         return -errno;
 779
 780                                 if (!safe_transition(&previous_stat, &st))
 781                                         return -EPERM;
 782
 783                                 previous_stat = st;
 784                         }
 785
 786                         safe_close(fd);
 787                         fd = TAKE_FD(fd_parent);
 788
 789                         continue;
 790                 }
 791
 792                 /* Otherwise let's see what this is. */
 793                 child = openat(fd, first + n, O_CLOEXEC|O_NOFOLLOW|O_PATH);
 794                 if (child < 0) {
 795
 796                         if (errno == ENOENT &&
 797                             (flags & CHASE_NONEXISTENT) &&
 798                             (isempty(todo) || path_is_normalized(todo))) {
 799
 800                                 /* If CHASE_NONEXISTENT is set, and the path does not exist, then that's OK, return
 801                                  * what we got so far. But don't allow this if the remaining path contains "../ or "./"
 802                                  * or something else weird. */
 803
 804                                 /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 805                                 if (streq_ptr(done, "/"))
 806                                         *done = '\0';
 807
 808                                 if (!strextend(&done, first, todo, NULL))
 809                                         return -ENOMEM;
 810
 811                                 exists = false;
 812                                 break;
 813                         }
 814
 815                         return -errno;
 816                 }
 817
 818                 if (fstat(child, &st) < 0)
 819                         return -errno;
 820                 if ((flags & CHASE_SAFE) &&
 821                     !safe_transition(&previous_stat, &st))
 822                         return -EPERM;
 823
 824                 previous_stat = st;
 825
 826                 if ((flags & CHASE_NO_AUTOFS) &&
 827                     fd_is_fs_type(child, AUTOFS_SUPER_MAGIC) > 0)
 828                         return -EREMOTE;
 829
 830                 if (S_ISLNK(st.st_mode)) {
 831                         char *joined;
 832
 833                         _cleanup_free_ char *destination = NULL;
 834
 835                         /* This is a symlink, in this case read the destination. But let's make sure we don't follow
 836                          * symlinks without bounds. */
 837                         if (--max_follow <= 0)
 838                                 return -ELOOP;
 839
 840                         r = readlinkat_malloc(fd, first + n, &destination);
 841                         if (r < 0)
 842                                 return r;
 843                         if (isempty(destination))
 844                                 return -EINVAL;
 845
 846                         if (path_is_absolute(destination)) {
 847
 848                                 /* An absolute destination. Start the loop from the beginning, but use the root
 849                                  * directory as base. */
 850
 851                                 safe_close(fd);
 852                                 fd = open(root ?: "/", O_CLOEXEC|O_NOFOLLOW|O_PATH);
 853                                 if (fd < 0)
 854                                         return -errno;
 855
 856                                 if (flags & CHASE_SAFE) {
 857                                         if (fstat(fd, &st) < 0)
 858                                                 return -errno;
 859
 860                                         if (!safe_transition(&previous_stat, &st))
 861                                                 return -EPERM;
 862
 863                                         previous_stat = st;
 864                                 }
 865
 866                                 free(done);
 867
 868                                 /* Note that we do not revalidate the root, we take it as is. */
 869                                 if (isempty(root))
 870                                         done = NULL;
 871                                 else {
 872                                         done = strdup(root);
 873                                         if (!done)
 874                                                 return -ENOMEM;
 875                                 }
 876
 877                                 /* Prefix what's left to do with what we just read, and start the loop again, but
 878                                  * remain in the current directory. */
 879                                 joined = strjoin(destination, todo);
 880                         } else
 881                                 joined = strjoin("/", destination, todo);
 882                         if (!joined)
 883                                 return -ENOMEM;
 884
 885                         free(buffer);
 886                         todo = buffer = joined;
 887
 888                         if (flags & CHASE_STEP)
 889                                 goto chased_one;
 890
 891                         continue;
 892                 }
 893
 894                 /* If this is not a symlink, then let's just add the name we read to what we already verified. */
 895                 if (!done)
 896                         done = TAKE_PTR(first);
 897                 else {
 898                         /* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
 899                         if (streq(done, "/"))
 900                                 *done = '\0';
 901
 902                         if (!strextend(&done, first, NULL))
 903                                 return -ENOMEM;
 904                 }
 905
 906                 /* And iterate again, but go one directory further down. */
 907                 safe_close(fd);
 908                 fd = TAKE_FD(child);
 909         }
 910
 911         if (!done) {
 912                 /* Special case, turn the empty string into "/", to indicate the root directory. */
 913                 done = strdup("/");
 914                 if (!done)
 915                         return -ENOMEM;
 916         }
 917
 918         if (ret)
 919                 *ret = TAKE_PTR(done);
 920
 921         if (flags & CHASE_OPEN) {
 922                 /* Return the O_PATH fd we currently are looking to the caller. It can translate it to a proper fd by
 923                  * opening /proc/self/fd/xyz. */
 924
 925                 assert(fd >= 0);
 926                 return TAKE_FD(fd);
 927         }
 928
 929         if (flags & CHASE_STEP)
 930                 return 1;
 931
 932         return exists;
 933
 934 chased_one:
 935         if (ret) {
 936                 char *c;
 937
 938                 c = strjoin(strempty(done), todo);
 939                 if (!c)
 940                         return -ENOMEM;
 941
 942                 *ret = c;
 943         }
 944
 945         return 0;
 946 }
 947
 948 int chase_symlinks_and_open(
 949                 const char *path,
 950                 const char *root,
 951                 unsigned chase_flags,
 952                 int open_flags,
 953                 char **ret_path) {
 954
 955         _cleanup_close_ int path_fd = -1;
 956         _cleanup_free_ char *p = NULL;
 957         int r;
 958
 959         if (chase_flags & CHASE_NONEXISTENT)
 960                 return -EINVAL;
 961
 962         if (empty_or_root(root) && !ret_path && (chase_flags & (CHASE_NO_AUTOFS|CHASE_SAFE)) == 0) {
 963                 /* Shortcut this call if none of the special features of this call are requested */
 964                 r = open(path, open_flags);
 965                 if (r < 0)
 966                         return -errno;
 967
 968                 return r;
 969         }
 970
 971         path_fd = chase_symlinks(path, root, chase_flags|CHASE_OPEN, ret_path ? &p : NULL);
 972         if (path_fd < 0)
 973                 return path_fd;
 974
 975         r = fd_reopen(path_fd, open_flags);
 976         if (r < 0)
 977                 return r;
 978
 979         if (ret_path)
 980                 *ret_path = TAKE_PTR(p);
 981
 982         return r;
 983 }
 984
 985 int chase_symlinks_and_opendir(
 986                 const char *path,
 987                 const char *root,
 988                 unsigned chase_flags,
 989                 char **ret_path,
 990                 DIR **ret_dir) {
 991
 992         char procfs_path[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
 993         _cleanup_close_ int path_fd = -1;
 994         _cleanup_free_ char *p = NULL;
 995         DIR *d;
 996
 997         if (!ret_dir)
 998                 return -EINVAL;
 999         if (chase_flags & CHASE_NONEXISTENT)
1000                 return -EINVAL;
1001
1002         if (empty_or_root(root) && !ret_path && (chase_flags & (CHASE_NO_AUTOFS|CHASE_SAFE)) == 0) {
1003                 /* Shortcut this call if none of the special features of this call are requested */
1004                 d = opendir(path);
1005                 if (!d)
1006                         return -errno;
1007
1008                 *ret_dir = d;
1009                 return 0;
1010         }
1011
1012         path_fd = chase_symlinks(path, root, chase_flags|CHASE_OPEN, ret_path ? &p : NULL);
1013         if (path_fd < 0)
1014                 return path_fd;
1015
1016         xsprintf(procfs_path, "/proc/self/fd/%i", path_fd);
1017         d = opendir(procfs_path);
1018         if (!d)
1019                 return -errno;
1020
1021         if (ret_path)
1022                 *ret_path = TAKE_PTR(p);
1023
1024         *ret_dir = d;
1025         return 0;
1026 }
1027
1028 int chase_symlinks_and_stat(
1029                 const char *path,
1030                 const char *root,
1031                 unsigned chase_flags,
1032                 char **ret_path,
1033                 struct stat *ret_stat) {
1034
1035         _cleanup_close_ int path_fd = -1;
1036         _cleanup_free_ char *p = NULL;
1037
1038         assert(path);
1039         assert(ret_stat);
1040
1041         if (chase_flags & CHASE_NONEXISTENT)
1042                 return -EINVAL;
1043
1044         if (empty_or_root(root) && !ret_path && (chase_flags & (CHASE_NO_AUTOFS|CHASE_SAFE)) == 0) {
1045                 /* Shortcut this call if none of the special features of this call are requested */
1046                 if (stat(path, ret_stat) < 0)
1047                         return -errno;
1048
1049                 return 1;
1050         }
1051
1052         path_fd = chase_symlinks(path, root, chase_flags|CHASE_OPEN, ret_path ? &p : NULL);
1053         if (path_fd < 0)
1054                 return path_fd;
1055
1056         if (fstat(path_fd, ret_stat) < 0)
1057                 return -errno;
1058
1059         if (ret_path)
1060                 *ret_path = TAKE_PTR(p);
1061
1062         if (chase_flags & CHASE_OPEN)
1063                 return TAKE_FD(path_fd);
1064
1065         return 1;
1066 }
1067
1068 int access_fd(int fd, int mode) {
1069         char p[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(fd) + 1];
1070         int r;
1071
1072         /* Like access() but operates on an already open fd */
1073
1074         xsprintf(p, "/proc/self/fd/%i", fd);
1075         r = access(p, mode);
1076         if (r < 0)
1077                 return -errno;
1078
1079         return r;
1080 }
1081
1082 void unlink_tempfilep(char (*p)[]) {
1083         /* If the file is created with mkstemp(), it will (almost always)
1084          * change the suffix. Treat this as a sign that the file was
1085          * successfully created. We ignore both the rare case where the
1086          * original suffix is used and unlink failures. */
1087         if (!endswith(*p, ".XXXXXX"))
1088                 (void) unlink_noerrno(*p);
1089 }
1090
1091 int unlinkat_deallocate(int fd, const char *name, int flags) {
1092         _cleanup_close_ int truncate_fd = -1;
1093         struct stat st;
1094         off_t l, bs;
1095
1096         /* Operates like unlinkat() but also deallocates the file contents if it is a regular file and there's no other
1097          * link to it. This is useful to ensure that other processes that might have the file open for reading won't be
1098          * able to keep the data pinned on disk forever. This call is particular useful whenever we execute clean-up
1099          * jobs ("vacuuming"), where we want to make sure the data is really gone and the disk space released and
1100          * returned to the free pool.
1101          *
1102          * Deallocation is preferably done by FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE (👊) if supported, which means
1103          * the file won't change size. That's a good thing since we shouldn't needlessly trigger SIGBUS in other
1104          * programs that have mmap()ed the file. (The assumption here is that changing file contents to all zeroes
1105          * underneath those programs is the better choice than simply triggering SIGBUS in them which truncation does.)
1106          * However if hole punching is not implemented in the kernel or file system we'll fall back to normal file
1107          * truncation (🔪), as our goal of deallocating the data space trumps our goal of being nice to readers (💐).
1108          *
1109          * Note that we attempt deallocation, but failure to succeed with that is not considered fatal, as long as the
1110          * primary job – to delete the file – is accomplished. */
1111
1112         if ((flags & AT_REMOVEDIR) == 0) {
1113                 truncate_fd = openat(fd, name, O_WRONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW|O_NONBLOCK);
1114                 if (truncate_fd < 0) {
1115
1116                         /* If this failed because the file doesn't exist propagate the error right-away. Also,
1117                          * AT_REMOVEDIR wasn't set, and we tried to open the file for writing, which means EISDIR is
1118                          * returned when this is a directory but we are not supposed to delete those, hence propagate
1119                          * the error right-away too. */
1120                         if (IN_SET(errno, ENOENT, EISDIR))
1121                                 return -errno;
1122
1123                         if (errno != ELOOP) /* don't complain if this is a symlink */
1124                                 log_debug_errno(errno, "Failed to open file '%s' for deallocation, ignoring: %m", name);
1125                 }
1126         }
1127
1128         if (unlinkat(fd, name, flags) < 0)
1129                 return -errno;
1130
1131         if (truncate_fd < 0) /* Don't have a file handle, can't do more ☹️ */
1132                 return 0;
1133
1134         if (fstat(truncate_fd, &st) < 0) {
1135                 log_debug_errno(errno, "Failed to stat file '%s' for deallocation, ignoring.", name);
1136                 return 0;
1137         }
1138
1139         if (!S_ISREG(st.st_mode) || st.st_blocks == 0 || st.st_nlink > 0)
1140                 return 0;
1141
1142         /* If this is a regular file, it actually took up space on disk and there are no other links it's time to
1143          * punch-hole/truncate this to release the disk space. */
1144
1145         bs = MAX(st.st_blksize, 512);
1146         l = DIV_ROUND_UP(st.st_size, bs) * bs; /* Round up to next block size */
1147
1148         if (fallocate(truncate_fd, FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE, 0, l) >= 0)
1149                 return 0; /* Successfully punched a hole! 😊 */
1150
1151         /* Fall back to truncation */
1152         if (ftruncate(truncate_fd, 0) < 0) {
1153                 log_debug_errno(errno, "Failed to truncate file to 0, ignoring: %m");
1154                 return 0;
1155         }
1156
1157         return 0;
1158 }
1159
1160 int fsync_directory_of_file(int fd) {
1161         _cleanup_free_ char *path = NULL, *dn = NULL;
1162         _cleanup_close_ int dfd = -1;
1163         int r;
1164
1165         r = fd_verify_regular(fd);
1166         if (r < 0)
1167                 return r;
1168
1169         r = fd_get_path(fd, &path);
1170         if (r < 0) {
1171                 log_debug_errno(r, "Failed to query /proc/self/fd/%d%s: %m",
1172                                 fd,
1173                                 r == -EOPNOTSUPP ? ", ignoring" : "");
1174
1175                 if (r == -EOPNOTSUPP)
1176                         /* If /proc is not available, we're most likely running in some
1177                          * chroot environment, and syncing the directory is not very
1178                          * important in that case. Let's just silently do nothing. */
1179                         return 0;
1180
1181                 return r;
1182         }
1183
1184         if (!path_is_absolute(path))
1185                 return -EINVAL;
1186
1187         dn = dirname_malloc(path);
1188         if (!dn)
1189                 return -ENOMEM;
1190
1191         dfd = open(dn, O_RDONLY|O_CLOEXEC|O_DIRECTORY);
1192         if (dfd < 0)
1193                 return -errno;
1194
1195         if (fsync(dfd) < 0)
1196                 return -errno;
1197
1198         return 0;
1199 }