HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/login/loginctl.c

63,024 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 8814b20234b78e2423dc625af451c390da44c09e

Lines 1001–1650 of 1,650

                                "org.freedesktop.login1",
                                "/org/freedesktop/login1/session/auto",
                                "org.freedesktop.login1.Session",
                                streq(argv[0], "lock-session")      ? "Lock" :
                                streq(argv[0], "unlock-session")    ? "Unlock" :
                                streq(argv[0], "terminate-session") ? "Terminate" :
                                                                      "Activate",
                                &error, NULL, NULL);
                if (r < 0)
                        return log_error_errno(r, "Failed to issue method call: %s", bus_error_message(&error, r));
 
                return 0;
        }
 
        for (int i = 1; i < argc; i++) {
                r = bus_call_method(
                                bus,
                                bus_login_mgr,
                                streq(argv[0], "lock-session")      ? "LockSession" :
                                streq(argv[0], "unlock-session")    ? "UnlockSession" :
                                streq(argv[0], "terminate-session") ? "TerminateSession" :
                                                                      "ActivateSession",
                                &error, NULL,
                                "s", argv[i]);
                if (r < 0)
                        return log_error_errno(r, "Failed to issue method call: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB_NOARG(verb_lock_sessions, "lock-sessions", "Screen lock all current sessions");
VERB_NOARG(verb_lock_sessions, "unlock-sessions", "Screen unlock all current sessions");
static int verb_lock_sessions(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        assert(argv);
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        r = bus_call_method(
                        bus,
                        bus_login_mgr,
                        streq(argv[0], "lock-sessions") ? "LockSessions" : "UnlockSessions",
                        &error, NULL,
                        NULL);
        if (r < 0)
                return log_error_errno(r, "Could not lock sessions: %s", bus_error_message(&error, r));
 
        return 0;
}
 
/* The implementation is above, but we put this here to preserve the logical order in --help. */
VERB(verb_activate, "terminate-session", "ID…\0", 2, VERB_ANY, 0,
     "Terminate one or more sessions");
 
VERB(verb_kill_session, "kill-session", "ID…\0", 2, VERB_ANY, 0,
     "Send signal to processes of a session");
static int verb_kill_session(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        assert(argv);
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        if (!arg_kill_whom)
                arg_kill_whom = "all";
 
        for (int i = 1; i < argc; i++) {
                r = bus_call_method(
                                bus,
                                bus_login_mgr,
                                "KillSession",
                                &error, NULL,
                                "ssi", argv[i], arg_kill_whom, arg_signal);
                if (r < 0)
                        return log_error_errno(r, "Could not kill session: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB_GROUP("User Commands");
 
VERB_NOARG(verb_list_users, "list-users", "List users");
static int verb_list_users(int argc, char *argv[], uintptr_t _data, void *userdata) {
 
        static const struct bus_properties_map property_map[] = {
                { "Linger", "b", NULL, offsetof(UserStatusInfo, linger) },
                { "State",  "s", NULL, offsetof(UserStatusInfo, state)  },
                {},
        };
 
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        _cleanup_(table_unrefp) Table *table = NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        assert(argv);
 
        r = bus_call_method(bus, bus_login_mgr, "ListUsers", &error, &reply, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to list users: %s", bus_error_message(&error, r));
 
        r = sd_bus_message_enter_container(reply, 'a', "(uso)");
        if (r < 0)
                return bus_log_parse_error(r);
 
        table = table_new("uid", "user", "linger", "state");
        if (!table)
                return log_oom();
 
        (void) table_set_align_percent(table, TABLE_HEADER_CELL(0), 100);
        table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
 
        for (;;) {
                _cleanup_(sd_bus_error_free) sd_bus_error error_property = SD_BUS_ERROR_NULL;
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply_property = NULL;
                _cleanup_(user_status_info_done) UserStatusInfo info = {};
                const char *user, *object;
                uint32_t uid;
 
                r = sd_bus_message_read(reply, "(uso)", &uid, &user, &object);
                if (r < 0)
                        return bus_log_parse_error(r);
                if (r == 0)
                        break;
 
                r = bus_map_all_properties(bus,
                                           "org.freedesktop.login1",
                                           object,
                                           property_map,
                                           BUS_MAP_BOOLEAN_AS_BOOL,
                                           &error_property,
                                           &reply_property,
                                           &info);
                if (r < 0) {
                        log_full_errno(sd_bus_error_has_name(&error_property, SD_BUS_ERROR_UNKNOWN_OBJECT) ? LOG_DEBUG : LOG_WARNING,
                                       r,
                                       "Failed to get properties of user %s, ignoring: %s",
                                       user, bus_error_message(&error_property, r));
                        continue;
                }
 
                r = table_add_many(table,
                                   TABLE_UID, (uid_t) uid,
                                   TABLE_STRING, user,
                                   TABLE_BOOLEAN, info.linger,
                                   TABLE_STRING, info.state);
                if (r < 0)
                        return table_log_add_error(r);
        }
 
        r = sd_bus_message_exit_container(reply);
        if (r < 0)
                return bus_log_parse_error(r);
 
        return list_table_print(table, "users");
}
 
VERB(verb_show_user, "user-status", "[USER…]\0", VERB_ANY, VERB_ANY, 0,
     "Show user status");
VERB(verb_show_user, "show-user", "[USER…]\0", VERB_ANY, VERB_ANY, 0,
     "Show properties of users or the manager");
static int verb_show_user(int argc, char *argv[], uintptr_t _data, void *userdata) {
        sd_bus *bus = ASSERT_PTR(userdata);
        bool properties;
        int r;
 
        assert(argv);
 
        properties = !strstr(argv[0], "status");
 
        pager_open(arg_pager_flags);
 
        if (argc <= 1) {
                /* If no argument is specified inspect the manager itself */
                if (properties)
                        return show_properties(bus, "/org/freedesktop/login1");
 
                return print_user_status_info(bus, "/org/freedesktop/login1/user/self");
        }
 
        for (int i = 1, first = true; i < argc; i++, first = false) {
                _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
                const char *path;
                uid_t uid;
 
                r = get_user_creds(argv[i], /* flags= */ 0, NULL, &uid, NULL, NULL, NULL);
                if (r < 0)
                        return log_error_errno(r, "Failed to look up user %s: %m", argv[i]);
 
                r = bus_call_method(bus, bus_login_mgr, "GetUser", &error, &reply, "u", (uint32_t) uid);
                if (r < 0)
                        return log_error_errno(r, "Failed to get user: %s", bus_error_message(&error, r));
 
                r = sd_bus_message_read(reply, "o", &path);
                if (r < 0)
                        return bus_log_parse_error(r);
 
                if (!first)
                        putchar('\n');
 
                if (properties)
                        r = show_properties(bus, path);
                else
                        r = print_user_status_info(bus, path);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
VERB(verb_enable_linger, "enable-linger", "[USER…]\0", VERB_ANY, VERB_ANY, 0,
     "Enable linger state of one or more users");
VERB(verb_enable_linger, "disable-linger", "[USER…]\0", VERB_ANY, VERB_ANY, 0,
     "Disable linger state of one or more users");
static int verb_enable_linger(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        char* short_argv[3];
        bool b;
        int r;
 
        assert(argv);
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        b = streq(argv[0], "enable-linger");
 
        if (argc < 2) {
                /* No argument? Let's use an empty user name,
                 * then logind will use our user. */
 
                short_argv[0] = argv[0];
                short_argv[1] = (char*) "";
                short_argv[2] = NULL;
                argv = short_argv;
                argc = 2;
        }
 
        for (int i = 1; i < argc; i++) {
                uid_t uid;
 
                if (isempty(argv[i]))
                        uid = UID_INVALID;
                else {
                        r = get_user_creds(argv[i], /* flags= */ 0, NULL, &uid, NULL, NULL, NULL);
                        if (r < 0)
                                return log_error_errno(r, "Failed to look up user %s: %m", argv[i]);
                }
 
                r = bus_call_method(
                                bus,
                                bus_login_mgr,
                                "SetUserLinger",
                                &error, NULL,
                                "ubb", (uint32_t) uid, b, true);
                if (r < 0)
                        return log_error_errno(r, "Could not enable linger: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB(verb_terminate_user, "terminate-user", "USER…\0", 2, VERB_ANY, 0,
     "Terminate all sessions of one or more users");
static int verb_terminate_user(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        assert(argv);
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        for (int i = 1; i < argc; i++) {
                uid_t uid;
 
                if (isempty(argv[i]))
                        uid = getuid();
                else {
                        r = get_user_creds(argv[i], /* flags= */ 0, NULL, &uid, NULL, NULL, NULL);
                        if (r < 0)
                                return log_error_errno(r, "Failed to look up user %s: %m", argv[i]);
                }
 
                r = bus_call_method(bus, bus_login_mgr, "TerminateUser", &error, NULL, "u", (uint32_t) uid);
                if (r < 0)
                        return log_error_errno(r, "Could not terminate user: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB(verb_kill_user, "kill-user", "USER…\0", 2, VERB_ANY, 0,
     "Send signal to processes of a user");
static int verb_kill_user(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        assert(argv);
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        if (!arg_kill_whom)
                arg_kill_whom = "all";
 
        for (int i = 1; i < argc; i++) {
                uid_t uid;
 
                if (isempty(argv[i]))
                        uid = getuid();
                else {
                        r = get_user_creds(argv[i], /* flags= */ 0, NULL, &uid, NULL, NULL, NULL);
                        if (r < 0)
                                return log_error_errno(r, "Failed to look up user %s: %m", argv[i]);
                }
 
                r = bus_call_method(
                        bus,
                        bus_login_mgr,
                        "KillUser",
                        &error, NULL,
                        "ui", (uint32_t) uid, arg_signal);
                if (r < 0)
                        return log_error_errno(r, "Could not kill user: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB_GROUP("Seat Commands");
 
VERB_NOARG(verb_list_seats, "list-seats", "List seats");
static int verb_list_seats(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        _cleanup_(table_unrefp) Table *table = NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        assert(argv);
 
        r = bus_call_method(bus, bus_login_mgr, "ListSeats", &error, &reply, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to list seats: %s", bus_error_message(&error, r));
 
        r = sd_bus_message_enter_container(reply, 'a', "(so)");
        if (r < 0)
                return bus_log_parse_error(r);
 
        table = table_new("seat");
        if (!table)
                return log_oom();
 
        table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
 
        for (;;) {
                const char *seat;
 
                r = sd_bus_message_read(reply, "(so)", &seat, NULL);
                if (r < 0)
                        return bus_log_parse_error(r);
                if (r == 0)
                        break;
 
                r = table_add_cell(table, NULL, TABLE_STRING, seat);
                if (r < 0)
                        return table_log_add_error(r);
        }
 
        r = sd_bus_message_exit_container(reply);
        if (r < 0)
                return bus_log_parse_error(r);
 
        return list_table_print(table, "seats");
}
 
VERB(verb_show_seat, "seat-status", "[NAME…]\0", VERB_ANY, VERB_ANY, 0,
     "Show seat status");
VERB(verb_show_seat, "show-seat", "[NAME…]\0", VERB_ANY, VERB_ANY, 0,
     "Show properties of seats or the manager");
static int verb_show_seat(int argc, char *argv[], uintptr_t _data, void *userdata) {
        sd_bus *bus = ASSERT_PTR(userdata);
        bool properties;
        int r;
 
        assert(argv);
 
        properties = !strstr(argv[0], "status");
 
        pager_open(arg_pager_flags);
 
        if (argc <= 1) {
                _cleanup_free_ char *path = NULL;
 
                /* If no argument is specified inspect the manager itself */
                if (properties)
                        return show_properties(bus, "/org/freedesktop/login1");
 
                r = get_bus_path_by_id(bus, "seat", "GetSeat", "auto", &path);
                if (r < 0)
                        return r;
 
                return print_seat_status_info(bus, path);
        }
 
        for (int i = 1, first = true; i < argc; i++, first = false) {
                _cleanup_free_ char *path = NULL;
 
                r = get_bus_path_by_id(bus, "seat", "GetSeat", argv[i], &path);
                if (r < 0)
                        return r;
 
                if (!first)
                        putchar('\n');
 
                if (properties)
                        r = show_properties(bus, path);
                else
                        r = print_seat_status_info(bus, path);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
VERB(verb_attach, "attach", "NAME DEVICE…\0", 3, VERB_ANY, 0,
     "Attach one or more devices to a seat");
static int verb_attach(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        assert(argv);
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        for (int i = 2; i < argc; i++) {
 
                r = bus_call_method(
                        bus,
                        bus_login_mgr,
                        "AttachDevice",
                        &error, NULL,
                        "ssb", argv[1], argv[i], true);
                if (r < 0)
                        return log_error_errno(r, "Could not attach device: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB_NOARG(verb_flush_devices, "flush-devices", "Flush all device associations");
static int verb_flush_devices(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        assert(argv);
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        r = bus_call_method(bus, bus_login_mgr, "FlushDevices", &error, NULL, "b", true);
        if (r < 0)
                return log_error_errno(r, "Could not flush devices: %s", bus_error_message(&error, r));
 
        return 0;
}
 
VERB(verb_terminate_seat, "terminate-seat", "NAME…\0", 2, VERB_ANY, 0,
     "Terminate all sessions on one or more seats");
static int verb_terminate_seat(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        assert(argv);
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        for (int i = 1; i < argc; i++) {
 
                r = bus_call_method(bus, bus_login_mgr, "TerminateSeat", &error, NULL, "s", argv[i]);
                if (r < 0)
                        return log_error_errno(r, "Could not terminate seat: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB_COMMON_HELP_AUTO_HIDDEN();
 
static int parse_argv(int argc, char *argv[], char ***remaining_args) {
        int r;
 
        assert(argc >= 0);
        assert(argv);
        assert(remaining_args);
 
        OptionParser opts = { argc, argv };
 
        FOREACH_OPTION_OR_RETURN(c, &opts)
                switch (c) {
 
                OPTION_COMMON_HELP:
                        return command_print_help();
 
                OPTION_COMMON_VERSION:
                        return version();
 
                OPTION_COMMON_HOST:
                        arg_transport = BUS_TRANSPORT_REMOTE;
                        arg_host = opts.arg;
                        break;
 
                OPTION_COMMON_MACHINE:
                        r = parse_machine_argument(opts.arg, &arg_host, &arg_transport);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION('p', "property", "NAME", "Show only properties by this name"): {}
                OPTION_SHORT('P', "NAME", "Equivalent to --value --property=NAME"):
                        r = strv_extend(&arg_property, opts.arg);
                        if (r < 0)
                                return log_oom();
 
                        /* If the user asked for a particular property, show it to them, even if it is
                         * empty. */
                        SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_SHOW_EMPTY, true);
 
                        if (opts.opt->short_code == 'P')
                                SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
 
                        break;
 
                OPTION('a', "all", NULL, "Show all properties, including empty ones"):
                        SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_SHOW_EMPTY, true);
                        break;
 
                OPTION_LONG("value", NULL, "When showing properties, only print the value"):
                        SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
                        break;
 
                OPTION('l', "full", NULL, "Do not ellipsize output"):
                        arg_full = true;
                        break;
 
                OPTION_LONG("kill-whom", "WHOM", "Whom to send signal to"):
                        arg_kill_whom = opts.arg;
                        break;
 
                OPTION('s', "signal", "SIGNAL", "Which signal to send"):
                        r = parse_signal_argument(opts.arg, &arg_signal);
                        if (r <= 0)
                                return r;
                        break;
 
                OPTION('n', "lines", "INTEGER", "Number of journal entries to show"):
                        if (safe_atou(opts.arg, &arg_lines) < 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Failed to parse lines '%s'", opts.arg);
                        break;
 
                OPTION_COMMON_JSON:
                        r = parse_json_argument(opts.arg, &arg_json_format_flags);
                        if (r <= 0)
                                return r;
 
                        if (sd_json_format_enabled(arg_json_format_flags))
                                arg_legend = false;
 
                        break;
 
                OPTION_COMMON_LOWERCASE_J:
                        arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
                        arg_legend = false;
                        break;
 
                OPTION('o', "output", "MODE",
                       "Change journal output mode (short, short-precise, short-iso, "
                       "short-iso-precise, short-full, short-monotonic, short-unix, short-delta, "
                       "json, json-pretty, json-sse, json-seq, cat, verbose, export, with-unit)"):
                        if (streq(opts.arg, "help"))
                                return DUMP_STRING_TABLE(output_mode, OutputMode, _OUTPUT_MODE_MAX);
 
                        arg_output = output_mode_from_string(opts.arg);
                        if (arg_output < 0)
                                return log_error_errno(arg_output, "Unknown output '%s'.", opts.arg);
 
                        break;
 
                OPTION_COMMON_NO_PAGER:
                        arg_pager_flags |= PAGER_DISABLE;
                        break;
 
                OPTION_COMMON_NO_LEGEND:
                        arg_legend = false;
                        break;
 
                OPTION_COMMON_NO_ASK_PASSWORD:
                        arg_ask_password = false;
                        break;
 
                OPTION_COMMON_INTROSPECT_CLI:
                        return introspect_cli(arg_json_format_flags);
                }
 
        *remaining_args = option_parser_get_args(&opts);
        return 1;
}
 
static int run(int argc, char *argv[]) {
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        char **args = NULL;
        int r;
 
        COMPRESS_JOURNAL_NOTE;
 
        setlocale(LC_ALL, "");
        log_setup();
 
        r = parse_argv(argc, argv, &args);
        if (r <= 0)
                return r;
 
        journal_browse_prepare();
 
        r = bus_connect_transport(arg_transport, arg_host, RUNTIME_SCOPE_SYSTEM, &bus);
        if (r < 0)
                return bus_log_connect_error(r, arg_transport, RUNTIME_SCOPE_SYSTEM);
 
        (void) sd_bus_set_allow_interactive_authorization(bus, arg_ask_password);
 
        return dispatch_verb(args, bus);
}
 
DEFINE_MAIN_FUNCTION(run);