src/nspawn/nspawn.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <signal.h>
  23 #include <sched.h>
  24 #include <unistd.h>
  25 #include <sys/types.h>
  26 #include <sys/syscall.h>
  27 #include <sys/mount.h>
  28 #include <sys/wait.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <stdio.h>
  32 #include <errno.h>
  33 #include <sys/prctl.h>
  34 #include <sys/capability.h>
  35 #include <getopt.h>
  36 #include <sys/poll.h>
  37 #include <sys/epoll.h>
  38 #include <termios.h>
  39 #include <sys/signalfd.h>
  40 #include <grp.h>
  41 #include <linux/fs.h>
  42 #include <sys/un.h>
  43 #include <sys/socket.h>
  44 #include <linux/netlink.h>
  45
  46 #include <systemd/sd-daemon.h>
  47 #include <systemd/sd-bus.h>
  48
  49 #include "log.h"
  50 #include "util.h"
  51 #include "mkdir.h"
  52 #include "macro.h"
  53 #include "audit.h"
  54 #include "missing.h"
  55 #include "cgroup-util.h"
  56 #include "strv.h"
  57 #include "path-util.h"
  58 #include "loopback-setup.h"
  59 #include "sd-id128.h"
  60 #include "dev-setup.h"
  61 #include "fdset.h"
  62 #include "build.h"
  63 #include "fileio.h"
  64 #include "bus-util.h"
  65 #include "ptyfwd.h"
  66
  67 #ifndef TTY_GID
  68 #define TTY_GID 5
  69 #endif
  70
  71 typedef enum LinkJournal {
  72         LINK_NO,
  73         LINK_AUTO,
  74         LINK_HOST,
  75         LINK_GUEST
  76 } LinkJournal;
  77
  78 static char *arg_directory = NULL;
  79 static char *arg_user = NULL;
  80 static sd_id128_t arg_uuid = {};
  81 static char *arg_machine = NULL;
  82 static const char *arg_slice = NULL;
  83 static bool arg_private_network = false;
  84 static bool arg_read_only = false;
  85 static bool arg_boot = false;
  86 static LinkJournal arg_link_journal = LINK_AUTO;
  87 static uint64_t arg_retain =
  88         (1ULL << CAP_CHOWN) |
  89         (1ULL << CAP_DAC_OVERRIDE) |
  90         (1ULL << CAP_DAC_READ_SEARCH) |
  91         (1ULL << CAP_FOWNER) |
  92         (1ULL << CAP_FSETID) |
  93         (1ULL << CAP_IPC_OWNER) |
  94         (1ULL << CAP_KILL) |
  95         (1ULL << CAP_LEASE) |
  96         (1ULL << CAP_LINUX_IMMUTABLE) |
  97         (1ULL << CAP_NET_BIND_SERVICE) |
  98         (1ULL << CAP_NET_BROADCAST) |
  99         (1ULL << CAP_NET_RAW) |
 100         (1ULL << CAP_SETGID) |
 101         (1ULL << CAP_SETFCAP) |
 102         (1ULL << CAP_SETPCAP) |
 103         (1ULL << CAP_SETUID) |
 104         (1ULL << CAP_SYS_ADMIN) |
 105         (1ULL << CAP_SYS_CHROOT) |
 106         (1ULL << CAP_SYS_NICE) |
 107         (1ULL << CAP_SYS_PTRACE) |
 108         (1ULL << CAP_SYS_TTY_CONFIG) |
 109         (1ULL << CAP_SYS_RESOURCE) |
 110         (1ULL << CAP_SYS_BOOT) |
 111         (1ULL << CAP_AUDIT_WRITE) |
 112         (1ULL << CAP_AUDIT_CONTROL);
 113 static char **arg_bind = NULL;
 114 static char **arg_bind_ro = NULL;
 115
 116 static int help(void) {
 117
 118         printf("%s [OPTIONS...] [PATH] [ARGUMENTS...]\n\n"
 119                "Spawn a minimal namespace container for debugging, testing and building.\n\n"
 120                "  -h --help                Show this help\n"
 121                "     --version             Print version string\n"
 122                "  -D --directory=NAME      Root directory for the container\n"
 123                "  -b --boot                Boot up full system (i.e. invoke init)\n"
 124                "  -u --user=USER           Run the command under specified user or uid\n"
 125                "     --uuid=UUID           Set a specific machine UUID for the container\n"
 126                "  -M --machine=NAME        Set the machine name for the container\n"
 127                "  -S --slice=SLICE         Place the container in the specified slice\n"
 128                "     --private-network     Disable network in container\n"
 129                "     --read-only           Mount the root directory read-only\n"
 130                "     --capability=CAP      In addition to the default, retain specified\n"
 131                "                           capability\n"
 132                "     --link-journal=MODE   Link up guest journal, one of no, auto, guest, host\n"
 133                "  -j                       Equivalent to --link-journal=host\n"
 134                "     --bind=PATH[:PATH]    Bind mount a file or directory from the host into\n"
 135                "                           the container\n"
 136                "     --bind-ro=PATH[:PATH] Similar, but creates a read-only bind mount\n",
 137                program_invocation_short_name);
 138
 139         return 0;
 140 }
 141
 142 static int parse_argv(int argc, char *argv[]) {
 143
 144         enum {
 145                 ARG_VERSION = 0x100,
 146                 ARG_PRIVATE_NETWORK,
 147                 ARG_UUID,
 148                 ARG_READ_ONLY,
 149                 ARG_CAPABILITY,
 150                 ARG_LINK_JOURNAL,
 151                 ARG_BIND,
 152                 ARG_BIND_RO
 153         };
 154
 155         static const struct option options[] = {
 156                 { "help",            no_argument,       NULL, 'h'                 },
 157                 { "version",         no_argument,       NULL, ARG_VERSION         },
 158                 { "directory",       required_argument, NULL, 'D'                 },
 159                 { "user",            required_argument, NULL, 'u'                 },
 160                 { "private-network", no_argument,       NULL, ARG_PRIVATE_NETWORK },
 161                 { "boot",            no_argument,       NULL, 'b'                 },
 162                 { "uuid",            required_argument, NULL, ARG_UUID            },
 163                 { "read-only",       no_argument,       NULL, ARG_READ_ONLY       },
 164                 { "capability",      required_argument, NULL, ARG_CAPABILITY      },
 165                 { "link-journal",    required_argument, NULL, ARG_LINK_JOURNAL    },
 166                 { "bind",            required_argument, NULL, ARG_BIND            },
 167                 { "bind-ro",         required_argument, NULL, ARG_BIND_RO         },
 168                 { "machine",         required_argument, NULL, 'M'                 },
 169                 { "slice",           required_argument, NULL, 'S'                 },
 170                 { NULL,              0,                 NULL, 0                   }
 171         };
 172
 173         int c, r;
 174
 175         assert(argc >= 0);
 176         assert(argv);
 177
 178         while ((c = getopt_long(argc, argv, "+hD:u:bM:jS:", options, NULL)) >= 0) {
 179
 180                 switch (c) {
 181
 182                 case 'h':
 183                         help();
 184                         return 0;
 185
 186                 case ARG_VERSION:
 187                         puts(PACKAGE_STRING);
 188                         puts(SYSTEMD_FEATURES);
 189                         return 0;
 190
 191                 case 'D':
 192                         free(arg_directory);
 193                         arg_directory = canonicalize_file_name(optarg);
 194                         if (!arg_directory) {
 195                                 log_error("Failed to canonicalize root directory.");
 196                                 return -ENOMEM;
 197                         }
 198
 199                         break;
 200
 201                 case 'u':
 202                         free(arg_user);
 203                         arg_user = strdup(optarg);
 204                         if (!arg_user)
 205                                 return log_oom();
 206
 207                         break;
 208
 209                 case ARG_PRIVATE_NETWORK:
 210                         arg_private_network = true;
 211                         break;
 212
 213                 case 'b':
 214                         arg_boot = true;
 215                         break;
 216
 217                 case ARG_UUID:
 218                         r = sd_id128_from_string(optarg, &arg_uuid);
 219                         if (r < 0) {
 220                                 log_error("Invalid UUID: %s", optarg);
 221                                 return r;
 222                         }
 223                         break;
 224
 225                 case 'S':
 226                         arg_slice = strdup(optarg);
 227                         if (!arg_slice)
 228                                 return log_oom();
 229
 230                         break;
 231
 232                 case 'M':
 233                         if (!hostname_is_valid(optarg)) {
 234                                 log_error("Invalid machine name: %s", optarg);
 235                                 return -EINVAL;
 236                         }
 237
 238                         free(arg_machine);
 239                         arg_machine = strdup(optarg);
 240                         if (!arg_machine)
 241                                 return log_oom();
 242
 243                         break;
 244
 245                 case ARG_READ_ONLY:
 246                         arg_read_only = true;
 247                         break;
 248
 249                 case ARG_CAPABILITY: {
 250                         char *state, *word;
 251                         size_t length;
 252
 253                         FOREACH_WORD_SEPARATOR(word, length, optarg, ",", state) {
 254                                 cap_value_t cap;
 255                                 char *t;
 256
 257                                 t = strndup(word, length);
 258                                 if (!t)
 259                                         return log_oom();
 260
 261                                 if (cap_from_name(t, &cap) < 0) {
 262                                         log_error("Failed to parse capability %s.", t);
 263                                         free(t);
 264                                         return -EINVAL;
 265                                 }
 266
 267                                 free(t);
 268                                 arg_retain |= 1ULL << (uint64_t) cap;
 269                         }
 270
 271                         break;
 272                 }
 273
 274                 case 'j':
 275                         arg_link_journal = LINK_GUEST;
 276                         break;
 277
 278                 case ARG_LINK_JOURNAL:
 279                         if (streq(optarg, "auto"))
 280                                 arg_link_journal = LINK_AUTO;
 281                         else if (streq(optarg, "no"))
 282                                 arg_link_journal = LINK_NO;
 283                         else if (streq(optarg, "guest"))
 284                                 arg_link_journal = LINK_GUEST;
 285                         else if (streq(optarg, "host"))
 286                                 arg_link_journal = LINK_HOST;
 287                         else {
 288                                 log_error("Failed to parse link journal mode %s", optarg);
 289                                 return -EINVAL;
 290                         }
 291
 292                         break;
 293
 294                 case ARG_BIND:
 295                 case ARG_BIND_RO: {
 296                         _cleanup_free_ char *a = NULL, *b = NULL;
 297                         char *e;
 298                         char ***x;
 299
 300                         x = c == ARG_BIND ? &arg_bind : &arg_bind_ro;
 301
 302                         e = strchr(optarg, ':');
 303                         if (e) {
 304                                 a = strndup(optarg, e - optarg);
 305                                 b = strdup(e + 1);
 306                         } else {
 307                                 a = strdup(optarg);
 308                                 b = strdup(optarg);
 309                         }
 310
 311                         if (!a || !b)
 312                                 return log_oom();
 313
 314                         if (!path_is_absolute(a) || !path_is_absolute(b)) {
 315                                 log_error("Invalid bind mount specification: %s", optarg);
 316                                 return -EINVAL;
 317                         }
 318
 319                         r = strv_extend(x, a);
 320                         if (r < 0)
 321                                 return log_oom();
 322
 323                         r = strv_extend(x, b);
 324                         if (r < 0)
 325                                 return log_oom();
 326
 327                         break;
 328                 }
 329
 330                 case '?':
 331                         return -EINVAL;
 332
 333                 default:
 334                         log_error("Unknown option code %c", c);
 335                         return -EINVAL;
 336                 }
 337         }
 338
 339         return 1;
 340 }
 341
 342 static int mount_all(const char *dest) {
 343
 344         typedef struct MountPoint {
 345                 const char *what;
 346                 const char *where;
 347                 const char *type;
 348                 const char *options;
 349                 unsigned long flags;
 350                 bool fatal;
 351         } MountPoint;
 352
 353         static const MountPoint mount_table[] = {
 354                 { "proc",      "/proc",     "proc",  NULL,       MS_NOSUID|MS_NOEXEC|MS_NODEV, true  },
 355                 { "/proc/sys", "/proc/sys", NULL,    NULL,       MS_BIND, true                       },   /* Bind mount first */
 356                 { NULL,        "/proc/sys", NULL,    NULL,       MS_BIND|MS_RDONLY|MS_REMOUNT, true  },   /* Then, make it r/o */
 357                 { "sysfs",     "/sys",      "sysfs", NULL,       MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV, true  },
 358                 { "tmpfs",     "/dev",      "tmpfs", "mode=755", MS_NOSUID|MS_STRICTATIME,     true  },
 359                 { "devpts",    "/dev/pts",  "devpts","newinstance,ptmxmode=0666,mode=620,gid=" STRINGIFY(TTY_GID), MS_NOSUID|MS_NOEXEC, true },
 360                 { "tmpfs",     "/dev/shm",  "tmpfs", "mode=1777", MS_NOSUID|MS_NODEV|MS_STRICTATIME, true  },
 361                 { "tmpfs",     "/run",      "tmpfs", "mode=755", MS_NOSUID|MS_NODEV|MS_STRICTATIME, true  },
 362 #ifdef HAVE_SELINUX
 363                 { "/sys/fs/selinux", "/sys/fs/selinux", NULL, NULL, MS_BIND,                      false },  /* Bind mount first */
 364                 { NULL,              "/sys/fs/selinux", NULL, NULL, MS_BIND|MS_RDONLY|MS_REMOUNT, false },  /* Then, make it r/o */
 365 #endif
 366         };
 367
 368         unsigned k;
 369         int r = 0;
 370
 371         for (k = 0; k < ELEMENTSOF(mount_table); k++) {
 372                 _cleanup_free_ char *where = NULL;
 373                 int t;
 374
 375                 where = strjoin(dest, "/", mount_table[k].where, NULL);
 376                 if (!where)
 377                         return log_oom();
 378
 379                 t = path_is_mount_point(where, true);
 380                 if (t < 0) {
 381                         log_error("Failed to detect whether %s is a mount point: %s", where, strerror(-t));
 382
 383                         if (r == 0)
 384                                 r = t;
 385
 386                         continue;
 387                 }
 388
 389                 /* Skip this entry if it is not a remount. */
 390                 if (mount_table[k].what && t > 0)
 391                         continue;
 392
 393                 mkdir_p(where, 0755);
 394
 395                 if (mount(mount_table[k].what,
 396                           where,
 397                           mount_table[k].type,
 398                           mount_table[k].flags,
 399                           mount_table[k].options) < 0 &&
 400                     mount_table[k].fatal) {
 401
 402                         log_error("mount(%s) failed: %m", where);
 403
 404                         if (r == 0)
 405                                 r = -errno;
 406                 }
 407         }
 408
 409         return r;
 410 }
 411
 412 static int mount_binds(const char *dest, char **l, unsigned long flags) {
 413         char **x, **y;
 414
 415         STRV_FOREACH_PAIR(x, y, l) {
 416                 _cleanup_free_ char *where = NULL;
 417                 struct stat source_st, dest_st;
 418
 419                 if (stat(*x, &source_st) < 0) {
 420                         log_error("failed to stat %s: %m", *x);
 421                         return -errno;
 422                 }
 423
 424                 where = strjoin(dest, "/", *y, NULL);
 425                 if (!where)
 426                         return log_oom();
 427
 428                 if (stat(where, &dest_st) == 0) {
 429                         if ((source_st.st_mode & S_IFMT) != (dest_st.st_mode & S_IFMT)) {
 430                                 log_error("The file types of %s and %s do not match. Refusing bind mount",
 431                                                 *x, where);
 432                                 return -EINVAL;
 433                         }
 434                 } else {
 435                         /* Create the mount point, but be conservative -- refuse to create block
 436                          * and char devices. */
 437                         if (S_ISDIR(source_st.st_mode))
 438                                 mkdir_p_label(where, 0755);
 439                         else if (S_ISFIFO(source_st.st_mode))
 440                                 mkfifo(where, 0644);
 441                         else if (S_ISSOCK(source_st.st_mode))
 442                                 mknod(where, 0644 | S_IFSOCK, 0);
 443                         else if (S_ISREG(source_st.st_mode))
 444                                 touch(where);
 445                         else {
 446                                 log_error("Refusing to create mountpoint for file: %s", *x);
 447                                 return -ENOTSUP;
 448                         }
 449                 }
 450
 451                 if (mount(*x, where, "bind", MS_BIND, NULL) < 0) {
 452                         log_error("mount(%s) failed: %m", where);
 453                         return -errno;
 454                 }
 455
 456                 if (flags && mount(NULL, where, NULL, MS_REMOUNT|MS_BIND|flags, NULL) < 0) {
 457                         log_error("mount(%s) failed: %m", where);
 458                         return -errno;
 459                 }
 460         }
 461
 462         return 0;
 463 }
 464
 465 static int setup_timezone(const char *dest) {
 466         _cleanup_free_ char *where = NULL, *p = NULL, *q = NULL, *check = NULL, *what = NULL;
 467         char *z, *y;
 468         int r;
 469
 470         assert(dest);
 471
 472         /* Fix the timezone, if possible */
 473         r = readlink_malloc("/etc/localtime", &p);
 474         if (r < 0) {
 475                 log_warning("/etc/localtime is not a symlink, not updating container timezone.");
 476                 return 0;
 477         }
 478
 479         z = path_startswith(p, "../usr/share/zoneinfo/");
 480         if (!z)
 481                 z = path_startswith(p, "/usr/share/zoneinfo/");
 482         if (!z) {
 483                 log_warning("/etc/localtime does not point into /usr/share/zoneinfo/, not updating container timezone.");
 484                 return 0;
 485         }
 486
 487         where = strappend(dest, "/etc/localtime");
 488         if (!where)
 489                 return log_oom();
 490
 491         r = readlink_malloc(where, &q);
 492         if (r >= 0) {
 493                 y = path_startswith(q, "../usr/share/zoneinfo/");
 494                 if (!y)
 495                         y = path_startswith(q, "/usr/share/zoneinfo/");
 496
 497
 498                 /* Already pointing to the right place? Then do nothing .. */
 499                 if (y && streq(y, z))
 500                         return 0;
 501         }
 502
 503         check = strjoin(dest, "/usr/share/zoneinfo/", z, NULL);
 504         if (!check)
 505                 return log_oom();
 506
 507         if (access(check, F_OK) < 0) {
 508                 log_warning("Timezone %s does not exist in container, not updating container timezone.", z);
 509                 return 0;
 510         }
 511
 512         what = strappend("../usr/share/zoneinfo/", z);
 513         if (!what)
 514                 return log_oom();
 515
 516         unlink(where);
 517         if (symlink(what, where) < 0) {
 518                 log_error("Failed to correct timezone of container: %m");
 519                 return 0;
 520         }
 521
 522         return 0;
 523 }
 524
 525 static int setup_resolv_conf(const char *dest) {
 526         char _cleanup_free_ *where = NULL;
 527
 528         assert(dest);
 529
 530         if (arg_private_network)
 531                 return 0;
 532
 533         /* Fix resolv.conf, if possible */
 534         where = strappend(dest, "/etc/resolv.conf");
 535         if (!where)
 536                 return log_oom();
 537
 538         /* We don't really care for the results of this really. If it
 539          * fails, it fails, but meh... */
 540         copy_file("/etc/resolv.conf", where, O_TRUNC|O_NOFOLLOW);
 541
 542         return 0;
 543 }
 544
 545 static int setup_boot_id(const char *dest) {
 546         _cleanup_free_ char *from = NULL, *to = NULL;
 547         sd_id128_t rnd;
 548         char as_uuid[37];
 549         int r;
 550
 551         assert(dest);
 552
 553         /* Generate a new randomized boot ID, so that each boot-up of
 554          * the container gets a new one */
 555
 556         from = strappend(dest, "/dev/proc-sys-kernel-random-boot-id");
 557         to = strappend(dest, "/proc/sys/kernel/random/boot_id");
 558         if (!from || !to)
 559                 return log_oom();
 560
 561         r = sd_id128_randomize(&rnd);
 562         if (r < 0) {
 563                 log_error("Failed to generate random boot id: %s", strerror(-r));
 564                 return r;
 565         }
 566
 567         snprintf(as_uuid, sizeof(as_uuid),
 568                  "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 569                  SD_ID128_FORMAT_VAL(rnd));
 570         char_array_0(as_uuid);
 571
 572         r = write_string_file(from, as_uuid);
 573         if (r < 0) {
 574                 log_error("Failed to write boot id: %s", strerror(-r));
 575                 return r;
 576         }
 577
 578         if (mount(from, to, "bind", MS_BIND, NULL) < 0) {
 579                 log_error("Failed to bind mount boot id: %m");
 580                 r = -errno;
 581         } else if (mount(from, to, "bind", MS_BIND|MS_REMOUNT|MS_RDONLY, NULL))
 582                 log_warning("Failed to make boot id read-only: %m");
 583
 584         unlink(from);
 585         return r;
 586 }
 587
 588 static int copy_devnodes(const char *dest) {
 589
 590         static const char devnodes[] =
 591                 "null\0"
 592                 "zero\0"
 593                 "full\0"
 594                 "random\0"
 595                 "urandom\0"
 596                 "tty\0";
 597
 598         const char *d;
 599         int r = 0;
 600         _cleanup_umask_ mode_t u;
 601
 602         assert(dest);
 603
 604         u = umask(0000);
 605
 606         NULSTR_FOREACH(d, devnodes) {
 607                 struct stat st;
 608                 _cleanup_free_ char *from = NULL, *to = NULL;
 609
 610                 asprintf(&from, "/dev/%s", d);
 611                 asprintf(&to, "%s/dev/%s", dest, d);
 612
 613                 if (!from || !to) {
 614                         log_oom();
 615
 616                         if (r == 0)
 617                                 r = -ENOMEM;
 618
 619                         break;
 620                 }
 621
 622                 if (stat(from, &st) < 0) {
 623
 624                         if (errno != ENOENT) {
 625                                 log_error("Failed to stat %s: %m", from);
 626                                 if (r == 0)
 627                                         r = -errno;
 628                         }
 629
 630                 } else if (!S_ISCHR(st.st_mode) && !S_ISBLK(st.st_mode)) {
 631
 632                         log_error("%s is not a char or block device, cannot copy", from);
 633                         if (r == 0)
 634                                 r = -EIO;
 635
 636                 } else if (mknod(to, st.st_mode, st.st_rdev) < 0) {
 637
 638                         log_error("mknod(%s) failed: %m", dest);
 639                         if (r == 0)
 640                                 r = -errno;
 641                 }
 642         }
 643
 644         return r;
 645 }
 646
 647 static int setup_ptmx(const char *dest) {
 648         _cleanup_free_ char *p = NULL;
 649
 650         p = strappend(dest, "/dev/ptmx");
 651         if (!p)
 652                 return log_oom();
 653
 654         if (symlink("pts/ptmx", p) < 0) {
 655                 log_error("Failed to create /dev/ptmx symlink: %m");
 656                 return -errno;
 657         }
 658
 659         return 0;
 660 }
 661
 662 static int setup_dev_console(const char *dest, const char *console) {
 663         struct stat st;
 664         _cleanup_free_ char *to = NULL;
 665         int r;
 666         _cleanup_umask_ mode_t u;
 667
 668         assert(dest);
 669         assert(console);
 670
 671         u = umask(0000);
 672
 673         if (stat(console, &st) < 0) {
 674                 log_error("Failed to stat %s: %m", console);
 675                 return -errno;
 676
 677         } else if (!S_ISCHR(st.st_mode)) {
 678                 log_error("/dev/console is not a char device");
 679                 return -EIO;
 680         }
 681
 682         r = chmod_and_chown(console, 0600, 0, 0);
 683         if (r < 0) {
 684                 log_error("Failed to correct access mode for TTY: %s", strerror(-r));
 685                 return r;
 686         }
 687
 688         if (asprintf(&to, "%s/dev/console", dest) < 0)
 689                 return log_oom();
 690
 691         /* We need to bind mount the right tty to /dev/console since
 692          * ptys can only exist on pts file systems. To have something
 693          * to bind mount things on we create a device node first, that
 694          * has the right major/minor (note that the major minor
 695          * doesn't actually matter here, since we mount it over
 696          * anyway). */
 697
 698         if (mknod(to, (st.st_mode & ~07777) | 0600, st.st_rdev) < 0) {
 699                 log_error("mknod() for /dev/console failed: %m");
 700                 return -errno;
 701         }
 702
 703         if (mount(console, to, "bind", MS_BIND, NULL) < 0) {
 704                 log_error("Bind mount for /dev/console failed: %m");
 705                 return -errno;
 706         }
 707
 708         return 0;
 709 }
 710
 711 static int setup_kmsg(const char *dest, int kmsg_socket) {
 712         _cleanup_free_ char *from = NULL, *to = NULL;
 713         int r, fd, k;
 714         _cleanup_umask_ mode_t u;
 715         union {
 716                 struct cmsghdr cmsghdr;
 717                 uint8_t buf[CMSG_SPACE(sizeof(int))];
 718         } control = {};
 719         struct msghdr mh = {
 720                 .msg_control = &control,
 721                 .msg_controllen = sizeof(control),
 722         };
 723         struct cmsghdr *cmsg;
 724
 725         assert(dest);
 726         assert(kmsg_socket >= 0);
 727
 728         u = umask(0000);
 729
 730         /* We create the kmsg FIFO as /dev/kmsg, but immediately
 731          * delete it after bind mounting it to /proc/kmsg. While FIFOs
 732          * on the reading side behave very similar to /proc/kmsg,
 733          * their writing side behaves differently from /dev/kmsg in
 734          * that writing blocks when nothing is reading. In order to
 735          * avoid any problems with containers deadlocking due to this
 736          * we simply make /dev/kmsg unavailable to the container. */
 737         if (asprintf(&from, "%s/dev/kmsg", dest) < 0 ||
 738             asprintf(&to, "%s/proc/kmsg", dest) < 0)
 739                 return log_oom();
 740
 741         if (mkfifo(from, 0600) < 0) {
 742                 log_error("mkfifo() for /dev/kmsg failed: %m");
 743                 return -errno;
 744         }
 745
 746         r = chmod_and_chown(from, 0600, 0, 0);
 747         if (r < 0) {
 748                 log_error("Failed to correct access mode for /dev/kmsg: %s", strerror(-r));
 749                 return r;
 750         }
 751
 752         if (mount(from, to, "bind", MS_BIND, NULL) < 0) {
 753                 log_error("Bind mount for /proc/kmsg failed: %m");
 754                 return -errno;
 755         }
 756
 757         fd = open(from, O_RDWR|O_NDELAY|O_CLOEXEC);
 758         if (fd < 0) {
 759                 log_error("Failed to open fifo: %m");
 760                 return -errno;
 761         }
 762
 763         cmsg = CMSG_FIRSTHDR(&mh);
 764         cmsg->cmsg_level = SOL_SOCKET;
 765         cmsg->cmsg_type = SCM_RIGHTS;
 766         cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 767         memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
 768
 769         mh.msg_controllen = cmsg->cmsg_len;
 770
 771         /* Store away the fd in the socket, so that it stays open as
 772          * long as we run the child */
 773         k = sendmsg(kmsg_socket, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
 774         close_nointr_nofail(fd);
 775
 776         if (k < 0) {
 777                 log_error("Failed to send FIFO fd: %m");
 778                 return -errno;
 779         }
 780
 781         /* And now make the FIFO unavailable as /dev/kmsg... */
 782         unlink(from);
 783         return 0;
 784 }
 785
 786 static int setup_hostname(void) {
 787
 788         if (sethostname(arg_machine, strlen(arg_machine)) < 0)
 789                 return -errno;
 790
 791         return 0;
 792 }
 793
 794 static int setup_journal(const char *directory) {
 795         sd_id128_t machine_id;
 796         _cleanup_free_ char *p = NULL, *b = NULL, *q = NULL, *d = NULL;
 797         char *id;
 798         int r;
 799
 800         if (arg_link_journal == LINK_NO)
 801                 return 0;
 802
 803         p = strappend(directory, "/etc/machine-id");
 804         if (!p)
 805                 return log_oom();
 806
 807         r = read_one_line_file(p, &b);
 808         if (r == -ENOENT && arg_link_journal == LINK_AUTO)
 809                 return 0;
 810         else if (r < 0) {
 811                 log_error("Failed to read machine ID from %s: %s", p, strerror(-r));
 812                 return r;
 813         }
 814
 815         id = strstrip(b);
 816         if (isempty(id) && arg_link_journal == LINK_AUTO)
 817                 return 0;
 818
 819         /* Verify validity */
 820         r = sd_id128_from_string(id, &machine_id);
 821         if (r < 0) {
 822                 log_error("Failed to parse machine ID from %s: %s", p, strerror(-r));
 823                 return r;
 824         }
 825
 826         free(p);
 827         p = strappend("/var/log/journal/", id);
 828         q = strjoin(directory, "/var/log/journal/", id, NULL);
 829         if (!p || !q)
 830                 return log_oom();
 831
 832         if (path_is_mount_point(p, false) > 0) {
 833                 if (arg_link_journal != LINK_AUTO) {
 834                         log_error("%s: already a mount point, refusing to use for journal", p);
 835                         return -EEXIST;
 836                 }
 837
 838                 return 0;
 839         }
 840
 841         if (path_is_mount_point(q, false) > 0) {
 842                 if (arg_link_journal != LINK_AUTO) {
 843                         log_error("%s: already a mount point, refusing to use for journal", q);
 844                         return -EEXIST;
 845                 }
 846
 847                 return 0;
 848         }
 849
 850         r = readlink_and_make_absolute(p, &d);
 851         if (r >= 0) {
 852                 if ((arg_link_journal == LINK_GUEST ||
 853                      arg_link_journal == LINK_AUTO) &&
 854                     path_equal(d, q)) {
 855
 856                         r = mkdir_p(q, 0755);
 857                         if (r < 0)
 858                                 log_warning("failed to create directory %s: %m", q);
 859                         return 0;
 860                 }
 861
 862                 if (unlink(p) < 0) {
 863                         log_error("Failed to remove symlink %s: %m", p);
 864                         return -errno;
 865                 }
 866         } else if (r == -EINVAL) {
 867
 868                 if (arg_link_journal == LINK_GUEST &&
 869                     rmdir(p) < 0) {
 870
 871                         if (errno == ENOTDIR) {
 872                                 log_error("%s already exists and is neither a symlink nor a directory", p);
 873                                 return r;
 874                         } else {
 875                                 log_error("Failed to remove %s: %m", p);
 876                                 return -errno;
 877                         }
 878                 }
 879         } else if (r != -ENOENT) {
 880                 log_error("readlink(%s) failed: %m", p);
 881                 return r;
 882         }
 883
 884         if (arg_link_journal == LINK_GUEST) {
 885
 886                 if (symlink(q, p) < 0) {
 887                         log_error("Failed to symlink %s to %s: %m", q, p);
 888                         return -errno;
 889                 }
 890
 891                 r = mkdir_p(q, 0755);
 892                 if (r < 0)
 893                         log_warning("failed to create directory %s: %m", q);
 894                 return 0;
 895         }
 896
 897         if (arg_link_journal == LINK_HOST) {
 898                 r = mkdir_p(p, 0755);
 899                 if (r < 0) {
 900                         log_error("Failed to create %s: %m", p);
 901                         return r;
 902                 }
 903
 904         } else if (access(p, F_OK) < 0)
 905                 return 0;
 906
 907         if (dir_is_empty(q) == 0) {
 908                 log_error("%s not empty.", q);
 909                 return -ENOTEMPTY;
 910         }
 911
 912         r = mkdir_p(q, 0755);
 913         if (r < 0) {
 914                 log_error("Failed to create %s: %m", q);
 915                 return r;
 916         }
 917
 918         if (mount(p, q, "bind", MS_BIND, NULL) < 0) {
 919                 log_error("Failed to bind mount journal from host into guest: %m");
 920                 return -errno;
 921         }
 922
 923         return 0;
 924 }
 925
 926 static int drop_capabilities(void) {
 927         return capability_bounding_set_drop(~arg_retain, false);
 928 }
 929
 930 static int register_machine(void) {
 931         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 932         _cleanup_bus_unref_ sd_bus *bus = NULL;
 933         int r;
 934
 935         r = sd_bus_open_system(&bus);
 936         if (r < 0) {
 937                 log_error("Failed to open system bus: %s", strerror(-r));
 938                 return r;
 939         }
 940
 941         r = sd_bus_call_method(
 942                         bus,
 943                         "org.freedesktop.machine1",
 944                         "/org/freedesktop/machine1",
 945                         "org.freedesktop.machine1.Manager",
 946                         "CreateMachine",
 947                         &error,
 948                         NULL,
 949                         "sayssusa(sv)",
 950                         arg_machine,
 951                         SD_BUS_MESSAGE_APPEND_ID128(arg_uuid),
 952                         "nspawn",
 953                         "container",
 954                         (uint32_t) 0,
 955                         strempty(arg_directory),
 956                         !isempty(arg_slice), "Slice", "s", arg_slice);
 957         if (r < 0) {
 958                 log_error("Failed to register machine: %s", error.message ? error.message : strerror(-r));
 959                 return r;
 960         }
 961
 962         return 0;
 963 }
 964
 965 static bool audit_enabled(void) {
 966         int fd;
 967
 968         fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_AUDIT);
 969         if (fd >= 0) {
 970                 close_nointr_nofail(fd);
 971                 return true;
 972         }
 973         return false;
 974 }
 975
 976 int main(int argc, char *argv[]) {
 977         pid_t pid = 0;
 978         int r = EXIT_FAILURE, k;
 979         _cleanup_close_ int master = -1;
 980         int n_fd_passed;
 981         const char *console = NULL;
 982         sigset_t mask;
 983         _cleanup_close_pipe_ int kmsg_socket_pair[2] = { -1, -1 };
 984         _cleanup_fdset_free_ FDSet *fds = NULL;
 985
 986         log_parse_environment();
 987         log_open();
 988
 989         k = parse_argv(argc, argv);
 990         if (k < 0)
 991                 goto finish;
 992         else if (k == 0) {
 993                 r = EXIT_SUCCESS;
 994                 goto finish;
 995         }
 996
 997         if (arg_directory) {
 998                 char *p;
 999
1000                 p = path_make_absolute_cwd(arg_directory);
1001                 free(arg_directory);
1002                 arg_directory = p;
1003         } else
1004                 arg_directory = get_current_dir_name();
1005
1006         if (!arg_directory) {
1007                 log_error("Failed to determine path, please use -D.");
1008                 goto finish;
1009         }
1010
1011         path_kill_slashes(arg_directory);
1012
1013         if (!arg_machine) {
1014                 arg_machine = strdup(path_get_file_name(arg_directory));
1015                 if (!arg_machine) {
1016                         log_oom();
1017                         goto finish;
1018                 }
1019
1020                 hostname_cleanup(arg_machine, false);
1021                 if (isempty(arg_machine)) {
1022                         log_error("Failed to determine machine name automatically, please use -M.");
1023                         goto finish;
1024                 }
1025         }
1026
1027         if (geteuid() != 0) {
1028                 log_error("Need to be root.");
1029                 goto finish;
1030         }
1031
1032         if (sd_booted() <= 0) {
1033                 log_error("Not running on a systemd system.");
1034                 goto finish;
1035         }
1036
1037         if (arg_boot && audit_enabled()) {
1038                 log_warning("The kernel auditing subsystem is known to be incompatible with containers.\n"
1039                             "Please make sure to turn off auditing with 'audit=0' on the kernel command\n"
1040                             "line before using systemd-nspawn. Sleeping for 5s...\n");
1041                 sleep(5);
1042         }
1043
1044         if (path_equal(arg_directory, "/")) {
1045                 log_error("Spawning container on root directory not supported.");
1046                 goto finish;
1047         }
1048
1049         if (path_is_os_tree(arg_directory) <= 0) {
1050                 log_error("Directory %s doesn't look like an OS root directory (/etc/os-release is missing). Refusing.", arg_directory);
1051                 goto finish;
1052         }
1053
1054         log_close();
1055         n_fd_passed = sd_listen_fds(false);
1056         if (n_fd_passed > 0) {
1057                 k = fdset_new_listen_fds(&fds, false);
1058                 if (k < 0) {
1059                         log_error("Failed to collect file descriptors: %s", strerror(-k));
1060                         goto finish;
1061                 }
1062         }
1063         fdset_close_others(fds);
1064         log_open();
1065
1066         master = posix_openpt(O_RDWR|O_NOCTTY|O_CLOEXEC|O_NDELAY);
1067         if (master < 0) {
1068                 log_error("Failed to acquire pseudo tty: %m");
1069                 goto finish;
1070         }
1071
1072         console = ptsname(master);
1073         if (!console) {
1074                 log_error("Failed to determine tty name: %m");
1075                 goto finish;
1076         }
1077
1078         log_info("Spawning container %s on %s. Press ^] three times within 1s to abort execution.", arg_machine, arg_directory);
1079
1080         if (unlockpt(master) < 0) {
1081                 log_error("Failed to unlock tty: %m");
1082                 goto finish;
1083         }
1084
1085         if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, kmsg_socket_pair) < 0) {
1086                 log_error("Failed to create kmsg socket pair.");
1087                 goto finish;
1088         }
1089
1090         sd_notify(0, "READY=1");
1091
1092         assert_se(sigemptyset(&mask) == 0);
1093         sigset_add_many(&mask, SIGCHLD, SIGWINCH, SIGTERM, SIGINT, -1);
1094         assert_se(sigprocmask(SIG_BLOCK, &mask, NULL) == 0);
1095
1096         for (;;) {
1097                 siginfo_t status;
1098
1099                 pid = syscall(__NR_clone, SIGCHLD|CLONE_NEWIPC|CLONE_NEWNS|CLONE_NEWPID|CLONE_NEWUTS|(arg_private_network ? CLONE_NEWNET : 0), NULL);
1100                 if (pid < 0) {
1101                         if (errno == EINVAL)
1102                                 log_error("clone() failed, do you have namespace support enabled in your kernel? (You need UTS, IPC, PID and NET namespacing built in): %m");
1103                         else
1104                                 log_error("clone() failed: %m");
1105
1106                         goto finish;
1107                 }
1108
1109                 if (pid == 0) {
1110                         /* child */
1111                         const char *home = NULL;
1112                         uid_t uid = (uid_t) -1;
1113                         gid_t gid = (gid_t) -1;
1114                         unsigned n_env = 2;
1115                         const char *envp[] = {
1116                                 "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1117                                 "container=systemd-nspawn", /* LXC sets container=lxc, so follow the scheme here */
1118                                 NULL, /* TERM */
1119                                 NULL, /* HOME */
1120                                 NULL, /* USER */
1121                                 NULL, /* LOGNAME */
1122                                 NULL, /* container_uuid */
1123                                 NULL, /* LISTEN_FDS */
1124                                 NULL, /* LISTEN_PID */
1125                                 NULL
1126                         };
1127
1128                         envp[n_env] = strv_find_prefix(environ, "TERM=");
1129                         if (envp[n_env])
1130                                 n_env ++;
1131
1132                         close_nointr_nofail(master);
1133                         master = -1;
1134
1135                         close_nointr(STDIN_FILENO);
1136                         close_nointr(STDOUT_FILENO);
1137                         close_nointr(STDERR_FILENO);
1138
1139                         close_nointr_nofail(kmsg_socket_pair[0]);
1140                         kmsg_socket_pair[0] = -1;
1141
1142                         reset_all_signal_handlers();
1143
1144                         assert_se(sigemptyset(&mask) == 0);
1145                         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1146
1147                         k = open_terminal(console, O_RDWR);
1148                         if (k != STDIN_FILENO) {
1149                                 if (k >= 0) {
1150                                         close_nointr_nofail(k);
1151                                         k = -EINVAL;
1152                                 }
1153
1154                                 log_error("Failed to open console: %s", strerror(-k));
1155                                 goto child_fail;
1156                         }
1157
1158                         if (dup2(STDIN_FILENO, STDOUT_FILENO) != STDOUT_FILENO ||
1159                             dup2(STDIN_FILENO, STDERR_FILENO) != STDERR_FILENO) {
1160                                 log_error("Failed to duplicate console: %m");
1161                                 goto child_fail;
1162                         }
1163
1164                         if (setsid() < 0) {
1165                                 log_error("setsid() failed: %m");
1166                                 goto child_fail;
1167                         }
1168
1169                         if (prctl(PR_SET_PDEATHSIG, SIGKILL) < 0) {
1170                                 log_error("PR_SET_PDEATHSIG failed: %m");
1171                                 goto child_fail;
1172                         }
1173
1174                         r = register_machine();
1175                         if (r < 0)
1176                                 goto finish;
1177
1178                         /* Mark everything as slave, so that we still
1179                          * receive mounts from the real root, but don't
1180                          * propagate mounts to the real root. */
1181                         if (mount(NULL, "/", NULL, MS_SLAVE|MS_REC, NULL) < 0) {
1182                                 log_error("MS_SLAVE|MS_REC failed: %m");
1183                                 goto child_fail;
1184                         }
1185
1186                         /* Turn directory into bind mount */
1187                         if (mount(arg_directory, arg_directory, "bind", MS_BIND|MS_REC, NULL) < 0) {
1188                                 log_error("Failed to make bind mount.");
1189                                 goto child_fail;
1190                         }
1191
1192                         if (arg_read_only)
1193                                 if (mount(arg_directory, arg_directory, "bind", MS_BIND|MS_REMOUNT|MS_RDONLY|MS_REC, NULL) < 0) {
1194                                         log_error("Failed to make read-only.");
1195                                         goto child_fail;
1196                                 }
1197
1198                         if (mount_all(arg_directory) < 0)
1199                                 goto child_fail;
1200
1201                         if (copy_devnodes(arg_directory) < 0)
1202                                 goto child_fail;
1203
1204                         if (setup_ptmx(arg_directory) < 0)
1205                                 goto child_fail;
1206
1207                         dev_setup(arg_directory);
1208
1209                         if (setup_dev_console(arg_directory, console) < 0)
1210                                 goto child_fail;
1211
1212                         if (setup_kmsg(arg_directory, kmsg_socket_pair[1]) < 0)
1213                                 goto child_fail;
1214
1215                         close_nointr_nofail(kmsg_socket_pair[1]);
1216                         kmsg_socket_pair[1] = -1;
1217
1218                         if (setup_boot_id(arg_directory) < 0)
1219                                 goto child_fail;
1220
1221                         if (setup_timezone(arg_directory) < 0)
1222                                 goto child_fail;
1223
1224                         if (setup_resolv_conf(arg_directory) < 0)
1225                                 goto child_fail;
1226
1227                         if (setup_journal(arg_directory) < 0)
1228                                 goto child_fail;
1229
1230                         if (mount_binds(arg_directory, arg_bind, 0) < 0)
1231                                 goto child_fail;
1232
1233                         if (mount_binds(arg_directory, arg_bind_ro, MS_RDONLY) < 0)
1234                                 goto child_fail;
1235
1236                         if (chdir(arg_directory) < 0) {
1237                                 log_error("chdir(%s) failed: %m", arg_directory);
1238                                 goto child_fail;
1239                         }
1240
1241                         if (mount(arg_directory, "/", NULL, MS_MOVE, NULL) < 0) {
1242                                 log_error("mount(MS_MOVE) failed: %m");
1243                                 goto child_fail;
1244                         }
1245
1246                         if (chroot(".") < 0) {
1247                                 log_error("chroot() failed: %m");
1248                                 goto child_fail;
1249                         }
1250
1251                         if (chdir("/") < 0) {
1252                                 log_error("chdir() failed: %m");
1253                                 goto child_fail;
1254                         }
1255
1256                         umask(0022);
1257
1258                         loopback_setup();
1259
1260                         if (drop_capabilities() < 0) {
1261                                 log_error("drop_capabilities() failed: %m");
1262                                 goto child_fail;
1263                         }
1264
1265                         if (arg_user) {
1266
1267                                 /* Note that this resolves user names
1268                                  * inside the container, and hence
1269                                  * accesses the NSS modules from the
1270                                  * container and not the host. This is
1271                                  * a bit weird... */
1272
1273                                 if (get_user_creds((const char**)&arg_user, &uid, &gid, &home, NULL) < 0) {
1274                                         log_error("get_user_creds() failed: %m");
1275                                         goto child_fail;
1276                                 }
1277
1278                                 if (mkdir_parents_label(home, 0775) < 0) {
1279                                         log_error("mkdir_parents_label() failed: %m");
1280                                         goto child_fail;
1281                                 }
1282
1283                                 if (mkdir_safe_label(home, 0775, uid, gid) < 0) {
1284                                         log_error("mkdir_safe_label() failed: %m");
1285                                         goto child_fail;
1286                                 }
1287
1288                                 if (initgroups((const char*)arg_user, gid) < 0) {
1289                                         log_error("initgroups() failed: %m");
1290                                         goto child_fail;
1291                                 }
1292
1293                                 if (setresgid(gid, gid, gid) < 0) {
1294                                         log_error("setregid() failed: %m");
1295                                         goto child_fail;
1296                                 }
1297
1298                                 if (setresuid(uid, uid, uid) < 0) {
1299                                         log_error("setreuid() failed: %m");
1300                                         goto child_fail;
1301                                 }
1302                         } else {
1303                                 /* Reset everything fully to 0, just in case */
1304
1305                                 if (setgroups(0, NULL) < 0) {
1306                                         log_error("setgroups() failed: %m");
1307                                         goto child_fail;
1308                                 }
1309
1310                                 if (setresgid(0, 0, 0) < 0) {
1311                                         log_error("setregid() failed: %m");
1312                                         goto child_fail;
1313                                 }
1314
1315                                 if (setresuid(0, 0, 0) < 0) {
1316                                         log_error("setreuid() failed: %m");
1317                                         goto child_fail;
1318                                 }
1319                         }
1320
1321                         if ((asprintf((char**)(envp + n_env++), "HOME=%s", home ? home: "/root") < 0) ||
1322                             (asprintf((char**)(envp + n_env++), "USER=%s", arg_user ? arg_user : "root") < 0) ||
1323                             (asprintf((char**)(envp + n_env++), "LOGNAME=%s", arg_user ? arg_user : "root") < 0)) {
1324                                 log_oom();
1325                                 goto child_fail;
1326                         }
1327
1328                         if (!sd_id128_equal(arg_uuid, SD_ID128_NULL)) {
1329                                 if (asprintf((char**)(envp + n_env++), "container_uuid=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(arg_uuid)) < 0) {
1330                                         log_oom();
1331                                         goto child_fail;
1332                                 }
1333                         }
1334
1335                         if (fdset_size(fds) > 0) {
1336                                 k = fdset_cloexec(fds, false);
1337                                 if (k < 0) {
1338                                         log_error("Failed to unset O_CLOEXEC for file descriptors.");
1339                                         goto child_fail;
1340                                 }
1341
1342                                 if ((asprintf((char **)(envp + n_env++), "LISTEN_FDS=%u", n_fd_passed) < 0) ||
1343                                     (asprintf((char **)(envp + n_env++), "LISTEN_PID=1") < 0)) {
1344                                         log_oom();
1345                                         goto child_fail;
1346                                 }
1347                         }
1348
1349                         setup_hostname();
1350
1351                         if (arg_boot) {
1352                                 char **a;
1353                                 size_t l;
1354
1355                                 /* Automatically search for the init system */
1356
1357                                 l = 1 + argc - optind;
1358                                 a = newa(char*, l + 1);
1359                                 memcpy(a + 1, argv + optind, l * sizeof(char*));
1360
1361                                 a[0] = (char*) "/usr/lib/systemd/systemd";
1362                                 execve(a[0], a, (char**) envp);
1363
1364                                 a[0] = (char*) "/lib/systemd/systemd";
1365                                 execve(a[0], a, (char**) envp);
1366
1367                                 a[0] = (char*) "/sbin/init";
1368                                 execve(a[0], a, (char**) envp);
1369                         } else if (argc > optind)
1370                                 execvpe(argv[optind], argv + optind, (char**) envp);
1371                         else {
1372                                 chdir(home ? home : "/root");
1373                                 execle("/bin/bash", "-bash", NULL, (char**) envp);
1374                         }
1375
1376                         log_error("execv() failed: %m");
1377
1378                 child_fail:
1379                         _exit(EXIT_FAILURE);
1380                 }
1381
1382                 fdset_free(fds);
1383                 fds = NULL;
1384
1385                 k = process_pty(master, &mask, arg_boot ? pid : 0, SIGRTMIN+3);
1386                 if (k < 0) {
1387                         r = EXIT_FAILURE;
1388                         break;
1389                 }
1390
1391                 putc('\n', stdout);
1392
1393                 /* Kill if it is not dead yet anyway */
1394                 kill(pid, SIGKILL);
1395
1396                 k = wait_for_terminate(pid, &status);
1397                 pid = 0;
1398
1399                 if (k < 0) {
1400                         r = EXIT_FAILURE;
1401                         break;
1402                 }
1403
1404                 if (status.si_code == CLD_EXITED) {
1405                         r = status.si_status;
1406                         if (status.si_status != 0) {
1407                                 log_error("Container %s failed with error code %i.", arg_machine, status.si_status);
1408                                 break;
1409                         }
1410
1411                         log_debug("Container %s exited successfully.", arg_machine);
1412                         break;
1413                 } else if (status.si_code == CLD_KILLED &&
1414                            status.si_status == SIGINT) {
1415                         log_info("Container %s has been shut down.", arg_machine);
1416                         r = 0;
1417                         break;
1418                 } else if (status.si_code == CLD_KILLED &&
1419                            status.si_status == SIGHUP) {
1420                         log_info("Container %s is being rebooted.", arg_machine);
1421                         continue;
1422                 } else if (status.si_code == CLD_KILLED ||
1423                            status.si_code == CLD_DUMPED) {
1424
1425                         log_error("Container %s terminated by signal %s.", arg_machine,  signal_to_string(status.si_status));
1426                         r = EXIT_FAILURE;
1427                         break;
1428                 } else {
1429                         log_error("Container %s failed due to unknown reason.", arg_machine);
1430                         r = EXIT_FAILURE;
1431                         break;
1432                 }
1433         }
1434
1435 finish:
1436         if (pid > 0)
1437                 kill(pid, SIGKILL);
1438
1439         free(arg_directory);
1440         free(arg_machine);
1441
1442         return r;
1443 }