1b99214789
systemd-sysusers is a tool to reconstruct /etc/passwd and /etc/group from static definition files that take a lot of inspiration from tmpfiles snippets. These snippets should carry information about system users only. To make sure it is not misused for normal users these snippets only allow configuring UID and gecos field for each user, but do not allow configuration of the home directory or shell, which is necessary for real login users. The purpose of this tool is to enable state-less systems that can populate /etc with the minimal files necessary, solely from static data in /usr. systemd-sysuser is additive only, and will never override existing users. This tool will create these files directly, and not via some user database abtsraction layer. This is appropriate as this tool is supposed to run really early at boot, and is only useful for creating system users, and system users cannot be stored in remote databases anyway. The tool is also useful to be invoked from RPM scriptlets, instead of useradd. This allows moving from imperative user descriptions in RPM to declarative descriptions. The UID/GID for a user/group to be created can either be chosen dynamic, or fixed, or be read from the owner of a file in the file system, in order to support reconstructing the correct IDs for files that shall be owned by them. This also adds a minimal user definition file, that should be sufficient for most basic systems. Distributions are expected to patch these files and augment the contents, for example with fixed UIDs for the users where that's necessary.
293 lines
8 KiB
C
293 lines
8 KiB
C
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
|
|
|
/***
|
|
This file is part of systemd.
|
|
|
|
Copyright 2014 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 "util.h"
|
|
#include "copy.h"
|
|
|
|
int copy_bytes(int fdf, int fdt) {
|
|
assert(fdf >= 0);
|
|
assert(fdt >= 0);
|
|
|
|
for (;;) {
|
|
char buf[PIPE_BUF];
|
|
ssize_t n, k;
|
|
|
|
n = read(fdf, buf, sizeof(buf));
|
|
if (n < 0)
|
|
return -errno;
|
|
if (n == 0)
|
|
break;
|
|
|
|
errno = 0;
|
|
k = loop_write(fdt, buf, n, false);
|
|
if (k < 0)
|
|
return k;
|
|
if (k != n)
|
|
return errno ? -errno : -EIO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int fd_copy_symlink(int df, const char *from, const struct stat *st, int dt, const char *to) {
|
|
_cleanup_free_ char *target = NULL;
|
|
int r;
|
|
|
|
assert(from);
|
|
assert(st);
|
|
assert(to);
|
|
|
|
r = readlinkat_malloc(df, from, &target);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
if (symlinkat(target, dt, to) < 0) {
|
|
if (errno == EEXIST)
|
|
return 0;
|
|
|
|
return -errno;
|
|
}
|
|
|
|
if (fchownat(dt, to, st->st_uid, st->st_gid, AT_SYMLINK_NOFOLLOW) < 0)
|
|
return -errno;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int fd_copy_regular(int df, const char *from, const struct stat *st, int dt, const char *to) {
|
|
_cleanup_close_ int fdf = -1, fdt = -1;
|
|
int r, q;
|
|
|
|
assert(from);
|
|
assert(st);
|
|
assert(to);
|
|
|
|
fdf = openat(df, from, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
|
|
if (fdf < 0)
|
|
return -errno;
|
|
|
|
fdt = openat(dt, to, O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, st->st_mode & 07777);
|
|
if (fdt < 0) {
|
|
if (errno == EEXIST)
|
|
return 0;
|
|
|
|
return -errno;
|
|
}
|
|
|
|
r = copy_bytes(fdf, fdt);
|
|
if (r < 0) {
|
|
unlinkat(dt, to, 0);
|
|
return r;
|
|
}
|
|
|
|
if (fchown(fdt, st->st_uid, st->st_gid) < 0)
|
|
r = -errno;
|
|
|
|
if (fchmod(fdt, st->st_mode & 07777) < 0)
|
|
r = -errno;
|
|
|
|
q = close(fdt);
|
|
fdt = -1;
|
|
|
|
if (q < 0) {
|
|
r = -errno;
|
|
unlinkat(dt, to, 0);
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
static int fd_copy_fifo(int df, const char *from, const struct stat *st, int dt, const char *to) {
|
|
int r;
|
|
|
|
assert(from);
|
|
assert(st);
|
|
assert(to);
|
|
|
|
r = mkfifoat(dt, to, st->st_mode & 07777);
|
|
if (r < 0) {
|
|
if (errno == EEXIST)
|
|
return 0;
|
|
|
|
return -errno;
|
|
}
|
|
|
|
if (fchownat(dt, to, st->st_uid, st->st_gid, AT_SYMLINK_NOFOLLOW) < 0)
|
|
r = -errno;
|
|
|
|
if (fchmodat(dt, to, st->st_mode & 07777, 0) < 0)
|
|
r = -errno;
|
|
|
|
return r;
|
|
}
|
|
|
|
static int fd_copy_node(int df, const char *from, const struct stat *st, int dt, const char *to) {
|
|
int r;
|
|
|
|
assert(from);
|
|
assert(st);
|
|
assert(to);
|
|
|
|
r = mknodat(dt, to, st->st_mode, st->st_rdev);
|
|
if (r < 0) {
|
|
if (errno == EEXIST)
|
|
return 0;
|
|
|
|
return -errno;
|
|
}
|
|
|
|
if (fchownat(dt, to, st->st_uid, st->st_gid, AT_SYMLINK_NOFOLLOW) < 0)
|
|
r = -errno;
|
|
|
|
if (fchmodat(dt, to, st->st_mode & 07777, 0) < 0)
|
|
r = -errno;
|
|
|
|
return r;
|
|
}
|
|
|
|
static int fd_copy_directory(int df, const char *from, const struct stat *st, int dt, const char *to, dev_t original_device) {
|
|
_cleanup_close_ int fdf = -1, fdt = -1;
|
|
_cleanup_closedir_ DIR *d = NULL;
|
|
struct dirent *de;
|
|
bool created;
|
|
int r;
|
|
|
|
assert(from);
|
|
assert(st);
|
|
assert(to);
|
|
|
|
fdf = openat(df, from, O_RDONLY|O_DIRECTORY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
|
|
if (fdf < 0)
|
|
return -errno;
|
|
|
|
d = fdopendir(fdf);
|
|
if (!d)
|
|
return -errno;
|
|
fdf = -1;
|
|
|
|
r = mkdirat(dt, to, st->st_mode & 07777);
|
|
if (r >= 0)
|
|
created = true;
|
|
else if (errno == EEXIST)
|
|
created = false;
|
|
else
|
|
return -errno;
|
|
|
|
fdt = openat(dt, to, O_RDONLY|O_DIRECTORY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
|
|
if (fdt < 0)
|
|
return -errno;
|
|
|
|
if (created) {
|
|
if (fchown(fdt, st->st_uid, st->st_gid) < 0)
|
|
r = -errno;
|
|
|
|
if (fchmod(fdt, st->st_mode & 07777) < 0)
|
|
r = -errno;
|
|
}
|
|
|
|
FOREACH_DIRENT(de, d, return -errno) {
|
|
struct stat buf;
|
|
int q;
|
|
|
|
if (fstatat(dirfd(d), de->d_name, &buf, AT_SYMLINK_NOFOLLOW) < 0) {
|
|
r = -errno;
|
|
continue;
|
|
}
|
|
|
|
if (buf.st_dev != original_device)
|
|
continue;
|
|
|
|
if (S_ISREG(buf.st_mode))
|
|
q = fd_copy_regular(dirfd(d), de->d_name, &buf, fdt, de->d_name);
|
|
else if (S_ISDIR(buf.st_mode))
|
|
q = fd_copy_directory(dirfd(d), de->d_name, &buf, fdt, de->d_name, original_device);
|
|
else if (S_ISLNK(buf.st_mode))
|
|
q = fd_copy_symlink(dirfd(d), de->d_name, &buf, fdt, de->d_name);
|
|
else if (S_ISFIFO(buf.st_mode))
|
|
q = fd_copy_fifo(dirfd(d), de->d_name, &buf, fdt, de->d_name);
|
|
else if (S_ISBLK(buf.st_mode) || S_ISCHR(buf.st_mode))
|
|
q = fd_copy_node(dirfd(d), de->d_name, &buf, fdt, de->d_name);
|
|
else
|
|
q = -ENOTSUP;
|
|
|
|
if (q < 0)
|
|
r = q;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
int copy_tree(const char *from, const char *to) {
|
|
struct stat st;
|
|
|
|
assert(from);
|
|
assert(to);
|
|
|
|
if (lstat(from, &st) < 0)
|
|
return -errno;
|
|
|
|
if (S_ISREG(st.st_mode))
|
|
return fd_copy_regular(AT_FDCWD, from, &st, AT_FDCWD, to);
|
|
else if (S_ISDIR(st.st_mode))
|
|
return fd_copy_directory(AT_FDCWD, from, &st, AT_FDCWD, to, st.st_dev);
|
|
else if (S_ISLNK(st.st_mode))
|
|
return fd_copy_symlink(AT_FDCWD, from, &st, AT_FDCWD, to);
|
|
else if (S_ISFIFO(st.st_mode))
|
|
return fd_copy_fifo(AT_FDCWD, from, &st, AT_FDCWD, to);
|
|
else if (S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode))
|
|
return fd_copy_node(AT_FDCWD, from, &st, AT_FDCWD, to);
|
|
else
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
int copy_file(const char *from, const char *to, int flags, mode_t mode) {
|
|
_cleanup_close_ int fdf = -1, fdt = -1;
|
|
int r;
|
|
|
|
assert(from);
|
|
assert(to);
|
|
|
|
fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
|
|
if (fdf < 0)
|
|
return -errno;
|
|
|
|
fdt = open(to, flags|O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode);
|
|
if (fdt < 0)
|
|
return -errno;
|
|
|
|
r = copy_bytes(fdf, fdt);
|
|
if (r < 0) {
|
|
unlink(to);
|
|
return r;
|
|
}
|
|
|
|
r = close(fdt);
|
|
fdt = -1;
|
|
|
|
if (r < 0) {
|
|
r = -errno;
|
|
unlink(to);
|
|
return r;
|
|
}
|
|
|
|
return 0;
|
|
}
|