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 1–1000 of 2,205

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include "sd-bus.h"
#include "sd-json.h"
 
#include "build-path.h"
#include "bus-common-errors.h"
#include "bus-error.h"
#include "bus-get-properties.h"
#include "bus-label.h"
#include "bus-log-control-api.h"
#include "bus-object.h"
#include "bus-polkit.h"
#include "bus-util.h"
#include "common-signal.h"
#include "constants.h"
#include "discover-image.h"
#include "dropin.h"
#include "env-util.h"
#include "escape.h"
#include "event-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "hashmap.h"
#include "log.h"
#include "main-func.h"
#include "memfd-util.h"
#include "notify-recv.h"
#include "os-util.h"
#include "parse-util.h"
#include "pidref.h"
#include "process-util.h"
#include "runtime-scope.h"
#include "service-util.h"
#include "signal-util.h"
#include "string-table.h"
#include "strv.h"
#include "sysupdate-target.h"
#include "sysupdate-util.h"
#include "verbs.h"
 
#define FEATURES_DROPIN_NAME "systemd-sysupdate-enabled"
 
typedef struct Manager {
        sd_event *event;
        sd_bus *bus;
 
        Hashmap *targets;
 
        uint64_t last_job_id;
        Hashmap *jobs;
 
        Hashmap *polkit_registry;
 
        char *notify_socket_path;
 
        RuntimeScope runtime_scope; /* For now only RUNTIME_SCOPE_SYSTEM */
} Manager;
 
/* Forward declare so that jobs can call it on exit */
static void manager_check_idle(Manager *m);
 
typedef struct Target {
        Manager *manager;
 
        TargetClass class;
        char *name;
        char *path;
 
        char *id;
        ImageType image_type;
        bool busy;
} Target;
 
typedef enum JobType {
        JOB_LIST,
        JOB_DESCRIBE,
        JOB_CHECK_NEW,
        JOB_ACQUIRE,
        JOB_INSTALL,
        JOB_VACUUM,
        JOB_DESCRIBE_FEATURE,
        _JOB_TYPE_MAX,
        _JOB_TYPE_INVALID = -EINVAL,
} JobType;
 
typedef struct Job Job;
 
typedef int (*JobReady)(sd_bus_message *msg, const Job *job);
typedef int (*JobComplete)(sd_bus_message *msg, const Job *job, sd_json_variant *response, sd_bus_error *error);
 
struct Job {
        Manager *manager;
        Target *target;
 
        uint64_t id;
        char *object_path;
 
        JobType type;
        bool offline;
        char *version; /* Passed into sysupdate for JOB_DESCRIBE, JOB_ACQUIRE and JOB_INSTALL */
        char *feature; /* Passed into sysupdate for JOB_DESCRIBE_FEATURE */
 
        unsigned progress_percent;
 
        sd_event_source *child;
        int stdout_fd;
        int status_errno;
        unsigned n_cancelled;
 
        sd_json_variant *json;
 
        JobComplete complete_cb; /* Callback called on job exit */
        sd_bus_message *dbus_msg;
        JobReady detach_cb; /* Callback called when job has started.  Detaches the job to run in the background */
};
 
static const char* const job_type_table[_JOB_TYPE_MAX] = {
        [JOB_LIST]             = "list",
        [JOB_DESCRIBE]         = "describe",
        [JOB_CHECK_NEW]        = "check-new",
        [JOB_ACQUIRE]          = "acquire",
        [JOB_INSTALL]          = "install",
        [JOB_VACUUM]           = "vacuum",
        [JOB_DESCRIBE_FEATURE] = "describe-feature",
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(job_type, JobType);
 
static Job *job_free(Job *j) {
        if (!j)
                return NULL;
 
        if (j->manager)
                assert_se(hashmap_remove(j->manager->jobs, &j->id) == j);
 
        free(j->object_path);
        free(j->version);
        free(j->feature);
 
        sd_json_variant_unref(j->json);
 
        sd_bus_message_unref(j->dbus_msg);
 
        sd_event_source_disable_unref(j->child);
        safe_close(j->stdout_fd);
 
        return mfree(j);
}
 
DEFINE_TRIVIAL_CLEANUP_FUNC(Job*, job_free);
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(job_hash_ops,
                                              uint64_t, uint64_hash_func, uint64_compare_func,
                                              Job, job_free);
 
static int job_new(JobType type, Target *t, sd_bus_message *msg, JobComplete complete_cb, Job **ret) {
        _cleanup_(job_freep) Job *j = NULL;
        int r;
 
        assert(t);
        assert(ret);
 
        j = new(Job, 1);
        if (!j)
                return -ENOMEM;
 
        *j = (Job) {
                .type = type,
                .target = t,
                .id = t->manager->last_job_id + 1,
                .stdout_fd = -EBADF,
                .complete_cb = complete_cb,
                .dbus_msg = sd_bus_message_ref(msg),
        };
 
        if (asprintf(&j->object_path, "/org/freedesktop/sysupdate1/job/_%" PRIu64, j->id) < 0)
                return -ENOMEM;
 
        r = hashmap_ensure_put(&t->manager->jobs, &job_hash_ops, &j->id, j);
        if (r < 0)
                return r;
 
        j->manager = t->manager;
 
        t->manager->last_job_id = j->id;
 
        *ret = TAKE_PTR(j);
        return 0;
}
 
/* Is Job in the set of jobs which require Target.busy to be set so they run exclusively? */
static bool job_requires_busy(Job *j) {
        return IN_SET(j->type, JOB_ACQUIRE, JOB_INSTALL, JOB_VACUUM);
}
 
static int job_parse_child_output(int _fd, sd_json_variant **ret) {
        _cleanup_close_ int fd = ASSERT_FD(_fd); /* Take ownership of the passed fd */
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        struct stat st;
        int r;
 
        assert(ret);
 
        if (fstat(fd, &st) < 0)
                return log_debug_errno(errno, "Failed to stat stdout fd: %m");
 
        assert(S_ISREG(st.st_mode));
 
        if (st.st_size == 0) {
                log_warning("No output from child job, ignoring");
                return 0;
        }
 
        r = sd_json_parse_fd(
                        /* path= */ "stdout",
                        TAKE_FD(fd),
                        SD_JSON_PARSE_DONATE_FD|SD_JSON_PARSE_SEEK0,
                        &v,
                        /* reterr_line= */ NULL,
                        /* reterr_column= */ NULL);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse child output as JSON: %m");
 
        *ret = TAKE_PTR(v);
        return 0;
}
 
static void job_on_ready(Job *j) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *msg = NULL;
        int r;
 
        assert(j);
 
        /* Some jobs run in the background as we return the job ID to the dbus caller (i.e. for the Update
         * method). However, the worker will perform some sanity-checks on startup which would be valuable
         * as dbus errors. So, we wait for the worker to signal via READY=1 that it has completed its sanity
         * checks and we should continue the job in the background. */
 
        if (!j->detach_cb)
                return;
 
        log_debug("Got READY=1 from job %" PRIu64", detaching.", j->id);
 
        assert(j->dbus_msg);
        msg = TAKE_PTR(j->dbus_msg);
 
        j->complete_cb = NULL;
 
        r = j->detach_cb(msg, j);
        if (r < 0)
                log_warning_errno(r, "Failed to detach job %" PRIu64 ", ignoring: %m", j->id);
}
 
static void job_on_errno(Job *j, const char *buf) {
        int r;
 
        assert(j);
        assert(buf);
 
        r = parse_errno(buf);
        if (r < 0) {
                log_warning_errno(r, "Got invalid errno value from job %" PRIu64 ", ignoring: %m", j->id);
                return;
        }
 
        j->status_errno = r;
 
        log_debug_errno(r, "Got errno from job %" PRIu64 ": %i (%m)", j->id, r);
}
 
static void job_on_progress(Job *j, const char *buf) {
        unsigned progress;
        int r;
 
        assert(j);
        assert(buf);
 
        r = safe_atou(buf, &progress);
        if (r < 0 || progress > 100) {
                log_warning("Got invalid percent value, ignoring.");
                return;
        }
 
        j->progress_percent = progress;
        (void) sd_bus_emit_properties_changed(j->manager->bus, j->object_path,
                                              "org.freedesktop.sysupdate1.Job",
                                              "Progress", NULL);
 
        log_debug("Got percentage from job %" PRIu64 ": %u%%", j->id, j->progress_percent);
}
 
static void job_on_version(Job *j, const char *version) {
        assert(j);
        assert(version);
 
        if (free_and_strdup_warn(&j->version, version) < 0)
                return;
 
        log_debug("Got version from job %" PRIu64 ": %s ", j->id, j->version);
}
 
static int job_on_exit(sd_event_source *s, const siginfo_t *si, void *userdata) {
        Job *j = ASSERT_PTR(userdata);
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *json = NULL;
        Manager *manager = j->manager;
        int r;
 
        assert(j);
        assert(s);
        assert(si);
 
        if (job_requires_busy(j)) {
                assert(j->target->busy);
                j->target->busy = false;
        }
 
        if (si->si_code != CLD_EXITED) {
                assert(IN_SET(si->si_code, CLD_KILLED, CLD_DUMPED));
                sd_bus_error_setf(&error, SD_BUS_ERROR_FAILED,
                                  "Job terminated abnormally with signal %s.",
                                  signal_to_string(si->si_status));
        } else if (si->si_status != EXIT_SUCCESS) {
                bool check_new_no_update = false;
 
                if (j->type == JOB_CHECK_NEW &&
                    si->si_status == EXIT_FAILURE &&
                    job_parse_child_output(TAKE_FD(j->stdout_fd), &json) >= 0) {
                        sd_json_variant *v = sd_json_variant_by_key(json, "available");
                        check_new_no_update = v && sd_json_variant_is_null(v);
                }
 
                if (!check_new_no_update) {
                        if (j->status_errno != 0)
                                sd_bus_error_set_errno(&error, j->status_errno);
                        else
                                sd_bus_error_setf(&error, SD_BUS_ERROR_FAILED,
                                                  "Job failed with exit code %i.", si->si_status);
                }
        } else {
                r = job_parse_child_output(TAKE_FD(j->stdout_fd), &json);
                if (r < 0)
                        sd_bus_error_set_errnof(&error, r, "Failed to parse job worker output: %m");
        }
 
        /* Only send notification of exit if the job was actually detached */
        if (j->detach_cb) {
                r = sd_bus_emit_signal(
                                j->manager->bus,
                                "/org/freedesktop/sysupdate1",
                                "org.freedesktop.sysupdate1.Manager",
                                "JobRemoved",
                                "toi",
                                j->id,
                                j->object_path,
                                j->status_errno != 0 ? -j->status_errno : si->si_status);
                if (r < 0)
                        log_warning_errno(r,
                                          "Cannot emit JobRemoved message for job %" PRIu64 ", ignoring: %m",
                                          j->id);
        }
 
        if (j->dbus_msg && j->complete_cb) {
                if (sd_bus_error_is_set(&error)) {
                        log_warning("Job %" PRIu64 " failed with bus error, ignoring callback: %s",
                                    j->id, error.message);
                        sd_bus_reply_method_error(j->dbus_msg, &error);
                } else {
                        r = j->complete_cb(j->dbus_msg, j, json, &error);
                        if (r < 0) {
                                log_warning_errno(r,
                                                  "Error during execution of job callback for job %" PRIu64 ": %s",
                                                  j->id,
                                                  bus_error_message(&error, r));
                                sd_bus_reply_method_errno(j->dbus_msg, r, &error);
                        }
                }
        }
 
        job_free(j);
 
        if (manager)
                manager_check_idle(manager);
 
        return 0;
}
 
static inline const char* sysupdate_binary_path(void) {
        return secure_getenv("SYSTEMD_SYSUPDATE_PATH") ?: SYSTEMD_SYSUPDATE_PATH;
}
 
static int target_get_argument(Target *t, char **ret) {
        _cleanup_free_ char *target_arg = NULL;
 
        assert(t);
        assert(ret);
 
        if (t->class != TARGET_HOST) {
                if (t->class == TARGET_COMPONENT)
                        target_arg = strjoin("--component=", t->name);
                else if (IN_SET(t->image_type, IMAGE_DIRECTORY, IMAGE_SUBVOLUME))
                        target_arg = strjoin("--root=", t->path);
                else if (IN_SET(t->image_type, IMAGE_RAW, IMAGE_BLOCK))
                        target_arg = strjoin("--image=", t->path);
                else
                        assert_not_reached();
                if (!target_arg)
                        return -ENOMEM;
        }
 
        *ret = TAKE_PTR(target_arg);
        return 0;
}
 
static int job_start(Job *j) {
        _cleanup_close_ int stdout_fd = -EBADF;
        _cleanup_(pidref_done_sigkill_wait) PidRef pid = PIDREF_NULL;
        int r;
 
        assert(j);
 
        if (job_requires_busy(j) && j->target->busy)
                return log_notice_errno(SYNTHETIC_ERRNO(EBUSY), "Target %s busy, ignoring job.", j->target->name);
 
        stdout_fd = memfd_new("sysupdate-stdout");
        if (stdout_fd < 0)
                return log_error_errno(stdout_fd, "Failed to create memfd: %m");
 
        r = pidref_safe_fork_full("(sd-sysupdate)",
                                  (int[]) { -EBADF, stdout_fd, STDERR_FILENO }, NULL, 0,
                                  FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG_SIGTERM|
                                  FORK_REARRANGE_STDIO|FORK_LOG|FORK_REOPEN_LOG, &pid);
        if (r < 0)
                return r; /* FORK_LOG means pidref_safe_fork_full will handle the logging */
        if (r == 0) {
                /* Child */
 
                _cleanup_free_ char *target_arg = NULL;
                const char *cmd[] = {
                        "systemd-sysupdate",
                        "--json=short",
                        NULL, /* maybe --verify=no */
                        NULL, /* maybe --component=, --root=, or --image= */
                        NULL, /* maybe --offline */
                        NULL, /* list, check-new, acquire, update, vacuum, features */
                        NULL, /* maybe version (for list, acquire, update), maybe feature (features) */
                        NULL
                };
                size_t k = 2;
 
                if (setenv("NOTIFY_SOCKET", j->manager->notify_socket_path, /* overwrite= */ 1) < 0) {
                        log_error_errno(errno, "setenv() failed: %m");
                        _exit(EXIT_FAILURE);
                }
 
                if (getenv_bool("SYSTEMD_SYSUPDATE_NO_VERIFY") > 0)
                        cmd[k++] = "--verify=no"; /* For testing */
 
                r = setenv_systemd_exec_pid(true);
                if (r < 0)
                        log_warning_errno(r, "Failed to update $SYSTEMD_EXEC_PID, ignoring: %m");
 
                r = target_get_argument(j->target, &target_arg);
                if (r < 0) {
                        log_oom();
                        _exit(EXIT_FAILURE);
                }
                if (target_arg)
                        cmd[k++] = target_arg;
 
                if (j->offline || j->type == JOB_INSTALL)  /* install is implemented as `update --offline` */
                        cmd[k++] = "--offline";
 
                switch (j->type) {
                case JOB_LIST:
                        cmd[k++] = "list";
                        break;
 
                case JOB_DESCRIBE:
                        cmd[k++] = "list";
                        assert(!isempty(j->version));
                        cmd[k++] = j->version;
                        break;
 
                case JOB_CHECK_NEW:
                        cmd[k++] = "check-new";
                        break;
 
                case JOB_ACQUIRE:
                        cmd[k++] = "acquire";
                        cmd[k++] = empty_to_null(j->version);
                        break;
 
                case JOB_INSTALL:
                        cmd[k++] = "update";  /* install is implemented as `update --offline` */
                        cmd[k++] = empty_to_null(j->version);
                        break;
 
                case JOB_VACUUM:
                        cmd[k++] = "vacuum";
                        break;
 
                case JOB_DESCRIBE_FEATURE:
                        cmd[k++] = "features";
                        assert(!isempty(j->feature));
                        cmd[k++] = j->feature;
                        break;
 
                default:
                        assert_not_reached();
                }
 
                if (DEBUG_LOGGING) {
                        _cleanup_free_ char *s = NULL;
 
                        s = quote_command_line((char**) cmd, SHELL_ESCAPE_EMPTY);
                        if (!s) {
                                log_oom();
                                _exit(EXIT_FAILURE);
                        }
 
                        log_debug("Spawning worker for job %" PRIu64 ": %s", j->id, s);
                }
 
                r = invoke_callout_binary(sysupdate_binary_path(), (char *const *) cmd);
                log_error_errno(r, "Failed to execute systemd-sysupdate: %m");
                _exit(EXIT_FAILURE);
        }
 
        log_info("Started job %" PRIu64 " with worker PID " PID_FMT,
                 j->id, pid.pid);
 
        r = event_add_child_pidref(j->manager->event, &j->child, &pid, WEXITED, job_on_exit, j);
        if (r < 0)
                return log_error_errno(r, "Failed to add child process to event loop: %m");
 
        r = sd_event_source_set_child_process_own(j->child, true);
        if (r < 0)
                return log_error_errno(r, "Event loop failed to take ownership of child process: %m");
        pidref_done(&pid); /* disarm sigkill_wait */
 
        j->stdout_fd = TAKE_FD(stdout_fd);
 
        if (job_requires_busy(j))
                j->target->busy = true;
 
        return 0;
}
 
static int job_cancel(Job *j) {
        int r;
 
        assert(j);
 
        r = sd_event_source_send_child_signal(j->child, j->n_cancelled < 3 ? SIGTERM : SIGKILL,
                                              NULL, 0);
        if (r < 0)
                return r;
 
        j->n_cancelled++;
        return 0;
}
 
static int job_method_cancel(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
        Job *j = ASSERT_PTR(userdata);
        const char *action;
        int r;
 
        assert(msg);
 
        switch (j->type) {
        case JOB_LIST:
        case JOB_DESCRIBE:
        case JOB_CHECK_NEW:
                action = "org.freedesktop.sysupdate1.cancel-check";
                break;
 
        case JOB_ACQUIRE:
        case JOB_INSTALL:
                if (j->version)
                        action = "org.freedesktop.sysupdate1.cancel-update-to-version";
                else
                        action = "org.freedesktop.sysupdate1.cancel-update";
                break;
 
        case JOB_VACUUM:
                action = "org.freedesktop.sysupdate1.cancel-vacuum";
                break;
 
        case JOB_DESCRIBE_FEATURE:
                action = NULL;
                break;
 
        default:
                assert_not_reached();
        }
 
        if (action) {
                r = bus_verify_polkit_async(
                                msg,
                                action,
                                /* details= */ NULL,
                                &j->manager->polkit_registry,
                                error);
                if (r < 0)
                        return r;
                if (r == 0)
                        return 1; /* Will call us back */
        }
 
        r = job_cancel(j);
        if (r < 0)
                return r;
 
        return sd_bus_reply_method_return(msg, NULL);
}
 
static BUS_DEFINE_PROPERTY_GET_ENUM(job_property_get_type, job_type, JobType);
 
static int job_object_find(
                sd_bus *bus,
                const char *path,
                const char *iface,
                void *userdata,
                void **ret,
                sd_bus_error *error) {
 
        Manager *m = ASSERT_PTR(userdata);
        Job *j;
        const char *p;
        uint64_t id;
        int r;
 
        assert(bus);
        assert(path);
        assert(ret);
 
        p = startswith(path, "/org/freedesktop/sysupdate1/job/_");
        if (!p)
                return 0;
 
        r = safe_atou64(p, &id);
        if (r < 0 || id == 0)
                return 0;
 
        j = hashmap_get(m->jobs, &id);
        if (!j)
                return 0;
 
        *ret = j;
        return 1;
}
 
static int job_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);
        Job *j;
        unsigned k = 0;
 
        assert(nodes);
 
        l = new0(char*, hashmap_size(m->jobs) + 1);
        if (!l)
                return -ENOMEM;
 
        HASHMAP_FOREACH(j, m->jobs) {
                l[k] = strdup(j->object_path);
                if (!l[k])
                        return -ENOMEM;
                k++;
        }
 
        *nodes = TAKE_PTR(l);
        return 1;
}
 
static const sd_bus_vtable job_vtable[] = {
        SD_BUS_VTABLE_START(0),
 
        SD_BUS_PROPERTY("Id", "t", NULL, offsetof(Job, id), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("Type", "s", job_property_get_type, offsetof(Job, type), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("Offline", "b", bus_property_get_bool, offsetof(Job, offline), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("Progress", "u", bus_property_get_unsigned, offsetof(Job, progress_percent), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 
        SD_BUS_METHOD("Cancel", NULL, NULL, job_method_cancel, SD_BUS_VTABLE_UNPRIVILEGED),
 
        SD_BUS_VTABLE_END
};
 
static const BusObjectImplementation job_object = {
        "/org/freedesktop/sysupdate1/job",
        "org.freedesktop.sysupdate1.Job",
        .fallback_vtables = BUS_FALLBACK_VTABLES({job_vtable, job_object_find}),
        .node_enumerator = job_node_enumerator,
};
 
static Target *target_free(Target *t) {
        if (!t)
                return NULL;
 
        free(t->name);
        free(t->path);
        free(t->id);
 
        return mfree(t);
}
 
DEFINE_TRIVIAL_CLEANUP_FUNC(Target*, target_free);
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(target_hash_ops,
                                              char, string_hash_func, string_compare_func,
                                              Target, target_free);
 
static int target_new(Manager *m, TargetClass class, const char *name, const char *path, Target **ret) {
        _cleanup_(target_freep) Target *t = NULL;
 
        assert(m);
        assert(ret);
 
        t = new(Target, 1);
        if (!t)
                return -ENOMEM;
 
        *t = (Target) {
                .manager = m,
                .class = class,
                .image_type = _IMAGE_TYPE_INVALID,
        };
 
        t->name = strdup(name);
        if (!t->name)
                return -ENOMEM;
 
        t->path = strdup(path);
        if (!t->path)
                return -ENOMEM;
 
        if (class == TARGET_HOST)
                t->id = strdup("host"); /* This is what appears in the object path */
        else
                t->id = strjoin(target_class_to_string(class), ":", name);
        if (!t->id)
                return -ENOMEM;
 
        *ret = TAKE_PTR(t);
        return 0;
}
 
static int sysupdate_run_simple(sd_json_variant **ret, Target *t, ...) {
        _cleanup_close_pair_ int pipe[2] = EBADF_PAIR;
        _cleanup_(pidref_done_sigkill_wait) PidRef pid = PIDREF_NULL;
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        _cleanup_free_ char *target_arg = NULL;
        int r;
 
        assert(ret);
 
        if (t) {
                r = target_get_argument(t, &target_arg);
                if (r < 0)
                        return r;
        }
 
        r = pipe2(pipe, O_CLOEXEC);
        if (r < 0)
                return -errno;
 
        r = pidref_safe_fork_full("(sd-sysupdate)",
                                  (int[]) { -EBADF, pipe[1], STDERR_FILENO },
                                  NULL, 0,
                                  FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG_SIGTERM|
                                  FORK_REARRANGE_STDIO|FORK_LOG|FORK_REOPEN_LOG,
                                  &pid);
        if (r < 0)
                return r;
        if (r == 0) {
                /* Child */
                va_list ap;
                char *arg;
                _cleanup_strv_free_ char **args = NULL;
 
                if (strv_extend(&args, "systemd-sysupdate") < 0) {
                        log_oom();
                        _exit(EXIT_FAILURE);
                }
 
                if (strv_extend(&args, "--json=short") < 0) {
                        log_oom();
                        _exit(EXIT_FAILURE);
                }
 
                if (target_arg && strv_extend(&args, target_arg) < 0) {
                        log_oom();
                        _exit(EXIT_FAILURE);
                }
 
                va_start(ap, t);
                while ((arg = va_arg(ap, char*))) {
                        r = strv_extend(&args, arg);
                        if (r < 0)
                                break;
                }
                va_end(ap);
                if (r < 0) {
                        log_oom();
                        _exit(EXIT_FAILURE);
                }
 
                if (DEBUG_LOGGING) {
                        _cleanup_free_ char *s = NULL;
 
                        s = quote_command_line(args, SHELL_ESCAPE_EMPTY);
                        if (!s) {
                                log_oom();
                                _exit(EXIT_FAILURE);
                        }
 
                        log_debug("Spawning sysupdate: %s", s);
                }
 
                r = invoke_callout_binary(sysupdate_binary_path(), args);
                log_error_errno(r, "Failed to execute systemd-sysupdate: %m");
                _exit(EXIT_FAILURE);
        }
 
        pipe[1] = safe_close(pipe[1]);
 
        r = sd_json_parse_fd(
                        "stdout",
                        TAKE_FD(pipe[0]),
                        SD_JSON_PARSE_DONATE_FD,
                        &v,
                        /* reterr_line= */ NULL,
                        /* reterr_column= */ NULL);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse JSON: %m");
 
        *ret = TAKE_PTR(v);
        return 0;
}
 
static BUS_DEFINE_PROPERTY_GET_ENUM(target_property_get_class, target_class, TargetClass);
 
#define log_sysupdate_bad_json_full(lvl, r, verb, msg) \
        log_full_errno((lvl), (r), "Invalid JSON response from 'systemd-sysupdate %s': %s", (verb), (msg))
#define log_sysupdate_bad_json(r, verb, msg) \
        log_sysupdate_bad_json_full(LOG_ERR, (r), (verb), (msg))
#define log_sysupdate_bad_json_debug(r, verb, msg) \
        log_sysupdate_bad_json_full(LOG_DEBUG, (r), (verb), (msg))
 
static int target_method_list_finish(
                sd_bus_message *msg,
                const Job *j,
                sd_json_variant *json,
                sd_bus_error *error) {
 
        sd_json_variant *v;
        _cleanup_strv_free_ char **versions = NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        int r;
 
        assert(json);
 
        v = sd_json_variant_by_key(json, "all");
        if (!v)
                return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "list", "Missing key 'all'");
 
        r = sd_json_variant_strv(v, &versions);
        if (r < 0)
                return log_sysupdate_bad_json(SYNTHETIC_ERRNO(EPROTO), "list", "Key 'all' should be strv");
 
        r = sd_bus_message_new_method_return(msg, &reply);
        if (r < 0)
                return r;
 
        r = sd_bus_message_append_strv(reply, versions);
        if (r < 0)
                return r;
 
        return sd_bus_message_send(reply);
}
 
static int target_method_list(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
        Target *t = ASSERT_PTR(userdata);
        _cleanup_(job_freep) Job *j = NULL;
        uint64_t flags;
        int r;
 
        assert(msg);
 
        r = sd_bus_message_read(msg, "t", &flags);
        if (r < 0)
                return r;
 
        if ((flags & ~SD_SYSUPDATE_FLAGS_ALL) != 0)
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid flags specified");
 
        const char *details[] = {
                "class", target_class_to_string(t->class),
                "name", t->name,
                "offline", one_zero(FLAGS_SET(flags, SD_SYSUPDATE_OFFLINE)),
                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_LIST, t, msg, target_method_list_finish, &j);
        if (r < 0)
                return r;
 
        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_describe_finish(
                sd_bus_message *msg,
                const Job *j,
                sd_json_variant *json,
                sd_bus_error *error) {
        _cleanup_free_ char *text = NULL;
        int r;
 
        /* NOTE: This is also reused by target_method_describe_feature */
 
        assert(json);
 
        r = sd_json_variant_format(json, 0, &text);
        if (r < 0)
                return r;
 
        return sd_bus_reply_method_return(msg, "s", text);
}
 
static int target_method_describe(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
        Target *t = ASSERT_PTR(userdata);
        _cleanup_(job_freep) Job *j = NULL;
        const char *version;
        uint64_t flags;
        int r;
 
        assert(msg);
 
        r = sd_bus_message_read(msg, "st", &version, &flags);
        if (r < 0)
                return r;
 
        if (!version_is_valid(version, VERSION_ALLOW_UNDERSCORE|VERSION_ALLOW_PLUS))
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid version");
 
        if ((flags & ~SD_SYSUPDATE_FLAGS_ALL) != 0)
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid flags specified");
 
        const char *details[] = {
                "class", target_class_to_string(t->class),
                "name", t->name,
                "version", version,
                "offline", one_zero(FLAGS_SET(flags, SD_SYSUPDATE_OFFLINE)),
                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_DESCRIBE, t, msg, target_method_describe_finish, &j);
        if (r < 0)
                return r;
 
        j->version = strdup(version);