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

/* SPDX-License-Identifier: LGPL-2.1+ */
/***
***/

#include <poll.h>
#include <string.h>

#include "sd-login.h"

#include "alloc-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "log.h"
#include "string-util.h"
#include "strv.h"
#include "util.h"

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

        assert_se(*buf = malloc(size));

        for (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 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;
        char *t, **seats, **sessions;

        r = sd_pid_get_unit(0, &unit);
        assert_se(r >= 0 || r == -ENODATA);
        log_info("sd_pid_get_unit(0, …) → \"%s\"", strna(unit));

        r = sd_pid_get_user_unit(0, &user_unit);
        assert_se(r >= 0 || r == -ENODATA);
        log_info("sd_pid_get_user_unit(0, …) → \"%s\"", strna(user_unit));

        r = sd_pid_get_slice(0, &slice);
        assert_se(r >= 0 || r == -ENODATA);
        log_info("sd_pid_get_slice(0, …) → \"%s\"", strna(slice));

        r = sd_pid_get_session(0, &session);
        if (r < 0) {
                log_warning_errno(r, "sd_pid_get_session(0, …): %m");
                if (r == -ENODATA)
                        log_info("Seems we are not running in a session, skipping some tests.");
        } else {
                log_info("sd_pid_get_session(0, …) → \"%s\"", session);

                assert_se(sd_pid_get_owner_uid(0, &u2) == 0);
                log_info("sd_pid_get_owner_uid(0, …) → "UID_FMT, u2);

                assert_se(sd_pid_get_cgroup(0, &cgroup) == 0);
                log_info("sd_pid_get_cgroup(0, …) → \"%s\"", cgroup);

                r = sd_uid_get_display(u2, &display_session);
                assert_se(r >= 0 || r == -ENODATA);
                log_info("sd_uid_get_display("UID_FMT", …) → \"%s\"",
                         u2, strnull(display_session));

                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(r >= 0);
                assert_se(r == (int) strv_length(sessions));
                assert_se(t = strv_join(sessions, " "));
                strv_free(sessions);
                log_info("sd_uid_get_sessions("UID_FMT", …) → [%i] \"%s\"", u2, r, t);
                free(t);

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

                r = sd_uid_get_seats(u2, false, &seats);
                assert_se(r >= 0);
                assert_se(r == (int) strv_length(seats));
                assert_se(t = strv_join(seats, " "));
                strv_free(seats);
                log_info("sd_uid_get_seats("UID_FMT", …) → [%i] \"%s\"", u2, r, t);
                free(t);

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

        if (session) {
                r = sd_session_is_active(session);
                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(r >= 0 || r == -ENODATA);
                log_info("sd_session_get_display(\"%s\") → \"%s\"", session, strna(display));

                r = sd_session_get_remote_user(session, &remote_user);
                assert_se(r >= 0 || r == -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(r >= 0 || r == -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);

                        r = sd_seat_can_multi_session(seat);
                        assert_se(r >= 0);
                        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(r >= 0);
                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\", …) → %i, \"%s\", [%i] {%s}",
                         seat, 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));
        log_info("sd_seat_get_active(NULL, …) (active session on current seat) → %s", 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;
        unsigned n;
        int r;

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

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