5430f7f2bc
We finally got the OK from all contributors with non-trivial commits to relicense systemd from GPL2+ to LGPL2.1+. Some udev bits continue to be GPL2+ for now, but we are looking into relicensing them too, to allow free copy/paste of all code within systemd. The bits that used to be MIT continue to be MIT. The big benefit of the relicensing is that closed source code may now link against libsystemd-login.so and friends.
266 lines
7.8 KiB
C
266 lines
7.8 KiB
C
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
|
|
|
/***
|
|
This file is part of systemd.
|
|
|
|
Copyright 2010 Lennart Poettering
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
***/
|
|
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <sys/mount.h>
|
|
|
|
#include <systemd/sd-id128.h>
|
|
|
|
#include "machine-id-setup.h"
|
|
#include "macro.h"
|
|
#include "util.h"
|
|
#include "mkdir.h"
|
|
#include "log.h"
|
|
#include "virt.h"
|
|
|
|
static int shorten_uuid(char destination[36], const char *source) {
|
|
unsigned i, j;
|
|
|
|
for (i = 0, j = 0; i < 36 && j < 32; i++) {
|
|
int t;
|
|
|
|
t = unhexchar(source[i]);
|
|
if (t < 0)
|
|
continue;
|
|
|
|
destination[j++] = hexchar(t);
|
|
}
|
|
|
|
if (i == 36 && j == 32) {
|
|
destination[32] = '\n';
|
|
destination[33] = 0;
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int generate(char id[34]) {
|
|
int fd, r;
|
|
unsigned char *p;
|
|
sd_id128_t buf;
|
|
char *q;
|
|
ssize_t k;
|
|
const char *vm_id;
|
|
|
|
assert(id);
|
|
|
|
/* First, try reading the D-Bus machine id, unless it is a symlink */
|
|
fd = open("/var/lib/dbus/machine-id", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
|
|
if (fd >= 0) {
|
|
|
|
k = loop_read(fd, id, 32, false);
|
|
close_nointr_nofail(fd);
|
|
|
|
if (k >= 32) {
|
|
id[32] = '\n';
|
|
id[33] = 0;
|
|
|
|
log_info("Initializing machine ID from D-Bus machine ID.");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* If that didn't work, see if we are running in qemu/kvm and a
|
|
* machine ID was passed in via -uuid on the qemu/kvm command
|
|
* line */
|
|
|
|
r = detect_vm(&vm_id);
|
|
if (r > 0 && streq(vm_id, "kvm")) {
|
|
char uuid[37];
|
|
|
|
fd = open("/sys/class/dmi/id/product_uuid", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
|
|
if (fd >= 0) {
|
|
k = loop_read(fd, uuid, 36, false);
|
|
close_nointr_nofail(fd);
|
|
|
|
if (k >= 36) {
|
|
r = shorten_uuid(id, uuid);
|
|
if (r >= 0) {
|
|
log_info("Initializing machine ID from KVM UUID");
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* If that didn't work either, see if we are running in a
|
|
* container, and a machine ID was passed in via
|
|
* $container_uuid the way libvirt/LXC does it */
|
|
|
|
r = detect_container(NULL);
|
|
if (r > 0) {
|
|
FILE *f;
|
|
|
|
f = fopen("/proc/1/environ", "re");
|
|
if (f) {
|
|
bool done = false;
|
|
|
|
do {
|
|
char line[LINE_MAX];
|
|
unsigned i;
|
|
|
|
for (i = 0; i < sizeof(line)-1; i++) {
|
|
int c;
|
|
|
|
c = getc(f);
|
|
if (_unlikely_(c == EOF)) {
|
|
done = true;
|
|
break;
|
|
} else if (c == 0)
|
|
break;
|
|
|
|
line[i] = c;
|
|
}
|
|
line[i] = 0;
|
|
|
|
if (startswith(line, "container_uuid=") &&
|
|
strlen(line + 15) >= 36) {
|
|
r = shorten_uuid(id, line + 15);
|
|
if (r >= 0) {
|
|
log_info("Initializing machine ID from container UUID");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
} while (!done);
|
|
|
|
fclose(f);
|
|
}
|
|
}
|
|
|
|
/* If that didn't work, generate a random machine id */
|
|
r = sd_id128_randomize(&buf);
|
|
if (r < 0) {
|
|
log_error("Failed to open /dev/urandom: %s", strerror(-r));
|
|
return r;
|
|
}
|
|
|
|
for (p = buf.bytes, q = id; p < buf.bytes + sizeof(buf); p++, q += 2) {
|
|
q[0] = hexchar(*p >> 4);
|
|
q[1] = hexchar(*p & 15);
|
|
}
|
|
|
|
id[32] = '\n';
|
|
id[33] = 0;
|
|
|
|
log_info("Initializing machine ID from random generator.");
|
|
|
|
return 0;
|
|
}
|
|
|
|
int machine_id_setup(void) {
|
|
int fd, r;
|
|
bool writable;
|
|
struct stat st;
|
|
char id[34]; /* 32 + \n + \0 */
|
|
mode_t m;
|
|
|
|
m = umask(0000);
|
|
|
|
/* We create this 0444, to indicate that this isn't really
|
|
* something you should ever modify. Of course, since the file
|
|
* will be owned by root it doesn't matter much, but maybe
|
|
* people look. */
|
|
|
|
fd = open("/etc/machine-id", O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0444);
|
|
if (fd >= 0)
|
|
writable = true;
|
|
else {
|
|
fd = open("/etc/machine-id", O_RDONLY|O_CLOEXEC|O_NOCTTY);
|
|
if (fd < 0) {
|
|
umask(m);
|
|
log_error("Cannot open /etc/machine-id: %m");
|
|
return -errno;
|
|
}
|
|
|
|
writable = false;
|
|
}
|
|
|
|
umask(m);
|
|
|
|
if (fstat(fd, &st) < 0) {
|
|
log_error("fstat() failed: %m");
|
|
r = -errno;
|
|
goto finish;
|
|
}
|
|
|
|
if (S_ISREG(st.st_mode)) {
|
|
if (loop_read(fd, id, 32, false) >= 32) {
|
|
r = 0;
|
|
goto finish;
|
|
}
|
|
}
|
|
|
|
/* Hmm, so, the id currently stored is not useful, then let's
|
|
* generate one */
|
|
|
|
r = generate(id);
|
|
if (r < 0)
|
|
goto finish;
|
|
|
|
if (S_ISREG(st.st_mode) && writable) {
|
|
lseek(fd, 0, SEEK_SET);
|
|
|
|
if (loop_write(fd, id, 33, false) == 33) {
|
|
r = 0;
|
|
goto finish;
|
|
}
|
|
}
|
|
|
|
close_nointr_nofail(fd);
|
|
fd = -1;
|
|
|
|
/* Hmm, we couldn't write it? So let's write it to
|
|
* /run/machine-id as a replacement */
|
|
|
|
m = umask(0022);
|
|
r = write_one_line_file("/run/machine-id", id);
|
|
umask(m);
|
|
|
|
if (r < 0) {
|
|
log_error("Cannot write /run/machine-id: %s", strerror(-r));
|
|
|
|
unlink("/run/machine-id");
|
|
goto finish;
|
|
}
|
|
|
|
/* And now, let's mount it over */
|
|
r = mount("/run/machine-id", "/etc/machine-id", "bind", MS_BIND|MS_RDONLY, NULL) < 0 ? -errno : 0;
|
|
if (r < 0) {
|
|
unlink("/run/machine-id");
|
|
log_error("Failed to mount /etc/machine-id: %s", strerror(-r));
|
|
} else
|
|
log_info("Installed transient /etc/machine-id file.");
|
|
|
|
finish:
|
|
|
|
if (fd >= 0)
|
|
close_nointr_nofail(fd);
|
|
|
|
return r;
|
|
}
|