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                 log_error("Failed to open /dev/urandom: %s", strerror(-r));
 146                 return r;
 147         }
 148
 149         for (p = buf.bytes, q = id; p < buf.bytes + sizeof(buf); p++, q += 2) {
 150                 q[0] = hexchar(*p >> 4);
 151                 q[1] = hexchar(*p & 15);
 152         }
 153
 154         id[32] = '\n';
 155         id[33] = 0;
 156
 157         log_info("Initializing machine ID from random generator.");
 158
 159         return 0;
 160 }
 161
 162 int machine_id_setup(const char *root) {
 163         const char *etc_machine_id, *run_machine_id;
 164         _cleanup_close_ int fd = -1;
 165         bool writable = false;
 166         struct stat st;
 167         char id[34]; /* 32 + \n + \0 */
 168         int r;
 169
 170         if (isempty(root))  {
 171                 etc_machine_id = "/etc/machine-id";
 172                 run_machine_id = "/run/machine-id";
 173         } else {
 174                 etc_machine_id = strappenda(root, "/etc/machine-id");
 175                 path_kill_slashes((char*) etc_machine_id);
 176
 177                 run_machine_id = strappenda(root, "/run/machine-id");
 178                 path_kill_slashes((char*) run_machine_id);
 179         }
 180
 181         RUN_WITH_UMASK(0000) {
 182                 /* We create this 0444, to indicate that this isn't really
 183                  * something you should ever modify. Of course, since the file
 184                  * will be owned by root it doesn't matter much, but maybe
 185                  * people look. */
 186
 187                 mkdir_parents(etc_machine_id, 0755);
 188                 fd = open(etc_machine_id, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0444);
 189                 if (fd >= 0)
 190                         writable = true;
 191                 else {
 192                         fd = open(etc_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY);
 193                         if (fd < 0) {
 194                                 log_error("Cannot open %s: %m", etc_machine_id);
 195                                 return -errno;
 196                         }
 197
 198                         writable = false;
 199                 }
 200         }
 201
 202         if (fstat(fd, &st) < 0) {
 203                 log_error("fstat() failed: %m");
 204                 return -errno;
 205         }
 206
 207         if (S_ISREG(st.st_mode))
 208                 if (loop_read(fd, id, 33, false) == 33 && id[32] == '\n') {
 209                         id[32] = 0;
 210
 211                         if (id128_is_valid(id))
 212                                 return 0;
 213                 }
 214
 215         /* Hmm, so, the id currently stored is not useful, then let's
 216          * generate one */
 217
 218         r = generate(id, root);
 219         if (r < 0)
 220                 return r;
 221
 222         if (S_ISREG(st.st_mode) && writable) {
 223                 lseek(fd, 0, SEEK_SET);
 224
 225                 if (loop_write(fd, id, 33, false) == 33)
 226                         return 0;
 227         }
 228
 229         fd = safe_close(fd);
 230
 231         /* Hmm, we couldn't write it? So let's write it to
 232          * /run/machine-id as a replacement */
 233
 234         RUN_WITH_UMASK(0022) {
 235                 r = write_string_file(run_machine_id, id);
 236         }
 237         if (r < 0) {
 238                 log_error("Cannot write %s: %s", run_machine_id, strerror(-r));
 239                 unlink(run_machine_id);
 240                 return r;
 241         }
 242
 243         /* And now, let's mount it over */
 244         r = mount(run_machine_id, etc_machine_id, NULL, MS_BIND, NULL);
 245         if (r < 0) {
 246                 log_error("Failed to mount %s: %m", etc_machine_id);
 247                 unlink_noerrno(run_machine_id);
 248                 return -errno;
 249         }
 250
 251         log_info("Installed transient %s file.", etc_machine_id);
 252
 253         /* Mark the mount read-only */
 254         if (mount(NULL, etc_machine_id, NULL, MS_BIND|MS_RDONLY|MS_REMOUNT, NULL) < 0)
 255                 log_warning("Failed to make transient %s read-only: %m", etc_machine_id);
 256
 257         return 0;
 258 }