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

/* SPDX-License-Identifier: LGPL-2.1+ */
/***
  This file is part of systemd.

  Copyright 2011 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#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
	1	/* SPDX-License-Identifier: LGPL-2.1+ */
	2	/***
	3	This file is part of systemd.
	4
	5	Copyright 2011 Lennart Poettering
	6
	7	systemd is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU Lesser General Public License as published by
	9	the Free Software Foundation; either version 2.1 of the License, or
	10	(at your option) any later version.
	11
	12	systemd is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	Lesser General Public License for more details.
	16
	17	You should have received a copy of the GNU Lesser General Public License
	18	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	19	***/
	20
	21	#include <poll.h>
	22	#include <string.h>
	23
	24	#include "sd-login.h"
	25
	26	#include "alloc-util.h"
	27	#include "fd-util.h"
	28	#include "format-util.h"
	29	#include "log.h"
	30	#include "string-util.h"
	31	#include "strv.h"
	32	#include "util.h"
	33
	34	static char* format_uids(char *buf, uid_t uids, int count) {
	35	int pos = 0, k, inc;
	36	size_t size = (DECIMAL_STR_MAX(uid_t) + 1) * count + 1;
	37
	38	assert_se(*buf = malloc(size));
	39
	40	for (k = 0; k < count; k++) {
	41	sprintf(*buf + pos, "%s"UID_FMT"%n", k > 0 ? " " : "", uids[k], &inc);
	42	pos += inc;
	43	}
	44
	45	assert_se(pos < (ssize_t)size);
	46	(*buf)[pos] = '\0';
	47
	48	return *buf;
	49	}
	50
	51	static void test_login(void) {
	52	_cleanup_close_pair_ int pair[2] = { -1, -1 };
	53	_cleanup_free_ char pp = NULL, qq = NULL,
	54	display_session = NULL, cgroup = NULL,
	55	display = NULL, remote_user = NULL, *remote_host = NULL,
	56	type = NULL, class = NULL, state = NULL, state2 = NULL,
	57	seat = NULL, session = NULL,
	58	unit = NULL, user_unit = NULL, *slice = NULL;
	59	int r;
	60	uid_t u, u2;
	61	char t, seats, *sessions;
	62
	63	r = sd_pid_get_unit(0, &unit);
	64	assert_se(r >= 0 \|\| r == -ENODATA);
	65	log_info("sd_pid_get_unit(0, …) → \"%s\"", strna(unit));
	66
	67	r = sd_pid_get_user_unit(0, &user_unit);
	68	assert_se(r >= 0 \|\| r == -ENODATA);
	69	log_info("sd_pid_get_user_unit(0, …) → \"%s\"", strna(user_unit));
	70
	71	r = sd_pid_get_slice(0, &slice);
	72	assert_se(r >= 0 \|\| r == -ENODATA);
	73	log_info("sd_pid_get_slice(0, …) → \"%s\"", strna(slice));
	74
	75	r = sd_pid_get_session(0, &session);
	76	if (r < 0) {
	77	log_warning_errno(r, "sd_pid_get_session(0, …): %m");
	78	if (r == -ENODATA)
	79	log_info("Seems we are not running in a session, skipping some tests.");
	80	} else {
	81	log_info("sd_pid_get_session(0, …) → \"%s\"", session);
	82
	83	assert_se(sd_pid_get_owner_uid(0, &u2) == 0);
	84	log_info("sd_pid_get_owner_uid(0, …) → "UID_FMT, u2);
	85
	86	assert_se(sd_pid_get_cgroup(0, &cgroup) == 0);
	87	log_info("sd_pid_get_cgroup(0, …) → \"%s\"", cgroup);
	88
	89	r = sd_uid_get_display(u2, &display_session);
	90	assert_se(r >= 0 \|\| r == -ENODATA);
	91	log_info("sd_uid_get_display("UID_FMT", …) → \"%s\"",
	92	u2, strnull(display_session));
	93
	94	assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == 0);
	95	sd_peer_get_session(pair[0], &pp);
	96	sd_peer_get_session(pair[1], &qq);
	97	assert_se(streq_ptr(pp, qq));
	98
	99	r = sd_uid_get_sessions(u2, false, &sessions);
	100	assert_se(r >= 0);
	101	assert_se(r == (int) strv_length(sessions));
	102	assert_se(t = strv_join(sessions, " "));
	103	strv_free(sessions);
	104	log_info("sd_uid_get_sessions("UID_FMT", …) → [%i] \"%s\"", u2, r, t);
	105	free(t);
	106
	107	assert_se(r == sd_uid_get_sessions(u2, false, NULL));
	108
	109	r = sd_uid_get_seats(u2, false, &seats);
	110	assert_se(r >= 0);
	111	assert_se(r == (int) strv_length(seats));
	112	assert_se(t = strv_join(seats, " "));
	113	strv_free(seats);
	114	log_info("sd_uid_get_seats("UID_FMT", …) → [%i] \"%s\"", u2, r, t);
	115	free(t);
	116
	117	assert_se(r == sd_uid_get_seats(u2, false, NULL));
	118	}
	119
	120	if (session) {
	121	r = sd_session_is_active(session);
	122	assert_se(r >= 0);
	123	log_info("sd_session_is_active(\"%s\") → %s", session, yes_no(r));
	124
	125	r = sd_session_is_remote(session);
	126	assert_se(r >= 0);
	127	log_info("sd_session_is_remote(\"%s\") → %s", session, yes_no(r));
	128
	129	r = sd_session_get_state(session, &state);
	130	assert_se(r >= 0);
	131	log_info("sd_session_get_state(\"%s\") → \"%s\"", session, state);
	132
	133	assert_se(sd_session_get_uid(session, &u) >= 0);
	134	log_info("sd_session_get_uid(\"%s\") → "UID_FMT, session, u);
	135	assert_se(u == u2);
	136
	137	assert_se(sd_session_get_type(session, &type) >= 0);
	138	log_info("sd_session_get_type(\"%s\") → \"%s\"", session, type);
	139
	140	assert_se(sd_session_get_class(session, &class) >= 0);
	141	log_info("sd_session_get_class(\"%s\") → \"%s\"", session, class);
	142
	143	r = sd_session_get_display(session, &display);
	144	assert_se(r >= 0 \|\| r == -ENODATA);
	145	log_info("sd_session_get_display(\"%s\") → \"%s\"", session, strna(display));
	146
	147	r = sd_session_get_remote_user(session, &remote_user);
	148	assert_se(r >= 0 \|\| r == -ENODATA);
	149	log_info("sd_session_get_remote_user(\"%s\") → \"%s\"",
	150	session, strna(remote_user));
	151
	152	r = sd_session_get_remote_host(session, &remote_host);
	153	assert_se(r >= 0 \|\| r == -ENODATA);
	154	log_info("sd_session_get_remote_host(\"%s\") → \"%s\"",
	155	session, strna(remote_host));
	156
	157	r = sd_session_get_seat(session, &seat);
	158	if (r >= 0) {
	159	assert_se(seat);
	160
	161	log_info("sd_session_get_seat(\"%s\") → \"%s\"", session, seat);
	162
	163	r = sd_seat_can_multi_session(seat);
	164	assert_se(r >= 0);
	165	log_info("sd_session_can_multi_seat(\"%s\") → %s", seat, yes_no(r));
	166
	167	r = sd_seat_can_tty(seat);
	168	assert_se(r >= 0);
	169	log_info("sd_session_can_tty(\"%s\") → %s", seat, yes_no(r));
	170
	171	r = sd_seat_can_graphical(seat);
	172	assert_se(r >= 0);
	173	log_info("sd_session_can_graphical(\"%s\") → %s", seat, yes_no(r));
	174	} else {
	175	log_info_errno(r, "sd_session_get_seat(\"%s\"): %m", session);
	176	assert_se(r == -ENODATA);
	177	}
	178
	179	assert_se(sd_uid_get_state(u, &state2) >= 0);
	180	log_info("sd_uid_get_state("UID_FMT", …) → %s", u, state2);
	181	}
	182
	183	if (seat) {
	184	_cleanup_free_ char session2 = NULL, buf = NULL;
	185	_cleanup_free_ uid_t *uids = NULL;
	186	unsigned n;
	187
	188	assert_se(sd_uid_is_on_seat(u, 0, seat) > 0);
	189
	190	r = sd_seat_get_active(seat, &session2, &u2);
	191	assert_se(r >= 0);
	192	log_info("sd_seat_get_active(\"%s\", …) → \"%s\", "UID_FMT, seat, session2, u2);
	193
	194	r = sd_uid_is_on_seat(u, 1, seat);
	195	assert_se(r >= 0);
	196	assert_se(!!r == streq(session, session2));
	197
	198	r = sd_seat_get_sessions(seat, &sessions, &uids, &n);
	199	assert_se(r >= 0);
	200	assert_se(r == (int) strv_length(sessions));
	201	assert_se(t = strv_join(sessions, " "));
	202	strv_free(sessions);
	203	log_info("sd_seat_get_sessions(\"%s\", …) → %i, \"%s\", [%i] {%s}",
	204	seat, r, t, n, format_uids(&buf, uids, n));
	205	free(t);
	206
	207	assert_se(sd_seat_get_sessions(seat, NULL, NULL, NULL) == r);
	208	}
	209
	210	r = sd_get_seats(&seats);
	211	assert_se(r >= 0);
	212	assert_se(r == (int) strv_length(seats));
	213	assert_se(t = strv_join(seats, ", "));
	214	strv_free(seats);
	215	log_info("sd_get_seats(…) → [%i] \"%s\"", r, t);
	216	t = mfree(t);
	217
	218	assert_se(sd_get_seats(NULL) == r);
	219
	220	r = sd_seat_get_active(NULL, &t, NULL);
	221	assert_se(IN_SET(r, 0, -ENODATA));
	222	log_info("sd_seat_get_active(NULL, …) (active session on current seat) → %s", strnull(t));
	223	free(t);
	224
	225	r = sd_get_sessions(&sessions);
	226	assert_se(r >= 0);
	227	assert_se(r == (int) strv_length(sessions));
	228	assert_se(t = strv_join(sessions, ", "));
	229	strv_free(sessions);
	230	log_info("sd_get_sessions(…) → [%i] \"%s\"", r, t);
	231	free(t);
	232
	233	assert_se(sd_get_sessions(NULL) == r);
	234
	235	{
	236	_cleanup_free_ uid_t *uids = NULL;
	237	_cleanup_free_ char *buf = NULL;
	238
	239	r = sd_get_uids(&uids);
	240	assert_se(r >= 0);
	241	log_info("sd_get_uids(…) → [%i] {%s}", r, format_uids(&buf, uids, r));
	242
	243	assert_se(sd_get_uids(NULL) == r);
	244	}
	245
	246	{
	247	_cleanup_strv_free_ char **machines = NULL;
	248	_cleanup_free_ char *buf = NULL;
	249
	250	r = sd_get_machine_names(&machines);
	251	assert_se(r >= 0);
	252	assert_se(r == (int) strv_length(machines));
	253	assert_se(buf = strv_join(machines, " "));
	254	log_info("sd_get_machines(…) → [%i] \"%s\"", r, buf);
	255
	256	assert_se(sd_get_machine_names(NULL) == r);
	257	}
	258	}
	259
	260	static void test_monitor(void) {
	261	sd_login_monitor *m = NULL;
	262	unsigned n;
	263	int r;
	264
	265	r = sd_login_monitor_new("session", &m);
	266	assert_se(r >= 0);
	267
	268	for (n = 0; n < 5; n++) {
	269	struct pollfd pollfd = {};
	270	usec_t timeout, nw;
	271
	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,
	280	timeout == (uint64_t) -1 ? -1 :
	281	timeout > nw ? (int) ((timeout - nw) / 1000) :
	282	0);
	283
	284	assert_se(r >= 0);
	285
	286	sd_login_monitor_flush(m);
	287	printf("Wake!\n");
	288	}
	289
	290	sd_login_monitor_unref(m);
	291	}
	292
	293	int main(int argc, char* argv[]) {
	294	log_parse_environment();
	295	log_open();
	296
	297	log_info("/* Information printed is from the live system */");
	298
	299	test_login();
	300
	301	if (streq_ptr(argv[1], "-m"))
	302	test_monitor();
	303
	304	return 0;
	305	}