HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/sysinstall/sysinstall.c

86,594 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 15f9030eead93872d6f325ccefe6e02869266389

Lines 1001–2000 of 2,226

 
        r = table_add_many(
                        table,
                        TABLE_FIELD, "Selected Disk",
                        TABLE_STRING, context->node,
                        TABLE_FIELD, "Erase Disk",
                        TABLE_BOOLEAN, context->erase,
                        TABLE_SET_COLOR, context->erase ? ansi_highlight_red() : NULL,
                        TABLE_FIELD, "Register in Firmware",
                        TABLE_BOOLEAN, context->touch_variables);
        if (r < 0)
                return table_log_add_error(r);
 
        static const char * const map[] = {
                "firstboot.keymap",          "Keyboard Map",
                "firstboot.locale",          "Locale",
                "firstboot.locale-messages", "Locale (Messages)",
                "firstboot.timezone",        "Timezone",
                NULL
        };
 
        STRV_FOREACH_PAIR(id, text, map) {
                MachineCredential *c = machine_credential_find(&context->credentials, *id);
                if (!c)
                        continue;
 
                _cleanup_free_ char *escaped = cescape_length(c->data, c->size);
                if (!escaped)
                        return log_oom();
 
                r = table_add_many(
                                table,
                                TABLE_FIELD, *text,
                                TABLE_STRING, escaped);
                if (r < 0)
                        return table_log_add_error(r);
        }
 
        unsigned n_extra_credentials = 0;
        FOREACH_ARRAY(cred, context->credentials.credentials, context->credentials.n_credentials) {
                bool covered = false;
 
                STRV_FOREACH_PAIR(id, text, map)
                        if (streq(*id, cred->id)) {
                                covered = true;
                                break;
                        }
 
                if (!covered)
                        n_extra_credentials++;
        }
 
        if (n_extra_credentials > 0) {
                r = table_add_many(
                                table,
                                TABLE_FIELD, "Extra Credentials",
                                TABLE_UINT, n_extra_credentials);
                if (r < 0)
                        return table_log_add_error(r);
        }
 
        r = table_print(table);
        if (r < 0)
                return r;
 
        return 0;
}
 
static int find_current_kernel(
                char **ret_filename,
                int *ret_fd) {
 
        int r;
 
        sd_id128_t uuid;
        r = efi_stub_get_device_part_uuid(&uuid);
        if (r == -ENOENT)
                return log_error_errno(r, "Cannot find current kernel, no stub partition UUID passed via EFI variables.");
        if (r < 0)
                return log_error_errno(r, "Unable to determine stub partition UUID: %m");
 
        _cleanup_free_ char *image = NULL;
        r = efi_get_variable_path(EFI_LOADER_VARIABLE_STR("StubImageIdentifier"), &image);
        if (r == -ENOENT)
                return log_error_errno(r, "Cannot find current kernel, no stub EFI binary path passed.");
        if (r < 0)
                return log_error_errno(r, "Unable to determine stub EFI binary path: %m");
 
        /* Note: we search for the *host* ESP here (i.e. the one the current EFI paths relate to), not the
         * one of the target image */
 
        _cleanup_free_ char *partition_path = NULL;
        _cleanup_close_ int partition_fd = -EBADF;
        sd_id128_t partition_uuid;
        r = find_esp_and_warn_full(
                        /* root= */ NULL,
                        /* path= */ NULL,
                        /* unprivileged_mode= */ false,
                        &partition_path,
                        &partition_fd,
                        /* ret_part= */ NULL,
                        /* ret_pstart= */ NULL,
                        /* ret_psize= */ NULL,
                        &partition_uuid,
                        /* ret_devid= */ NULL);
        if (r < 0 && r != -ENOKEY)
                return r;
        if (r < 0 || !sd_id128_equal(uuid, partition_uuid)) {
                partition_path = mfree(partition_path);
                partition_fd = safe_close(partition_fd);
 
                r = find_xbootldr_and_warn_full(
                                /* root= */ NULL,
                                /* path= */ NULL,
                                /* unprivileged_mode= */ false,
                                &partition_path,
                                &partition_fd,
                                &partition_uuid,
                                /* ret_devid= */ NULL);
                if (r < 0 && r != -ENOKEY)
                        return r;
 
                if (r < 0 || !sd_id128_equal(uuid, partition_uuid))
                        return log_error_errno(SYNTHETIC_ERRNO(ENOENT), "Unable to find UKI on ESP/XBOOTLDR partitions.");
        }
 
        _cleanup_free_ char *resolved = NULL;
        _cleanup_close_ int fd = chase_and_openat(
                        /* root_fd= */ partition_fd,
                        /* dir_fd= */ partition_fd,
                        image,
                        CHASE_PROHIBIT_SYMLINKS|CHASE_MUST_BE_REGULAR,
                        O_RDONLY|O_CLOEXEC,
                        &resolved);
        if (fd < 0)
                return log_error_errno(fd, "Failed to find EFI binary '%s' on partition '%s': %m", image, partition_path);
 
        _cleanup_free_ char *fn = NULL;
        r = path_extract_filename(resolved, &fn);
        if (r < 0)
                return log_error_errno(r, "Failed to extract UKI file name from '%s': %m", resolved);
 
        if (ret_filename)
                *ret_filename = TAKE_PTR(fn);
        if (ret_fd)
                *ret_fd = TAKE_FD(fd);
 
        return 0;
}
 
static int connect_to_bootctl(sd_varlink **link) {
        int r;
 
        assert(link);
 
        if (*link)
                return 0;
 
        _cleanup_close_ int fd = -EBADF;
        _cleanup_free_ char *bootctl = NULL;
        fd = pin_callout_binary("bootctl", &bootctl);
        if (fd < 0)
                return log_error_errno(fd, "Failed to find bootctl binary: %m");
 
        r = sd_varlink_connect_exec(link, bootctl, /* argv= */ NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to connect to bootctl: %m");
 
        r = sd_varlink_set_allow_fd_passing_output(*link, true);
        if (r < 0)
                return log_error_errno(r, "Failed to enable fd passing to bootctl: %m");
 
        return 1;
}
 
static int invoke_bootctl_install(
                sd_varlink **link,
                bool variables,
                const char *root_dir,
                int root_fd) {
        int r;
 
        assert(link);
        assert(root_dir);
        assert(root_fd >= 0);
 
        r = connect_to_bootctl(link);
        if (r < 0)
                return r;
 
        int fd_idx = sd_varlink_push_dup_fd(*link, root_fd);
        if (fd_idx < 0)
                return log_error_errno(fd_idx, "Failed to submit root fd onto Varlink connection: %m");
 
        const char *error_id = NULL;
        r = varlink_callbo_and_log(
                        *link,
                        "io.systemd.BootControl.Install",
                        /* reply= */ NULL,
                        &error_id,
                        SD_JSON_BUILD_PAIR_STRING("operation", "new"),
                        SD_JSON_BUILD_PAIR_INTEGER("rootFileDescriptor", fd_idx),
                        SD_JSON_BUILD_PAIR_STRING("rootDirectory", root_dir),
                        SD_JSON_BUILD_PAIR_BOOLEAN("touchVariables", variables));
        if (r < 0)
                return r;
 
        return 0;
}
 
static int invoke_bootctl_link(
                sd_varlink **link,
                const char *root_dir,
                int root_fd,
                const char *kernel_filename,
                int kernel_fd,
                char **encrypted_credentials) {
        int r;
 
        assert(link);
        assert(root_dir);
        assert(root_fd >= 0);
        assert(kernel_filename);
        assert(kernel_fd >= 0);
 
        r = connect_to_bootctl(link);
        if (r < 0)
                return r;
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
        STRV_FOREACH_PAIR(name, value, encrypted_credentials) {
                _cleanup_free_ char *j = strjoin(*name, ".cred");
                if (!j)
                        return log_oom();
 
                r = sd_json_variant_append_arraybo(
                                &array,
                                SD_JSON_BUILD_PAIR_STRING("filename", j),
                                SD_JSON_BUILD_PAIR_BASE64("data", *value, strlen(*value)));
                if (r < 0)
                        return log_error_errno(r, "Failed to append credential to message: %m");
        }
 
        int root_fd_idx = sd_varlink_push_dup_fd(*link, root_fd);
        if (root_fd_idx < 0)
                return log_error_errno(root_fd_idx, "Failed to submit root fd onto Varlink connection: %m");
 
        int kernel_fd_idx = sd_varlink_push_dup_fd(*link, kernel_fd);
        if (kernel_fd_idx < 0)
                return log_error_errno(kernel_fd_idx, "Failed to submit kernel fd onto Varlink connection: %m");
 
        const char *error_id = NULL;
        r = varlink_callbo_and_log(
                        *link,
                        "io.systemd.BootControl.Link",
                        /* reply= */ NULL,
                        &error_id,
                        SD_JSON_BUILD_PAIR_INTEGER("rootFileDescriptor", root_fd_idx),
                        SD_JSON_BUILD_PAIR_STRING("rootDirectory", root_dir),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("kernelFilename", kernel_filename),
                        SD_JSON_BUILD_PAIR_INTEGER("kernelFileDescriptor", kernel_fd_idx),
                        SD_JSON_BUILD_PAIR_CONDITION(!!array, "extraFiles", SD_JSON_BUILD_VARIANT(array)));
        if (r < 0)
                return r;
 
        return 0;
}
 
static int maybe_reboot(void) {
        int r;
 
        if (!arg_reboot)
                return 0;
 
        log_notice("%s%sSystem will reboot now.",
                   emoji_enabled() ? glyph(GLYPH_CIRCLE_ARROW) : "", emoji_enabled() ? " " : "");
 
        if (!any_key_to_proceed())
                return 0;
 
        log_notice("%s%sInitiating reboot.",
                   emoji_enabled() ? glyph(GLYPH_CIRCLE_ARROW) : "", emoji_enabled() ? " " : "");
 
        _cleanup_(sd_varlink_unrefp) sd_varlink *link = NULL;
        r = sd_varlink_connect_address(&link, "/run/systemd/io.systemd.Shutdown");
        if (r < 0)
                return log_error_errno(r, "Failed to connect to systemd-logind: %m");
 
        sd_json_variant *reply = NULL;
        const char *error_id = NULL;
        r = varlink_callbo_and_log(
                        link,
                        "io.systemd.Shutdown.Reboot",
                        &reply,
                        &error_id);
        if (r < 0)
                return r;
 
        return 0;
}
 
static int read_credential_locale(MachineCredentialContext *credentials) {
        int r;
 
        if (machine_credential_find(credentials, "firstboot.locale") ||
            machine_credential_find(credentials, "firstboot.locale-messages"))
                return 0;
 
        /* For the main locale we check the two env vars, and if neither is there, we use LC_NUMERIC, since
         * it seems to be one of the most fundamental ones, and is not LC_MESSAGES for which we have a
         * separate setting after all */
        const char *l = getenv("LC_ALL") ?: getenv("LANG") ?: setlocale(LC_NUMERIC, NULL);
        if (l) {
                r = machine_credential_add(credentials, "firstboot.locale", l, /* size= */ SIZE_MAX);
                if (r < 0)
                        return log_oom();
        }
 
        const char *m = setlocale(LC_MESSAGES, NULL);
        if (m && !streq_ptr(m, l)) {
                r = machine_credential_add(credentials, "firstboot.locale-messages", m, /* size= */ SIZE_MAX);
                if (r < 0)
                        return log_oom();
        }
 
        return 0;
}
 
static int read_credential_keymap(MachineCredentialContext *credentials) {
        int r;
 
        if (machine_credential_find(credentials, "firstboot.keymap"))
                return 0;
 
        _cleanup_free_ char *keymap = NULL;
        r = parse_env_file(
                        /* f= */ NULL,
                        etc_vconsole_conf(),
                        "KEYMAP", &keymap);
        if (r < 0 && r != -ENOENT)
                return log_error_errno(r, "Failed to parse '%s': %m", etc_vconsole_conf());
 
        if (!isempty(keymap)) {
                r = machine_credential_add(credentials, "firstboot.keymap", keymap, /* size= */ SIZE_MAX);
                if (r < 0)
                        return log_oom();
        }
 
        return 0;
}
 
static int read_credential_timezone(MachineCredentialContext *credentials) {
        int r;
 
        if (machine_credential_find(credentials, "firstboot.timezone"))
                return 0;
 
        _cleanup_free_ char *tz = NULL;
        r = get_timezone_prefer_env(&tz);
        if (r < 0)
                log_warning_errno(r, "Failed to read timezone, skipping timezone propagation: %m");
        else {
                r = machine_credential_add(credentials, "firstboot.timezone", tz, /* size= */ SIZE_MAX);
                if (r < 0)
                        return log_oom();
        }
 
        return 0;
}
 
static int sysinstall_context_read_credentials(SysInstallContext *context) {
        int r;
 
        if (context->copy_locale) {
                r = read_credential_locale(&context->credentials);
                if (r < 0)
                        return r;
        }
 
        if (context->copy_keymap) {
                r = read_credential_keymap(&context->credentials);
                if (r < 0)
                        return r;
        }
 
        if (context->copy_timezone) {
                r = read_credential_timezone(&context->credentials);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
static int connect_to_creds(sd_varlink **link) {
        int r;
 
        assert(link);
 
        if (*link)
                return 0;
 
        _cleanup_close_ int fd = -EBADF;
        _cleanup_free_ char *creds = NULL;
        fd = pin_callout_binary("systemd-creds", &creds);
        if (fd < 0)
                return log_error_errno(fd, "Failed to find systemd-creds binary: %m");
 
        r = sd_varlink_connect_exec(link, creds, /* argv= */ NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to connect to systemd-creds: %m");
 
        return 1;
}
 
static int encrypt_one_credential(sd_varlink **link, const MachineCredential *input, char ***encrypted) {
        int r;
 
        assert(link);
        assert(input);
        assert(encrypted);
 
        log_info("Encrypting credential '%s'...", input->id);
 
        r = connect_to_creds(link);
        if (r < 0)
                return r;
 
        sd_json_variant *reply = NULL;
        const char *error_id = NULL;
        r = varlink_callbo_and_log(
                        *link,
                        "io.systemd.Credentials.Encrypt",
                        &reply,
                        &error_id,
                        SD_JSON_BUILD_PAIR_STRING("name", input->id),
                        SD_JSON_BUILD_PAIR_BASE64("data", input->data, input->size),
                        SD_JSON_BUILD_PAIR_STRING("scope", "system"),
                        /* We pick the 'auto_initrd' key for this, since we want TPM if available, but are fine with NULL if not */
                        SD_JSON_BUILD_PAIR_STRING("withKey", "auto_initrd"));
        if (r < 0)
                return r;
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "blob", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, 0, 0 },
                {}
        };
 
        const char *blob = NULL;
        r = sd_json_dispatch(reply, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &blob);
        if (r < 0)
                return r;
 
        r = strv_extend_many(encrypted, input->id, blob);
        if (r < 0)
                return r;
 
        return 0;
}
 
static int encrypt_credentials(sd_varlink **link, MachineCredentialContext *credentials, char ***encrypted) {
        int r;
 
        assert(link);
        assert(encrypted);
 
        FOREACH_ARRAY(cred, credentials->credentials, credentials->n_credentials) {
                r = encrypt_one_credential(link, cred, encrypted);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
static const ImagePolicy image_policy = {
        .n_policies = 4,
        .policies = {
                /* We mount / and /usr/ so that we can get access to /etc/machine-id and /etc/kernel/ */
                { PARTITION_ROOT,     PARTITION_POLICY_VERITY|PARTITION_POLICY_SIGNED|PARTITION_POLICY_UNPROTECTED|PARTITION_POLICY_ABSENT },
                { PARTITION_USR,      PARTITION_POLICY_VERITY|PARTITION_POLICY_SIGNED|PARTITION_POLICY_UNPROTECTED|PARTITION_POLICY_ABSENT },
                { PARTITION_ESP,      PARTITION_POLICY_UNPROTECTED|PARTITION_POLICY_ABSENT },
                { PARTITION_XBOOTLDR, PARTITION_POLICY_UNPROTECTED|PARTITION_POLICY_ABSENT },
        },
        .default_flags = PARTITION_POLICY_IGNORE,
};
 
static int settle_definitions(char **definitions, char ***ret_definitions) {
 
        _cleanup_strv_free_ char **d = NULL;
        int r;
 
        assert(ret_definitions);
 
        if (definitions) {
                d = strv_copy(definitions);
                if (!d)
                        return log_oom();
 
                *ret_definitions = TAKE_PTR(d);
 
                return 0;
        }
 
        /* If /usr/lib/repart.sysinstall.d/ is populated, use it, otherwise use the regular definition
         * files */
 
        _cleanup_strv_free_ char **files = NULL;
        r = conf_files_list_strv(
                        &files,
                        ".conf",
                        /* root= */ NULL,
                        CONF_FILES_REGULAR|CONF_FILES_FILTER_MASKED|CONF_FILES_WARN|CONF_FILES_DONT_PREFIX_ROOT,
                        (const char**) CONF_PATHS_STRV("repart.sysinstall.d"));
        if (r < 0)
                return log_error_errno(r, "Failed to enumerate *.conf files: %m");
 
        if (!strv_isempty(files)) {
                d = strv_copy(CONF_PATHS_STRV("repart.sysinstall.d"));
                if (!d)
                        return log_oom();
 
                *ret_definitions = TAKE_PTR(d);
        }
 
        return 0;
}
 
static int sysinstall_context_settle_definitions(SysInstallContext *context,
                                                 char **definitions) {
 
        return settle_definitions(definitions, &context->definitions);
}
 
static int sysinstall_context_settle_kernel_image(SysInstallContext *context,
                                                  const char *kernel_image) {
 
        _cleanup_free_ char *kernel_filename = NULL;
        _cleanup_close_ int kernel_fd = -EBADF;
        int r;
 
        assert(context->kernel_fd < 0);
        assert(!context->kernel_filename);
 
        if (kernel_image) {
                r = path_extract_filename(kernel_image, &kernel_filename);
                if (r < 0)
                        return log_error_errno(r, "Failed to extract filename from kernel path '%s': %m", kernel_image);
                if (r == O_DIRECTORY)
                        return log_error_errno(SYNTHETIC_ERRNO(EISDIR), "Kernel path '%s' refers to directory, must be regular file, refusing.", kernel_image);
 
                kernel_fd = xopenat_full(XAT_FDROOT, kernel_image, O_RDONLY|O_CLOEXEC, XO_REGULAR, MODE_INVALID);
                if (kernel_fd < 0)
                        return log_error_errno(kernel_fd, "Failed to open kernel image '%s': %m", kernel_image);
 
        } else {
                r = find_current_kernel(&kernel_filename, &kernel_fd);
                if (r < 0)
                        return r;
        }
 
        context->kernel_filename = TAKE_PTR(kernel_filename);
        context->kernel_fd = TAKE_FD(kernel_fd);
 
        return 0;
}
 
static int sysinstall_context_run(SysInstallContext *context) {
 
        int r;
 
        assert(context);
 
        (void) sysinstall_context_notify(context, PROGRESS_ENCRYPT_CREDENTIALS, NULL, UINT_MAX);
 
        _cleanup_(sd_varlink_flush_close_unrefp) sd_varlink *creds_link = NULL;
        _cleanup_strv_free_ char **encrypted_credentials = NULL;
        r = encrypt_credentials(&creds_link, &context->credentials, &encrypted_credentials);
        if (r < 0)
                return r;
 
        (void) sysinstall_context_notify(context, PROGRESS_INSTALL_PARTITIONS, NULL, UINT_MAX);
 
        /* Do the main part of the installation */
 
        r = sysinstall_context_invoke_repart_run(context);
        if (r < 0)
                return r;
 
        (void) sysinstall_context_notify(context, PROGRESS_MOUNT_PARTITIONS, NULL, UINT_MAX);
 
        _cleanup_(loop_device_unrefp) LoopDevice *loop_device = NULL;
        _cleanup_(umount_and_freep) char *root_dir = NULL;
        _cleanup_close_ int root_fd = -EBADF;
        r = mount_image_privately_interactively(
                        context->node,
                        &image_policy,
                        DISSECT_IMAGE_REQUIRE_ROOT |
                        DISSECT_IMAGE_RELAX_VAR_CHECK |
                        DISSECT_IMAGE_ALLOW_USERSPACE_VERITY |
                        DISSECT_IMAGE_DISCARD_ANY |
                        DISSECT_IMAGE_GPT_ONLY |
                        DISSECT_IMAGE_FSCK |
                        DISSECT_IMAGE_USR_NO_ROOT |
                        DISSECT_IMAGE_ADD_PARTITION_DEVICES |
                        DISSECT_IMAGE_PIN_PARTITION_DEVICES,
                        &root_dir,
                        &root_fd,
                        &loop_device);
        if (r < 0)
                return log_error_errno(r, "Failed to mount new image: %m");
 
        (void) sysinstall_context_notify(context, PROGRESS_INSTALL_KERNEL, NULL, UINT_MAX);
 
        _cleanup_(sd_varlink_flush_close_unrefp) sd_varlink *bootctl_link = NULL;
        r = invoke_bootctl_link(&bootctl_link, root_dir, root_fd, context->kernel_filename, context->kernel_fd, encrypted_credentials);
        if (r < 0)
                return r;
 
        (void) sysinstall_context_notify(context, PROGRESS_INSTALL_BOOTLOADER, NULL, UINT_MAX);
 
        r = invoke_bootctl_install(&bootctl_link, context->touch_variables, root_dir, root_fd);
        if (r < 0)
                return r;
 
        (void) sysinstall_context_notify(context, PROGRESS_UNMOUNT_PARTITIONS, NULL, UINT_MAX);
 
        root_fd = safe_close(root_fd);
        r = umount_recursive(root_dir, /* flags= */ 0);
        if (r < 0)
                log_warning_errno(r, "Failed to unmount target disk, proceeding anyway: %m");
        loop_device = loop_device_unref(loop_device);
        sync();
 
        return 0;
}
 
typedef struct ListCandidateDevicesContext {
        char **definitions;
        bool subscribe;
 
        sd_varlink *repart_link; /* A repart connection to get candidate devices */
        sd_varlink *dry_run_repart_link; /* A second repart connection to perform a dry run on each node */
 
        sd_varlink *link;
} ListCandidateDevicesContext;
 
static ListCandidateDevicesContext* list_candidate_devices_context_new(void) {
        ListCandidateDevicesContext *context = new(ListCandidateDevicesContext, 1);
 
        if (!context)
                return NULL;
 
        *context = (ListCandidateDevicesContext) {};
 
        return context;
}
 
static ListCandidateDevicesContext* list_candidate_devices_context_free(ListCandidateDevicesContext *context) {
        if (!context)
                return NULL;
 
        strv_free(context->definitions);
 
        context->repart_link = sd_varlink_flush_close_unref(context->repart_link);
        context->dry_run_repart_link = sd_varlink_flush_close_unref(context->dry_run_repart_link);
        context->link = sd_varlink_unref(context->link);
 
        return mfree(context);
}
 
DEFINE_TRIVIAL_CLEANUP_FUNC(ListCandidateDevicesContext*, list_candidate_devices_context_free);
 
static int list_candidate_devices_context_settle_definitions(ListCandidateDevicesContext *context,
                                                             char **definitions) {
 
        return settle_definitions(definitions, &context->definitions);
}
 
static void vl_on_disconnect(sd_varlink_server *server, sd_varlink *link, void *userdata) {
        assert(server);
        assert(link);
 
        list_candidate_devices_context_free(sd_varlink_set_userdata(link, NULL));
}
 
typedef struct DevicesResponse {
        const char *node;
        char **symlinks;
        uint64_t diskseq;
        uint64_t size;
        const char *model;
        const char *vendor;
        const char *subsystem;
        const char *action;
} DevicesResponse;
 
static void devices_response_done(DevicesResponse *p) {
        assert(p);
 
        p->symlinks = strv_free(p->symlinks);
}
 
static int fetch_candidate_devices_reply(
                sd_varlink *repart_link,
                sd_json_variant *reply,
                const char *error_id,
                sd_varlink_reply_flags_t flags,
                void *userdata) {
 
        int r;
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        ListCandidateDevicesContext *context = ASSERT_PTR(userdata);
 
        if (error_id) {
                if (streq(error_id, "io.systemd.Repart.NoCandidateDevices"))
                        return sd_varlink_error(context->link, "io.systemd.SysInstall.NoCandidateDevices", NULL);
 
                return sd_varlink_error(context->link, error_id, NULL);
        }
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "node",      SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(DevicesResponse, node),      0 },
                { "symlinks",  SD_JSON_VARIANT_ARRAY,         sd_json_dispatch_strv,         offsetof(DevicesResponse, symlinks),  0 },
                { "diskseq",   _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,       offsetof(DevicesResponse, diskseq),   0 },
                { "sizeBytes", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,       offsetof(DevicesResponse, size),      0 },
                { "model",     SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(DevicesResponse, model),     0 },
                { "vendor",    SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(DevicesResponse, vendor),    0 },
                { "subsystem", SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(DevicesResponse, subsystem), 0 },
                { "action",    SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(DevicesResponse, action),    0 },
                {}
        };
 
        _cleanup_(devices_response_done) DevicesResponse p = {
                .diskseq = UINT64_MAX,
                .size = UINT64_MAX,
        };
        r = sd_json_dispatch(reply, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &p);
        if (r < 0)
                return r;
 
        if (context->subscribe) {
                /* The action needs to be ready, remove or add else we don't support the action */
                if (streq(p.action, "ready"))
                        return sd_varlink_notifybo(context->link, SD_JSON_BUILD_PAIR("action", JSON_BUILD_CONST_STRING("ready")));
 
                if (streq(p.action, "remove"))
                        return sd_varlink_notifybo(context->link,
                                        SD_JSON_BUILD_PAIR("action", JSON_BUILD_CONST_STRING("remove")),
                                        SD_JSON_BUILD_PAIR_STRING("node", p.node));
 
                if (!streq(p.action, "add")) {
                        log_debug("Skip unsupported action '%s' while fetching candidate devices.", p.action);
                        return 0;
                }
        }
 
        uint64_t min_size = UINT64_MAX, current_size = UINT64_MAX, need_free = UINT64_MAX;
        r = invoke_repart(
                        &context->dry_run_repart_link,
                        p.node,
                        /* erase= */ false,
                        /* dry_run= */ true,
                        context->definitions,
                        &min_size,
                        &current_size,
                        &need_free,
                        /* n_partitions= */ NULL);
 
        DeviceFit fit;
        if (r < 0) {
                if (r == -ENOSPC)
                        fit = DEVICE_FIT_INSUFFICIENT_FREE_SPACE;
                else if (r == -E2BIG)
                        fit = DEVICE_FIT_DISK_TOO_SMALL;
                else if (r == -EHWPOISON)
                        fit = DEVICE_FIT_CONFLICTING_DISK_LABEL_PRESENT;
                else
                        return r;
        } else
                fit = DEVICE_FIT_ENOUGH_FREE_SPACE;
 
        r = sd_json_buildo(&v,
                        SD_JSON_BUILD_PAIR_STRING("node", p.node),
                        JSON_BUILD_PAIR_STRV_NON_EMPTY("symlinks", p.symlinks),
                        JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("diskseq", p.diskseq, UINT64_MAX),
                        JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("sizeBytes", p.size, UINT64_MAX),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("model", p.model),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("vendor", p.vendor),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("subsystem", p.subsystem),
                        JSON_BUILD_PAIR_ENUM("fit", device_fit_to_string(fit)),
                        JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("currentSizeBytes", current_size, UINT64_MAX),
                        JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("needFreeBytes", need_free, UINT64_MAX),
                        JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("minimalSizeBytes", min_size, UINT64_MAX),
                        SD_JSON_BUILD_PAIR_CONDITION(context->subscribe, "action", JSON_BUILD_CONST_STRING("add")));
        if (r < 0)
                return r;
 
        if (FLAGS_SET(flags, SD_VARLINK_REPLY_CONTINUES))
                return sd_varlink_notify(context->link, v);
 
        return sd_varlink_reply(context->link, v);
}
 
typedef struct ListCandidateDevicesParameters {
        char **definitions;
        bool subscribe;
} ListCandidateDevicesParameters;
 
static void list_candidate_devices_parameters_done(ListCandidateDevicesParameters *p) {
        assert(p);
 
        p->definitions = strv_free(p->definitions);
}
 
static int vl_method_list_candidate_devices(
                sd_varlink *link,
                sd_json_variant *parameters,
                sd_varlink_method_flags_t flags,
                void *userdata) {
        int r;
 
        assert(link);
 
        /* Refuse multiple requests */
        if (sd_varlink_get_userdata(link))
                return -EBUSY;
 
        sd_varlink_server *varlink_server = sd_varlink_get_server(link);
        sd_event *event = sd_varlink_server_get_event(varlink_server);
        Hashmap **polkit_registry = ASSERT_PTR(sd_varlink_server_get_userdata(varlink_server));
 
        assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
 
        r = varlink_verify_polkit_async(
                        link,
                        /* bus= */ NULL,
                        "io.systemd.sysinstall.ListCandidateDevices",
                        /* details= */ NULL,
                        polkit_registry);
        if (r <= 0)
                return r;
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "definitions", SD_JSON_VARIANT_ARRAY,   json_dispatch_strv_path,  offsetof(ListCandidateDevicesParameters, definitions), SD_JSON_STRICT },
                { "subscribe",   SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(ListCandidateDevicesParameters, subscribe),   0              },
                {}
        };
 
        _cleanup_(list_candidate_devices_parameters_done) ListCandidateDevicesParameters p = {};
        r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
        if (r != 0)
                return r;
 
        _cleanup_(list_candidate_devices_context_freep) ListCandidateDevicesContext* context = list_candidate_devices_context_new();
        if (!context)
                return log_oom();
 
        context->subscribe = p.subscribe;
        r = list_candidate_devices_context_settle_definitions(context, p.definitions);
        if (r < 0)
                return r;
 
        context->link = sd_varlink_ref(link);
 
        r = connect_to_repart(&context->repart_link);
        if (r < 0)
                return r;
 
        r = sd_varlink_attach_event(context->repart_link, event, SD_EVENT_PRIORITY_NORMAL);
        if (r < 0)
                return log_error_errno(
                                r,
                                "Failed to attach io.systemd.Repart.ListCandidateDevices() varlink connection to event loop: %m");
 
        r = sd_varlink_bind_reply(context->repart_link, fetch_candidate_devices_reply);
        if (r < 0)
                return r;
 
        r = sd_varlink_observebo(
                        context->repart_link,
                        "io.systemd.Repart.ListCandidateDevices",
                        SD_JSON_BUILD_PAIR_BOOLEAN("subscribe", context->subscribe),
                        SD_JSON_BUILD_PAIR_BOOLEAN("ignoreRoot", true));
 
        if (r < 0)
                return log_error_errno(
                                r,
                                "Failed to issue io.systemd.Repart.ListCandidateDevices() varlink call: %m");
 
        r = sd_varlink_server_bind_disconnect(varlink_server, vl_on_disconnect);
        if (r < 0)
                return r;
 
        /* Disable connection timeout so that the connection to repart doesn't close before the link is
         * disconnected */
        r = sd_varlink_set_relative_timeout(context->repart_link, UINT64_MAX);
        if (r < 0)
                return r;
 
        /* The context is freed in vl_on_disconnect() */
        sd_varlink_set_userdata(context->repart_link, context);
        sd_varlink_set_userdata(link, TAKE_PTR(context));
 
        return 0;
}
 
typedef struct RunParameters {
        char *node;
        char **definitions;
        bool erase;
        bool variables;
        char *kernel_image;
        bool copy_locale;
        bool copy_keymap;
        bool copy_timezone;
        sd_json_variant *credentials;
} RunParameters;
 
static void run_parameters_done(RunParameters *p) {
        assert(p);
 
        p->node = mfree(p->node);
        p->definitions = strv_free(p->definitions);
        p->kernel_image = mfree(p->kernel_image);
        p->credentials = sd_json_variant_unref(p->credentials);
}
 
typedef struct CredentialParameters {
        const char *id;
        struct iovec value;
} CredentialParameters;
 
static void credential_parameters_done(CredentialParameters *p) {
        assert(p);
 
        iovec_done_erase(&p->value);
}
 
static int credentials_from_json_array(MachineCredentialContext *credentials, sd_json_variant *v) {
 
        int r;
        sd_json_variant *credential;
 
        assert(credentials);
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "id",    SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(CredentialParameters, id),    SD_JSON_MANDATORY },
                { "value", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec,  offsetof(CredentialParameters, value), SD_JSON_MANDATORY },
                {}
        };
 
        JSON_VARIANT_ARRAY_FOREACH(credential, v) {
                _cleanup_(credential_parameters_done) CredentialParameters p = {};
 
                r = sd_json_dispatch(credential, dispatch_table, /* flags= */ 0, &p);
                if (r < 0)
                        return r;
 
                r = machine_credential_add(credentials, p.id, p.value.iov_base, p.value.iov_len);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
static int vl_method_run(
                sd_varlink *link,
                sd_json_variant *parameters,
                sd_varlink_method_flags_t flags,
                void *userdata) {
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "node",            SD_JSON_VARIANT_STRING,  json_dispatch_path,       offsetof(RunParameters, node),          SD_JSON_MANDATORY | SD_JSON_STRICT },
                { "definitions",     SD_JSON_VARIANT_ARRAY,   json_dispatch_strv_path,  offsetof(RunParameters, definitions),   SD_JSON_NULLABLE | SD_JSON_STRICT  },
                { "erase",           SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(RunParameters, erase),         SD_JSON_MANDATORY                  },
                { "variables",       SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(RunParameters, variables),     SD_JSON_NULLABLE                   },
                { "kernelImagePath", SD_JSON_VARIANT_STRING,  json_dispatch_path,       offsetof(RunParameters, kernel_image),  SD_JSON_NULLABLE | SD_JSON_STRICT  },
                { "copyLocale",      SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(RunParameters, copy_locale),   SD_JSON_NULLABLE                   },
                { "copyKeymap",      SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(RunParameters, copy_keymap),   SD_JSON_NULLABLE                   },
                { "copyTimezone",    SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(RunParameters, copy_timezone), SD_JSON_NULLABLE                   },
                { "credentials",     SD_JSON_VARIANT_ARRAY,   sd_json_dispatch_variant, offsetof(RunParameters, credentials),   SD_JSON_NULLABLE                   },
                {}
        };
 
        int r;
 
        assert(link);
 
        sd_varlink_server *varlink_server = sd_varlink_get_server(link);
        Hashmap **polkit_registry = ASSERT_PTR(sd_varlink_server_get_userdata(varlink_server));
 
        r = varlink_verify_polkit_async(
                        link,
                        /* bus= */ NULL,
                        "io.systemd.sysinstall.Run",
                        /* details= */ NULL,
                        polkit_registry);
        if (r <= 0)