HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/core/dbus-manager.c

159,246 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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;