[thirdparty/systemd.git] / src / libsystemd-terminal / evcat.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com>

  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/>.
***/

/*
 * Event Catenation
 * The evcat tool catenates input events of all requested devices and prints
 * them to standard-output. It's only meant for debugging of input-related
 * problems.
 */

#include <assert.h>
#include <errno.h>
#include <getopt.h>
#include <libevdev/libevdev.h>
#include <linux/kd.h>
#include <linux/vt.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <systemd/sd-bus.h>
#include <systemd/sd-event.h>
#include <systemd/sd-login.h>
#include <termios.h>
#include <unistd.h>
#include <xkbcommon/xkbcommon.h>
#include "build.h"
#include "bus-util.h"
#include "event-util.h"
#include "idev.h"
#include "macro.h"
#include "sysview.h"
#include "term-internal.h"
#include "util.h"

typedef struct Evcat Evcat;

struct Evcat {
        char *session;
        char *seat;
        sd_event *event;
        sd_bus *bus;
        sysview_context *sysview;
        idev_context *idev;
        idev_session *idev_session;

        bool managed : 1;
};

static Evcat *evcat_free(Evcat *e) {
        if (!e)
                return NULL;

        e->idev_session = idev_session_free(e->idev_session);
        e->idev = idev_context_unref(e->idev);
        e->sysview = sysview_context_free(e->sysview);
        e->bus = sd_bus_unref(e->bus);
        e->event = sd_event_unref(e->event);
        free(e->seat);
        free(e->session);
        free(e);

        tcflush(0, TCIOFLUSH);

        return NULL;
}

DEFINE_TRIVIAL_CLEANUP_FUNC(Evcat*, evcat_free);

static bool is_managed(const char *session) {
        unsigned int vtnr;
        struct stat st;
        long mode;
        int r;

        /* Using logind's Controller API is highly fragile if there is already
         * a session controller running. If it is registered as controller
         * itself, TakeControl will simply fail. But if its a legacy controller
         * that does not use logind's controller API, we must never register
         * our own controller. Otherwise, we really mess up the VT. Therefore,
         * only run in managed mode if there's no-one else. */

        if (geteuid() == 0)
                return false;

        if (!isatty(1))
                return false;

        if (!session)
                return false;

        r = sd_session_get_vt(session, &vtnr);
        if (r < 0 || vtnr < 1 || vtnr > 63)
                return false;

        mode = 0;
        r = ioctl(1, KDGETMODE, &mode);
        if (r < 0 || mode != KD_TEXT)
                return false;

        r = fstat(1, &st);
        if (r < 0 || minor(st.st_rdev) != vtnr)
                return false;

        return true;
}

static int evcat_new(Evcat **out) {
        _cleanup_(evcat_freep) Evcat *e = NULL;
        int r;

        assert(out);

        e = new0(Evcat, 1);
        if (!e)
                return log_oom();

        r = sd_pid_get_session(getpid(), &e->session);
        if (r < 0)
                return log_error_errno(r, "Cannot retrieve logind session: %m");

        r = sd_session_get_seat(e->session, &e->seat);
        if (r < 0)
                return log_error_errno(r, "Cannot retrieve seat of logind session: %m");

        e->managed = is_managed(e->session);

        r = sd_event_default(&e->event);
        if (r < 0)
                return r;

        r = sd_bus_open_system(&e->bus);
        if (r < 0)
                return r;

        r = sd_bus_attach_event(e->bus, e->event, SD_EVENT_PRIORITY_NORMAL);
        if (r < 0)
                return r;

        r = sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1);
        if (r < 0)
                return r;

        r = sd_event_add_signal(e->event, NULL, SIGTERM, NULL, NULL);
        if (r < 0)
                return r;

        r = sd_event_add_signal(e->event, NULL, SIGINT, NULL, NULL);
        if (r < 0)
                return r;

        r = sysview_context_new(&e->sysview,
                                SYSVIEW_CONTEXT_SCAN_LOGIND |
                                SYSVIEW_CONTEXT_SCAN_EVDEV,
                                e->event,
                                e->bus,
                                NULL);
        if (r < 0)
                return r;

        r = idev_context_new(&e->idev, e->event, e->bus);
        if (r < 0)
                return r;

        *out = e;
        e = NULL;
        return 0;
}

static void kdata_print(idev_data *data) {
        idev_data_keyboard *k = &data->keyboard;
        char buf[128];
        uint32_t i, c;
        int cwidth;

        /* Key-press state: UP/DOWN/REPEAT */
        printf(" %-6s", k->value == 0 ? "UP" :
                        k->value == 1 ? "DOWN" :
                        "REPEAT");

        /* Resync state */
        printf(" | %-6s", data->resync ? "RESYNC" : "");

        /* Keycode that triggered the event */
        printf(" | %5u", (unsigned)k->keycode);

        /* Well-known name of the keycode */
        printf(" | %-20s", libevdev_event_code_get_name(EV_KEY, k->keycode) ? : "<unknown>");

        /* Well-known modifiers */
        printf(" | %-5s", (k->mods & IDEV_KBDMOD_SHIFT) ? "SHIFT" : "");
        printf(" %-4s", (k->mods & IDEV_KBDMOD_CTRL) ? "CTRL" : "");
        printf(" %-3s", (k->mods & IDEV_KBDMOD_ALT) ? "ALT" : "");
        printf(" %-5s", (k->mods & IDEV_KBDMOD_LINUX) ? "LINUX" : "");
        printf(" %-4s", (k->mods & IDEV_KBDMOD_CAPS) ? "CAPS" : "");

        /* Consumed modifiers */
        printf(" | %-5s", (k->consumed_mods & IDEV_KBDMOD_SHIFT) ? "SHIFT" : "");
        printf(" %-4s", (k->consumed_mods & IDEV_KBDMOD_CTRL) ? "CTRL" : "");
        printf(" %-3s", (k->consumed_mods & IDEV_KBDMOD_ALT) ? "ALT" : "");
        printf(" %-5s", (k->consumed_mods & IDEV_KBDMOD_LINUX) ? "LINUX" : "");
        printf(" %-4s", (k->consumed_mods & IDEV_KBDMOD_CAPS) ? "CAPS" : "");

        /* Resolved symbols */
        printf(" |");
        for (i = 0; i < k->n_syms; ++i) {
                buf[0] = 0;
                xkb_keysym_get_name(k->keysyms[i], buf, sizeof(buf));

                if (is_locale_utf8()) {
                        c = k->codepoints[i];
                        if (c < 0x110000 && c > 0x20 && (c < 0x7f || c > 0x9f)) {
                                /* "%4lc" doesn't work well, so hard-code it */
                                cwidth = mk_wcwidth(c);
                                while (cwidth++ < 2)
                                        printf(" ");

                                printf(" '%lc':", (wchar_t)c);
                        } else {
                                printf("      ");
                        }
                }

                printf(" XKB_KEY_%-30s", buf);
        }

        printf("\n");
}

static bool kdata_is_exit(idev_data *data) {
        idev_data_keyboard *k = &data->keyboard;

        if (k->value != 1)
                return false;
        if (k->n_syms != 1)
                return false;

        return k->codepoints[0] == 'q';
}

static int evcat_idev_fn(idev_session *session, void *userdata, idev_event *ev) {
        Evcat *e = userdata;

        switch (ev->type) {
        case IDEV_EVENT_DEVICE_ADD:
                idev_device_enable(ev->device_add.device);
                break;
        case IDEV_EVENT_DEVICE_REMOVE:
                idev_device_disable(ev->device_remove.device);
                break;
        case IDEV_EVENT_DEVICE_DATA:
                switch (ev->device_data.data.type) {
                case IDEV_DATA_KEYBOARD:
                        if (kdata_is_exit(&ev->device_data.data))
                                sd_event_exit(e->event, 0);
                        else
                                kdata_print(&ev->device_data.data);

                        break;
                }

                break;
        }

        return 0;
}

static int evcat_sysview_fn(sysview_context *c, void *userdata, sysview_event *ev) {
        unsigned int flags, type;
        Evcat *e = userdata;
        sysview_device *d;
        const char *name;
        int r;

        switch (ev->type) {
        case SYSVIEW_EVENT_SESSION_FILTER:
                if (streq_ptr(e->session, ev->session_filter.id))
                        return 1;

                break;
        case SYSVIEW_EVENT_SESSION_ADD:
                assert(!e->idev_session);

                name = sysview_session_get_name(ev->session_add.session);
                flags = 0;

                if (e->managed)
                        flags |= IDEV_SESSION_MANAGED;

                r = idev_session_new(&e->idev_session,
                                     e->idev,
                                     flags,
                                     name,
                                     evcat_idev_fn,
                                     e);
                if (r < 0)
                        return log_error_errno(r, "Cannot create idev session: %m");

                if (e->managed) {
                        r = sysview_session_take_control(ev->session_add.session);
                        if (r < 0)
                                return log_error_errno(r, "Cannot request session control: %m");
                }

                idev_session_enable(e->idev_session);

                break;
        case SYSVIEW_EVENT_SESSION_REMOVE:
                idev_session_disable(e->idev_session);
                e->idev_session = idev_session_free(e->idev_session);
                if (sd_event_get_exit_code(e->event, &r) == -ENODATA)
                        sd_event_exit(e->event, 0);
                break;
        case SYSVIEW_EVENT_SESSION_ATTACH:
                d = ev->session_attach.device;
                type = sysview_device_get_type(d);
                if (type == SYSVIEW_DEVICE_EVDEV) {
                        r = idev_session_add_evdev(e->idev_session, sysview_device_get_ud(d));
                        if (r < 0)
                                return log_error_errno(r, "Cannot add evdev device to idev: %m");
                }

                break;
        case SYSVIEW_EVENT_SESSION_DETACH:
                d = ev->session_detach.device;
                type = sysview_device_get_type(d);
                if (type == SYSVIEW_DEVICE_EVDEV) {
                        r = idev_session_remove_evdev(e->idev_session, sysview_device_get_ud(d));
                        if (r < 0)
                                return log_error_errno(r, "Cannot remove evdev device from idev: %m");
                }

                break;
        case SYSVIEW_EVENT_SESSION_CONTROL:
                r = ev->session_control.error;
                if (r < 0)
                        return log_error_errno(r, "Cannot acquire session control: %m");

                r = ioctl(1, KDSKBMODE, K_UNICODE);
                if (r < 0)
                        return log_error_errno(errno, "Cannot set K_UNICODE on stdout: %m");

                r = ioctl(1, KDSETMODE, KD_TEXT);
                if (r < 0)
                        return log_error_errno(errno, "Cannot set KD_TEXT on stdout: %m");

                printf("\n");

                break;
        }

        return 0;
}

static int evcat_run(Evcat *e) {
        struct termios in_attr, saved_attr;
        int r;

        assert(e);

        if (!e->managed && geteuid() > 0)
                log_warning("You run in unmanaged mode without being root. This is likely to produce no output..");

        printf("evcat - Read and catenate events from selected input devices\n"
               "        Running on seat '%s' in user-session '%s'\n"
               "        Exit by pressing ^C or 'q'\n\n",
               e->seat ? : "seat0", e->session ? : "<none>");

        r = sysview_context_start(e->sysview, evcat_sysview_fn, e);
        if (r < 0)
                goto out;

        r = tcgetattr(0, &in_attr);
        if (r < 0) {
                r = -errno;
                goto out;
        }

        saved_attr = in_attr;
        in_attr.c_lflag &= ~ECHO;

        r = tcsetattr(0, TCSANOW, &in_attr);
        if (r < 0) {
                r = -errno;
                goto out;
        }

        r = sd_event_loop(e->event);
        tcsetattr(0, TCSANOW, &saved_attr);
        printf("exiting..\n");

out:
        sysview_context_stop(e->sysview);
        return r;
}

static int help(void) {
        printf("%s [OPTIONS...]\n\n"
               "Read and catenate events from selected input devices.\n\n"
               "  -h --help               Show this help\n"
               "     --version            Show package version\n"
               , program_invocation_short_name);

        return 0;
}

static int parse_argv(int argc, char *argv[]) {
        enum {
                ARG_VERSION = 0x100,
        };
        static const struct option options[] = {
                { "help",       no_argument,    NULL, 'h'               },
                { "version",    no_argument,    NULL, ARG_VERSION       },
                {},
        };
        int c;

        assert(argc >= 0);
        assert(argv);

        while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
                switch (c) {
                case 'h':
                        help();
                        return 0;

                case ARG_VERSION:
                        puts(PACKAGE_STRING);
                        puts(SYSTEMD_FEATURES);
                        return 0;

                case '?':
                        return -EINVAL;

                default:
                        assert_not_reached("Unhandled option");
                }

        if (argc > optind) {
                log_error("Too many arguments");
                return -EINVAL;
        }

        return 1;
}

int main(int argc, char *argv[]) {
        _cleanup_(evcat_freep) Evcat *e = NULL;
        int r;

        log_set_target(LOG_TARGET_AUTO);
        log_parse_environment();
        log_open();

        setlocale(LC_ALL, "");
        if (!is_locale_utf8())
                log_warning("Locale is not set to UTF-8. Codepoints will not be printed!");

        r = parse_argv(argc, argv);
        if (r <= 0)
                goto finish;

        r = evcat_new(&e);
        if (r < 0)
                goto finish;

        r = evcat_run(e);

finish:
        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
Commit	Line	Data
8e937190 DH	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com>
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	/*
	23	* Event Catenation
	24	* The evcat tool catenates input events of all requested devices and prints
	25	* them to standard-output. It's only meant for debugging of input-related
	26	* problems.
	27	*/
	28
	29	#include <assert.h>
	30	#include <errno.h>
	31	#include <getopt.h>
	32	#include <libevdev/libevdev.h>
	33	#include <linux/kd.h>
	34	#include <linux/vt.h>
	35	#include <stdarg.h>
	36	#include <stdbool.h>
	37	#include <stdio.h>
	38	#include <stdlib.h>
	39	#include <string.h>
	40	#include <sys/ioctl.h>
	41	#include <sys/stat.h>
	42	#include <systemd/sd-bus.h>
	43	#include <systemd/sd-event.h>
	44	#include <systemd/sd-login.h>
	45	#include <termios.h>
	46	#include <unistd.h>
	47	#include <xkbcommon/xkbcommon.h>
	48	#include "build.h"
	49	#include "bus-util.h"
	50	#include "event-util.h"
	51	#include "idev.h"
	52	#include "macro.h"
	53	#include "sysview.h"
	54	#include "term-internal.h"
	55	#include "util.h"
	56
	57	typedef struct Evcat Evcat;
	58
	59	struct Evcat {
	60	char *session;
	61	char *seat;
	62	sd_event *event;
	63	sd_bus *bus;
	64	sysview_context *sysview;
65	idev_context *idev;
66	idev_session *idev_session;
67
68	bool managed : 1;
69	};
70
71	static Evcat evcat_free(Evcat e) {
72	if (!e)
73	return NULL;
74
75	e->idev_session = idev_session_free(e->idev_session);
76	e->idev = idev_context_unref(e->idev);
77	e->sysview = sysview_context_free(e->sysview);
78	e->bus = sd_bus_unref(e->bus);
79	e->event = sd_event_unref(e->event);
80	free(e->seat);
81	free(e->session);
82	free(e);
83
84	tcflush(0, TCIOFLUSH);
85
86	return NULL;
87	}
88
89	DEFINE_TRIVIAL_CLEANUP_FUNC(Evcat*, evcat_free);
90
91	static bool is_managed(const char *session) {
92	unsigned int vtnr;
93	struct stat st;
94	long mode;
95	int r;
96
97	/* Using logind's Controller API is highly fragile if there is already
98	* a session controller running. If it is registered as controller
99	* itself, TakeControl will simply fail. But if its a legacy controller
100	* that does not use logind's controller API, we must never register
101	* our own controller. Otherwise, we really mess up the VT. Therefore,
102	* only run in managed mode if there's no-one else. */
103
104	if (geteuid() == 0)
105	return false;
106
107	if (!isatty(1))
108	return false;
109
110	if (!session)
111	return false;
112
113	r = sd_session_get_vt(session, &vtnr);
114	if (r < 0 \|\| vtnr < 1 \|\| vtnr > 63)
115	return false;
116
117	mode = 0;
118	r = ioctl(1, KDGETMODE, &mode);
119	if (r < 0 \|\| mode != KD_TEXT)
120	return false;
121
122	r = fstat(1, &st);
123	if (r < 0 \|\| minor(st.st_rdev) != vtnr)
124	return false;
125
126	return true;
127	}
128
129	static int evcat_new(Evcat **out) {
130	_cleanup_(evcat_freep) Evcat *e = NULL;
131	int r;
132
133	assert(out);
134
135	e = new0(Evcat, 1);
136	if (!e)
137	return log_oom();
138
139	r = sd_pid_get_session(getpid(), &e->session);
23bbb0de MS	140	if (r < 0)
23bbb0de MS	141	return log_error_errno(r, "Cannot retrieve logind session: %m");
8e937190 DH	142
8e937190 DH	143	r = sd_session_get_seat(e->session, &e->seat);
23bbb0de MS	144	if (r < 0)
23bbb0de MS	145	return log_error_errno(r, "Cannot retrieve seat of logind session: %m");
8e937190 DH	146
	147	e->managed = is_managed(e->session);
	148
	149	r = sd_event_default(&e->event);
	150	if (r < 0)
	151	return r;
	152
	153	r = sd_bus_open_system(&e->bus);
	154	if (r < 0)
	155	return r;
	156
	157	r = sd_bus_attach_event(e->bus, e->event, SD_EVENT_PRIORITY_NORMAL);
	158	if (r < 0)
	159	return r;
	160
	161	r = sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1);
	162	if (r < 0)
	163	return r;
	164
	165	r = sd_event_add_signal(e->event, NULL, SIGTERM, NULL, NULL);
	166	if (r < 0)
	167	return r;
	168
	169	r = sd_event_add_signal(e->event, NULL, SIGINT, NULL, NULL);
	170	if (r < 0)
	171	return r;
	172
	173	r = sysview_context_new(&e->sysview,
	174	SYSVIEW_CONTEXT_SCAN_LOGIND \|
	175	SYSVIEW_CONTEXT_SCAN_EVDEV,
	176	e->event,
	177	e->bus,
	178	NULL);
	179	if (r < 0)
	180	return r;
	181
	182	r = idev_context_new(&e->idev, e->event, e->bus);
	183	if (r < 0)
	184	return r;
	185
	186	*out = e;
	187	e = NULL;
	188	return 0;
	189	}
	190
	191	static void kdata_print(idev_data *data) {
	192	idev_data_keyboard *k = &data->keyboard;
	193	char buf[128];
	194	uint32_t i, c;
	195	int cwidth;
	196
	197	/* Key-press state: UP/DOWN/REPEAT */
	198	printf(" %-6s", k->value == 0 ? "UP" :
	199	k->value == 1 ? "DOWN" :
	200	"REPEAT");
	201
4c4e4128 DH	202	/* Resync state */
	203	printf(" \| %-6s", data->resync ? "RESYNC" : "");
	204
8e937190 DH	205	/* Keycode that triggered the event */
	206	printf(" \| %5u", (unsigned)k->keycode);
	207
	208	/* Well-known name of the keycode */
	209	printf(" \| %-20s", libevdev_event_code_get_name(EV_KEY, k->keycode) ? : "<unknown>");
	210
	211	/* Well-known modifiers */
	212	printf(" \| %-5s", (k->mods & IDEV_KBDMOD_SHIFT) ? "SHIFT" : "");
	213	printf(" %-4s", (k->mods & IDEV_KBDMOD_CTRL) ? "CTRL" : "");
	214	printf(" %-3s", (k->mods & IDEV_KBDMOD_ALT) ? "ALT" : "");
	215	printf(" %-5s", (k->mods & IDEV_KBDMOD_LINUX) ? "LINUX" : "");
	216	printf(" %-4s", (k->mods & IDEV_KBDMOD_CAPS) ? "CAPS" : "");
	217
62d5068d DH	218	/* Consumed modifiers */
	219	printf(" \| %-5s", (k->consumed_mods & IDEV_KBDMOD_SHIFT) ? "SHIFT" : "");
	220	printf(" %-4s", (k->consumed_mods & IDEV_KBDMOD_CTRL) ? "CTRL" : "");
	221	printf(" %-3s", (k->consumed_mods & IDEV_KBDMOD_ALT) ? "ALT" : "");
	222	printf(" %-5s", (k->consumed_mods & IDEV_KBDMOD_LINUX) ? "LINUX" : "");
	223	printf(" %-4s", (k->consumed_mods & IDEV_KBDMOD_CAPS) ? "CAPS" : "");
	224
8e937190 DH	225	/* Resolved symbols */
	226	printf(" \|");
	227	for (i = 0; i < k->n_syms; ++i) {
	228	buf[0] = 0;
	229	xkb_keysym_get_name(k->keysyms[i], buf, sizeof(buf));
	230
	231	if (is_locale_utf8()) {
	232	c = k->codepoints[i];
	233	if (c < 0x110000 && c > 0x20 && (c < 0x7f \|\| c > 0x9f)) {
	234	/* "%4lc" doesn't work well, so hard-code it */
	235	cwidth = mk_wcwidth(c);
	236	while (cwidth++ < 2)
	237	printf(" ");
	238
	239	printf(" '%lc':", (wchar_t)c);
	240	} else {
	241	printf(" ");
	242	}
	243	}
	244
	245	printf(" XKB_KEY_%-30s", buf);
	246	}
	247
	248	printf("\n");
	249	}
	250
	251	static bool kdata_is_exit(idev_data *data) {
	252	idev_data_keyboard *k = &data->keyboard;
	253
	254	if (k->value != 1)
	255	return false;
	256	if (k->n_syms != 1)
	257	return false;
	258
	259	return k->codepoints[0] == 'q';
	260	}
	261
	262	static int evcat_idev_fn(idev_session session, void userdata, idev_event *ev) {
	263	Evcat *e = userdata;
	264
	265	switch (ev->type) {
	266	case IDEV_EVENT_DEVICE_ADD:
	267	idev_device_enable(ev->device_add.device);
	268	break;
	269	case IDEV_EVENT_DEVICE_REMOVE:
	270	idev_device_disable(ev->device_remove.device);
	271	break;
	272	case IDEV_EVENT_DEVICE_DATA:
	273	switch (ev->device_data.data.type) {
	274	case IDEV_DATA_KEYBOARD:
	275	if (kdata_is_exit(&ev->device_data.data))
	276	sd_event_exit(e->event, 0);
	277	else
	278	kdata_print(&ev->device_data.data);
	279
	280	break;
	281	}
	282
	283	break;
	284	}
	285
	286	return 0;
	287	}
	288
289	static int evcat_sysview_fn(sysview_context c, void userdata, sysview_event *ev) {
290	unsigned int flags, type;
291	Evcat *e = userdata;
292	sysview_device *d;
293	const char *name;
294	int r;
295
296	switch (ev->type) {
297	case SYSVIEW_EVENT_SESSION_FILTER:
298	if (streq_ptr(e->session, ev->session_filter.id))
299	return 1;
300
301	break;
302	case SYSVIEW_EVENT_SESSION_ADD:
303	assert(!e->idev_session);
304
305	name = sysview_session_get_name(ev->session_add.session);
306	flags = 0;
307
308	if (e->managed)
309	flags \|= IDEV_SESSION_MANAGED;
310
311	r = idev_session_new(&e->idev_session,
312	e->idev,
313	flags,
314	name,
315	evcat_idev_fn,
316	e);
23bbb0de MS	317	if (r < 0)
23bbb0de MS	318	return log_error_errno(r, "Cannot create idev session: %m");
8e937190	319
8e937190 DH	320	if (e->managed) {
8e937190 DH	321	r = sysview_session_take_control(ev->session_add.session);
23bbb0de MS	322	if (r < 0)
23bbb0de MS	323	return log_error_errno(r, "Cannot request session control: %m");
8e937190 DH	324	}
8e937190 DH	325
c6000223 DH	326	idev_session_enable(e->idev_session);
c6000223 DH	327
8e937190 DH	328	break;
	329	case SYSVIEW_EVENT_SESSION_REMOVE:
	330	idev_session_disable(e->idev_session);
	331	e->idev_session = idev_session_free(e->idev_session);
c17091b7 DH	332	if (sd_event_get_exit_code(e->event, &r) == -ENODATA)
c17091b7 DH	333	sd_event_exit(e->event, 0);
8e937190 DH	334	break;
	335	case SYSVIEW_EVENT_SESSION_ATTACH:
	336	d = ev->session_attach.device;
	337	type = sysview_device_get_type(d);
	338	if (type == SYSVIEW_DEVICE_EVDEV) {
	339	r = idev_session_add_evdev(e->idev_session, sysview_device_get_ud(d));
23bbb0de MS	340	if (r < 0)
23bbb0de MS	341	return log_error_errno(r, "Cannot add evdev device to idev: %m");
8e937190 DH	342	}
	343
	344	break;
	345	case SYSVIEW_EVENT_SESSION_DETACH:
	346	d = ev->session_detach.device;
	347	type = sysview_device_get_type(d);
	348	if (type == SYSVIEW_DEVICE_EVDEV) {
	349	r = idev_session_remove_evdev(e->idev_session, sysview_device_get_ud(d));
23bbb0de MS	350	if (r < 0)
23bbb0de MS	351	return log_error_errno(r, "Cannot remove evdev device from idev: %m");
8e937190 DH	352	}
	353
	354	break;
	355	case SYSVIEW_EVENT_SESSION_CONTROL:
	356	r = ev->session_control.error;
23bbb0de MS	357	if (r < 0)
23bbb0de MS	358	return log_error_errno(r, "Cannot acquire session control: %m");
8e937190 DH	359
8e937190 DH	360	r = ioctl(1, KDSKBMODE, K_UNICODE);
4a62c710 MS	361	if (r < 0)
4a62c710 MS	362	return log_error_errno(errno, "Cannot set K_UNICODE on stdout: %m");
8e937190 DH	363
8e937190 DH	364	r = ioctl(1, KDSETMODE, KD_TEXT);
4a62c710 MS	365	if (r < 0)
4a62c710 MS	366	return log_error_errno(errno, "Cannot set KD_TEXT on stdout: %m");
8e937190 DH	367
	368	printf("\n");
	369
	370	break;
	371	}
	372
	373	return 0;
	374	}
	375
	376	static int evcat_run(Evcat *e) {
	377	struct termios in_attr, saved_attr;
	378	int r;
	379
	380	assert(e);
	381
	382	if (!e->managed && geteuid() > 0)
	383	log_warning("You run in unmanaged mode without being root. This is likely to produce no output..");
	384
	385	printf("evcat - Read and catenate events from selected input devices\n"
	386	" Running on seat '%s' in user-session '%s'\n"
	387	" Exit by pressing ^C or 'q'\n\n",
	388	e->seat ? : "seat0", e->session ? : "<none>");
	389
	390	r = sysview_context_start(e->sysview, evcat_sysview_fn, e);
	391	if (r < 0)
	392	goto out;
	393
	394	r = tcgetattr(0, &in_attr);
	395	if (r < 0) {
	396	r = -errno;
	397	goto out;
	398	}
	399
	400	saved_attr = in_attr;
	401	in_attr.c_lflag &= ~ECHO;
	402
	403	r = tcsetattr(0, TCSANOW, &in_attr);
	404	if (r < 0) {
	405	r = -errno;
	406	goto out;
	407	}
	408
	409	r = sd_event_loop(e->event);
	410	tcsetattr(0, TCSANOW, &saved_attr);
	411	printf("exiting..\n");
	412
	413	out:
	414	sysview_context_stop(e->sysview);
	415	return r;
	416	}
	417
	418	static int help(void) {
	419	printf("%s [OPTIONS...]\n\n"
	420	"Read and catenate events from selected input devices.\n\n"
	421	" -h --help Show this help\n"
	422	" --version Show package version\n"
	423	, program_invocation_short_name);
	424
	425	return 0;
	426	}
	427
	428	static int parse_argv(int argc, char *argv[]) {
	429	enum {
	430	ARG_VERSION = 0x100,
431	};
432	static const struct option options[] = {
433	{ "help", no_argument, NULL, 'h' },
434	{ "version", no_argument, NULL, ARG_VERSION },
435	{},
436	};
437	int c;
438
439	assert(argc >= 0);
440	assert(argv);
441
442	while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
443	switch (c) {
444	case 'h':
445	help();
446	return 0;
447
448	case ARG_VERSION:
449	puts(PACKAGE_STRING);
450	puts(SYSTEMD_FEATURES);
451	return 0;
452
453	case '?':
454	return -EINVAL;
455
456	default:
457	assert_not_reached("Unhandled option");
458	}
459
460	if (argc > optind) {
461	log_error("Too many arguments");
462	return -EINVAL;
463	}
464
465	return 1;
466	}
467
468	int main(int argc, char *argv[]) {
469	_cleanup_(evcat_freep) Evcat *e = NULL;
470	int r;
471
472	log_set_target(LOG_TARGET_AUTO);
473	log_parse_environment();
474	log_open();
475
476	setlocale(LC_ALL, "");
477	if (!is_locale_utf8())
478	log_warning("Locale is not set to UTF-8. Codepoints will not be printed!");
479
480	r = parse_argv(argc, argv);
481	if (r <= 0)
482	goto finish;
483
484	r = evcat_new(&e);
485	if (r < 0)
486	goto finish;
487
488	r = evcat_run(e);
489
490	finish:
491	return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
492	}