src/core/machine-id-setup.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 <unistd.h>
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <fcntl.h>
  28 #include <sys/mount.h>
  29
  30 #include "systemd/sd-id128.h"
  31
  32 #include "machine-id-setup.h"
  33 #include "macro.h"
  34 #include "util.h"
  35 #include "mkdir.h"
  36 #include "log.h"
  37 #include "virt.h"
  38 #include "fileio.h"
  39 #include "path-util.h"
  40
  41 static int shorten_uuid(char destination[34], const char source[36]) {
  42         unsigned i, j;
  43
  44         for (i = 0, j = 0; i < 36 && j < 32; i++) {
  45                 int t;
  46
  47                 t = unhexchar(source[i]);
  48                 if (t < 0)
  49                         continue;
  50
  51                 destination[j++] = hexchar(t);
  52         }
  53
  54         if (i == 36 && j == 32) {
  55                 destination[32] = '\n';
  56                 destination[33] = 0;
  57                 return 0;
  58         }
  59
  60         return -EINVAL;
  61 }
  62
  63 static int generate(char id[34], const char *root) {
  64         int fd, r;
  65         unsigned char *p;
  66         sd_id128_t buf;
  67         char  *q;
  68         ssize_t k;
  69         const char *vm_id, *dbus_machine_id;
  70
  71         assert(id);
  72
  73         if (isempty(root))
  74                 dbus_machine_id = "/var/lib/dbus/machine-id";
  75         else
  76                 dbus_machine_id = strappenda(root, "/var/lib/dbus/machine-id");
  77
  78         /* First, try reading the D-Bus machine id, unless it is a symlink */
  79         fd = open(dbus_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
  80         if (fd >= 0) {
  81                 k = loop_read(fd, id, 33, false);
  82                 safe_close(fd);
  83
  84                 if (k == 33 && id[32] == '\n') {
  85
  86                         id[32] = 0;
  87                         if (id128_is_valid(id)) {
  88                                 id[32] = '\n';
  89                                 id[33] = 0;
  90
  91                                 log_info("Initializing machine ID from D-Bus machine ID.");
  92                                 return 0;
  93                         }
  94                 }
  95         }
  96
  97         if (isempty(root)) {
  98                 /* If that didn't work, see if we are running in a container,
  99                  * and a machine ID was passed in via $container_uuid the way
 100                  * libvirt/LXC does it */
 101                 r = detect_container(NULL);
 102                 if (r > 0) {
 103                         _cleanup_free_ char *e = NULL;
 104
 105                         r = getenv_for_pid(1, "container_uuid", &e);
 106                         if (r > 0) {
 107                                 if (strlen(e) >= 36) {
 108                                         r = shorten_uuid(id, e);
 109                                         if (r >= 0) {
 110                                                 log_info("Initializing machine ID from container UUID.");
 111                                                 return 0;
 112                                         }
 113                                 }
 114                         }
 115
 116                 } else {
 117                         /* If we are not running in a container, see if we are
 118                          * running in qemu/kvm and a machine ID was passed in
 119                          * via -uuid on the qemu/kvm command line */
 120
 121                         r = detect_vm(&vm_id);
 122                         if (r > 0 && streq(vm_id, "kvm")) {
 123                                 char uuid[37];
 124
 125                                 fd = open("/sys/class/dmi/id/product_uuid", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
 126                                 if (fd >= 0) {
 127                                         k = loop_read(fd, uuid, 36, false);
 128                                         safe_close(fd);
 129
 130                                         if (k >= 36) {
 131                                                 r = shorten_uuid(id, uuid);
 132                                                 if (r >= 0) {
 133                                                         log_info("Initializing machine ID from KVM UUID.");
 134                                                         return 0;
 135                                                 }
 136                                         }
 137                                 }
 138                         }
 139                 }
 140         }
 141
 142         /* If that didn't work, generate a random machine id */
 143         r = sd_id128_randomize(&buf);
 144         if (r < 0)
 145                 return log_error_errno(r, "Failed to open /dev/urandom: %m");
 146
 147         for (p = buf.bytes, q = id; p < buf.bytes + sizeof(buf); p++, q += 2) {
 148                 q[0] = hexchar(*p >> 4);
 149                 q[1] = hexchar(*p & 15);
 150         }
 151
 152         id[32] = '\n';
 153         id[33] = 0;
 154
 155         log_info("Initializing machine ID from random generator.");
 156
 157         return 0;
 158 }
 159
 160 static int get_valid_machine_id(int fd, char id[34]) {
 161         char id_to_validate[34];
 162
 163         assert(fd >= 0);
 164         assert(id);
 165
 166         if (loop_read(fd, id_to_validate, 33, false) == 33 && id_to_validate[32] == '\n') {
 167                 id_to_validate[32] = 0;
 168
 169                 if (id128_is_valid(id_to_validate)) {
 170                         memcpy(id, id_to_validate, 32);
 171                         id[32] = '\n';
 172                         id[33] = 0;
 173                         return 0;
 174                 }
 175         }
 176
 177         return -EINVAL;
 178 }
 179
 180 static int write_machine_id(int fd, char id[34]) {
 181         assert(fd >= 0);
 182         assert(id);
 183         lseek(fd, 0, SEEK_SET);
 184
 185         if (loop_write(fd, id, 33, false) == 33)
 186                 return 0;
 187
 188         return -errno;
 189 }
 190
 191 int machine_id_setup(const char *root) {
 192         const char *etc_machine_id, *run_machine_id;
 193         _cleanup_close_ int fd = -1;
 194         bool writable = true;
 195         struct stat st;
 196         char id[34]; /* 32 + \n + \0 */
 197         int r;
 198
 199         if (isempty(root))  {
 200                 etc_machine_id = "/etc/machine-id";
 201                 run_machine_id = "/run/machine-id";
 202         } else {
 203                 char *x;
 204
 205                 x = strappenda(root, "/etc/machine-id");
 206                 etc_machine_id = path_kill_slashes(x);
 207
 208                 x = strappenda(root, "/run/machine-id");
 209                 run_machine_id = path_kill_slashes(x);
 210         }
 211
 212         RUN_WITH_UMASK(0000) {
 213                 /* We create this 0444, to indicate that this isn't really
 214                  * something you should ever modify. Of course, since the file
 215                  * will be owned by root it doesn't matter much, but maybe
 216                  * people look. */
 217
 218                 mkdir_parents(etc_machine_id, 0755);
 219                 fd = open(etc_machine_id, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0444);
 220                 if (fd < 0) {
 221                         int old_errno = errno;
 222
 223                         fd = open(etc_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY);
 224                         if (fd < 0) {
 225                                 if (old_errno == EROFS && errno == ENOENT)
 226                                         log_error("System cannot boot: Missing /etc/machine-id and /etc is mounted read-only.\n"
 227                                                   "Booting up is supported only when:\n"
 228                                                   "1) /etc/machine-id exists and is populated.\n"
 229                                                   "2) /etc/machine-id exists and is empty.\n"
 230                                                   "3) /etc/machine-id is missing and /etc is writable.\n");
 231                                 else
 232                                         log_error_errno(errno, "Cannot open %s: %m", etc_machine_id);
 233                                 return -errno;
 234                         }
 235
 236                         writable = false;
 237                 }
 238         }
 239
 240         if (fstat(fd, &st) < 0)
 241                 return log_error_errno(errno, "fstat() failed: %m");
 242
 243         if (S_ISREG(st.st_mode) && get_valid_machine_id(fd, id) == 0)
 244                 return 0;
 245
 246         /* Hmm, so, the id currently stored is not useful, then let's
 247          * generate one */
 248
 249         r = generate(id, root);
 250         if (r < 0)
 251                 return r;
 252
 253         if (S_ISREG(st.st_mode) && writable) {
 254                 if (write_machine_id(fd, id) == 0)
 255                         return 0;
 256         }
 257
 258         fd = safe_close(fd);
 259
 260         /* Hmm, we couldn't write it? So let's write it to
 261          * /run/machine-id as a replacement */
 262
 263         RUN_WITH_UMASK(0022) {
 264                 r = write_string_file(run_machine_id, id);
 265         }
 266         if (r < 0) {
 267                 log_error_errno(r, "Cannot write %s: %m", run_machine_id);
 268                 unlink(run_machine_id);
 269                 return r;
 270         }
 271
 272         /* And now, let's mount it over */
 273         r = mount(run_machine_id, etc_machine_id, NULL, MS_BIND, NULL);
 274         if (r < 0) {
 275                 log_error_errno(errno, "Failed to mount %s: %m", etc_machine_id);
 276                 unlink_noerrno(run_machine_id);
 277                 return -errno;
 278         }
 279
 280         log_info("Installed transient %s file.", etc_machine_id);
 281
 282         /* Mark the mount read-only */
 283         if (mount(NULL, etc_machine_id, NULL, MS_BIND|MS_RDONLY|MS_REMOUNT, NULL) < 0)
 284                 log_warning_errno(errno, "Failed to make transient %s read-only: %m", etc_machine_id);
 285
 286         return 0;
 287 }