src/import/import-common.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2015 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 <sched.h>
  22 #include <sys/prctl.h>
  23 #include <sys/stat.h>
  24 #include <unistd.h>
  25
  26 #include "btrfs-util.h"
  27 #include "capability-util.h"
  28 #include "fd-util.h"
  29 #include "import-common.h"
  30 #include "signal-util.h"
  31 #include "util.h"
  32
  33 int import_make_read_only_fd(int fd) {
  34         int r;
  35
  36         assert(fd >= 0);
  37
  38         /* First, let's make this a read-only subvolume if it refers
  39          * to a subvolume */
  40         r = btrfs_subvol_set_read_only_fd(fd, true);
  41         if (IN_SET(r, -ENOTTY, -ENOTDIR, -EINVAL)) {
  42                 struct stat st;
  43
  44                 /* This doesn't refer to a subvolume, or the file
  45                  * system isn't even btrfs. In that, case fall back to
  46                  * chmod()ing */
  47
  48                 r = fstat(fd, &st);
  49                 if (r < 0)
  50                         return log_error_errno(errno, "Failed to stat temporary image: %m");
  51
  52                 /* Drop "w" flag */
  53                 if (fchmod(fd, st.st_mode & 07555) < 0)
  54                         return log_error_errno(errno, "Failed to chmod() final image: %m");
  55
  56                 return 0;
  57
  58         } else if (r < 0)
  59                 return log_error_errno(r, "Failed to make subvolume read-only: %m");
  60
  61         return 0;
  62 }
  63
  64 int import_make_read_only(const char *path) {
  65         _cleanup_close_ int fd = 1;
  66
  67         fd = open(path, O_RDONLY|O_NOCTTY|O_CLOEXEC);
  68         if (fd < 0)
  69                 return log_error_errno(errno, "Failed to open %s: %m", path);
  70
  71         return import_make_read_only_fd(fd);
  72 }
  73
  74 int import_fork_tar_x(const char *path, pid_t *ret) {
  75         _cleanup_close_pair_ int pipefd[2] = { -1, -1 };
  76         pid_t pid;
  77         int r;
  78
  79         assert(path);
  80         assert(ret);
  81
  82         if (pipe2(pipefd, O_CLOEXEC) < 0)
  83                 return log_error_errno(errno, "Failed to create pipe for tar: %m");
  84
  85         pid = fork();
  86         if (pid < 0)
  87                 return log_error_errno(errno, "Failed to fork off tar: %m");
  88
  89         if (pid == 0) {
  90                 int null_fd;
  91                 uint64_t retain =
  92                         (1ULL << CAP_CHOWN) |
  93                         (1ULL << CAP_FOWNER) |
  94                         (1ULL << CAP_FSETID) |
  95                         (1ULL << CAP_MKNOD) |
  96                         (1ULL << CAP_SETFCAP) |
  97                         (1ULL << CAP_DAC_OVERRIDE);
  98
  99                 /* Child */
 100
 101                 (void) reset_all_signal_handlers();
 102                 (void) reset_signal_mask();
 103                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
 104
 105                 pipefd[1] = safe_close(pipefd[1]);
 106
 107                 r = move_fd(pipefd[0], STDIN_FILENO, false);
 108                 if (r < 0) {
 109                         log_error_errno(r, "Failed to move fd: %m");
 110                         _exit(EXIT_FAILURE);
 111                 }
 112
 113                 null_fd = open("/dev/null", O_WRONLY|O_NOCTTY);
 114                 if (null_fd < 0) {
 115                         log_error_errno(errno, "Failed to open /dev/null: %m");
 116                         _exit(EXIT_FAILURE);
 117                 }
 118
 119                 r = move_fd(null_fd, STDOUT_FILENO, false);
 120                 if (r < 0) {
 121                         log_error_errno(r, "Failed to move fd: %m");
 122                         _exit(EXIT_FAILURE);
 123                 }
 124
 125                 stdio_unset_cloexec();
 126
 127                 if (unshare(CLONE_NEWNET) < 0)
 128                         log_error_errno(errno, "Failed to lock tar into network namespace, ignoring: %m");
 129
 130                 r = capability_bounding_set_drop(retain, true);
 131                 if (r < 0)
 132                         log_error_errno(r, "Failed to drop capabilities, ignoring: %m");
 133
 134                 execlp("tar", "tar", "--numeric-owner", "-C", path, "-px", "--xattrs", "--xattrs-include=*", NULL);
 135                 log_error_errno(errno, "Failed to execute tar: %m");
 136                 _exit(EXIT_FAILURE);
 137         }
 138
 139         pipefd[0] = safe_close(pipefd[0]);
 140         r = pipefd[1];
 141         pipefd[1] = -1;
 142
 143         *ret = pid;
 144
 145         return r;
 146 }
 147
 148 int import_fork_tar_c(const char *path, pid_t *ret) {
 149         _cleanup_close_pair_ int pipefd[2] = { -1, -1 };
 150         pid_t pid;
 151         int r;
 152
 153         assert(path);
 154         assert(ret);
 155
 156         if (pipe2(pipefd, O_CLOEXEC) < 0)
 157                 return log_error_errno(errno, "Failed to create pipe for tar: %m");
 158
 159         pid = fork();
 160         if (pid < 0)
 161                 return log_error_errno(errno, "Failed to fork off tar: %m");
 162
 163         if (pid == 0) {
 164                 int null_fd;
 165                 uint64_t retain = (1ULL << CAP_DAC_OVERRIDE);
 166
 167                 /* Child */
 168
 169                 (void) reset_all_signal_handlers();
 170                 (void) reset_signal_mask();
 171                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
 172
 173                 pipefd[0] = safe_close(pipefd[0]);
 174
 175                 r = move_fd(pipefd[1], STDOUT_FILENO, false);
 176                 if (r < 0) {
 177                         log_error_errno(r, "Failed to move fd: %m");
 178                         _exit(EXIT_FAILURE);
 179                 }
 180
 181                 null_fd = open("/dev/null", O_RDONLY|O_NOCTTY);
 182                 if (null_fd < 0) {
 183                         log_error_errno(errno, "Failed to open /dev/null: %m");
 184                         _exit(EXIT_FAILURE);
 185                 }
 186
 187                 r = move_fd(null_fd, STDIN_FILENO, false);
 188                 if (r < 0) {
 189                         log_error_errno(errno, "Failed to move fd: %m");
 190                         _exit(EXIT_FAILURE);
 191                 }
 192
 193                 stdio_unset_cloexec();
 194
 195                 if (unshare(CLONE_NEWNET) < 0)
 196                         log_error_errno(errno, "Failed to lock tar into network namespace, ignoring: %m");
 197
 198                 r = capability_bounding_set_drop(retain, true);
 199                 if (r < 0)
 200                         log_error_errno(r, "Failed to drop capabilities, ignoring: %m");
 201
 202                 execlp("tar", "tar", "-C", path, "-c", "--xattrs", "--xattrs-include=*", ".", NULL);
 203                 log_error_errno(errno, "Failed to execute tar: %m");
 204                 _exit(EXIT_FAILURE);
 205         }
 206
 207         pipefd[1] = safe_close(pipefd[1]);
 208         r = pipefd[0];
 209         pipefd[0] = -1;
 210
 211         *ret = pid;
 212
 213         return r;
 214 }