HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/sysext/sysext.c

132,720 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: e31d38d83f0ebe3c4643975d7ec98aa1f9102715

Lines 3001–3321 of 3,321

        if (r < 0)
                return r;
 
        return sd_varlink_reply(link, NULL);
}
 
static int refresh_class(ImageClass image_class) {
        _cleanup_(context_done) Context c = CONTEXT_NULL;
        int r;
 
        /* The sysupdate notification service is systemd-sysext, but it refreshes both sysexts and
         * confexts. Apply the relevant class-specific environment and configuration for each refresh. */
        r = context_from_cmdline(&c, image_class);
        if (r < 0)
                return r;
 
        return refresh(&c);
}
 
static int vl_method_on_completed_update(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        int r;
 
        assert(link);
 
        /* Only honour update notifications if they come from root */
        r = varlink_check_privileged_peer(link);
        if (r < 0)
                return r;
 
        /* Triggered by systemd-sysupdate after an update completed. We deliberately ignore all parameters
         * (we don't even dispatch them). This method is reached through the sysext socket, but a single
         * notification refreshes both image classes, so freshly downloaded sysexts and confexts are both
         * picked up, equivalent to "systemd-confext refresh" plus "systemd-sysext refresh", in the same order
         * as at boot. We attempt both classes and only fail afterwards, so a problem with one does not
         * prevent refreshing the other. */
 
        r = 0;
        RET_GATHER(r, refresh_class(IMAGE_CONFEXT));
        RET_GATHER(r, refresh_class(IMAGE_SYSEXT));
        if (r < 0)
                return r;
 
        return sd_varlink_reply(link, NULL);
}
 
VERB_NOARG(verb_list, "list", "List installed extensions");
static int verb_list(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_hashmap_free_ Hashmap *images = NULL;
        _cleanup_(table_unrefp) Table *t = NULL;
        Image *img;
        int r;
 
        r = image_discover(RUNTIME_SCOPE_SYSTEM, arg_image_class, arg_root, &images);
        if (r < 0)
                return log_error_errno(r, "Failed to discover images: %m");
 
        if (hashmap_isempty(images) && !sd_json_format_enabled(arg_json_format_flags)) {
                log_info("No OS extensions found.");
                return 0;
        }
 
        t = table_new("name", "type", "path", "time");
        if (!t)
                return log_oom();
 
        HASHMAP_FOREACH(img, images) {
                r = table_add_many(
                                t,
                                TABLE_STRING, img->name,
                                TABLE_STRING, image_type_to_string(img->type),
                                TABLE_PATH, img->path,
                                TABLE_TIMESTAMP, img->mtime != 0 ? img->mtime : img->crtime);
                if (r < 0)
                        return table_log_add_error(r);
        }
 
        (void) table_set_sort(t, (size_t) 0);
 
        return table_print_with_pager(t, arg_json_format_flags, arg_pager_flags, arg_legend);
}
 
static int vl_method_list(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "class", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, 0, 0 },
                VARLINK_DISPATCH_POLKIT_FIELD,
                {}
        };
        Hashmap **polkit_registry = ASSERT_PTR(userdata);
        int r;
 
        assert(link);
        assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
 
        const char *class = NULL;
        r = sd_varlink_dispatch(link, parameters, dispatch_table, &class);
        if (r != 0)
                return r;
 
        ImageClass image_class = arg_image_class;
        r = parse_image_class_parameter(link, class, &image_class);
        if (r < 0)
                return r;
 
        r = varlink_verify_polkit_async(
                        link,
                        /* bus= */ NULL,
                        image_class_info[image_class].polkit_ro_action_id,
                        (const char**) STRV_MAKE("verb", "list"),
                        polkit_registry);
        if (r <= 0)
                return r;
 
        _cleanup_hashmap_free_ Hashmap *images = NULL;
        r = image_discover(RUNTIME_SCOPE_SYSTEM, image_class, arg_root, &images);
        if (r < 0)
                return r;
 
        r = sd_varlink_set_sentinel(link, "io.systemd.sysext.NoImagesFound");
        if (r < 0)
                return r;
 
        Image *img;
        HASHMAP_FOREACH(img, images) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
                r = image_to_json(img, &v);
                if (r < 0)
                        return r;
 
                r = sd_varlink_reply(link, v);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
VERB_FULL(verb_help, "help", NULL, VERB_ANY, VERB_ANY, 0, /* dat= */ 0u, /* help= */ NULL);
static int verb_help(int argc, char **argv, uintptr_t data, void *userdata) {
        return command_print_help_name(
                        arg_image_class == IMAGE_SYSEXT ? "systemd-sysext" : "systemd-confext");
}
 
static int parse_argv(int argc, char *argv[], char ***ret_args) {
        int r;
 
        assert(argc >= 0);
        assert(argv);
        assert(ret_args);
 
        OptionParser opts = { argc, argv };
 
        FOREACH_OPTION_OR_RETURN(c, &opts)
                switch (c) {
 
                OPTION_COMMON_HELP:
                        return verb_help(argc, argv, /* data= */ 0u, /* userdata= */ NULL);
 
                OPTION_COMMON_VERSION:
                        return version();
 
                OPTION_LONG("root", "PATH", "Operate relative to root PATH"):
                        r = parse_path_argument(opts.arg, false, &arg_root);
                        if (r < 0)
                                return r;
                        /* If --root= is provided, do not reload the service manager */
                        arg_no_reload = true;
                        break;
 
                OPTION_LONG("mutable", "MODE",
                            "Specify a mutability mode (yes, no, auto, import, ephemeral, ephemeral-import, help)"):
                        if (streq(opts.arg, "help")) {
                                if (arg_legend)
                                        puts("Known mutability modes:");
 
                                return DUMP_STRING_TABLE(mutable_mode, MutableMode, _MUTABLE_MAX);
                        }
 
                        r = parse_mutable_mode(opts.arg);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse argument to --mutable=: %s", opts.arg);
                        arg_mutable = r;
                        arg_mutable_argv_set = true;
                        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;
                        arg_image_policy_argv_set = true;
                        break;
 
                OPTION_LONG("noexec", "BOOL", "Whether to mount extension overlay with noexec"):
                        r = parse_boolean_argument("--noexec", opts.arg, NULL);
                        if (r < 0)
                                return r;
 
                        arg_noexec = r;
                        break;
 
                OPTION_LONG("force", NULL, "Ignore version incompatibilities"):
                        arg_force = true;
                        break;
 
                OPTION_LONG("no-reload", NULL, "Do not reload the service manager"):
                        arg_no_reload = true;
                        break;
 
                OPTION_LONG("always-refresh", "BOOL", "Whether to refresh when no changes were found"):
                        r = parse_boolean_argument("--always-refresh", opts.arg, &arg_always_refresh);
                        if (r < 0)
                                return r;
                        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);
                }
 
        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;
 
        *ret_args = option_parser_get_args(&opts);
        return 1;
}
 
static int run(int argc, char *argv[]) {
        char **args = NULL;
        int r;
 
        LIBBLKID_NOTE(required);
        LIBCRYPTO_NOTE(suggested);
        LIBCRYPTSETUP_NOTE(recommended);
        LIBMOUNT_NOTE(required);
        LIBSELINUX_NOTE(recommended);
 
        log_setup();
 
        arg_image_class = invoked_as(argv, "systemd-confext") ? IMAGE_CONFEXT : IMAGE_SYSEXT;
 
        /* Parse command line */
        r = parse_argv(argc, argv, &args);
        if (r <= 0)
                return r;
 
        /* PROC_CMDLINE_STRIP_RD_PREFIX cannot be used here as we need to be able to distinguish between
         * rd.systemd.{sysext,confext} and systemd.{sysext,confext} in the initrd where they are both used
         * and have different meaning. */
        const char *string_class = image_class_to_string(arg_image_class);
        const char *cmdline_opt = strjoina(in_initrd() && !arg_root ? "rd." : "", "systemd.", string_class);
 
        bool enabled;
        r = proc_cmdline_get_bool(cmdline_opt, PROC_CMDLINE_TRUE_WHEN_MISSING, &enabled);
        if (r < 0)
                log_debug_errno(r, "Failed to check '%s=' kernel command line option, proceeding: %m", cmdline_opt);
        else if (!enabled && invoked_by_systemd()) {
                /* Kernel command line option should not affect manual invocation. */
                log_notice("Disabled by the kernel command line option '%s=', skipping execution.", cmdline_opt);
                return 0;
        }
 
        if (arg_varlink) {
                _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *varlink_server = NULL;
                _cleanup_hashmap_free_ Hashmap *polkit_registry = NULL;
 
                /* Invocation as Varlink service */
 
                r = varlink_server_new(
                                &varlink_server,
                                SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA,
                                &polkit_registry);
                if (r < 0)
                        return log_error_errno(r, "Failed to allocate Varlink server: %m");
 
                r = sd_varlink_server_add_interface_many(
                                varlink_server,
                                &vl_interface_io_systemd_sysext,
                                &vl_interface_io_systemd_SysUpdate_Notify);
                if (r < 0)
                        return log_error_errno(r, "Failed to add Varlink interfaces: %m");
 
                r = sd_varlink_server_bind_method_many(
                                varlink_server,
                                "io.systemd.sysext.Merge", vl_method_merge,
                                "io.systemd.sysext.Unmerge", vl_method_unmerge,
                                "io.systemd.sysext.Refresh", vl_method_refresh,
                                "io.systemd.sysext.List", vl_method_list,
                                "io.systemd.SysUpdate.Notify.OnCompletedUpdate", vl_method_on_completed_update);
                if (r < 0)
                        return log_error_errno(r, "Failed to bind Varlink methods: %m");
 
                r = sd_varlink_server_loop_auto(varlink_server);
                if (r == -EPERM)
                        return log_error_errno(r, "Invoked by unprivileged Varlink peer, refusing.");
                if (r < 0)
                        return log_error_errno(r, "Failed to run Varlink event loop: %m");
 
                return EXIT_SUCCESS;
        }
 
        return dispatch_verb(args, NULL);
}
 
DEFINE_MAIN_FUNCTION(run);