[thirdparty/systemd.git] / src / libsystemd / sd-login / test-login.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <poll.h>

#include "sd-login.h"

#include "alloc-util.h"
#include "errno-list.h"
#include "fd-util.h"
#include "format-util.h"
#include "log.h"
#include "string-util.h"
#include "strv.h"
#include "time-util.h"
#include "user-util.h"

static char* format_uids(char **buf, uid_t* uids, int count) {
        int pos = 0, inc;
        size_t size = (DECIMAL_STR_MAX(uid_t) + 1) * count + 1;

        assert_se(*buf = malloc(size));

        for (int k = 0; k < count; k++) {
                sprintf(*buf + pos, "%s"UID_FMT"%n", k > 0 ? " " : "", uids[k], &inc);
                pos += inc;
        }

        assert_se(pos < (ssize_t)size);
        (*buf)[pos] = '\0';

        return *buf;
}

static const char *e(int r) {
        return r == 0 ? "OK" : errno_to_name(r);
}

static void test_login(void) {
        _cleanup_close_pair_ int pair[2] = { -1, -1 };
        _cleanup_free_ char *pp = NULL, *qq = NULL,
                *display_session = NULL, *cgroup = NULL,
                *display = NULL, *remote_user = NULL, *remote_host = NULL,
                *type = NULL, *class = NULL, *state = NULL, *state2 = NULL,
                *seat = NULL, *session = NULL,
                *unit = NULL, *user_unit = NULL, *slice = NULL;
        int r;
        uid_t u, u2 = UID_INVALID;
        char *t, **seats = NULL, **sessions = NULL;

        r = sd_pid_get_unit(0, &unit);
        log_info("sd_pid_get_unit(0, …) → %s / \"%s\"", e(r), strnull(unit));
        assert_se(IN_SET(r, 0, -ENODATA));

        r = sd_pid_get_user_unit(0, &user_unit);
        log_info("sd_pid_get_user_unit(0, …) → %s / \"%s\"", e(r), strnull(user_unit));
        assert_se(IN_SET(r, 0, -ENODATA));

        r = sd_pid_get_slice(0, &slice);
        log_info("sd_pid_get_slice(0, …) → %s / \"%s\"", e(r), strnull(slice));
        assert_se(IN_SET(r, 0, -ENODATA));

        r = sd_pid_get_owner_uid(0, &u2);
        log_info("sd_pid_get_owner_uid(0, …) → %s / "UID_FMT, e(r), u2);
        assert_se(IN_SET(r, 0, -ENODATA));

        r = sd_pid_get_session(0, &session);
        log_info("sd_pid_get_session(0, …) → %s / \"%s\"", e(r), strnull(session));

        r = sd_pid_get_cgroup(0, &cgroup);
        log_info("sd_pid_get_cgroup(0, …) → %s / \"%s\"", e(r), strnull(cgroup));
        assert_se(IN_SET(r, 0, -ENOMEDIUM));

        r = sd_uid_get_display(u2, &display_session);
        log_info("sd_uid_get_display("UID_FMT", …) → %s / \"%s\"", u2, e(r), strnull(display_session));
        if (u2 == UID_INVALID)
                assert_se(r == -EINVAL);
        else
                assert_se(IN_SET(r, 0, -ENODATA));

        assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == 0);
        sd_peer_get_session(pair[0], &pp);
        sd_peer_get_session(pair[1], &qq);
        assert_se(streq_ptr(pp, qq));

        r = sd_uid_get_sessions(u2, false, &sessions);
        assert_se(t = strv_join(sessions, " "));
        log_info("sd_uid_get_sessions("UID_FMT", …) → %s \"%s\"", u2, e(r), t);
        if (u2 == UID_INVALID)
                assert_se(r == -EINVAL);
        else {
                assert_se(r >= 0);
                assert_se(r == (int) strv_length(sessions));
        }
        sessions = strv_free(sessions);
        free(t);

        assert_se(r == sd_uid_get_sessions(u2, false, NULL));

        r = sd_uid_get_seats(u2, false, &seats);
        assert_se(t = strv_join(seats, " "));
        log_info("sd_uid_get_seats("UID_FMT", …) → %s \"%s\"", u2, e(r), t);
        if (u2 == UID_INVALID)
                assert_se(r == -EINVAL);
        else {
                assert_se(r >= 0);
                assert_se(r == (int) strv_length(seats));
        }
        seats = strv_free(seats);
        free(t);

        assert_se(r == sd_uid_get_seats(u2, false, NULL));

        if (session) {
                r = sd_session_is_active(session);
                if (r == -ENXIO)
                        log_notice("sd_session_is_active() failed with ENXIO, it seems logind is not running.");
                else {
                        /* All those tests will fail with ENXIO, so let's skip them. */

                        assert_se(r >= 0);
                        log_info("sd_session_is_active(\"%s\") → %s", session, yes_no(r));

                        r = sd_session_is_remote(session);
                        assert_se(r >= 0);
                        log_info("sd_session_is_remote(\"%s\") → %s", session, yes_no(r));

                        r = sd_session_get_state(session, &state);
                        assert_se(r == 0);
                        log_info("sd_session_get_state(\"%s\") → \"%s\"", session, state);

                        assert_se(sd_session_get_uid(session, &u) >= 0);
                        log_info("sd_session_get_uid(\"%s\") → "UID_FMT, session, u);
                        assert_se(u == u2);

                        assert_se(sd_session_get_type(session, &type) >= 0);
                        log_info("sd_session_get_type(\"%s\") → \"%s\"", session, type);

                        assert_se(sd_session_get_class(session, &class) >= 0);
                        log_info("sd_session_get_class(\"%s\") → \"%s\"", session, class);

                        r = sd_session_get_display(session, &display);
                        assert_se(IN_SET(r, 0, -ENODATA));
                        log_info("sd_session_get_display(\"%s\") → \"%s\"", session, strna(display));

                        r = sd_session_get_remote_user(session, &remote_user);
                        assert_se(IN_SET(r, 0, -ENODATA));
                        log_info("sd_session_get_remote_user(\"%s\") → \"%s\"",
                                 session, strna(remote_user));

                        r = sd_session_get_remote_host(session, &remote_host);
                        assert_se(IN_SET(r, 0, -ENODATA));
                        log_info("sd_session_get_remote_host(\"%s\") → \"%s\"",
                                 session, strna(remote_host));

                        r = sd_session_get_seat(session, &seat);
                        if (r >= 0) {
                                assert_se(seat);

                                log_info("sd_session_get_seat(\"%s\") → \"%s\"", session, seat);

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
                                r = sd_seat_can_multi_session(seat);
#pragma GCC diagnostic pop
                                assert_se(r == 1);
                                log_info("sd_session_can_multi_seat(\"%s\") → %s", seat, yes_no(r));

                                r = sd_seat_can_tty(seat);
                                assert_se(r >= 0);
                                log_info("sd_session_can_tty(\"%s\") → %s", seat, yes_no(r));

                                r = sd_seat_can_graphical(seat);
                                assert_se(r >= 0);
                                log_info("sd_session_can_graphical(\"%s\") → %s", seat, yes_no(r));
                        } else {
                                log_info_errno(r, "sd_session_get_seat(\"%s\"): %m", session);
                                assert_se(r == -ENODATA);
                        }

                        assert_se(sd_uid_get_state(u, &state2) == 0);
                        log_info("sd_uid_get_state("UID_FMT", …) → %s", u, state2);
                }
        }

        if (seat) {
                _cleanup_free_ char *session2 = NULL, *buf = NULL;
                _cleanup_free_ uid_t *uids = NULL;
                unsigned n;

                assert_se(sd_uid_is_on_seat(u, 0, seat) > 0);

                r = sd_seat_get_active(seat, &session2, &u2);
                assert_se(r == 0);
                log_info("sd_seat_get_active(\"%s\", …) → \"%s\", "UID_FMT, seat, session2, u2);

                r = sd_uid_is_on_seat(u, 1, seat);
                assert_se(IN_SET(r, 0, 1));
                assert_se(!!r == streq(session, session2));

                r = sd_seat_get_sessions(seat, &sessions, &uids, &n);
                assert_se(r >= 0);
                assert_se(r == (int) strv_length(sessions));
                assert_se(t = strv_join(sessions, " "));
                strv_free(sessions);
                log_info("sd_seat_get_sessions(\"%s\", …) → %s, \"%s\", [%u] {%s}",
                         seat, e(r), t, n, format_uids(&buf, uids, n));
                free(t);

                assert_se(sd_seat_get_sessions(seat, NULL, NULL, NULL) == r);
        }

        r = sd_get_seats(&seats);
        assert_se(r >= 0);
        assert_se(r == (int) strv_length(seats));
        assert_se(t = strv_join(seats, ", "));
        strv_free(seats);
        log_info("sd_get_seats(…) → [%i] \"%s\"", r, t);
        t = mfree(t);

        assert_se(sd_get_seats(NULL) == r);

        r = sd_seat_get_active(NULL, &t, NULL);
        assert_se(IN_SET(r, 0, -ENODATA, -ENXIO));
        log_info("sd_seat_get_active(NULL, …) (active session on current seat) → %s / \"%s\"", e(r), strnull(t));
        free(t);

        r = sd_get_sessions(&sessions);
        assert_se(r >= 0);
        assert_se(r == (int) strv_length(sessions));
        assert_se(t = strv_join(sessions, ", "));
        strv_free(sessions);
        log_info("sd_get_sessions(…) → [%i] \"%s\"", r, t);
        free(t);

        assert_se(sd_get_sessions(NULL) == r);

        {
                _cleanup_free_ uid_t *uids = NULL;
                _cleanup_free_ char *buf = NULL;

                r = sd_get_uids(&uids);
                assert_se(r >= 0);
                log_info("sd_get_uids(…) → [%i] {%s}", r, format_uids(&buf, uids, r));

                assert_se(sd_get_uids(NULL) == r);
        }

        {
                _cleanup_strv_free_ char **machines = NULL;
                _cleanup_free_ char *buf = NULL;

                r = sd_get_machine_names(&machines);
                assert_se(r >= 0);
                assert_se(r == (int) strv_length(machines));
                assert_se(buf = strv_join(machines, " "));
                log_info("sd_get_machines(…) → [%i] \"%s\"", r, buf);

                assert_se(sd_get_machine_names(NULL) == r);
        }
}

static void test_monitor(void) {
        sd_login_monitor *m = NULL;
        int r;

        assert_se(sd_login_monitor_new("session", &m) == 0);

        for (unsigned n = 0; n < 5; n++) {
                struct pollfd pollfd = {};
                usec_t timeout, nw;

                assert_se((pollfd.fd = sd_login_monitor_get_fd(m)) >= 0);
                assert_se((pollfd.events = sd_login_monitor_get_events(m)) >= 0);

                assert_se(sd_login_monitor_get_timeout(m, &timeout) >= 0);

                nw = now(CLOCK_MONOTONIC);

                r = poll(&pollfd, 1,
                         timeout == UINT64_MAX ? -1 :
                         timeout > nw ? (int) ((timeout - nw) / 1000) :
                         0);

                assert_se(r >= 0);

                sd_login_monitor_flush(m);
                printf("Wake!\n");
        }

        sd_login_monitor_unref(m);
}

int main(int argc, char* argv[]) {
        log_parse_environment();
        log_open();

        log_info("/* Information printed is from the live system */");

        test_login();

        if (streq_ptr(argv[1], "-m"))
                test_monitor();

        return 0;
}
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
74b91131	2
0a6f50c0	3	#include <poll.h>
034a2a52	4
07630cea	5	#include "sd-login.h"
81527be1	6
b5efdb8a	7	#include "alloc-util.h"
1b5b507c	8	#include "errno-list.h"
3ffd4af2	9	#include "fd-util.h"
f97b34a6	10	#include "format-util.h"
ce737f46	11	#include "log.h"
07630cea LP	12	#include "string-util.h"
07630cea LP	13	#include "strv.h"
ca78ad1d	14	#include "time-util.h"
1b5b507c	15	#include "user-util.h"
74b91131	16
ce737f46	17	static char* format_uids(char *buf, uid_t uids, int count) {
1b5b507c	18	int pos = 0, inc;
ce737f46 ZJS	19	size_t size = (DECIMAL_STR_MAX(uid_t) + 1) * count + 1;
	20
	21	assert_se(*buf = malloc(size));
	22
1b5b507c	23	for (int k = 0; k < count; k++) {
ce737f46 ZJS	24	sprintf(*buf + pos, "%s"UID_FMT"%n", k > 0 ? " " : "", uids[k], &inc);
	25	pos += inc;
	26	}
	27
0bf7d7cc	28	assert_se(pos < (ssize_t)size);
ce737f46 ZJS	29	(*buf)[pos] = '\0';
	30
	31	return *buf;
	32	}
	33
1b5b507c ZJS	34	static const char *e(int r) {
	35	return r == 0 ? "OK" : errno_to_name(r);
	36	}
	37
e9e506ed	38	static void test_login(void) {
3d94f76c	39	_cleanup_close_pair_ int pair[2] = { -1, -1 };
ce737f46 ZJS	40	_cleanup_free_ char pp = NULL, qq = NULL,
	41	display_session = NULL, cgroup = NULL,
	42	display = NULL, remote_user = NULL, *remote_host = NULL,
	43	type = NULL, class = NULL, state = NULL, state2 = NULL,
	44	seat = NULL, session = NULL,
	45	unit = NULL, user_unit = NULL, *slice = NULL;
e6f44233	46	int r;
1b5b507c ZJS	47	uid_t u, u2 = UID_INVALID;
1b5b507c ZJS	48	char t, seats = NULL, *sessions = NULL;
74b91131	49
171f8f59	50	r = sd_pid_get_unit(0, &unit);
1b5b507c ZJS	51	log_info("sd_pid_get_unit(0, …) → %s / \"%s\"", e(r), strnull(unit));
1b5b507c ZJS	52	assert_se(IN_SET(r, 0, -ENODATA));
74b91131	53
ce737f46	54	r = sd_pid_get_user_unit(0, &user_unit);
1b5b507c ZJS	55	log_info("sd_pid_get_user_unit(0, …) → %s / \"%s\"", e(r), strnull(user_unit));
1b5b507c ZJS	56	assert_se(IN_SET(r, 0, -ENODATA));
034a2a52	57
bc9e9af1	58	r = sd_pid_get_slice(0, &slice);
1b5b507c ZJS	59	log_info("sd_pid_get_slice(0, …) → %s / \"%s\"", e(r), strnull(slice));
	60	assert_se(IN_SET(r, 0, -ENODATA));
	61
	62	r = sd_pid_get_owner_uid(0, &u2);
	63	log_info("sd_pid_get_owner_uid(0, …) → %s / "UID_FMT, e(r), u2);
	64	assert_se(IN_SET(r, 0, -ENODATA));
f5aaf575	65
ce737f46	66	r = sd_pid_get_session(0, &session);
1b5b507c ZJS	67	log_info("sd_pid_get_session(0, …) → %s / \"%s\"", e(r), strnull(session));
	68
	69	r = sd_pid_get_cgroup(0, &cgroup);
	70	log_info("sd_pid_get_cgroup(0, …) → %s / \"%s\"", e(r), strnull(cgroup));
352ab9d7	71	assert_se(IN_SET(r, 0, -ENOMEDIUM));
1b5b507c ZJS	72
	73	r = sd_uid_get_display(u2, &display_session);
	74	log_info("sd_uid_get_display("UID_FMT", …) → %s / \"%s\"", u2, e(r), strnull(display_session));
	75	if (u2 == UID_INVALID)
	76	assert_se(r == -EINVAL);
	77	else
	78	assert_se(IN_SET(r, 0, -ENODATA));
	79
	80	assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == 0);
	81	sd_peer_get_session(pair[0], &pp);
	82	sd_peer_get_session(pair[1], &qq);
	83	assert_se(streq_ptr(pp, qq));
	84
	85	r = sd_uid_get_sessions(u2, false, &sessions);
	86	assert_se(t = strv_join(sessions, " "));
	87	log_info("sd_uid_get_sessions("UID_FMT", …) → %s \"%s\"", u2, e(r), t);
	88	if (u2 == UID_INVALID)
	89	assert_se(r == -EINVAL);
	90	else {
ce737f46 ZJS	91	assert_se(r >= 0);
ce737f46 ZJS	92	assert_se(r == (int) strv_length(sessions));
1b5b507c ZJS	93	}
	94	sessions = strv_free(sessions);
	95	free(t);
d60ef526	96
1b5b507c	97	assert_se(r == sd_uid_get_sessions(u2, false, NULL));
74b91131	98
1b5b507c ZJS	99	r = sd_uid_get_seats(u2, false, &seats);
	100	assert_se(t = strv_join(seats, " "));
	101	log_info("sd_uid_get_seats("UID_FMT", …) → %s \"%s\"", u2, e(r), t);
	102	if (u2 == UID_INVALID)
	103	assert_se(r == -EINVAL);
	104	else {
ce737f46 ZJS	105	assert_se(r >= 0);
ce737f46 ZJS	106	assert_se(r == (int) strv_length(seats));
ce737f46	107	}
1b5b507c ZJS	108	seats = strv_free(seats);
	109	free(t);
	110
	111	assert_se(r == sd_uid_get_seats(u2, false, NULL));
0604381b	112
ce737f46 ZJS	113	if (session) {
ce737f46 ZJS	114	r = sd_session_is_active(session);
ac564463 ZJS	115	if (r == -ENXIO)
	116	log_notice("sd_session_is_active() failed with ENXIO, it seems logind is not running.");
	117	else {
	118	/* All those tests will fail with ENXIO, so let's skip them. */
74b91131	119
ac564463 ZJS	120	assert_se(r >= 0);
ac564463 ZJS	121	log_info("sd_session_is_active(\"%s\") → %s", session, yes_no(r));
51f58f08	122
ac564463 ZJS	123	r = sd_session_is_remote(session);
	124	assert_se(r >= 0);
	125	log_info("sd_session_is_remote(\"%s\") → %s", session, yes_no(r));
51f58f08	126
ac564463 ZJS	127	r = sd_session_get_state(session, &state);
	128	assert_se(r == 0);
	129	log_info("sd_session_get_state(\"%s\") → \"%s\"", session, state);
fc8af9ff	130
ac564463 ZJS	131	assert_se(sd_session_get_uid(session, &u) >= 0);
	132	log_info("sd_session_get_uid(\"%s\") → "UID_FMT, session, u);
	133	assert_se(u == u2);
5b04fe60	134
ac564463 ZJS	135	assert_se(sd_session_get_type(session, &type) >= 0);
ac564463 ZJS	136	log_info("sd_session_get_type(\"%s\") → \"%s\"", session, type);
5b04fe60	137
ac564463 ZJS	138	assert_se(sd_session_get_class(session, &class) >= 0);
ac564463 ZJS	139	log_info("sd_session_get_class(\"%s\") → \"%s\"", session, class);
74b91131	140
ac564463 ZJS	141	r = sd_session_get_display(session, &display);
	142	assert_se(IN_SET(r, 0, -ENODATA));
	143	log_info("sd_session_get_display(\"%s\") → \"%s\"", session, strna(display));
add30678	144
ac564463 ZJS	145	r = sd_session_get_remote_user(session, &remote_user);
	146	assert_se(IN_SET(r, 0, -ENODATA));
	147	log_info("sd_session_get_remote_user(\"%s\") → \"%s\"",
	148	session, strna(remote_user));
20747498	149
ac564463 ZJS	150	r = sd_session_get_remote_host(session, &remote_host);
	151	assert_se(IN_SET(r, 0, -ENODATA));
	152	log_info("sd_session_get_remote_host(\"%s\") → \"%s\"",
	153	session, strna(remote_host));
20747498	154
ac564463 ZJS	155	r = sd_session_get_seat(session, &seat);
	156	if (r >= 0) {
	157	assert_se(seat);
	158
	159	log_info("sd_session_get_seat(\"%s\") → \"%s\"", session, seat);
74b91131	160
8f8cc84b ZJS	161	#pragma GCC diagnostic push
8f8cc84b ZJS	162	#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
ac564463	163	r = sd_seat_can_multi_session(seat);
8f8cc84b	164	#pragma GCC diagnostic pop
ac564463 ZJS	165	assert_se(r == 1);
	166	log_info("sd_session_can_multi_seat(\"%s\") → %s", seat, yes_no(r));
	167
	168	r = sd_seat_can_tty(seat);
	169	assert_se(r >= 0);
	170	log_info("sd_session_can_tty(\"%s\") → %s", seat, yes_no(r));
	171
	172	r = sd_seat_can_graphical(seat);
	173	assert_se(r >= 0);
	174	log_info("sd_session_can_graphical(\"%s\") → %s", seat, yes_no(r));
	175	} else {
	176	log_info_errno(r, "sd_session_get_seat(\"%s\"): %m", session);
	177	assert_se(r == -ENODATA);
	178	}
	179
	180	assert_se(sd_uid_get_state(u, &state2) == 0);
	181	log_info("sd_uid_get_state("UID_FMT", …) → %s", u, state2);
ce737f46	182	}
ce737f46 ZJS	183	}
	184
	185	if (seat) {
	186	_cleanup_free_ char session2 = NULL, buf = NULL;
	187	_cleanup_free_ uid_t *uids = NULL;
	188	unsigned n;
	189
	190	assert_se(sd_uid_is_on_seat(u, 0, seat) > 0);
034a2a52	191
e6f44233	192	r = sd_seat_get_active(seat, &session2, &u2);
1b5b507c	193	assert_se(r == 0);
ce737f46 ZJS	194	log_info("sd_seat_get_active(\"%s\", …) → \"%s\", "UID_FMT, seat, session2, u2);
ce737f46 ZJS	195
e6f44233	196	r = sd_uid_is_on_seat(u, 1, seat);
1b5b507c	197	assert_se(IN_SET(r, 0, 1));
e6f44233 AJ	198	assert_se(!!r == streq(session, session2));
e6f44233 AJ	199
ce737f46 ZJS	200	r = sd_seat_get_sessions(seat, &sessions, &uids, &n);
	201	assert_se(r >= 0);
	202	assert_se(r == (int) strv_length(sessions));
	203	assert_se(t = strv_join(sessions, " "));
	204	strv_free(sessions);
1b5b507c ZJS	205	log_info("sd_seat_get_sessions(\"%s\", …) → %s, \"%s\", [%u] {%s}",
1b5b507c ZJS	206	seat, e(r), t, n, format_uids(&buf, uids, n));
ce737f46 ZJS	207	free(t);
	208
	209	assert_se(sd_seat_get_sessions(seat, NULL, NULL, NULL) == r);
	210	}
74b91131	211
d60ef526 LP	212	r = sd_get_seats(&seats);
	213	assert_se(r >= 0);
	214	assert_se(r == (int) strv_length(seats));
034a2a52 LP	215	assert_se(t = strv_join(seats, ", "));
034a2a52 LP	216	strv_free(seats);
ce737f46 ZJS	217	log_info("sd_get_seats(…) → [%i] \"%s\"", r, t);
ce737f46 ZJS	218	t = mfree(t);
034a2a52	219
51f58f08 LP	220	assert_se(sd_get_seats(NULL) == r);
51f58f08 LP	221
50b1678a	222	r = sd_seat_get_active(NULL, &t, NULL);
ac564463	223	assert_se(IN_SET(r, 0, -ENODATA, -ENXIO));
1b5b507c	224	log_info("sd_seat_get_active(NULL, …) (active session on current seat) → %s / \"%s\"", e(r), strnull(t));
50b1678a LP	225	free(t);
50b1678a LP	226
d60ef526 LP	227	r = sd_get_sessions(&sessions);
	228	assert_se(r >= 0);
	229	assert_se(r == (int) strv_length(sessions));
034a2a52 LP	230	assert_se(t = strv_join(sessions, ", "));
034a2a52 LP	231	strv_free(sessions);
ce737f46	232	log_info("sd_get_sessions(…) → [%i] \"%s\"", r, t);
034a2a52 LP	233	free(t);
034a2a52 LP	234
d60ef526 LP	235	assert_se(sd_get_sessions(NULL) == r);
d60ef526 LP	236
ce737f46 ZJS	237	{
	238	_cleanup_free_ uid_t *uids = NULL;
	239	_cleanup_free_ char *buf = NULL;
	240
	241	r = sd_get_uids(&uids);
	242	assert_se(r >= 0);
	243	log_info("sd_get_uids(…) → [%i] {%s}", r, format_uids(&buf, uids, r));
034a2a52	244
ce737f46 ZJS	245	assert_se(sd_get_uids(NULL) == r);
ce737f46 ZJS	246	}
034a2a52	247
ce737f46 ZJS	248	{
	249	_cleanup_strv_free_ char **machines = NULL;
	250	_cleanup_free_ char *buf = NULL;
d60ef526	251
ce737f46 ZJS	252	r = sd_get_machine_names(&machines);
	253	assert_se(r >= 0);
	254	assert_se(r == (int) strv_length(machines));
	255	assert_se(buf = strv_join(machines, " "));
ce737f46	256	log_info("sd_get_machines(…) → [%i] \"%s\"", r, buf);
76ed21e1 YW	257
76ed21e1 YW	258	assert_se(sd_get_machine_names(NULL) == r);
ce737f46 ZJS	259	}
	260	}
	261
	262	static void test_monitor(void) {
	263	sd_login_monitor *m = NULL;
ce737f46	264	int r;
034a2a52	265
1b5b507c	266	assert_se(sd_login_monitor_new("session", &m) == 0);
034a2a52	267
1b5b507c	268	for (unsigned n = 0; n < 5; n++) {
ce737f46	269	struct pollfd pollfd = {};
667c24a6 LP	270	usec_t timeout, nw;
667c24a6 LP	271
667c24a6 LP	272	assert_se((pollfd.fd = sd_login_monitor_get_fd(m)) >= 0);
	273	assert_se((pollfd.events = sd_login_monitor_get_events(m)) >= 0);
	274
	275	assert_se(sd_login_monitor_get_timeout(m, &timeout) >= 0);
	276
	277	nw = now(CLOCK_MONOTONIC);
	278
	279	r = poll(&pollfd, 1,
f5fbe71d	280	timeout == UINT64_MAX ? -1 :
667c24a6 LP	281	timeout > nw ? (int) ((timeout - nw) / 1000) :
	282	0);
	283
b9b2b042	284	assert_se(r >= 0);
034a2a52	285
b9b2b042 LP	286	sd_login_monitor_flush(m);
	287	printf("Wake!\n");
	288	}
034a2a52	289
b9b2b042	290	sd_login_monitor_unref(m);
e9e506ed ZJS	291	}
	292
	293	int main(int argc, char* argv[]) {
	294	log_parse_environment();
	295	log_open();
	296
ce737f46 ZJS	297	log_info("/* Information printed is from the live system */");
ce737f46 ZJS	298
e9e506ed	299	test_login();
034a2a52	300
ce737f46 ZJS	301	if (streq_ptr(argv[1], "-m"))
	302	test_monitor();
	303
74b91131 LP	304	return 0;
74b91131 LP	305	}