HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/sysupdate/sysupdated.c

71,861 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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;
        }