HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/login/logind-dbus.c
Git blob: 38cb6ce3dd8e7c377cf4004e698626c8561e1006
Lines 4001–4785 of 4,785
SD_BUS_METHOD("LockSessions",
NULL,
NULL,
method_lock_sessions,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD("UnlockSessions",
NULL,
NULL,
method_lock_sessions,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("KillSession",
SD_BUS_ARGS("s", session_id, "s", whom, "i", signal_number),
SD_BUS_NO_RESULT,
method_kill_session,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("KillUser",
SD_BUS_ARGS("u", uid, "i", signal_number),
SD_BUS_NO_RESULT,
method_kill_user,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("TerminateSession",
SD_BUS_ARGS("s", session_id),
SD_BUS_NO_RESULT,
method_terminate_session,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("TerminateUser",
SD_BUS_ARGS("u", uid),
SD_BUS_NO_RESULT,
method_terminate_user,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("TerminateSeat",
SD_BUS_ARGS("s", seat_id),
SD_BUS_NO_RESULT,
method_terminate_seat,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetUserLinger",
SD_BUS_ARGS("u", uid, "b", enable, "b", interactive),
SD_BUS_NO_RESULT,
method_set_user_linger,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("AttachDevice",
SD_BUS_ARGS("s", seat_id, "s", sysfs_path, "b", interactive),
SD_BUS_NO_RESULT,
method_attach_device,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("FlushDevices",
SD_BUS_ARGS("b", interactive),
SD_BUS_NO_RESULT,
method_flush_devices,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("PowerOff",
SD_BUS_ARGS("b", interactive),
SD_BUS_NO_RESULT,
method_poweroff,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("PowerOffWithFlags",
SD_BUS_ARGS("t", flags),
SD_BUS_NO_RESULT,
method_poweroff,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Reboot",
SD_BUS_ARGS("b", interactive),
SD_BUS_NO_RESULT,
method_reboot,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("RebootWithFlags",
SD_BUS_ARGS("t", flags),
SD_BUS_NO_RESULT,
method_reboot,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Halt",
SD_BUS_ARGS("b", interactive),
SD_BUS_NO_RESULT,
method_halt,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("HaltWithFlags",
SD_BUS_ARGS("t", flags),
SD_BUS_NO_RESULT,
method_halt,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Suspend",
SD_BUS_ARGS("b", interactive),
SD_BUS_NO_RESULT,
method_suspend,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SuspendWithFlags",
SD_BUS_ARGS("t", flags),
SD_BUS_NO_RESULT,
method_suspend,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Hibernate",
SD_BUS_ARGS("b", interactive),
SD_BUS_NO_RESULT,
method_hibernate,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("HibernateWithFlags",
SD_BUS_ARGS("t", flags),
SD_BUS_NO_RESULT,
method_hibernate,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("HybridSleep",
SD_BUS_ARGS("b", interactive),
SD_BUS_NO_RESULT,
method_hybrid_sleep,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("HybridSleepWithFlags",
SD_BUS_ARGS("t", flags),
SD_BUS_NO_RESULT,
method_hybrid_sleep,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SuspendThenHibernate",
SD_BUS_ARGS("b", interactive),
SD_BUS_NO_RESULT,
method_suspend_then_hibernate,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SuspendThenHibernateWithFlags",
SD_BUS_ARGS("t", flags),
SD_BUS_NO_RESULT,
method_suspend_then_hibernate,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Sleep",
SD_BUS_ARGS("t", flags),
SD_BUS_NO_RESULT,
method_sleep,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanPowerOff",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_poweroff,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanReboot",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_reboot,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanHalt",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_halt,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanSuspend",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_suspend,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanHibernate",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_hibernate,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanHybridSleep",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_hybrid_sleep,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanSuspendThenHibernate",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_suspend_then_hibernate,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanSleep",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_sleep,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("ScheduleShutdown",
SD_BUS_ARGS("s", type, "t", usec),
SD_BUS_NO_RESULT,
method_schedule_shutdown,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CancelScheduledShutdown",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("b", cancelled),
method_cancel_scheduled_shutdown,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Inhibit",
SD_BUS_ARGS("s", what, "s", who, "s", why, "s", mode),
SD_BUS_RESULT("h", pipe_fd),
method_inhibit,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanRebootParameter",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_reboot_parameter,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetRebootParameter",
SD_BUS_ARGS("s", parameter),
SD_BUS_NO_RESULT,
method_set_reboot_parameter,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanRebootToFirmwareSetup",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_reboot_to_firmware_setup,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetRebootToFirmwareSetup",
SD_BUS_ARGS("b", enable),
SD_BUS_NO_RESULT,
method_set_reboot_to_firmware_setup,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanRebootToBootLoaderMenu",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_reboot_to_boot_loader_menu,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetRebootToBootLoaderMenu",
SD_BUS_ARGS("t", timeout),
SD_BUS_NO_RESULT,
method_set_reboot_to_boot_loader_menu,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CanRebootToBootLoaderEntry",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", result),
method_can_reboot_to_boot_loader_entry,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetRebootToBootLoaderEntry",
SD_BUS_ARGS("s", boot_loader_entry),
SD_BUS_NO_RESULT,
method_set_reboot_to_boot_loader_entry,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetWallMessage",
SD_BUS_ARGS("s", wall_message, "b", enable),
SD_BUS_NO_RESULT,
method_set_wall_message,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_SIGNAL_WITH_ARGS("SecureAttentionKey",
SD_BUS_ARGS("s", seat_id, "o", object_path),
0),
SD_BUS_SIGNAL_WITH_ARGS("SessionNew",
SD_BUS_ARGS("s", session_id, "o", object_path),
0),
SD_BUS_SIGNAL_WITH_ARGS("SessionRemoved",
SD_BUS_ARGS("s", session_id, "o", object_path),
0),
SD_BUS_SIGNAL_WITH_ARGS("UserNew",
SD_BUS_ARGS("u", uid, "o", object_path),
0),
SD_BUS_SIGNAL_WITH_ARGS("UserRemoved",
SD_BUS_ARGS("u", uid, "o", object_path),
0),
SD_BUS_SIGNAL_WITH_ARGS("SeatNew",
SD_BUS_ARGS("s", seat_id, "o", object_path),
0),
SD_BUS_SIGNAL_WITH_ARGS("SeatRemoved",
SD_BUS_ARGS("s", seat_id, "o", object_path),
0),
SD_BUS_SIGNAL_WITH_ARGS("PrepareForShutdown",
SD_BUS_ARGS("b", start),
0),
SD_BUS_SIGNAL_WITH_ARGS("PrepareForShutdownWithMetadata",
SD_BUS_ARGS("b", start, "a{sv}", metadata),
0),
SD_BUS_SIGNAL_WITH_ARGS("PrepareForSleep",
SD_BUS_ARGS("b", start),
0),
SD_BUS_VTABLE_END
};
const BusObjectImplementation manager_object = {
"/org/freedesktop/login1",
"org.freedesktop.login1.Manager",
.vtables = BUS_VTABLES(manager_vtable),
.children = BUS_IMPLEMENTATIONS(&seat_object,
&session_object,
&user_object),
};
static void session_jobs_reply(Session *s, uint32_t jid, const char *unit, const char *result) {
assert(s);
assert(unit);
if (!s->started)
return;
if (result && !streq(result, "done")) {
_cleanup_(sd_bus_error_free) sd_bus_error e = SD_BUS_ERROR_NULL;
sd_bus_error_setf(&e, BUS_ERROR_JOB_FAILED,
"Job %u for unit '%s' failed with '%s'", jid, unit, result);
(void) session_send_create_reply(s, &e);
(void) session_send_upgrade_reply(s, &e);
return;
}
(void) session_send_create_reply(s, /* error= */ NULL);
(void) session_send_upgrade_reply(s, /* error= */ NULL);
}
int match_job_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
const char *path, *result, *unit;
uint32_t id;
int r;
assert(message);
r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
if (r < 0) {
bus_log_parse_error(r);
return 0;
}
if (m->action_job && streq(m->action_job, path)) {
assert(m->delayed_action);
log_info("Operation '%s' finished.", handle_action_to_string(m->delayed_action->handle));
/* Tell people that they now may take a lock again */
(void) send_prepare_for(m, m->delayed_action, false);
m->action_job = mfree(m->action_job);
m->delayed_action = NULL;
return 0;
}
Session *session;
User *user;
session = hashmap_get(m->session_units, unit);
if (session) {
if (streq_ptr(path, session->scope_job)) {
session->scope_job = mfree(session->scope_job);
session_jobs_reply(session, id, unit, result);
session_save(session);
user_save(session->user);
}
session_add_to_gc_queue(session);
}
user = hashmap_get(m->user_units, unit);
if (user) {
/* If the user is stopping, we're tracking stop jobs here. So don't send reply. */
if (!user->stopping) {
char **user_job;
FOREACH_ARGUMENT(user_job, &user->runtime_dir_job, &user->service_manager_job, &user->measure_job)
if (streq_ptr(path, *user_job)) {
*user_job = mfree(*user_job);
LIST_FOREACH(sessions_by_user, s, user->sessions)
/* Don't propagate user service failures to the client */
session_jobs_reply(s, id, unit, /* result= */ NULL);
user_save(user);
break;
}
}
user_add_to_gc_queue(user);
}
return 0;
}
int match_unit_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *path, *unit;
Manager *m = ASSERT_PTR(userdata);
Session *session;
User *user;
int r;
assert(message);
r = sd_bus_message_read(message, "so", &unit, &path);
if (r < 0) {
bus_log_parse_error(r);
return 0;
}
session = hashmap_get(m->session_units, unit);
if (session)
session_add_to_gc_queue(session);
user = hashmap_get(m->user_units, unit);
if (user)
user_add_to_gc_queue(user);
return 0;
}
int match_properties_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *unit = NULL;
Manager *m = ASSERT_PTR(userdata);
const char *path;
Session *session;
User *user;
int r;
assert(message);
path = sd_bus_message_get_path(message);
if (!path)
return 0;
r = unit_name_from_dbus_path(path, &unit);
if (r == -EINVAL) /* not a unit */
return 0;
if (r < 0) {
log_oom();
return 0;
}
session = hashmap_get(m->session_units, unit);
if (session)
session_add_to_gc_queue(session);
user = hashmap_get(m->user_units, unit);
if (user)
user_add_to_gc_queue(user);
return 0;
}
int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
Session *session;
int b, r;
assert(message);
r = sd_bus_message_read(message, "b", &b);
if (r < 0) {
bus_log_parse_error(r);
return 0;
}
if (b)
return 0;
/* systemd finished reloading, let's recheck all our sessions */
log_debug("System manager has been reloaded, rechecking sessions...");
HASHMAP_FOREACH(session, m->sessions)
session_add_to_gc_queue(session);
return 0;
}
int manager_send_changed_strv(Manager *manager, char **properties) {
assert(manager);
return sd_bus_emit_properties_changed_strv(
manager->bus,
"/org/freedesktop/login1",
"org.freedesktop.login1.Manager",
properties);
}
int manager_start_scope(
Manager *manager,
const char *scope,
const PidRef *pidref,
bool allow_pidfd,
const char *slice,
const char *description,
const char * const *requires,
const char * const *wants,
const char * const *extra_after,
const char *requires_mounts_for,
sd_bus_message *more_properties,
sd_bus_error *error,
char **ret_job) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error e = SD_BUS_ERROR_NULL;
int r;
assert(manager);
assert(scope);
assert(pidref_is_set(pidref));
assert(ret_job);
r = bus_message_new_method_call(manager->bus, &m, bus_systemd_mgr, "StartTransientUnit");
if (r < 0)
return r;
r = sd_bus_message_append(m, "ss", scope, "fail");
if (r < 0)
return r;
r = sd_bus_message_open_container(m, 'a', "(sv)");
if (r < 0)
return r;
if (!isempty(slice)) {
r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
if (r < 0)
return r;
}
if (!isempty(description)) {
r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
if (r < 0)
return r;
}
STRV_FOREACH(i, requires) {
r = sd_bus_message_append(m, "(sv)", "Requires", "as", 1, *i);
if (r < 0)
return r;
r = sd_bus_message_append(m, "(sv)", "After", "as", 1, *i);
if (r < 0)
return r;
}
STRV_FOREACH(i, wants) {
r = sd_bus_message_append(m, "(sv)", "Wants", "as", 1, *i);
if (r < 0)
return r;
r = sd_bus_message_append(m, "(sv)", "After", "as", 1, *i);
if (r < 0)
return r;
}
STRV_FOREACH(i, extra_after) {
r = sd_bus_message_append(m, "(sv)", "After", "as", 1, *i);
if (r < 0)
return r;
}
if (!empty_or_root(requires_mounts_for)) {
r = sd_bus_message_append(m, "(sv)", "RequiresMountsFor", "as", 1, requires_mounts_for);
if (r < 0)
return r;
}
/* Make sure that the session shells are terminated with SIGHUP since bash and friends tend to ignore
* SIGTERM */
r = sd_bus_message_append(m, "(sv)", "SendSIGHUP", "b", true);
if (r < 0)
return r;
r = bus_append_scope_pidref(m, pidref, allow_pidfd);
if (r < 0)
return r;
/* For login session scopes, if a process is OOM killed by the kernel, *don't* terminate the rest of
the scope */
r = sd_bus_message_append(m, "(sv)", "OOMPolicy", "s", "continue");
if (r < 0)
return r;
/* disable TasksMax= for the session scope, rely on the slice setting for it */
r = sd_bus_message_append(m, "(sv)", "TasksMax", "t", UINT64_MAX);
if (r < 0)
return bus_log_create_error(r);
if (more_properties) {
/* If TasksMax also appears here, it will overwrite the default value set above */
r = sd_bus_message_copy(m, more_properties, true);
if (r < 0)
return r;
}
r = sd_bus_message_close_container(m);
if (r < 0)
return r;
r = sd_bus_message_append(m, "a(sa(sv))", 0);
if (r < 0)
return r;
r = sd_bus_call(manager->bus, m, 0, &e, &reply);
if (r < 0) {
/* If this failed with a property we couldn't write, this is quite likely because the server
* doesn't support PIDFDs yet, let's try without. */
if (allow_pidfd &&
sd_bus_error_has_names(&e, SD_BUS_ERROR_UNKNOWN_PROPERTY, SD_BUS_ERROR_PROPERTY_READ_ONLY))
return manager_start_scope(
manager,
scope,
pidref,
/* allow_pidfd= */ false,
slice,
description,
requires,
wants,
extra_after,
requires_mounts_for,
more_properties,
error,
ret_job);
return sd_bus_error_move(error, &e);
}
return strdup_job(reply, ret_job);
}
int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error, char **ret_job) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
int r;
assert(manager);
assert(unit);
assert(ret_job);
r = bus_call_method(
manager->bus,
bus_systemd_mgr,
"StartUnit",
error,
&reply,
"ss", unit, "replace");
if (r < 0)
return r;
return strdup_job(reply, ret_job);
}
int manager_stop_unit(
Manager *manager,
const char *unit,
const char *job_mode,
sd_bus_error *ret_error,
char **ret_job) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
assert(manager);
assert(unit);
assert(ret_job);
r = bus_call_method(
manager->bus,
bus_systemd_mgr,
"StopUnit",
&error,
&reply,
"ss", unit, job_mode ?: "fail");
if (r < 0) {
if (sd_bus_error_has_names(&error, BUS_ERROR_NO_SUCH_UNIT, BUS_ERROR_LOAD_FAILED)) {
*ret_job = NULL;
return 0;
}
sd_bus_error_move(ret_error, &error);
return r;
}
r = strdup_job(reply, ret_job);
if (r < 0)
return r;
return 1;
}
int manager_abandon_scope(Manager *manager, const char *scope, sd_bus_error *ret_error) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *path = NULL;
int r;
assert(manager);
assert(scope);
path = unit_dbus_path_from_name(scope);
if (!path)
return -ENOMEM;
r = sd_bus_call_method(
manager->bus,
"org.freedesktop.systemd1",
path,
"org.freedesktop.systemd1.Scope",
"Abandon",
&error,
NULL,
NULL);
if (r < 0) {
if (sd_bus_error_has_names(&error, BUS_ERROR_NO_SUCH_UNIT,
BUS_ERROR_LOAD_FAILED,
BUS_ERROR_SCOPE_NOT_RUNNING))
return 0;
sd_bus_error_move(ret_error, &error);
return r;
}
return 1;
}
int manager_kill_unit(Manager *manager, const char *unit, KillWhom whom, int signo, sd_bus_error *error) {
assert(manager);
assert(unit);
assert(SIGNAL_VALID(signo));
return bus_call_method(
manager->bus,
bus_systemd_mgr,
"KillUnit",
error,
NULL,
"ssi",
unit,
whom == KILL_LEADER ? "main" : "all",
signo);
}
int manager_unit_is_active(Manager *manager, const char *unit, sd_bus_error *ret_error) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_free_ char *path = NULL;
const char *state;
int r;
assert(manager);
assert(unit);
path = unit_dbus_path_from_name(unit);
if (!path)
return -ENOMEM;
r = sd_bus_get_property(
manager->bus,
"org.freedesktop.systemd1",
path,
"org.freedesktop.systemd1.Unit",
"ActiveState",
&error,
&reply,
"s");
if (r < 0) {
/* systemd might have dropped off momentarily, let's
* not make this an error */
if (bus_error_is_connection(&error))
return true;
/* If the unit is already unloaded then it's not
* active */
if (sd_bus_error_has_names(&error, BUS_ERROR_NO_SUCH_UNIT,
BUS_ERROR_LOAD_FAILED))
return false;
sd_bus_error_move(ret_error, &error);
return r;
}
r = sd_bus_message_read(reply, "s", &state);
if (r < 0)
return r;
return !STR_IN_SET(state, "inactive", "failed");
}
int manager_job_is_active(Manager *manager, const char *path, sd_bus_error *ret_error) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
int r;
assert(manager);
assert(path);
r = sd_bus_get_property(
manager->bus,
"org.freedesktop.systemd1",
path,
"org.freedesktop.systemd1.Job",
"State",
&error,
&reply,
"s");
if (r < 0) {
if (bus_error_is_connection(&error))
return true;
if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
return false;
sd_bus_error_move(ret_error, &error);
return r;
}
/* We don't actually care about the state really. The fact
* that we could read the job state is enough for us */
return true;
}