HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/sysupdate/sysupdate.c

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

Git blob: 53c690b9bc5a42764e46b95cc8a991b63a15dadc

Lines 3001–3595 of 3,595

        if (ret_has_default_component)
                *ret_has_default_component =
                        !context->definitions &&
                        !context->component &&
                        context->n_transfers + context->n_disabled_transfers > 0;
 
        return 0;
}
 
static int context_component_is_suggested(Context *c) {
        assert(c);
 
        /* Only applies to components, not to the main system */
        if (!c->component)
                return -ENOTTY;
 
        if (c->component_suggest >= 0)
                return c->component_suggest;
 
        if (!c->component_suggest_on) /* no condition → false */
                return false;
 
        return condition_test_list(c->component_suggest_on, environ, suggest_on_type_to_string, /* logger= */ NULL, /* userdata= */ NULL);
}
 
VERB_NOARG(verb_components, "components",
           "Show list of components");
static int verb_components(int argc, char *argv[], uintptr_t _data, void *userdata) {
        int r;
 
        assert(argc <= 1);
 
        _cleanup_(context_done) Context context = CONTEXT_NULL;
        r = context_from_cmdline(&context);
        if (r < 0)
                return r;
 
        if (context.feature_select != SELECT_EXPLICIT)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--feature-all/--feature-suggested is not supported for '%s'.", argv[0]);
        if (context.component_select != SELECT_EXPLICIT)
                return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "--component-all/--component-suggested currently not supported for '%s'.", argv[0]);
        if (context.definitions)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "The --definitions= switch may not be combined with '%s'.", argv[0]);
 
        r = context_load_offline(
                        &context,
                        /* process_image_flags= */ 0,
                        /* read_definitions_flags= */ 0);
        if (r < 0)
                return r;
 
        _cleanup_strv_free_ char **component_names = NULL;
        bool has_default_component = false;
        r = context_list_components(&context, &component_names, &has_default_component);
        if (r < 0)
                return log_error_errno(r, "Failed to enumerate components: %m");
 
        if (!sd_json_format_enabled(arg_json_format_flags)) {
                if (!has_default_component && strv_isempty(component_names)) {
                        log_info("No components defined.");
                        return 0;
                }
 
                _cleanup_(table_unrefp) Table *t = table_new("enabled", "suggested", "component", "description", "documentation");
                if (!t)
                        return log_oom();
 
                table_set_ersatz_string(t, TABLE_ERSATZ_DASH);
 
                if (has_default_component) {
                        r = table_add_many(
                                        t,
                                        TABLE_EMPTY,
                                        TABLE_EMPTY,
                                        TABLE_STRING, "<default>",
                                        TABLE_SET_COLOR, ansi_highlight(),
                                        TABLE_STRING, "Default Component",
                                        TABLE_EMPTY);
                        if (r < 0)
                                return table_log_add_error(r);
                }
 
                STRV_FOREACH(i, component_names) {
                        _cleanup_(context_done) Context cc = CONTEXT_NULL;
 
                        r = context_from_base_with_component(
                                        &context,
                                        *i,
                                        &cc);
                        if (r < 0)
                                return r;
 
                        r = context_load_offline(
                                        &cc,
                                        /* process_image_flags= */ 0,
                                        /* read_definitions_flags= */ 0);
                        if (r == -ENOMEM)
                                return r;
                        if (r < 0)
                                continue;
 
                        r = table_add_many(
                                        t,
                                        TABLE_BOOLEAN_CHECKMARK, cc.component_enabled,
                                        TABLE_SET_COLOR, ansi_highlight_green_red(cc.component_enabled));
                        if (r < 0)
                                return table_log_add_error(r);
 
                        r = context_component_is_suggested(&cc);
                        if (r < 0)
                                r = table_add_many(t, TABLE_EMPTY);
                        else
                                r = table_add_many(t, TABLE_BOOLEAN_CHECKMARK, r);
                        if (r < 0)
                                return table_log_add_error(r);
 
                        r = table_add_many(
                                        t,
                                        TABLE_STRING, *i,
                                        TABLE_STRING, cc.component_description,
                                        TABLE_STRV_WRAPPED, cc.component_documentation);
                        if (r < 0)
                                return table_log_add_error(r);
                }
 
                return table_print_with_pager(t, arg_json_format_flags, arg_pager_flags, arg_legend);
        } else {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *json = NULL;
 
                r = sd_json_buildo(&json,
                                   SD_JSON_BUILD_PAIR_BOOLEAN("default", has_default_component),
                                   SD_JSON_BUILD_PAIR_STRV("components", component_names));
                if (r < 0)
                        return log_error_errno(r, "Failed to create JSON: %m");
 
                r = sd_json_variant_dump(json, arg_json_format_flags, stdout, NULL);
                if (r < 0)
                        return log_error_errno(r, "Failed to print JSON: %m");
        }
 
        return 0;
}
 
static int vl_method_list_targets(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        _cleanup_(context_done) Context context = CONTEXT_NULL;
        _cleanup_set_free_ Set *targets = NULL;
        int r;
 
        assert(link);
 
        r = sd_varlink_dispatch(link, parameters, NULL, NULL);
        if (r != 0)
                return r;
 
        /* Listing targets doesn’t require a polkit check */
 
        if (getenv_bool("SYSTEMD_SYSUPDATE_NO_VERIFY") > 0)
                context.verify = 0;
 
        /* ListTargets is always offline */
        context.offline = true;
 
        r = context_load_offline(
                        &context,
                        PROCESS_IMAGE_READ_ONLY,
                        /* read_definitions_flags= */ 0);
        if (r < 0)
                return r;
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
 
        r = context_enumerate_targets(&context, &targets);
        if (r < 0)
                return r;
 
        /* Sort to ensure consistent ordering */
        size_t n;
        _cleanup_free_ TargetIdentifier **sorted = NULL;
        r = set_dump_sorted(targets, (void***) &sorted, &n);
        if (r < 0)
                return log_oom();
 
        FOREACH_ARRAY(p, sorted, n) {
                TargetIdentifier *target_identifier = *p;
                const char *name = (target_identifier->class != TARGET_HOST) ? target_identifier->name : NULL;
 
                r = sd_json_variant_append_arraybo(&l,
                                SD_JSON_BUILD_PAIR_OBJECT("id",
                                                JSON_BUILD_PAIR_ENUM("class", target_class_to_string(target_identifier->class)),
                                                SD_JSON_BUILD_PAIR_STRING("name", name)));
                if (r < 0)
                        return r;
        }
 
        if (!l) {
                r = sd_json_variant_new_array(&l, NULL, 0);
                if (r < 0)
                        return r;
        }
 
        return sd_varlink_replybo(link,
                        SD_JSON_BUILD_PAIR_VARIANT("targets", l));
}
 
VERB(verb_enable_component, "enable-component", "COMPONENT…\0", 1, VERB_ANY, 0,
     "Enable component");
VERB(verb_enable_component, "disable-component", "COMPONENT…\0", 1, VERB_ANY, 0,
     "Disable component");
static int verb_enable_component(int argc, char *argv[], uintptr_t _data, void *userdata) {
        bool enable = streq(argv[0], "enable-component");
        int r;
 
        _cleanup_(context_done) Context context = CONTEXT_NULL;
        r = context_from_cmdline(&context);
        if (r < 0)
                return r;
 
        if (context.feature_select != SELECT_EXPLICIT)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--feature-all/--feature-suggested is not supported for '%s'.", argv[0]);
        if (context.definitions)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "The --definitions= switch may not be combined with '%s'.", argv[0]);
 
        char **arguments, *array[2];
        if (argc > 1) {
                if (context.component || context.component_select != SELECT_EXPLICIT)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Either specify component names as positional parameter or via --component=/--component-all/--component-suggested, not both.");
 
                arguments = strv_skip(argv, 1);
 
        } else if (context.component_select == SELECT_EXPLICIT) {
                if (!context.component)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No component specified.");
 
                array[0] = context.component;
                array[1] = NULL;
                arguments = array;
        } else {
                assert(!context.component);
                arguments = NULL;
        }
 
        STRV_FOREACH(name, arguments)
                if (!component_name_valid(*name))
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Component name invalid: %s", *name);
 
        r = context_load_offline(
                        &context,
                        /* process_image_flags= */ 0,
                        /* read_definitions_flags= */ 0);
        if (r < 0)
                return r;
 
        _cleanup_strv_free_ char **component_names = NULL;
        r = context_list_components(&context, &component_names, /* ret_has_default_component= */ NULL);
        if (r < 0)
                return r;
 
        _cleanup_strv_free_ char **suggested = NULL;
 
        switch (context.component_select) {
 
        case SELECT_EXPLICIT:
                STRV_FOREACH(name, arguments)
                        if (!strv_contains(component_names, *name))
                                return log_error_errno(SYNTHETIC_ERRNO(ENOENT), "Component not found: %s", *name);
                break;
 
        case SELECT_ALL:
                assert(!arguments);
                arguments = component_names;
                break;
 
        case SELECT_SUGGESTED:
                assert(!arguments);
                STRV_FOREACH(name, component_names) {
                        _cleanup_(context_done) Context cc = CONTEXT_NULL;
 
                        r = context_from_base_with_component(&context, *name, &cc);
                        if (r < 0)
                                return r;
 
                        r = context_load_offline(
                                        &cc,
                                        /* process_image_flags= */ 0,
                                        /* read_definitions_flags= */ 0);
                        if (r < 0)
                                continue;
 
                        r = context_component_is_suggested(&cc);
                        if (r < 0) {
                                log_warning_errno(r, "Failed to determine whether '%s' is suggested, skipping: %m", *name);
                                continue;
                        }
                        if (r == 0) {
                                log_debug("Component '%s' is not suggested, skipping.", *name);
                                continue;
                        }
 
                        log_info("%s '%s'.", enable ? "Enabling" : "Disabling", *name);
 
                        if (strv_extend(&suggested, *name) < 0)
                                return log_oom();
                }
 
                arguments = suggested;
                break;
 
        default:
                assert_not_reached();
        }
 
        if (strv_isempty(arguments)) {
                log_info("No components selected.");
                return 0;
        }
 
        /* Component definition files live directly below the configuration directories, hence the drop-in
         * goes right next to them below /etc. */
        _cleanup_free_ char *dropin_dir = path_join(context.root, SYSCONF_DIR);
        if (!dropin_dir)
                return log_oom();
 
        STRV_FOREACH(name, arguments) {
                _cleanup_free_ char *fname = strjoin("sysupdate.", *name, ".component");
                if (!fname)
                        return log_oom();
 
                /* We assume that no sysadmin will name their config 50-systemd-sysupdate-enabled.conf */
                r = write_drop_in_format(
                                dropin_dir,
                                fname,
                                50, "systemd-sysupdate-enabled",
                                "# Generated via 'systemd-sysupdate %s'\n\n"
                                "[Component]\n"
                                "Enabled=%s\n",
                                argv[0],
                                yes_no(enable));
                if (r < 0)
                        return log_error_errno(r, "Failed to write drop-in for component '%s': %m", *name);
 
                log_info("Component '%s' %s.", *name, enable ? "enabled" : "disabled");
        }
 
        return 0;
}
 
VERB_COMMON_HELP_AUTO_HIDDEN();
 
static int parse_argv(int argc, char *argv[], char ***remaining_args) {
        assert(argc >= 0);
        assert(argv);
        assert(remaining_args);
 
        OptionParser opts = { argc, argv };
        int r;
 
        FOREACH_OPTION_OR_RETURN(c, &opts)
                switch (c) {
 
                OPTION_COMMON_HELP:
                        return command_print_help();
 
                OPTION_COMMON_VERSION:
                        return version();
 
                OPTION('C', "component", "NAME",
                       "Select component to update"):
                        if (isempty(opts.arg)) {
                                arg_component = mfree(arg_component);
                                arg_component_select = SELECT_EXPLICIT;
                                break;
                        }
 
                        if (!component_name_valid(opts.arg))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Component name invalid: %s", opts.arg);
 
                        r = free_and_strdup_warn(&arg_component, opts.arg);
                        if (r < 0)
                                return r;
 
                        arg_component_select = SELECT_EXPLICIT;
                        break;
 
                OPTION('A', "component-all", NULL, "Select all components"):
                        arg_component = mfree(arg_component);
                        arg_component_select = SELECT_ALL;
                        break;
 
                OPTION('S', "component-suggested", NULL, "Select all suggested components"):
                        arg_component = mfree(arg_component);
                        arg_component_select = SELECT_SUGGESTED;
                        break;
 
                OPTION('a', "feature-all", NULL, "Select all features"):
                        arg_feature_select = SELECT_ALL;
                        break;
 
                OPTION('s', "feature-suggested", NULL, "Select all suggested features"):
                        arg_feature_select = SELECT_SUGGESTED;
                        break;
 
                OPTION_LONG("definitions", "DIR",
                            "Find transfer definitions in specified directory"):
                        r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_definitions);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("root", "PATH",
                            "Operate on an alternate filesystem root"):
                        r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_root);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("image", "PATH",
                            "Operate on disk image as filesystem root"):
                        r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("image-policy", "POLICY",
                            "Specify disk image dissection policy"):
                        r = parse_image_policy_argument(opts.arg, &arg_image_policy);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("transfer-source", "PATH",
                            "Specify the directory to transfer sources from"):
                        r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_transfer_source);
                        if (r < 0)
                                return r;
 
                        break;
 
                OPTION('m', "instances-max", "INT",
                       "How many instances to maintain"):
                        r = safe_atou64(opts.arg, &arg_instances_max);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse --instances-max= parameter: %s", opts.arg);
 
                        break;
 
                OPTION_LONG("sync", "BOOL",
                            "Controls whether to sync data to disk"):
                        r = parse_boolean_argument("--sync=", opts.arg, &arg_sync);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("verify", "BOOL",
                            "Force signature verification on or off"): {
                        bool b;
 
                        r = parse_boolean_argument("--verify=", opts.arg, &b);
                        if (r < 0)
                                return r;
 
                        arg_verify = b;
                        break;
                }
 
                OPTION_LONG("reboot", NULL,
                            "Reboot after updating to newer version"):
                        arg_reboot = true;
                        break;
 
                OPTION_LONG("offline", NULL,
                            "Do not fetch metadata from the network"):
                        arg_offline = true;
                        break;
 
                OPTION_LONG("cleanup", "BOOL", "Clean up orphaned files after completing update"): {
                        bool b;
 
                        r = parse_boolean_argument("--cleanup=", opts.arg, &b);
                        if (r < 0)
                                return r;
 
                        arg_cleanup = b;
                        break;
                }
 
                OPTION_COMMON_NO_PAGER:
                        arg_pager_flags |= PAGER_DISABLE;
                        break;
 
                OPTION_COMMON_NO_LEGEND:
                        arg_legend = false;
                        break;
 
                OPTION_COMMON_JSON:
                        r = parse_json_argument(opts.arg, &arg_json_format_flags);
                        if (r <= 0)
                                return r;
 
                        break;
 
                OPTION_COMMON_INTROSPECT_CLI:
                        return introspect_cli(arg_json_format_flags);
                }
 
        if (arg_image && arg_root)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Please specify either --root= or --image=, the combination of both is not supported.");
 
        if (arg_image || arg_root) {
                if (arg_reboot)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "The --reboot switch may not be combined with --root= or --image=.");
 
                if (arg_definitions)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "The --definitions= switch may not be combined with --root= or --image=.");
        }
 
        if ((arg_component || arg_component_select != SELECT_EXPLICIT)) {
                if (arg_reboot)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "The --reboot switch may not be combined with --component=/--component-all/--component-suggested, as automatic reboots only apply to the booted OS version.");
 
                if (arg_definitions)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "The --definitions= and --component=/--component-all/--component-suggested switches may not be combined.");
        }
 
        r = sd_varlink_invocation(SD_VARLINK_ALLOW_ACCEPT);
        if (r < 0)
                return log_error_errno(r, "Failed to check if invoked in Varlink mode: %m");
        if (r > 0)
                arg_varlink = true;
 
        *remaining_args = option_parser_get_args(&opts);
        return 1;
}
 
static int vl_server(void) {
        _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *varlink_server = NULL;
        _cleanup_(server_done) Server server = SERVER_NULL;
        int r;
 
        r = varlink_server_new(&varlink_server,
                               SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA,
                               &server);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate Varlink server: %m");
 
        r = sd_varlink_server_add_interface(varlink_server, &vl_interface_io_systemd_SysUpdate);
        if (r < 0)
                return log_error_errno(r, "Failed to add Varlink interface: %m");
 
        r = sd_varlink_server_bind_method_many(
                        varlink_server,
                        "io.systemd.SysUpdate.CheckNew",     vl_method_check_new,
                        "io.systemd.SysUpdate.ListFeatures", vl_method_list_features,
                        "io.systemd.SysUpdate.ListTargets",  vl_method_list_targets);
        if (r < 0)
                return log_error_errno(r, "Failed to bind Varlink method: %m");
 
        r = sd_varlink_server_loop_auto(varlink_server);
        if (r < 0)
                return log_error_errno(r, "Failed to run Varlink event loop: %m");
 
        return 0;
}
 
static int run(int argc, char *argv[]) {
        int r;
 
        LIBAPPARMOR_NOTE(recommended);
        LIBAUDIT_NOTE(recommended);
        LIBBLKID_NOTE(recommended);
        LIBCRYPTO_NOTE(suggested);
        LIBCRYPTSETUP_NOTE(suggested);
        LIBFDISK_NOTE(recommended);
        LIBMOUNT_NOTE(recommended);
        LIBSELINUX_NOTE(recommended);
        LIBTSS2_ESYS_NOTE(suggested);
        LIBTSS2_MU_NOTE(suggested);
        LIBTSS2_RC_NOTE(suggested);
 
        log_setup();
 
        char **args = NULL;
        r = parse_argv(argc, argv, &args);
        if (r <= 0)
                return r;
 
        if (arg_varlink)
                return vl_server(); /* Invocation as Varlink service */
 
        return dispatch_verb(args, NULL);
}
 
DEFINE_MAIN_FUNCTION_WITH_POSITIVE_FAILURE(run);