HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/sysupdate/sysupdated.c
Git blob: 13fa52f29fde14dcc4ff523b5f0b63cb5eb0a8d5
Lines 1001–2000 of 2,205
if (!j->version)
return log_oom();
j->offline = FLAGS_SET(flags, SD_SYSUPDATE_OFFLINE);
r = job_start(j);
if (r < 0)
return sd_bus_error_set_errnof(error, r, "Failed to start job: %m");
TAKE_PTR(j); /* Avoid job from being killed & freed */
return 1;
}
static int target_method_check_new_finish(
sd_bus_message *msg,
const Job *j,
sd_json_variant *json,
sd_bus_error *error) {
const char *reply;
assert(json);
sd_json_variant *v = sd_json_variant_by_key(json, "available");
if (!v)
return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "check-new", "Missing key 'available'");
if (sd_json_variant_is_null(v))
reply = "";
else
reply = sd_json_variant_string(v);
if (!reply)
return -EINVAL;
return sd_bus_reply_method_return(msg, "s", reply);
}
static int target_method_check_new(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
Target *t = ASSERT_PTR(userdata);
_cleanup_(job_freep) Job *j = NULL;
int r;
assert(msg);
const char *details[] = {
"class", target_class_to_string(t->class),
"name", t->name,
"offline", "0",
NULL
};
r = bus_verify_polkit_async(
msg,
"org.freedesktop.sysupdate1.check",
details,
&t->manager->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = job_new(JOB_CHECK_NEW, t, msg, target_method_check_new_finish, &j);
if (r < 0)
return r;
r = job_start(j);
if (r < 0)
return sd_bus_error_set_errnof(error, r, "Failed to start job: %m");
TAKE_PTR(j); /* Avoid job from being killed & freed */
return 1;
}
static int target_method_acquire_finished_early(
sd_bus_message *msg,
const Job *j,
sd_json_variant *json,
sd_bus_error *error) {
/* Called when job finishes w/ a successful exit code, but before any work begins.
* This happens when there is no candidate (i.e. we're already up-to-date), or
* specified update is already acquired. */
return sd_bus_error_setf(error, BUS_ERROR_NO_UPDATE_CANDIDATE,
"Job exited successfully with no work to do, assume already acquired");
}
static int target_method_acquire_detach(sd_bus_message *msg, const Job *j) {
int r;
assert(msg);
assert(j);
r = sd_bus_reply_method_return(msg, "sto", j->version, j->id, j->object_path);
if (r < 0)
return bus_log_parse_error(r);
return 0;
}
static int target_method_acquire(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
Target *t = ASSERT_PTR(userdata);
_cleanup_(job_freep) Job *j = NULL;
const char *version, *action;
uint64_t flags;
int r;
assert(msg);
r = sd_bus_message_read(msg, "st", &version, &flags);
if (r < 0)
return r;
if (flags != 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Flags must be 0");
/* We don’t have a separate polkit action for acquire/install as they are both effectively (part of)
* an update anyway. */
if (isempty(version))
action = "org.freedesktop.sysupdate1.update";
else {
if (!version_is_valid(version, VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid version");
action = "org.freedesktop.sysupdate1.update-to-version";
}
const char *details[] = {
"class", target_class_to_string(t->class),
"name", t->name,
"version", version,
NULL
};
r = bus_verify_polkit_async(
msg,
action,
details,
&t->manager->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = job_new(JOB_ACQUIRE, t, msg, target_method_acquire_finished_early, &j);
if (r < 0)
return r;
j->detach_cb = target_method_acquire_detach;
j->version = strdup(version);
if (!j->version)
return -ENOMEM;
r = job_start(j);
if (r < 0)
return sd_bus_error_set_errnof(error, r, "Failed to start job: %m");
TAKE_PTR(j);
return 1;
}
static int target_method_install_finished_early(
sd_bus_message *msg,
const Job *j,
sd_json_variant *json,
sd_bus_error *error) {
/* Called when job finishes w/ a successful exit code, but before any work begins.
* This happens when there is no candidate (i.e. we're already up-to-date), or
* specified update is already installed. */
return sd_bus_error_setf(error, BUS_ERROR_NO_UPDATE_CANDIDATE,
"Job exited successfully with no work to do, assume already installed");
}
static int target_method_install_detach(sd_bus_message *msg, const Job *j) {
int r;
assert(msg);
assert(j);
r = sd_bus_reply_method_return(msg, "sto", j->version, j->id, j->object_path);
if (r < 0)
return bus_log_parse_error(r);
return 0;
}
static int target_method_install(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
Target *t = ASSERT_PTR(userdata);
_cleanup_(job_freep) Job *j = NULL;
const char *version, *action;
uint64_t flags;
int r;
assert(msg);
r = sd_bus_message_read(msg, "st", &version, &flags);
if (r < 0)
return r;
if (flags != 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Flags must be 0");
/* We don’t have a separate polkit action for acquire/install as they are both effectively (part of)
* an update anyway. */
if (isempty(version))
action = "org.freedesktop.sysupdate1.update";
else {
if (!version_is_valid(version, VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid version");
action = "org.freedesktop.sysupdate1.update-to-version";
}
const char *details[] = {
"class", target_class_to_string(t->class),
"name", t->name,
"version", version,
NULL
};
r = bus_verify_polkit_async(
msg,
action,
details,
&t->manager->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = job_new(JOB_INSTALL, t, msg, target_method_install_finished_early, &j);
if (r < 0)
return r;
j->detach_cb = target_method_install_detach;
j->version = strdup(version);
if (!j->version)
return -ENOMEM;
r = job_start(j);
if (r < 0)
return sd_bus_error_set_errnof(error, r, "Failed to start job: %m");
TAKE_PTR(j);
return 1;
}
static int target_method_vacuum_finish(
sd_bus_message *msg,
const Job *j,
sd_json_variant *json,
sd_bus_error *error) {
sd_json_variant *v;
uint64_t instances, disabled;
assert(json);
v = sd_json_variant_by_key(json, "removed");
if (!v)
return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "vacuum", "Missing key 'removed'");
if (!sd_json_variant_is_unsigned(v))
return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "vacuum", "Key 'removed' should be an unsigned int");
instances = sd_json_variant_unsigned(v);
assert(instances <= UINT32_MAX);
v = sd_json_variant_by_key(json, "disabledTransfers");
if (!v)
return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "vacuum", "Missing key 'disabledTransfers'");
if (!sd_json_variant_is_unsigned(v))
return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "vacuum", "Key 'disabledTransfers' should be an unsigned int");
disabled = sd_json_variant_unsigned(v);
assert(disabled <= UINT32_MAX);
return sd_bus_reply_method_return(msg, "uu", (uint32_t) instances, (uint32_t) disabled);
}
static int target_method_vacuum(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
Target *t = ASSERT_PTR(userdata);
_cleanup_(job_freep) Job *j = NULL;
int r;
assert(msg);
const char *details[] = {
"class", target_class_to_string(t->class),
"name", t->name,
NULL
};
r = bus_verify_polkit_async(
msg,
"org.freedesktop.sysupdate1.vacuum",
details,
&t->manager->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = job_new(JOB_VACUUM, t, msg, target_method_vacuum_finish, &j);
if (r < 0)
return r;
r = job_start(j);
if (r < 0)
return sd_bus_error_set_errnof(error, r, "Failed to start job: %m");
TAKE_PTR(j); /* Avoid job from being killed & freed */
return 1;
}
static int target_method_get_version(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
Target *t = ASSERT_PTR(userdata);
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
sd_json_variant *version_json;
int r;
r = sysupdate_run_simple(&v, t, "--offline", "list", NULL);
if (r < 0)
return log_error_errno(r, "Failed to run 'systemd-sysupdate list': %m");
version_json = sd_json_variant_by_key(v, "current");
if (!version_json)
version_json = sd_json_variant_by_key(v, "current+pending");
if (!version_json)
return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "list", "Missing key 'current' or 'current+pending'");
if (sd_json_variant_is_null(version_json))
return sd_bus_reply_method_return(msg, "s", "");
if (!sd_json_variant_is_string(version_json))
return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "list", "Key 'current' should be a string");
return sd_bus_reply_method_return(msg, "s", sd_json_variant_string(version_json));
}
static int target_get_appstream(Target *t, char ***ret) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
sd_json_variant *appstream_url_json;
int r;
r = sysupdate_run_simple(&v, t, "--offline", "list", NULL);
if (r < 0)
return log_error_errno(r, "Failed to run 'systemd-sysupdate list': %m");
appstream_url_json = sd_json_variant_by_key(v, "appstreamUrls");
if (!appstream_url_json)
return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "list", "Missing key 'appstreamUrls'");
r = sd_json_variant_strv(appstream_url_json, ret);
if (r < 0)
return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "list", "Key 'appstreamUrls' should be strv");
return 0;
}
static int target_method_get_appstream(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
Target *t = ASSERT_PTR(userdata);
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_strv_free_ char **appstream_urls = NULL;
int r;
r = target_get_appstream(t, &appstream_urls);
if (r < 0)
return r;
r = sd_bus_message_new_method_return(msg, &reply);
if (r < 0)
return r;
r = sd_bus_message_append_strv(reply, appstream_urls);
if (r < 0)
return r;
return sd_bus_message_send(reply);
}
static int target_method_list_features(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *json = NULL;
_cleanup_strv_free_ char **features = NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Target *t = ASSERT_PTR(userdata);
sd_json_variant *v;
uint64_t flags;
int r;
assert(msg);
r = sd_bus_message_read(msg, "t", &flags);
if (r < 0)
return r;
if (flags != 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Flags must be 0");
r = sysupdate_run_simple(&json, t, "--offline", "features", NULL);
if (r < 0)
return r;
v = sd_json_variant_by_key(json, "features");
if (!v)
return -EINVAL;
r = sd_json_variant_strv(v, &features);
if (r < 0)
return r;
r = sd_bus_message_new_method_return(msg, &reply);
if (r < 0)
return r;
r = sd_bus_message_append_strv(reply, features);
if (r < 0)
return r;
return sd_bus_message_send(reply);
}
static int target_method_describe_feature(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
Target *t = ASSERT_PTR(userdata);
_cleanup_(job_freep) Job *j = NULL;
const char *feature;
uint64_t flags;
int r;
assert(msg);
r = sd_bus_message_read(msg, "st", &feature, &flags);
if (r < 0)
return r;
if (!feature_name_valid(feature))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid feature name");
if (flags != 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Flags must be 0");
r = job_new(JOB_DESCRIBE_FEATURE, t, msg, target_method_describe_finish, &j);
if (r < 0)
return r;
j->feature = strdup(feature);
if (!j->feature)
return log_oom();
r = job_start(j);
if (r < 0)
return sd_bus_error_set_errnof(error, r, "Failed to start job: %m");
TAKE_PTR(j); /* Avoid job from being killed & freed */
return 1;
}
static int target_method_set_feature_enabled(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *feature_ext = NULL;
Target *t = ASSERT_PTR(userdata);
const char *feature;
uint64_t flags;
int32_t enabled;
int r;
assert(msg);
if (t->class != TARGET_HOST)
return sd_bus_reply_method_errorf(msg,
SD_BUS_ERROR_NOT_SUPPORTED,
"For now, features can only be managed on the host system.");
r = sd_bus_message_read(msg, "sit", &feature, &enabled, &flags);
if (r < 0)
return r;
if (!feature_name_valid(feature))
return sd_bus_reply_method_errorf(msg,
SD_BUS_ERROR_INVALID_ARGS,
"The specified feature is invalid");
if (flags != 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Flags must be 0");
if (!endswith(feature, ".feature")) {
feature_ext = strjoin(feature, ".feature");
if (!feature_ext)
return -ENOMEM;
feature = feature_ext;
}
const char *details[] = {
"class", target_class_to_string(t->class),
"name", t->name,
"feature", feature,
"enabled", enabled >= 0 ? true_false(enabled) : "unset",
NULL
};
r = bus_verify_polkit_async(
msg,
"org.freedesktop.sysupdate1.manage-features",
details,
&t->manager->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
/* We assume that no sysadmin will name their config 50-systemd-sysupdate-enabled.conf */
if (enabled < 0) { /* Reset -> delete the drop-in file */
_cleanup_free_ char *path = NULL;
r = drop_in_file(SYSCONF_DIR "/sysupdate.d", feature, 50, FEATURES_DROPIN_NAME, NULL, &path);
if (r < 0)
return r;
if (unlink(path) < 0)
return -errno;
} else { /* otherwise, create the drop-in with the right settings */
r = write_drop_in_format(SYSCONF_DIR "/sysupdate.d", feature, 50, FEATURES_DROPIN_NAME,
"# Generated via org.freedesktop.sysupdate1 D-Bus interface\n\n"
"[Feature]\n"
"Enabled=%s\n",
yes_no(enabled));
if (r < 0)
return r;
}
return sd_bus_reply_method_return(msg, NULL);
}
static int target_list_components(Target *t, char ***ret_components, bool *ret_have_default) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *json = NULL;
_cleanup_strv_free_ char **components = NULL;
sd_json_variant *v;
bool have_default;
int r;
r = sysupdate_run_simple(&json, t, "components", NULL);
if (r < 0)
return log_debug_errno(r, "Failed to run 'systemd-sysupdate components': %m");
v = sd_json_variant_by_key(json, "default");
if (!v)
return log_sysupdate_bad_json_debug(SYNTHETIC_ERRNO(EPROTO), "components", "Missing key 'default'");
have_default = sd_json_variant_boolean(v);
v = sd_json_variant_by_key(json, "components");
if (!v)
return log_sysupdate_bad_json_debug(SYNTHETIC_ERRNO(EPROTO), "components", "Missing key 'components'");
r = sd_json_variant_strv(v, &components);
if (r < 0)
return log_sysupdate_bad_json_debug(SYNTHETIC_ERRNO(EPROTO), "components", "Key 'components' should be a strv");
if (ret_components)
*ret_components = TAKE_PTR(components);
if (ret_have_default)
*ret_have_default = have_default;
return 0;
}
static int manager_ensure_targets(Manager *m);
static int target_object_find(
sd_bus *bus,
const char *path,
const char *iface,
void *userdata,
void **found,
sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
Target *t;
_cleanup_free_ char *e = NULL;
const char *p;
int r;
assert(bus);
assert(path);
assert(found);
p = startswith(path, "/org/freedesktop/sysupdate1/target/");
if (!p)
return 0;
e = bus_label_unescape(p);
if (!e)
return -ENOMEM;
r = manager_ensure_targets(m);
if (r < 0)
return r;
t = hashmap_get(m->targets, e);
if (!t)
return 0;
*found = t;
return 1;
}
static char *target_bus_path(Target *t) {
_cleanup_free_ char *e = NULL;
assert(t);
e = bus_label_escape(t->id);
if (!e)
return NULL;
return strjoin("/org/freedesktop/sysupdate1/target/", e);
}
static int target_node_enumerator(
sd_bus *bus,
const char *path,
void *userdata,
char ***nodes,
sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
Manager *m = ASSERT_PTR(userdata);
Target *t;
unsigned k = 0;
int r;
assert(nodes);
r = manager_ensure_targets(m);
if (r < 0)
return r;
l = new0(char*, hashmap_size(m->targets) + 1);
if (!l)
return -ENOMEM;
HASHMAP_FOREACH(t, m->targets) {
l[k] = target_bus_path(t);
if (!l[k])
return -ENOMEM;
k++;
}
*nodes = TAKE_PTR(l);
return 1;
}
static const sd_bus_vtable target_vtable[] = {
SD_BUS_VTABLE_START(0),
SD_BUS_PROPERTY("Class", "s", target_property_get_class,
offsetof(Target, class), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("Name", "s", NULL, offsetof(Target, name),
SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("Path", "s", NULL, offsetof(Target, path),
SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_METHOD_WITH_ARGS("List",
SD_BUS_ARGS("t", flags),
SD_BUS_RESULT("as", versions),
target_method_list,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Describe",
SD_BUS_ARGS("s", version, "t", flags),
SD_BUS_RESULT("s", json),
target_method_describe,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("CheckNew",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", new_version),
target_method_check_new,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Acquire",
SD_BUS_ARGS("s", new_version, "t", flags),
SD_BUS_RESULT("s", new_version, "t", job_id, "o", job_path),
target_method_acquire,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Install",
SD_BUS_ARGS("s", new_version, "t", flags),
SD_BUS_RESULT("s", new_version, "t", job_id, "o", job_path),
target_method_install,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Vacuum",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("u", instances, "u", disabled_transfers),
target_method_vacuum,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("GetAppStream",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("as", appstream),
target_method_get_appstream,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("GetVersion",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", version),
target_method_get_version,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("ListFeatures",
SD_BUS_ARGS("t", flags),
SD_BUS_RESULT("as", features),
target_method_list_features,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("DescribeFeature",
SD_BUS_ARGS("s", feature, "t", flags),
SD_BUS_RESULT("s", json),
target_method_describe_feature,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetFeatureEnabled",
SD_BUS_ARGS("s", feature, "i", enabled, "t", flags),
SD_BUS_NO_RESULT,
target_method_set_feature_enabled,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_VTABLE_END
};
static const BusObjectImplementation target_object = {
"/org/freedesktop/sysupdate1/target",
"org.freedesktop.sysupdate1.Target",
.fallback_vtables = BUS_FALLBACK_VTABLES({target_vtable, target_object_find}),
.node_enumerator = target_node_enumerator,
};
static Manager *manager_free(Manager *m) {
if (!m)
return NULL;
hashmap_free(m->targets);
hashmap_free(m->jobs);
m->bus = sd_bus_flush_close_unref(m->bus);
free(m->notify_socket_path);
sd_event_unref(m->event);
return mfree(m);
}
DEFINE_TRIVIAL_CLEANUP_FUNC(Manager *, manager_free);
static int manager_on_notify(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(fd >= 0);
_cleanup_(pidref_done) PidRef sender_pidref = PIDREF_NULL;
_cleanup_free_ char *buf = NULL;
r = notify_recv(fd, &buf, /* ret_ucred= */ NULL, &sender_pidref);
if (r == -EAGAIN)
return 0;
if (r < 0)
return r;
Job *j;
HASHMAP_FOREACH(j, m->jobs) {
PidRef child_pidref = PIDREF_NULL;
r = event_source_get_child_pidref(j->child, &child_pidref);
if (r < 0)
return log_warning_errno(r, "Failed to get child pidref: %m");
if (pidref_equal(&sender_pidref, &child_pidref))
break;
}
if (!j) {
log_warning("Got notification datagram from unexpected peer, ignoring.");
return 0;
}
char *version = find_line_startswith(buf, "X_SYSUPDATE_VERSION=");
char *progress = find_line_startswith(buf, "X_SYSUPDATE_PROGRESS=");
char *errno_str = find_line_startswith(buf, "ERRNO=");
const char *ready = find_line_startswith(buf, "READY=1");
if (version)
job_on_version(j, truncate_nl(version));
if (progress)
job_on_progress(j, truncate_nl(progress));
if (errno_str)
job_on_errno(j, truncate_nl(errno_str));
/* Should come last, since this might actually detach the job */
if (ready)
job_on_ready(j);
return 0;
}
static int manager_new(Manager **ret) {
_cleanup_(manager_freep) Manager *m = NULL;
int r;
assert(ret);
m = new(Manager, 1);
if (!m)
return -ENOMEM;
*m = (Manager) {
.runtime_scope = RUNTIME_SCOPE_SYSTEM,
};
r = sd_event_default(&m->event);
if (r < 0)
return r;
(void) sd_event_set_watchdog(m->event, true);
r = sd_event_set_signal_exit(m->event, true);
if (r < 0)
return r;
r = sd_event_add_signal(m->event, NULL, (SIGRTMIN+18) | SD_EVENT_SIGNAL_PROCMASK,
sigrtmin18_handler, NULL);
if (r < 0)
return r;
r = sd_event_add_memory_pressure(m->event, NULL, NULL, NULL);
if (r < 0)
log_debug_errno(r, "Failed to allocate memory pressure event source, ignoring: %m");
r = sd_bus_default_system(&m->bus);
if (r < 0)
return r;
r = notify_socket_prepare(
m->event,
SD_EVENT_PRIORITY_NORMAL - 1, /* Make this processed before worker exit. */
manager_on_notify,
m,
&m->notify_socket_path);
if (r < 0)
return r;
*ret = TAKE_PTR(m);
return 0;
}
static int manager_enumerate_image_class(Manager *m, TargetClass class) {
_cleanup_hashmap_free_ Hashmap *images = NULL;
Image *image;
int r;
r = image_discover(m->runtime_scope, (ImageClass) class, NULL, &images);
if (r < 0)
return r;
HASHMAP_FOREACH(image, images) {
_cleanup_(target_freep) Target *t = NULL;
bool have = false;
if (image_is_host(image))
continue; /* We already enroll the host ourselves */
if (image->type == IMAGE_MSTACK)
continue; /* systemd-sysupdate doesn't support mstack images yet */
r = target_new(m, class, image->name, image->path, &t);
if (r < 0)
return r;
t->image_type = image->type;
r = target_list_components(t, NULL, &have);
if (r < 0)
return r;
if (!have) {
log_debug("Skipping %s because it has no default component", image->path);
continue;
}
r = hashmap_ensure_put(&m->targets, &target_hash_ops, t->id, t);
if (r < 0)
return r;
TAKE_PTR(t);
}
return 0;
}
static int manager_enumerate_components(Manager *m) {
_cleanup_strv_free_ char **components = NULL;
bool have_default;
int r;
r = target_list_components(NULL, &components, &have_default);
if (r < 0)
return r;
if (have_default) {
_cleanup_(target_freep) Target *t = NULL;
r = target_new(m, TARGET_HOST, "host", "sysupdate.d", &t);
if (r < 0)
return r;
r = hashmap_ensure_put(&m->targets, &target_hash_ops, t->id, t);
if (r < 0)
return r;
TAKE_PTR(t);
}
STRV_FOREACH(component, components) {
_cleanup_free_ char *path = NULL;
_cleanup_(target_freep) Target *t = NULL;
path = strjoin("sysupdate.", *component, ".d");
if (!path)
return -ENOMEM;
r = target_new(m, TARGET_COMPONENT, *component, path, &t);
if (r < 0)
return r;
r = hashmap_ensure_put(&m->targets, &target_hash_ops, t->id, t);
if (r < 0)
return r;
TAKE_PTR(t);
}
return 0;
}
static int manager_enumerate_targets(Manager *m) {
static const TargetClass discoverable_classes[] = {
TARGET_MACHINE,
TARGET_PORTABLE,
TARGET_SYSEXT,
TARGET_CONFEXT,
};
int r;
assert(m);
FOREACH_ARRAY(class, discoverable_classes, ELEMENTSOF(discoverable_classes)) {
r = manager_enumerate_image_class(m, *class);
if (r < 0)
log_warning_errno(r, "Failed to enumerate %ss, ignoring: %m",
target_class_to_string(*class));
}
r = manager_enumerate_components(m);
if (r < 0)
log_warning_errno(r, "Failed to enumerate components, ignoring: %m");
return 0;
}
static int manager_ensure_targets(Manager *m) {
assert(m);
if (!hashmap_isempty(m->targets))
return 0;
return manager_enumerate_targets(m);
}
static int method_list_targets(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = ASSERT_PTR(userdata);
Target *t;
int r;
assert(msg);
r = manager_ensure_targets(m);
if (r < 0)
return r;
r = sd_bus_message_new_method_return(msg, &reply);
if (r < 0)
return r;
r = sd_bus_message_open_container(reply, 'a', "(sso)");
if (r < 0)
return r;
HASHMAP_FOREACH(t, m->targets) {
_cleanup_free_ char *bus_path = NULL;
bus_path = target_bus_path(t);
if (!bus_path)
return -ENOMEM;
r = sd_bus_message_append(reply, "(sso)",
target_class_to_string(t->class),
t->name,
bus_path);
if (r < 0)
return r;
}