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
  40 static int shorten_uuid(char destination[36], const char *source) {
  41         unsigned i, j;
  42
  43         for (i = 0, j = 0; i < 36 && j < 32; i++) {
  44                 int t;
  45
  46                 t = unhexchar(source[i]);
  47                 if (t < 0)
  48                         continue;
  49
  50                 destination[j++] = hexchar(t);
  51         }
  52
  53         if (i == 36 && j == 32) {
  54                 destination[32] = '\n';
  55                 destination[33] = 0;
  56                 return 0;
  57         }
  58
  59         return -EINVAL;
  60 }
  61
  62 static int generate(char id[34]) {
  63         int fd, r;
  64         unsigned char *p;
  65         sd_id128_t buf;
  66         char *q;
  67         ssize_t k;
  68         const char *vm_id;
  69
  70         assert(id);
  71
  72         /* First, try reading the D-Bus machine id, unless it is a symlink */
  73         fd = open("/var/lib/dbus/machine-id", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
  74         if (fd >= 0) {
  75                 k = loop_read(fd, id, 33, false);
  76                 close_nointr_nofail(fd);
  77
  78                 if (k == 33 && id[32] == '\n') {
  79
  80                         id[32] = 0;
  81                         if (id128_is_valid(id)) {
  82                                 id[32] = '\n';
  83                                 id[33] = 0;
  84
  85                                 log_info("Initializing machine ID from D-Bus machine ID.");
  86                                 return 0;
  87                         }
  88                 }
  89         }
  90
  91         /* If that didn't work, see if we are running in qemu/kvm and a
  92          * machine ID was passed in via -uuid on the qemu/kvm command
  93          * line */
  94
  95         r = detect_vm(&vm_id);
  96         if (r > 0 && streq(vm_id, "kvm")) {
  97                 char uuid[37];
  98
  99                 fd = open("/sys/class/dmi/id/product_uuid", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
 100                 if (fd >= 0) {
 101                         k = loop_read(fd, uuid, 36, false);
 102                         close_nointr_nofail(fd);
 103
 104                         if (k >= 36) {
 105                                 r = shorten_uuid(id, uuid);
 106                                 if (r >= 0) {
 107                                         log_info("Initializing machine ID from KVM UUID.");
 108                                         return 0;
 109                                 }
 110                         }
 111                 }
 112         }
 113
 114         /* If that didn't work either, see if we are running in a
 115          * container, and a machine ID was passed in via
 116          * $container_uuid the way libvirt/LXC does it */
 117         r = detect_container(NULL);
 118         if (r > 0) {
 119                 _cleanup_free_ char *e = NULL;
 120
 121                 r = getenv_for_pid(1, "container_uuid", &e);
 122                 if (r > 0) {
 123                         if (strlen(e) >= 36) {
 124                                 r = shorten_uuid(id, e);
 125                                 if (r >= 0) {
 126                                         log_info("Initializing machine ID from container UUID.");
 127                                         return 0;
 128                                 }
 129                         }
 130                 }
 131         }
 132
 133         /* If that didn't work, generate a random machine id */
 134         r = sd_id128_randomize(&buf);
 135         if (r < 0) {
 136                 log_error("Failed to open /dev/urandom: %s", strerror(-r));
 137                 return r;
 138         }
 139
 140         for (p = buf.bytes, q = id; p < buf.bytes + sizeof(buf); p++, q += 2) {
 141                 q[0] = hexchar(*p >> 4);
 142                 q[1] = hexchar(*p & 15);
 143         }
 144
 145         id[32] = '\n';
 146         id[33] = 0;
 147
 148         log_info("Initializing machine ID from random generator.");
 149
 150         return 0;
 151 }
 152
 153 int machine_id_setup(void) {
 154         _cleanup_close_ int fd = -1;
 155         int r;
 156         bool writable = false;
 157         struct stat st;
 158         char id[34]; /* 32 + \n + \0 */
 159
 160         RUN_WITH_UMASK(0000) {
 161                 /* We create this 0444, to indicate that this isn't really
 162                  * something you should ever modify. Of course, since the file
 163                  * will be owned by root it doesn't matter much, but maybe
 164                  * people look. */
 165
 166                 fd = open("/etc/machine-id", O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0444);
 167                 if (fd >= 0)
 168                         writable = true;
 169                 else {
 170                         fd = open("/etc/machine-id", O_RDONLY|O_CLOEXEC|O_NOCTTY);
 171                         if (fd < 0) {
 172                                 log_error("Cannot open /etc/machine-id: %m");
 173                                 return -errno;
 174                         }
 175
 176                         writable = false;
 177                 }
 178         }
 179
 180         if (fstat(fd, &st) < 0) {
 181                 log_error("fstat() failed: %m");
 182                 return -errno;
 183         }
 184
 185         if (S_ISREG(st.st_mode))
 186                 if (loop_read(fd, id, 33, false) == 33 && id[32] == '\n') {
 187                         id[32] = 0;
 188
 189                         if (id128_is_valid(id))
 190                                 return 0;
 191                 }
 192
 193         /* Hmm, so, the id currently stored is not useful, then let's
 194          * generate one */
 195
 196         r = generate(id);
 197         if (r < 0)
 198                 return r;
 199
 200         if (S_ISREG(st.st_mode) && writable) {
 201                 lseek(fd, 0, SEEK_SET);
 202
 203                 if (loop_write(fd, id, 33, false) == 33)
 204                         return 0;
 205         }
 206
 207         close_nointr_nofail(fd);
 208         fd = -1;
 209
 210         /* Hmm, we couldn't write it? So let's write it to
 211          * /run/machine-id as a replacement */
 212
 213         RUN_WITH_UMASK(0022) {
 214                 r = write_string_file("/run/machine-id", id);
 215         }
 216         if (r < 0) {
 217                 log_error("Cannot write /run/machine-id: %s", strerror(-r));
 218                 unlink("/run/machine-id");
 219                 return r;
 220         }
 221
 222         /* And now, let's mount it over */
 223         r = mount("/run/machine-id", "/etc/machine-id", NULL, MS_BIND, NULL);
 224         if (r < 0) {
 225                 log_error("Failed to mount /etc/machine-id: %m");
 226                 unlink_noerrno("/run/machine-id");
 227                 return -errno;
 228         }
 229
 230         log_info("Installed transient /etc/machine-id file.");
 231
 232         /* Mark the mount read-only */
 233         if (mount(NULL, "/etc/machine-id", NULL, MS_BIND|MS_RDONLY|MS_REMOUNT, NULL) < 0)
 234                 log_warning("Failed to make transient /etc/machine-id read-only: %m");
 235
 236         return 0;
 237 }