HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/core/dbus-manager.c
Git blob: 4a6adcb82cb77d2d424a21f5e30e9014607685c6
Lines 1001–2000 of 3,732
return method_generic_unit_operation(message, userdata, reterr_error, _UNIT_TYPE_INVALID, bus_unit_method_reset_failed, /* flags= */ 0);
}
static int method_set_unit_properties(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
/* Only change properties on fully loaded units, and load them in order to set properties */
return method_generic_unit_operation(message, userdata, reterr_error, _UNIT_TYPE_INVALID, bus_unit_method_set_properties, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
}
static int method_bind_mount_unit(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
/* Only add mounts on fully loaded units */
return method_generic_unit_operation(message, userdata, reterr_error, UNIT_SERVICE, bus_service_method_bind_mount, GENERIC_UNIT_VALIDATE_LOADED);
}
static int method_mount_image_unit(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
/* Only add mounts on fully loaded units */
return method_generic_unit_operation(message, userdata, reterr_error, UNIT_SERVICE, bus_service_method_mount_image, GENERIC_UNIT_VALIDATE_LOADED);
}
static int method_ref_unit(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
/* Only allow reffing of fully loaded units, and make sure reffing a unit loads it. */
return method_generic_unit_operation(message, userdata, reterr_error, _UNIT_TYPE_INVALID, bus_unit_method_ref, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
}
static int method_unref_unit(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
/* Dropping a ref OTOH should not require the unit to still be loaded. And since a reffed unit is a
* loaded unit there's no need to load the unit for unreffing it. */
return method_generic_unit_operation(message, userdata, reterr_error, _UNIT_TYPE_INVALID, bus_unit_method_unref, /* flags= */ 0);
}
static int reply_unit_info(sd_bus_message *reply, Unit *u) {
_cleanup_free_ char *unit_path = NULL, *job_path = NULL;
Unit *following;
following = unit_following(u);
unit_path = unit_dbus_path(u);
if (!unit_path)
return -ENOMEM;
if (u->job) {
job_path = job_dbus_path(u->job);
if (!job_path)
return -ENOMEM;
}
return sd_bus_message_append(
reply, "(ssssssouso)",
u->id,
unit_description(u),
unit_load_state_to_string(u->load_state),
unit_active_state_to_string(unit_active_state(u)),
unit_sub_state_to_string(u),
following ? following->id : "",
unit_path,
u->job ? u->job->id : 0,
u->job ? job_type_to_string(u->job->type) : "",
empty_to_root(job_path));
}
static int method_list_units_by_names(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = ASSERT_PTR(userdata);
int r;
_cleanup_strv_free_ char **units = NULL;
assert(message);
r = sd_bus_message_read_strv(message, &units);
if (r < 0)
return r;
if (strv_length(units) > MAX(hashmap_size(m->units), (unsigned) MANAGER_MAX_NAMES / 2))
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_LIMITS_EXCEEDED,
"Too many unit names requested.");
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
return r;
r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
if (r < 0)
return r;
STRV_FOREACH(unit, units) {
Unit *u;
if (!unit_name_is_valid(*unit, UNIT_NAME_ANY))
continue;
r = bus_load_unit_by_name(m, message, *unit, &u, reterr_error);
if (r < 0)
return r;
r = reply_unit_info(reply, u);
if (r < 0)
return r;
}
r = sd_bus_message_close_container(reply);
if (r < 0)
return r;
return sd_bus_message_send(reply);
}
static int method_get_unit_processes(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
/* Don't load a unit actively (since it won't have any processes if it's not loaded), but don't
* insist on the unit being loaded either (because even improperly loaded units might still have
* processes around). */
return method_generic_unit_operation(message, userdata, reterr_error, _UNIT_TYPE_INVALID, bus_unit_method_get_processes, /* flags= */ 0);
}
static int method_attach_processes_to_unit(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
/* Don't allow attaching new processes to units that aren't loaded. Don't bother with loading a unit
* for this purpose though, as an unloaded unit is a stopped unit, and we don't allow attaching
* processes to stopped units anyway. */
return method_generic_unit_operation(message, userdata, reterr_error, _UNIT_TYPE_INVALID, bus_unit_method_attach_processes, GENERIC_UNIT_VALIDATE_LOADED);
}
static int method_remove_subgroup_from_unit(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
/* Don't allow removal of subgroups from units that aren't loaded. But allow loading the unit, since
* this is clean-up work, that is OK to do when the unit is stopped already. */
return method_generic_unit_operation(message, userdata, reterr_error, _UNIT_TYPE_INVALID, bus_unit_method_remove_subgroup, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
}
static int transient_unit_from_message(
Manager *m,
sd_bus_message *message,
const char *name,
Unit **ret_unit,
sd_bus_error *reterr_error) {
Unit *u;
int r;
assert(m);
assert(message);
assert(name);
r = manager_setup_transient_unit(m, name, &u, reterr_error);
if (r < 0)
return r;
/* Set our properties */
r = bus_unit_set_properties(u, message, UNIT_RUNTIME, false, reterr_error);
if (r < 0)
return r;
/* If the client asked for it, automatically add a reference to this unit. */
if (u->bus_track_add) {
r = bus_unit_track_add_sender(u, message);
if (r < 0)
return log_error_errno(r, "Failed to watch sender: %m");
}
/* Now load the missing bits of the unit we just created */
unit_add_to_load_queue(u);
manager_dispatch_load_queue(m);
if (ret_unit)
*ret_unit = u;
return 0;
}
static int transient_aux_units_from_message(
Manager *m,
sd_bus_message *message,
sd_bus_error *reterr_error) {
int r;
assert(m);
assert(message);
r = sd_bus_message_enter_container(message, 'a', "(sa(sv))");
if (r < 0)
return r;
while ((r = sd_bus_message_enter_container(message, 'r', "sa(sv)")) > 0) {
const char *name;
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
r = transient_unit_from_message(m, message, name, /* ret_unit= */ NULL, reterr_error);
if (r < 0)
return r;
r = sd_bus_message_exit_container(message);
if (r < 0)
return r;
}
if (r < 0)
return r;
r = sd_bus_message_exit_container(message);
if (r < 0)
return r;
return 0;
}
static int method_start_transient_unit(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
const char *name, *smode;
Manager *m = ASSERT_PTR(userdata);
JobMode mode;
Unit *u;
int r;
assert(message);
r = mac_selinux_access_check(message, "start", reterr_error);
if (r < 0)
return r;
r = sd_bus_message_read(message, "ss", &name, &smode);
if (r < 0)
return r;
mode = job_mode_from_string(smode);
if (mode < 0)
return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s is invalid.", smode);
r = bus_verify_manage_units_async_impl(
m,
name,
"start",
N_("Authentication is required to start transient unit '$(unit)'."),
message,
reterr_error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
r = transient_unit_from_message(m, message, name, &u, reterr_error);
if (r < 0)
return r;
r = transient_aux_units_from_message(m, message, reterr_error);
if (r < 0)
return r;
/* Finally, start it */
return bus_unit_queue_job(message, u, JOB_START, mode, 0, reterr_error);
}
static int method_get_job(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
_cleanup_free_ char *path = NULL;
Manager *m = ASSERT_PTR(userdata);
uint32_t id;
Job *j;
int r;
assert(message);
/* Anyone can call this method */
r = sd_bus_message_read(message, "u", &id);
if (r < 0)
return r;
j = manager_get_job(m, id);
if (!j)
return sd_bus_error_setf(reterr_error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
r = mac_selinux_unit_access_check(j->unit, message, "status", reterr_error);
if (r < 0)
return r;
path = job_dbus_path(j);
if (!path)
return -ENOMEM;
return sd_bus_reply_method_return(message, "o", path);
}
static int method_cancel_job(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
uint32_t id;
Job *j;
int r;
assert(message);
r = sd_bus_message_read(message, "u", &id);
if (r < 0)
return r;
j = manager_get_job(m, id);
if (!j)
return sd_bus_error_setf(reterr_error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
return bus_job_method_cancel(message, j, reterr_error);
}
static int method_clear_jobs(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
r = mac_selinux_access_check(message, "reload", reterr_error);
if (r < 0)
return r;
r = bus_verify_manage_units_async(m, message, reterr_error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
manager_clear_jobs(m);
return sd_bus_reply_method_return(message, NULL);
}
static int method_reset_failed(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
r = mac_selinux_access_check(message, "reload", reterr_error);
if (r < 0)
return r;
r = bus_verify_manage_units_async(m, message, reterr_error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
manager_reset_failed(m);
return sd_bus_reply_method_return(message, NULL);
}
static int list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error, char **states, char **patterns) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = ASSERT_PTR(userdata);
const char *k;
Unit *u;
int r;
assert(message);
/* Anyone can call this method */
if (strv_length(states) > MANAGER_MAX_STATES_PER_CALL)
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_LIMITS_EXCEEDED,
"Too many states in a single query.");
if (strv_length(patterns) > MANAGER_MAX_PATTERNS_PER_CALL)
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_LIMITS_EXCEEDED,
"Too many patterns in a single query.");
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
return r;
r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
if (r < 0)
return r;
HASHMAP_FOREACH_KEY(u, k, m->units) {
if (k != u->id)
continue;
r = mac_selinux_unit_access_check(u, message, "status", /* reterr_error= */ NULL);
if (r < 0)
continue; /* silently skip units the caller is not allowed to see */
if (!unit_passes_filter(u, states, patterns))
continue;
r = reply_unit_info(reply, u);
if (r < 0)
return r;
}
r = sd_bus_message_close_container(reply);
if (r < 0)
return r;
return sd_bus_message_send(reply);
}
static int method_list_units(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
return list_units_filtered(message, userdata, reterr_error, NULL, NULL);
}
static int method_list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
_cleanup_strv_free_ char **states = NULL;
int r;
r = sd_bus_message_read_strv(message, &states);
if (r < 0)
return r;
return list_units_filtered(message, userdata, reterr_error, states, NULL);
}
static int method_list_units_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
_cleanup_strv_free_ char **states = NULL;
_cleanup_strv_free_ char **patterns = NULL;
int r;
r = sd_bus_message_read_strv(message, &states);
if (r < 0)
return r;
r = sd_bus_message_read_strv(message, &patterns);
if (r < 0)
return r;
return list_units_filtered(message, userdata, reterr_error, states, patterns);
}
static int method_list_jobs(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = ASSERT_PTR(userdata);
Job *j;
int r;
assert(message);
/* Anyone can call this method */
r = mac_selinux_access_check(message, "status", reterr_error);
if (r < 0)
return r;
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
return r;
r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
if (r < 0)
return r;
HASHMAP_FOREACH(j, m->jobs) {
_cleanup_free_ char *unit_path = NULL, *job_path = NULL;
job_path = job_dbus_path(j);
if (!job_path)
return -ENOMEM;
unit_path = unit_dbus_path(j->unit);
if (!unit_path)
return -ENOMEM;
r = sd_bus_message_append(
reply, "(usssoo)",
j->id,
j->unit->id,
job_type_to_string(j->type),
job_state_to_string(j->state),
job_path,
unit_path);
if (r < 0)
return r;
}
r = sd_bus_message_close_container(reply);
if (r < 0)
return r;
return sd_bus_message_send(reply);
}
static int method_subscribe(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
/* Anyone can call this method */
r = mac_selinux_access_check(message, "status", reterr_error);
if (r < 0)
return r;
if (sd_bus_message_get_bus(message) == m->api_bus) {
/* Note that direct bus connection subscribe by
* default, we only track peers on the API bus here */
if (!m->subscribed) {
r = sd_bus_track_new(sd_bus_message_get_bus(message), &m->subscribed, NULL, NULL);
if (r < 0)
return r;
}
r = sd_bus_track_add_sender(m->subscribed, message);
if (r < 0)
return r;
if (r == 0)
return sd_bus_error_set(reterr_error, BUS_ERROR_ALREADY_SUBSCRIBED, "Client is already subscribed.");
}
return sd_bus_reply_method_return(message, NULL);
}
static int method_unsubscribe(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
/* Anyone can call this method */
r = mac_selinux_access_check(message, "status", reterr_error);
if (r < 0)
return r;
if (sd_bus_message_get_bus(message) == m->api_bus) {
r = sd_bus_track_remove_sender(m->subscribed, message);
if (r < 0)
return r;
if (r == 0)
return sd_bus_error_set(reterr_error, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
}
return sd_bus_reply_method_return(message, NULL);
}
static int dump_impl(
sd_bus_message *message,
void *userdata,
sd_bus_error *reterr_error,
char **patterns,
int (*reply)(sd_bus_message *, char *)) {
_cleanup_free_ char *dump = NULL;
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
if (strv_length(patterns) > MANAGER_MAX_PATTERNS_PER_CALL)
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_LIMITS_EXCEEDED,
"Too many patterns in a single query.");
/* 'status' access is the bare minimum always needed for this, as the policy might straight out
* forbid a client from querying any information from systemd, regardless of any rate limiting. */
r = mac_selinux_access_check(message, "status", reterr_error);
if (r < 0)
return r;
/* Rate limit reached? Check if the caller is privileged/allowed by policy to bypass this. We
* check the rate limit first to avoid the expensive roundtrip to polkit when not needed. */
if (!ratelimit_below(&m->dump_ratelimit)) {
/* We need a way for SELinux to constrain the operation when the rate limit is active, even
* if polkit would allow it, but we cannot easily add new named permissions, so we need to
* use an existing one. Reload/reexec are also slow but non-destructive/modifying
* operations, and can cause PID1 to stall. So it seems similar enough in terms of security
* considerations and impact, and thus use the same access check for dumps which, given the
* large amount of data to fetch, can stall PID1 for quite some time. */
r = mac_selinux_access_check(message, "reload", /* error= */ NULL);
if (r < 0)
goto ratelimited;
r = bus_verify_bypass_dump_ratelimit_async(m, message, /* reterr_error= */ NULL);
if (r < 0)
goto ratelimited;
if (r == 0)
/* No authorization for now, but the async polkit stuff will call us again when it
* has it */
return 1;
}
r = manager_get_dump_string(m, patterns, &dump);
if (r < 0)
return r;
return reply(message, dump);
ratelimited:
log_warning("Dump request rejected due to rate limit on unprivileged callers, blocked for %s.",
FORMAT_TIMESPAN(ratelimit_left(&m->dump_ratelimit), USEC_PER_SEC));
return sd_bus_error_setf(reterr_error,
SD_BUS_ERROR_LIMITS_EXCEEDED,
"Dump request rejected due to rate limit on unprivileged callers, blocked for %s.",
FORMAT_TIMESPAN(ratelimit_left(&m->dump_ratelimit), USEC_PER_SEC));
}
static int reply_dump(sd_bus_message *message, char *dump) {
return sd_bus_reply_method_return(message, "s", dump);
}
static int method_dump(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
return dump_impl(message, userdata, reterr_error, NULL, reply_dump);
}
static int reply_dump_by_fd(sd_bus_message *message, char *dump) {
_cleanup_close_ int fd = -EBADF;
fd = memfd_new_and_seal_string("dump", dump);
if (fd < 0)
return fd;
return sd_bus_reply_method_return(message, "h", fd);
}
static int method_dump_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
return dump_impl(message, userdata, reterr_error, NULL, reply_dump_by_fd);
}
static int dump_units_matching_patterns(
sd_bus_message *message,
void *userdata,
sd_bus_error *reterr_error,
int (*reply)(sd_bus_message *, char *)) {
_cleanup_strv_free_ char **patterns = NULL;
int r;
r = sd_bus_message_read_strv(message, &patterns);
if (r < 0)
return r;
return dump_impl(message, userdata, reterr_error, patterns, reply);
}
static int method_dump_units_matching_patterns(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
return dump_units_matching_patterns(message, userdata, reterr_error, reply_dump);
}
static int method_dump_units_matching_patterns_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
return dump_units_matching_patterns(message, userdata, reterr_error, reply_dump_by_fd);
}
static int method_refuse_snapshot(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for snapshots has been removed.");
}
static void log_caller(sd_bus_message *message, Manager *manager, const char *method) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
_cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
int r;
assert(message);
assert(manager);
assert(method);
r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID|SD_BUS_CREDS_PIDFD|SD_BUS_CREDS_AUGMENT, &creds);
if (r < 0)
log_debug_errno(r, "Failed to get dbus sender creds, ignoring: %m");
else {
r = bus_creds_get_pidref(creds, &pidref);
if (r < 0)
log_debug_errno(r, "Failed to get peer pidref, ignoring: %m");
}
manager_log_caller(manager, &pidref, method);
}
static int method_reload(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
r = mac_selinux_access_check(message, "reload", reterr_error);
if (r < 0)
return r;
r = bus_verify_reload_daemon_async(m, message, reterr_error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
/* Write a log message noting the unit or process who requested the Reload() */
log_caller(message, m, "Reload");
/* The reply to the previous Reload() is normally sent before the next request is dispatched.
* If it is still pending, refuse rather than drop it. Do this before the rate limit check, so
* that a refused request doesn't use up a token. */
if (m->pending_reload_message_dbus || m->pending_reload_message_vl) {
log_warning("Reloading request rejected, reply to previous reload still pending.");
return sd_bus_error_set_errnof(reterr_error, EBUSY,
"Reload() request rejected, previous reload still in progress.");
}
/* Check the rate limit after the authorization succeeds, to avoid denial-of-service issues. */
if (!ratelimit_below(&m->reload_reexec_ratelimit)) {
log_warning("Reloading request rejected due to rate limit.");
return sd_bus_error_set(reterr_error,
SD_BUS_ERROR_LIMITS_EXCEEDED,
"Reload() request rejected due to rate limit.");
}
/* Instead of sending the reply back right away, we just
* remember that we need to and then send it after the reload
* is finished. That way the caller knows when the reload
* finished. */
r = sd_bus_message_new_method_return(message, &m->pending_reload_message_dbus);
if (r < 0)
return r;
m->objective = MANAGER_RELOAD;
return 1;
}
static int method_reexecute(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
r = mac_selinux_access_check(message, "reload", reterr_error);
if (r < 0)
return r;
r = bus_verify_reload_daemon_async(m, message, reterr_error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
/* Write a log message noting the unit or process who requested the Reexecute() */
log_caller(message, m, "Reexecution");
/* Check the rate limit after the authorization succeeds, to avoid denial-of-service issues. */
if (!ratelimit_below(&m->reload_reexec_ratelimit)) {
log_warning("Reexecution request rejected due to rate limit.");
return sd_bus_error_set(reterr_error,
SD_BUS_ERROR_LIMITS_EXCEEDED,
"Reexecute() request rejected due to rate limit.");
}
/* We don't send a reply back here, the client should
* just wait for us disconnecting. */
m->objective = MANAGER_REEXECUTE;
return 1;
}
static int method_exit(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
r = mac_selinux_access_check(message, "halt", reterr_error);
if (r < 0)
return r;
log_caller(message, m, "Exit");
/* Exit() (in contrast to SetExitCode()) is actually allowed even if
* we are running on the host. It will fall back on reboot() in
* systemd-shutdown if it cannot do the exit() because it isn't a
* container. */
m->objective = MANAGER_EXIT;
return sd_bus_reply_method_return(message, NULL);
}
static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
if (!MANAGER_IS_SYSTEM(m))
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_NOT_SUPPORTED,
"Reboot is only supported by system manager.");
r = mac_selinux_access_check(message, "reboot", reterr_error);
if (r < 0)
return r;
log_caller(message, m, "Reboot");
m->objective = MANAGER_REBOOT;
return sd_bus_reply_method_return(message, NULL);
}
static int method_soft_reboot(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
_cleanup_free_ char *rt = NULL;
const char *root;
int r;
assert(message);
if (!MANAGER_IS_SYSTEM(m))
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_NOT_SUPPORTED,
"Soft reboot is only supported by system manager.");
/* Keep the checks in sync with varlink-manager.c:vl_method_soft_reboot_manager() */
r = mac_selinux_access_check(message, "reboot", reterr_error);
if (r < 0)
return r;
r = sd_bus_message_read(message, "s", &root);
if (r < 0)
return r;
if (!isempty(root)) {
if (!path_is_valid(root))
return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
"New root directory '%s' must be a valid path.", root);
if (!path_is_absolute(root))
return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
"New root directory path '%s' is not absolute.", root);
r = path_simplify_alloc(root, &rt);
if (r < 0)
return r;
}
log_caller(message, m, "Soft reboot");
free_and_replace(m->switch_root, rt);
m->objective = MANAGER_SOFT_REBOOT;
return sd_bus_reply_method_return(message, NULL);
}
static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
if (!MANAGER_IS_SYSTEM(m))
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_NOT_SUPPORTED,
"Powering off is only supported by system manager.");
r = mac_selinux_access_check(message, "halt", reterr_error);
if (r < 0)
return r;
log_caller(message, m, "Poweroff");
m->objective = MANAGER_POWEROFF;
return sd_bus_reply_method_return(message, NULL);
}
static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
if (!MANAGER_IS_SYSTEM(m))
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_NOT_SUPPORTED,
"Halt is only supported by system manager.");
r = mac_selinux_access_check(message, "halt", reterr_error);
if (r < 0)
return r;
log_caller(message, m, "Halt");
m->objective = MANAGER_HALT;
return sd_bus_reply_method_return(message, NULL);
}
static int method_kexec(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
if (!MANAGER_IS_SYSTEM(m))
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_NOT_SUPPORTED,
"KExec is only supported by system manager.");
r = mac_selinux_access_check(message, "reboot", reterr_error);
if (r < 0)
return r;
log_caller(message, m, "Kexec");
m->objective = MANAGER_KEXEC;
return sd_bus_reply_method_return(message, NULL);
}
static int method_switch_root(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
Manager *m = ASSERT_PTR(userdata);
_cleanup_free_ char *ri = NULL, *rt = NULL;
const char *root, *init;
int r;
assert(message);
if (!MANAGER_IS_SYSTEM(m))
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_NOT_SUPPORTED,
"Root switching is only supported by system manager.");
r = mac_selinux_access_check(message, "reboot", reterr_error);
if (r < 0)
return r;
r = sd_bus_message_read(message, "ss", &root, &init);
if (r < 0)
return r;
if (isempty(root))
/* If path is not specified, default to "/sysroot" which is what we generally expect initrds
* to use */
root = "/sysroot";
else {
if (!path_is_valid(root))
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
"New root directory must be a valid path.");
if (!path_is_absolute(root))
return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
"New root path '%s' is not absolute.", root);
r = path_is_root(root);
if (r < 0)
return sd_bus_error_set_errnof(reterr_error, r,
"Failed to check if new root directory '%s' is the same as old root: %m",
root);
if (r > 0)
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
"New root directory cannot be the old root directory.");
}
/* Safety check */
if (!in_initrd())
return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
"Not in initrd, refusing switch-root operation.");
r = path_is_os_tree(root);
if (r < 0)
return sd_bus_error_set_errnof(reterr_error, r,
"Failed to determine whether root path '%s' contains an OS tree: %m",
root);
if (r == 0)
return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
"Specified switch root path '%s' does not seem to be an OS tree. os-release file is missing.",
root);
if (!isempty(init)) {
if (!path_is_valid(init))
return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
"Path to init binary '%s' is not a valid path.", init);
if (!path_is_absolute(init))
return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
"Path to init binary '%s' not absolute.", init);
r = chase_and_access(init, root, CHASE_PREFIX_ROOT, X_OK, NULL);
if (r == -EACCES)
return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
"Init binary %s is not executable.", init);
if (r < 0)
return sd_bus_error_set_errnof(reterr_error, r,
"Could not resolve init executable %s: %m", init);
}
r = path_simplify_alloc(root, &rt);
if (r < 0)
return r;
if (!isempty(init)) {
r = path_simplify_alloc(init, &ri);
if (r < 0)
return r;
}
free_and_replace(m->switch_root, rt);
free_and_replace(m->switch_root_init, ri);
m->objective = MANAGER_SWITCH_ROOT;
return sd_bus_reply_method_return(message, NULL);
}
static int method_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
_cleanup_strv_free_ char **plus = NULL;
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
r = mac_selinux_access_check(message, "reload", reterr_error);
if (r < 0)
return r;
r = sd_bus_message_read_strv(message, &plus);
if (r < 0)
return r;