src/basic/fs-util.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <dirent.h>
  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 <time.h>
  28 #include <unistd.h>
  29
  30 #include "alloc-util.h"
  31 #include "dirent-util.h"
  32 #include "fd-util.h"
  33 #include "fileio.h"
  34 #include "fs-util.h"
  35 #include "log.h"
  36 #include "macro.h"
  37 #include "missing.h"
  38 #include "mkdir.h"
  39 #include "parse-util.h"
  40 #include "path-util.h"
  41 #include "stdio-util.h"
  42 #include "string-util.h"
  43 #include "strv.h"
  44 #include "time-util.h"
  45 #include "user-util.h"
  46 #include "util.h"
  47
  48 int unlink_noerrno(const char *path) {
  49         PROTECT_ERRNO;
  50         int r;
  51
  52         r = unlink(path);
  53         if (r < 0)
  54                 return -errno;
  55
  56         return 0;
  57 }
  58
  59 int rmdir_parents(const char *path, const char *stop) {
  60         size_t l;
  61         int r = 0;
  62
  63         assert(path);
  64         assert(stop);
  65
  66         l = strlen(path);
  67
  68         /* Skip trailing slashes */
  69         while (l > 0 && path[l-1] == '/')
  70                 l--;
  71
  72         while (l > 0) {
  73                 char *t;
  74
  75                 /* Skip last component */
  76                 while (l > 0 && path[l-1] != '/')
  77                         l--;
  78
  79                 /* Skip trailing slashes */
  80                 while (l > 0 && path[l-1] == '/')
  81                         l--;
  82
  83                 if (l <= 0)
  84                         break;
  85
  86                 t = strndup(path, l);
  87                 if (!t)
  88                         return -ENOMEM;
  89
  90                 if (path_startswith(stop, t)) {
  91                         free(t);
  92                         return 0;
  93                 }
  94
  95                 r = rmdir(t);
  96                 free(t);
  97
  98                 if (r < 0)
  99                         if (errno != ENOENT)
 100                                 return -errno;
 101         }
 102
 103         return 0;
 104 }
 105
 106
 107 int rename_noreplace(int olddirfd, const char *oldpath, int newdirfd, const char *newpath) {
 108         struct stat buf;
 109         int ret;
 110
 111         ret = renameat2(olddirfd, oldpath, newdirfd, newpath, RENAME_NOREPLACE);
 112         if (ret >= 0)
 113                 return 0;
 114
 115         /* renameat2() exists since Linux 3.15, btrfs added support for it later.
 116          * If it is not implemented, fallback to another method. */
 117         if (!IN_SET(errno, EINVAL, ENOSYS))
 118                 return -errno;
 119
 120         /* The link()/unlink() fallback does not work on directories. But
 121          * renameat() without RENAME_NOREPLACE gives the same semantics on
 122          * directories, except when newpath is an *empty* directory. This is
 123          * good enough. */
 124         ret = fstatat(olddirfd, oldpath, &buf, AT_SYMLINK_NOFOLLOW);
 125         if (ret >= 0 && S_ISDIR(buf.st_mode)) {
 126                 ret = renameat(olddirfd, oldpath, newdirfd, newpath);
 127                 return ret >= 0 ? 0 : -errno;
 128         }
 129
 130         /* If it is not a directory, use the link()/unlink() fallback. */
 131         ret = linkat(olddirfd, oldpath, newdirfd, newpath, 0);
 132         if (ret < 0)
 133                 return -errno;
 134
 135         ret = unlinkat(olddirfd, oldpath, 0);
 136         if (ret < 0) {
 137                 /* backup errno before the following unlinkat() alters it */
 138                 ret = errno;
 139                 (void) unlinkat(newdirfd, newpath, 0);
 140                 errno = ret;
 141                 return -errno;
 142         }
 143
 144         return 0;
 145 }
 146
 147 int readlinkat_malloc(int fd, const char *p, char **ret) {
 148         size_t l = 100;
 149         int r;
 150
 151         assert(p);
 152         assert(ret);
 153
 154         for (;;) {
 155                 char *c;
 156                 ssize_t n;
 157
 158                 c = new(char, l);
 159                 if (!c)
 160                         return -ENOMEM;
 161
 162                 n = readlinkat(fd, p, c, l-1);
 163                 if (n < 0) {
 164                         r = -errno;
 165                         free(c);
 166                         return r;
 167                 }
 168
 169                 if ((size_t) n < l-1) {
 170                         c[n] = 0;
 171                         *ret = c;
 172                         return 0;
 173                 }
 174
 175                 free(c);
 176                 l *= 2;
 177         }
 178 }
 179
 180 int readlink_malloc(const char *p, char **ret) {
 181         return readlinkat_malloc(AT_FDCWD, p, ret);
 182 }
 183
 184 int readlink_value(const char *p, char **ret) {
 185         _cleanup_free_ char *link = NULL;
 186         char *value;
 187         int r;
 188
 189         r = readlink_malloc(p, &link);
 190         if (r < 0)
 191                 return r;
 192
 193         value = basename(link);
 194         if (!value)
 195                 return -ENOENT;
 196
 197         value = strdup(value);
 198         if (!value)
 199                 return -ENOMEM;
 200
 201         *ret = value;
 202
 203         return 0;
 204 }
 205
 206 int readlink_and_make_absolute(const char *p, char **r) {
 207         _cleanup_free_ char *target = NULL;
 208         char *k;
 209         int j;
 210
 211         assert(p);
 212         assert(r);
 213
 214         j = readlink_malloc(p, &target);
 215         if (j < 0)
 216                 return j;
 217
 218         k = file_in_same_dir(p, target);
 219         if (!k)
 220                 return -ENOMEM;
 221
 222         *r = k;
 223         return 0;
 224 }
 225
 226 int readlink_and_canonicalize(const char *p, char **r) {
 227         char *t, *s;
 228         int j;
 229
 230         assert(p);
 231         assert(r);
 232
 233         j = readlink_and_make_absolute(p, &t);
 234         if (j < 0)
 235                 return j;
 236
 237         s = canonicalize_file_name(t);
 238         if (s) {
 239                 free(t);
 240                 *r = s;
 241         } else
 242                 *r = t;
 243
 244         path_kill_slashes(*r);
 245
 246         return 0;
 247 }
 248
 249 int readlink_and_make_absolute_root(const char *root, const char *path, char **ret) {
 250         _cleanup_free_ char *target = NULL, *t = NULL;
 251         const char *full;
 252         int r;
 253
 254         full = prefix_roota(root, path);
 255         r = readlink_malloc(full, &target);
 256         if (r < 0)
 257                 return r;
 258
 259         t = file_in_same_dir(path, target);
 260         if (!t)
 261                 return -ENOMEM;
 262
 263         *ret = t;
 264         t = NULL;
 265
 266         return 0;
 267 }
 268
 269 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
 270         assert(path);
 271
 272         /* Under the assumption that we are running privileged we
 273          * first change the access mode and only then hand out
 274          * ownership to avoid a window where access is too open. */
 275
 276         if (mode != MODE_INVALID)
 277                 if (chmod(path, mode) < 0)
 278                         return -errno;
 279
 280         if (uid != UID_INVALID || gid != GID_INVALID)
 281                 if (chown(path, uid, gid) < 0)
 282                         return -errno;
 283
 284         return 0;
 285 }
 286
 287 int fchmod_umask(int fd, mode_t m) {
 288         mode_t u;
 289         int r;
 290
 291         u = umask(0777);
 292         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 293         umask(u);
 294
 295         return r;
 296 }
 297
 298 int fd_warn_permissions(const char *path, int fd) {
 299         struct stat st;
 300
 301         if (fstat(fd, &st) < 0)
 302                 return -errno;
 303
 304         if (st.st_mode & 0111)
 305                 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
 306
 307         if (st.st_mode & 0002)
 308                 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
 309
 310         if (getpid() == 1 && (st.st_mode & 0044) != 0044)
 311                 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);
 312
 313         return 0;
 314 }
 315
 316 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
 317         _cleanup_close_ int fd;
 318         int r;
 319
 320         assert(path);
 321
 322         if (parents)
 323                 mkdir_parents(path, 0755);
 324
 325         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY,
 326                         (mode == 0 || mode == MODE_INVALID) ? 0644 : mode);
 327         if (fd < 0)
 328                 return -errno;
 329
 330         if (mode != MODE_INVALID) {
 331                 r = fchmod(fd, mode);
 332                 if (r < 0)
 333                         return -errno;
 334         }
 335
 336         if (uid != UID_INVALID || gid != GID_INVALID) {
 337                 r = fchown(fd, uid, gid);
 338                 if (r < 0)
 339                         return -errno;
 340         }
 341
 342         if (stamp != USEC_INFINITY) {
 343                 struct timespec ts[2];
 344
 345                 timespec_store(&ts[0], stamp);
 346                 ts[1] = ts[0];
 347                 r = futimens(fd, ts);
 348         } else
 349                 r = futimens(fd, NULL);
 350         if (r < 0)
 351                 return -errno;
 352
 353         return 0;
 354 }
 355
 356 int touch(const char *path) {
 357         return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, MODE_INVALID);
 358 }
 359
 360 int symlink_idempotent(const char *from, const char *to) {
 361         _cleanup_free_ char *p = NULL;
 362         int r;
 363
 364         assert(from);
 365         assert(to);
 366
 367         if (symlink(from, to) < 0) {
 368                 if (errno != EEXIST)
 369                         return -errno;
 370
 371                 r = readlink_malloc(to, &p);
 372                 if (r < 0)
 373                         return r;
 374
 375                 if (!streq(p, from))
 376                         return -EINVAL;
 377         }
 378
 379         return 0;
 380 }
 381
 382 int symlink_atomic(const char *from, const char *to) {
 383         _cleanup_free_ char *t = NULL;
 384         int r;
 385
 386         assert(from);
 387         assert(to);
 388
 389         r = tempfn_random(to, NULL, &t);
 390         if (r < 0)
 391                 return r;
 392
 393         if (symlink(from, t) < 0)
 394                 return -errno;
 395
 396         if (rename(t, to) < 0) {
 397                 unlink_noerrno(t);
 398                 return -errno;
 399         }
 400
 401         return 0;
 402 }
 403
 404 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
 405         _cleanup_free_ char *t = NULL;
 406         int r;
 407
 408         assert(path);
 409
 410         r = tempfn_random(path, NULL, &t);
 411         if (r < 0)
 412                 return r;
 413
 414         if (mknod(t, mode, dev) < 0)
 415                 return -errno;
 416
 417         if (rename(t, path) < 0) {
 418                 unlink_noerrno(t);
 419                 return -errno;
 420         }
 421
 422         return 0;
 423 }
 424
 425 int mkfifo_atomic(const char *path, mode_t mode) {
 426         _cleanup_free_ char *t = NULL;
 427         int r;
 428
 429         assert(path);
 430
 431         r = tempfn_random(path, NULL, &t);
 432         if (r < 0)
 433                 return r;
 434
 435         if (mkfifo(t, mode) < 0)
 436                 return -errno;
 437
 438         if (rename(t, path) < 0) {
 439                 unlink_noerrno(t);
 440                 return -errno;
 441         }
 442
 443         return 0;
 444 }
 445
 446 int get_files_in_directory(const char *path, char ***list) {
 447         _cleanup_closedir_ DIR *d = NULL;
 448         size_t bufsize = 0, n = 0;
 449         _cleanup_strv_free_ char **l = NULL;
 450
 451         assert(path);
 452
 453         /* Returns all files in a directory in *list, and the number
 454          * of files as return value. If list is NULL returns only the
 455          * number. */
 456
 457         d = opendir(path);
 458         if (!d)
 459                 return -errno;
 460
 461         for (;;) {
 462                 struct dirent *de;
 463
 464                 errno = 0;
 465                 de = readdir(d);
 466                 if (!de && errno > 0)
 467                         return -errno;
 468                 if (!de)
 469                         break;
 470
 471                 dirent_ensure_type(d, de);
 472
 473                 if (!dirent_is_file(de))
 474                         continue;
 475
 476                 if (list) {
 477                         /* one extra slot is needed for the terminating NULL */
 478                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
 479                                 return -ENOMEM;
 480
 481                         l[n] = strdup(de->d_name);
 482                         if (!l[n])
 483                                 return -ENOMEM;
 484
 485                         l[++n] = NULL;
 486                 } else
 487                         n++;
 488         }
 489
 490         if (list) {
 491                 *list = l;
 492                 l = NULL; /* avoid freeing */
 493         }
 494
 495         return n;
 496 }
 497
 498 int inotify_add_watch_fd(int fd, int what, uint32_t mask) {
 499         char path[strlen("/proc/self/fd/") + DECIMAL_STR_MAX(int) + 1];
 500         int r;
 501
 502         /* This is like inotify_add_watch(), except that the file to watch is not referenced by a path, but by an fd */
 503         xsprintf(path, "/proc/self/fd/%i", what);
 504
 505         r = inotify_add_watch(fd, path, mask);
 506         if (r < 0)
 507                 return -errno;
 508
 509         return r;
 510 }