HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/home/homectl.c
Git blob: 0fcf210f9340db07221cb542aaf5fc1759a817bb
Lines 2001–3000 of 5,181
if (r < 0)
return r;
} else
break;
}
return 0;
}
VERB(verb_remove_home, "remove", "USER…\0", 2, VERB_ANY, 0,
"Remove a home area");
static int verb_remove_home(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
int r, ret = 0;
r = acquire_bus(&bus);
if (r < 0)
return r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
STRV_FOREACH(i, strv_skip(argv, 1)) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_mgr, "RemoveHome");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", *i);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0) {
log_error_errno(r, "Failed to remove home: %s", bus_error_message(&error, r));
if (ret == 0)
ret = r;
}
}
return ret;
}
VERB_GROUP("Advanced User Manipulation Commands");
VERB(verb_activate_home, "activate", "USER…\0", 2, VERB_ANY, 0,
"Activate a home area");
static int verb_activate_home(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
int r, ret = 0;
r = acquire_bus(&bus);
if (r < 0)
return r;
STRV_FOREACH(i, strv_skip(argv, 1)) {
_cleanup_(user_record_unrefp) UserRecord *secret = NULL;
r = acquire_passed_secrets(*i, &secret);
if (r < 0)
return r;
for (;;) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_mgr, "ActivateHome");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", *i);
if (r < 0)
return bus_log_create_error(r);
r = bus_message_append_secret(m, secret);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0) {
r = handle_generic_user_record_error(*i, secret, &error, r, /* emphasize_current_password= */ false);
if (r < 0) {
if (ret == 0)
ret = r;
break;
}
} else
break;
}
}
return ret;
}
VERB(verb_deactivate_home, "deactivate", "USER…\0", 2, VERB_ANY, 0,
"Deactivate a home area");
static int verb_deactivate_home(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
int r, ret = 0;
r = acquire_bus(&bus);
if (r < 0)
return r;
STRV_FOREACH(i, strv_skip(argv, 1)) {
/* The home directory might still be busy for a brief moment after a preceding operation
* (e.g. a concurrent inspect/deactivate, or a stray reference holding the mount busy at
* unmount time). homed will transition the home into "lingering" state and retry
* deactivation internally after some time, but rather than failing immediately let's just
* retry the bus call here for a while, so callers don't need to deal with this transient
* condition themselves. Use double the time homed waits to avoid racing with it. */
usec_t end = usec_add(now(CLOCK_MONOTONIC), 2 * HOME_RETRY_DEACTIVATE_USEC);
for (;;) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_mgr, "DeactivateHome");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", *i);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, /* ret_reply= */ NULL);
if (r >= 0)
break;
if (sd_bus_error_has_name(&error, BUS_ERROR_HOME_BUSY) &&
now(CLOCK_MONOTONIC) < end) {
log_info("Home of user %s is currently busy, retrying deactivation.", *i);
(void) usleep_safe(1 * USEC_PER_SEC);
continue;
}
log_error_errno(r, "Failed to deactivate user home: %s", bus_error_message(&error, r));
if (ret == 0)
ret = r;
break;
}
}
return ret;
}
VERB_NOARG(verb_deactivate_all_homes, "deactivate-all",
"Deactivate all active home areas");
static int verb_deactivate_all_homes(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
r = bus_message_new_method_call(bus, &m, bus_mgr, "DeactivateAllHomes");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0)
return log_error_errno(r, "Failed to deactivate all homes: %s", bus_error_message(&error, r));
return 0;
}
VERB(verb_with_home, "with", "USER [COMMAND…]\0", 2, VERB_ANY, 0,
"Run shell or command with access to a home area");
static int verb_with_home(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_(user_record_unrefp) UserRecord *secret = NULL;
_cleanup_close_ int acquired_fd = -EBADF;
_cleanup_strv_free_ char **cmdline = NULL;
const char *home;
int r, ret;
r = acquire_bus(&bus);
if (r < 0)
return r;
if (argc < 3) {
_cleanup_free_ char *shell = NULL;
/* If no command is specified, spawn a shell */
r = get_shell(&shell);
if (r < 0)
return log_error_errno(r, "Failed to acquire shell: %m");
cmdline = strv_new(shell);
} else
cmdline = strv_copy(argv + 2);
if (!cmdline)
return log_oom();
r = acquire_passed_secrets(argv[1], &secret);
if (r < 0)
return r;
for (;;) {
r = bus_message_new_method_call(bus, &m, bus_mgr, "AcquireHome");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", argv[1]);
if (r < 0)
return bus_log_create_error(r);
r = bus_message_append_secret(m, secret);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "b", /* please_suspend= */ getenv_bool("SYSTEMD_PLEASE_SUSPEND_HOME") > 0);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, &reply);
m = sd_bus_message_unref(m);
if (r < 0) {
r = handle_generic_user_record_error(argv[1], secret, &error, r, false);
if (r < 0)
return r;
sd_bus_error_free(&error);
} else {
int fd;
r = sd_bus_message_read(reply, "h", &fd);
if (r < 0)
return bus_log_parse_error(r);
acquired_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
if (acquired_fd < 0)
return log_error_errno(errno, "Failed to duplicate acquired fd: %m");
reply = sd_bus_message_unref(reply);
break;
}
}
r = bus_call_method(bus, bus_mgr, "GetHomeByName", &error, &reply, "s", argv[1]);
if (r < 0)
return log_error_errno(r, "Failed to inspect home: %s", bus_error_message(&error, r));
r = sd_bus_message_read(reply, "usussso", NULL, NULL, NULL, NULL, &home, NULL, NULL);
if (r < 0)
return bus_log_parse_error(r);
_cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
r = pidref_safe_fork(
"(with)",
FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG_SIGTERM|FORK_LOG|FORK_RLIMIT_NOFILE_SAFE|FORK_REOPEN_LOG,
&pidref);
if (r < 0)
return r;
if (r == 0) {
if (chdir(home) < 0) {
log_error_errno(errno, "Failed to change to directory %s: %m", home);
_exit(255);
}
execvp(cmdline[0], cmdline);
log_error_errno(errno, "Failed to execute %s: %m", cmdline[0]);
_exit(255);
}
ret = pidref_wait_for_terminate_and_check(cmdline[0], &pidref, WAIT_LOG_ABNORMAL);
/* Close the fd that pings the home now. */
acquired_fd = safe_close(acquired_fd);
r = bus_message_new_method_call(bus, &m, bus_mgr, "ReleaseHome");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", argv[1]);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0) {
if (sd_bus_error_has_name(&error, BUS_ERROR_HOME_BUSY))
log_notice("Not deactivating home directory of %s, as it is still used.", argv[1]);
else
return log_error_errno(r, "Failed to release user home: %s", bus_error_message(&error, r));
}
return ret;
}
static int authenticate_home(sd_bus *bus, const char *name) {
_cleanup_(user_record_unrefp) UserRecord *secret = NULL;
int r;
r = acquire_passed_secrets(name, &secret);
if (r < 0)
return r;
for (;;) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_mgr, "AuthenticateHome");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", name);
if (r < 0)
return bus_log_create_error(r);
r = bus_message_append_secret(m, secret);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0) {
r = handle_generic_user_record_error(name, secret, &error, r, false);
if (r >= 0)
continue;
}
return r;
}
}
VERB(verb_authenticate_homes, "authenticate", "USER…\0", VERB_ANY, VERB_ANY, 0,
"Authenticate a home area");
static int verb_authenticate_homes(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
char **args = strv_skip(argv, 1);
if (args) {
STRV_FOREACH(arg, args)
RET_GATHER(r, authenticate_home(bus, *arg));
return r;
} else {
_cleanup_free_ char *myself = getusername_malloc();
if (!myself)
return log_oom();
return authenticate_home(bus, myself);
}
}
VERB_GROUP("User Migration Commands");
VERB(verb_adopt_home, "adopt", "PATH…\0", VERB_ANY, VERB_ANY, 0,
"Add an existing home area on this system");
static int verb_adopt_home(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r, ret = 0;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
r = acquire_bus(&bus);
if (r < 0)
return r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
STRV_FOREACH(i, strv_skip(argv, 1)) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_mgr, "AdoptHome");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "st", *i, UINT64_C(0));
if (r < 0)
return bus_log_create_error(r);
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0) {
log_error_errno(r, "Failed to adopt home: %s", bus_error_message(&error, r));
if (ret == 0)
ret = r;
}
}
return ret;
}
static int register_home_common(sd_bus *bus, sd_json_variant *v) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *_bus = NULL;
int r;
assert(v);
if (!bus) {
r = acquire_bus(&_bus);
if (r < 0)
return r;
bus = _bus;
}
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_mgr, "RegisterHome");
if (r < 0)
return bus_log_create_error(r);
_cleanup_free_ char *formatted = NULL;
r = sd_json_variant_format(v, /* flags= */ 0, &formatted);
if (r < 0)
return log_error_errno(r, "Failed to format JSON record: %m");
r = sd_bus_message_append(m, "s", formatted);
if (r < 0)
return bus_log_create_error(r);
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0)
return log_error_errno(r, "Failed to register home: %s", bus_error_message(&error, r));
return 0;
}
static int register_home_one(sd_bus *bus, FILE *f, const char *path) {
int r;
assert(bus);
assert(path);
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
unsigned line = 0, column = 0;
r = sd_json_parse_file(f, path, SD_JSON_PARSE_MUST_BE_OBJECT|SD_JSON_PARSE_SENSITIVE, &v, &line, &column);
if (r < 0)
return log_error_errno(r, "[%s:%u:%u] Failed to parse user record: %m", path, line, column);
return register_home_common(bus, v);
}
VERB(verb_register_home, "register", "PATH…\0", VERB_ANY, VERB_ANY, 0,
"Register a user record locally");
static int verb_register_home(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
r = acquire_bus(&bus);
if (r < 0)
return r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
if (arg_identity) {
if (argc > 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Not accepting an arguments if --identity= is specified, refusing.");
return register_home_one(bus, /* f= */ NULL, arg_identity);
}
if (argc == 1 || (argc == 2 && streq(argv[1], "-")))
return register_home_one(bus, /* f= */ stdin, "<stdio>");
r = 0;
STRV_FOREACH(i, strv_skip(argv, 1)) {
if (streq(*i, "-"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Refusing reading from standard input if multiple user records are specified.");
RET_GATHER(r, register_home_one(bus, /* f= */ NULL, *i));
}
return r;
}
VERB(verb_unregister_home, "unregister", "USER…\0", 2, VERB_ANY, 0,
"Unregister a user record locally");
static int verb_unregister_home(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
r = acquire_bus(&bus);
if (r < 0)
return r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
int ret = 0;
STRV_FOREACH(i, strv_skip(argv, 1)) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_mgr, "UnregisterHome");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", *i);
if (r < 0)
return bus_log_create_error(r);
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, /* ret_reply= */ NULL);
if (r < 0)
RET_GATHER(ret, log_error_errno(r, "Failed to unregister home: %s", bus_error_message(&error, r)));
}
return ret;
}
VERB_GROUP("Signing Keys Commands");
VERB_NOARG(verb_list_signing_keys, "list-signing-keys",
"List home signing keys");
static int verb_list_signing_keys(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
r = acquire_bus(&bus);
if (r < 0)
return r;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
r = bus_call_method(bus, bus_mgr, "ListSigningKeys", &error, &reply, NULL);
if (r < 0)
return log_error_errno(r, "Failed to list signing keys: %s", bus_error_message(&error, r));
_cleanup_(table_unrefp) Table *table = table_new("name", "key");
if (!table)
return log_oom();
r = sd_bus_message_enter_container(reply, 'a', "(sst)");
if (r < 0)
return bus_log_parse_error(r);
for (;;) {
const char *name, *pem;
r = sd_bus_message_read(reply, "(sst)", &name, &pem, NULL);
if (r < 0)
return bus_log_parse_error(r);
if (r == 0)
break;
_cleanup_free_ char *h = NULL;
if (!sd_json_format_enabled(arg_json_format_flags)) {
/* Let's decode the PEM key to DER (so that we lose prefix/suffix), then truncate it
* for display reasons. */
r = dlopen_libcrypto(LOG_DEBUG);
if (r < 0)
return r;
_cleanup_(EVP_PKEY_freep) EVP_PKEY *key = NULL;
r = openssl_pubkey_from_pem(pem, SIZE_MAX, &key);
if (r < 0)
return log_error_errno(r, "Failed to parse PEM: %m");
_cleanup_free_ void *der = NULL;
int n = sym_i2d_PUBKEY(key, (unsigned char**) &der);
if (n < 0)
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "Failed to encode key as DER.");
ssize_t m = base64mem(der, MIN(n, 64), &h);
if (m < 0)
return log_oom();
if (n > 64) /* check if we truncated the original version */
if (!strextend(&h, glyph(GLYPH_ELLIPSIS)))
return log_oom();
}
r = table_add_many(
table,
TABLE_STRING, name,
TABLE_STRING, h ?: pem);
if (r < 0)
return table_log_add_error(r);
}
r = sd_bus_message_exit_container(reply);
if (r < 0)
return bus_log_parse_error(r);
if (!table_isempty(table) || sd_json_format_enabled(arg_json_format_flags)) {
r = table_set_sort(table, (size_t) 0);
if (r < 0)
return table_log_sort_error(r);
r = table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, arg_legend);
if (r < 0)
return r;
}
if (arg_legend && !sd_json_format_enabled(arg_json_format_flags)) {
if (table_isempty(table))
printf("No signing keys.\n");
else
printf("\n%zu signing keys listed.\n", table_get_rows(table) - 1);
}
return 0;
}
VERB(verb_get_signing_key, "get-signing-key", "[NAME…]\0", VERB_ANY, VERB_ANY, 0,
"Get a named home signing key");
static int verb_get_signing_key(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
r = acquire_bus(&bus);
if (r < 0)
return r;
char **keys = argc >= 2 ? strv_skip(argv, 1) : STRV_MAKE("local.public");
int ret = 0;
STRV_FOREACH(k, keys) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
r = bus_call_method(bus, bus_mgr, "GetSigningKey", &error, &reply, "s", *k);
if (r < 0) {
RET_GATHER(ret, log_error_errno(r, "Failed to get signing key '%s': %s", *k, bus_error_message(&error, r)));
continue;
}
const char *pem;
r = sd_bus_message_read(reply, "st", &pem, NULL);
if (r < 0) {
RET_GATHER(ret, bus_log_parse_error(r));
continue;
}
fputs(pem, stdout);
if (!endswith(pem, "\n"))
fputc('\n', stdout);
fflush(stdout);
}
return ret;
}
static int add_signing_key_one(sd_bus *bus, const char *fn, FILE *key) {
int r;
assert_se(bus);
assert_se(fn);
assert_se(key);
_cleanup_free_ char *pem = NULL;
r = read_full_stream(key, &pem, /* ret_size= */ NULL);
if (r < 0)
return log_error_errno(r, "Failed to read key '%s': %m", fn);
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = bus_call_method(bus, bus_mgr, "AddSigningKey", &error, /* ret_reply= */ NULL, "sst", fn, pem, UINT64_C(0));
if (r < 0)
return log_error_errno(r, "Failed to add signing key '%s': %s", fn, bus_error_message(&error, r));
return 0;
}
VERB(verb_add_signing_key, "add-signing-key", "FILE…\0", VERB_ANY, VERB_ANY, 0,
"Add home signing key");
static int verb_add_signing_key(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
r = acquire_bus(&bus);
if (r < 0)
return r;
int ret = EXIT_SUCCESS;
if (argc < 2 || streq(argv[1], "-")) {
if (!arg_key_name)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Key name must be specified via --key-name= when reading key from standard input, refusing.");
RET_GATHER(ret, add_signing_key_one(bus, arg_key_name, stdin));
} else {
/* Refuse if more han one key is specified in combination with --key-name= */
if (argc >= 3 && arg_key_name)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--key-name= is not supported if multiple signing keys are specified, refusing.");
STRV_FOREACH(k, strv_skip(argv, 1)) {
if (streq(*k, "-"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Refusing to read from standard input if multiple keys are specified.");
_cleanup_free_ char *fn = NULL;
if (!arg_key_name) {
r = path_extract_filename(*k, &fn);
if (r < 0) {
RET_GATHER(ret, log_error_errno(r, "Failed to extract filename from path '%s': %m", *k));
continue;
}
}
_cleanup_fclose_ FILE *f = fopen(*k, "re");
if (!f) {
RET_GATHER(ret, log_error_errno(errno, "Failed to open '%s': %m", *k));
continue;
}
RET_GATHER(ret, add_signing_key_one(bus, fn ?: arg_key_name, f));
}
}
return ret;
}
static int add_signing_keys_from_credentials(void) {
int r;
_cleanup_close_ int fd = open_credentials_dir();
if (IN_SET(fd, -ENXIO, -ENOENT)) /* Credential env var not set, or dir doesn't exist. */
return 0;
if (fd < 0)
return log_error_errno(fd, "Failed to open credentials directory: %m");
_cleanup_free_ DirectoryEntries *des = NULL;
r = readdir_all(fd, RECURSE_DIR_SORT|RECURSE_DIR_IGNORE_DOT|RECURSE_DIR_ENSURE_TYPE, &des);
if (r < 0)
return log_error_errno(r, "Failed to enumerate credentials: %m");
int ret = 0;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
FOREACH_ARRAY(i, des->entries, des->n_entries) {
struct dirent *de = *i;
if (de->d_type != DT_REG)
continue;
const char *e = startswith(de->d_name, "home.add-signing-key.");
if (!e)
continue;
if (!filename_is_valid(e))
continue;
if (!bus) {
r = acquire_bus(&bus);
if (r < 0)
return r;
}
_cleanup_fclose_ FILE *f = NULL;
r = xfopenat(fd, de->d_name, "re", O_NOFOLLOW, &f);
if (r < 0) {
RET_GATHER(ret, log_error_errno(r, "Failed to open credential '%s': %m", de->d_name));
continue;
}
RET_GATHER(ret, add_signing_key_one(bus, e, f));
}
return ret;
}
static int remove_signing_key_one(sd_bus *bus, const char *fn) {
int r;
assert_se(bus);
assert_se(fn);
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = bus_call_method(bus, bus_mgr, "RemoveSigningKey", &error, /* ret_reply= */ NULL, "st", fn, UINT64_C(0));
if (r < 0)
return log_error_errno(r, "Failed to remove signing key '%s': %s", fn, bus_error_message(&error, r));
return 0;
}
VERB(verb_remove_signing_key, "remove-signing-key", "NAME…\0", 2, VERB_ANY, 0,
"Remove home signing key");
static int verb_remove_signing_key(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
r = acquire_bus(&bus);
if (r < 0)
return r;
r = EXIT_SUCCESS;
STRV_FOREACH(k, strv_skip(argv, 1))
RET_GATHER(r, remove_signing_key_one(bus, *k));
return r;
}
VERB_GROUP("Lock/Unlock Commands");
VERB(verb_lock_home, "lock", "USER…\0", 2, VERB_ANY, 0,
"Temporarily lock an active home area");
static int verb_lock_home(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
int r, ret = 0;
r = acquire_bus(&bus);
if (r < 0)
return r;
STRV_FOREACH(i, strv_skip(argv, 1)) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_mgr, "LockHome");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", *i);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0) {
log_error_errno(r, "Failed to lock home: %s", bus_error_message(&error, r));
if (ret == 0)
ret = r;
}
}
return ret;
}
VERB(verb_unlock_home, "unlock", "USER…\0", 2, VERB_ANY, 0,
"Unlock a temporarily locked home area");
static int verb_unlock_home(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
int r, ret = 0;
r = acquire_bus(&bus);
if (r < 0)
return r;
STRV_FOREACH(i, strv_skip(argv, 1)) {
_cleanup_(user_record_unrefp) UserRecord *secret = NULL;
r = acquire_passed_secrets(*i, &secret);
if (r < 0)
return r;
for (;;) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_mgr, "UnlockHome");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", *i);
if (r < 0)
return bus_log_create_error(r);
r = bus_message_append_secret(m, secret);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0) {
r = handle_generic_user_record_error(*i, secret, &error, r, false);
if (r < 0) {
if (ret == 0)
ret = r;
break;
}
} else
break;
}
}
return ret;
}
VERB_NOARG(verb_lock_all_homes, "lock-all",
"Lock all suitable home areas");
static int verb_lock_all_homes(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
r = bus_message_new_method_call(bus, &m, bus_mgr, "LockAllHomes");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0)
return log_error_errno(r, "Failed to lock all homes: %s", bus_error_message(&error, r));
return 0;
}
VERB_GROUP("Other Commands");
VERB_NOARG(verb_rebalance, "rebalance",
"Rebalance free space between home areas");
static int verb_rebalance(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
r = bus_message_new_method_call(bus, &m, bus_mgr, "Rebalance");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, NULL);
if (r < 0) {
if (sd_bus_error_has_name(&error, BUS_ERROR_REBALANCE_NOT_NEEDED))
log_info("No homes needed rebalancing.");
else
return log_error_errno(r, "Failed to rebalance: %s", bus_error_message(&error, r));
} else
log_info("Completed rebalancing.");
return 0;
}
static int create_or_register_from_credentials(void) {
int r;
_cleanup_close_ int fd = open_credentials_dir();
if (IN_SET(fd, -ENXIO, -ENOENT)) /* Credential env var not set, or dir doesn't exist. */
return 0;
if (fd < 0)
return log_error_errno(fd, "Failed to open credentials directory: %m");
_cleanup_free_ DirectoryEntries *des = NULL;
r = readdir_all(fd, RECURSE_DIR_SORT|RECURSE_DIR_IGNORE_DOT|RECURSE_DIR_ENSURE_TYPE, &des);
if (r < 0)
return log_error_errno(r, "Failed to enumerate credentials: %m");
int ret = 0, n_processed = 0;
FOREACH_ARRAY(i, des->entries, des->n_entries) {
struct dirent *de = *i;
if (de->d_type != DT_REG)
continue;
enum {
OPERATION_CREATE,
OPERATION_REGISTER,
} op;
const char *e;
if ((e = startswith(de->d_name, "home.create.")))
op = OPERATION_CREATE;
else if ((e = startswith(de->d_name, "home.register.")))
op = OPERATION_REGISTER;
else
continue;
if (!valid_user_group_name(e, /* flags= */ 0)) {
log_notice("Skipping over credential with name that is not a suitable user name: %s", de->d_name);
continue;
}
_cleanup_(sd_json_variant_unrefp) sd_json_variant *identity = NULL;
unsigned line = 0, column = 0;
r = sd_json_parse_file_at(
/* f= */ NULL,
fd,
de->d_name,
/* flags= */ SD_JSON_PARSE_MUST_BE_OBJECT,
&identity,
&line,
&column);
if (r < 0) {
log_warning_errno(r, "[%s:%u:%u] Failed to parse user record in credential, ignoring: %m", de->d_name, line, column);
continue;
}
sd_json_variant *un = sd_json_variant_by_key(identity, "userName");
if (un) {
if (!sd_json_variant_is_string(un)) {
log_warning("User record from credential '%s' contains 'userName' field of invalid type, ignoring.", de->d_name);
continue;
}
if (!streq(sd_json_variant_string(un), e)) {
log_warning("User record from credential '%s' contains 'userName' field (%s) that doesn't match credential name (%s), ignoring.", de->d_name, sd_json_variant_string(un), e);
continue;
}
} else {
r = sd_json_variant_set_field_string(&identity, "userName", e);
if (r < 0)
return log_warning_errno(r, "Failed to set userName field: %m");
}
log_notice("Processing user '%s' from credentials.", e);
if (op == OPERATION_CREATE)
r = create_home_common(identity, /* show_enforce_password_policy_hint= */ false);
else
r = register_home_common(/* bus= */ NULL, identity);
if (r >= 0)
n_processed++;
RET_GATHER(ret, r);
}