[thirdparty/systemd.git] / src / login / logind-button.c

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

/***
  This file is part of systemd.

  Copyright 2012 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 <assert.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <linux/input.h>
#include <sys/epoll.h>

#include "conf-parser.h"
#include "util.h"
#include "logind-button.h"
#include "special.h"
#include "dbus-common.h"

Button* button_new(Manager *m, const char *name) {
        Button *b;

        assert(m);
        assert(name);

        b = new0(Button, 1);
        if (!b)
                return NULL;

        b->name = strdup(name);
        if (!b->name) {
                free(b);
                return NULL;
        }

        if (hashmap_put(m->buttons, b->name, b) < 0) {
                free(b->name);
                free(b);
                return NULL;
        }

        b->manager = m;
        b->fd = -1;

        return b;
}

void button_free(Button *b) {
        assert(b);

        hashmap_remove(b->manager->buttons, b->name);

        if (b->fd >= 0) {
                hashmap_remove(b->manager->button_fds, INT_TO_PTR(b->fd + 1));
                assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
                close_nointr_nofail(b->fd);
        }

        free(b->name);
        free(b->seat);
        free(b);
}

int button_set_seat(Button *b, const char *sn) {
        char *s;

        assert(b);
        assert(sn);

        s = strdup(sn);
        if (!s)
                return -ENOMEM;

        free(b->seat);
        b->seat = s;

        return 0;
}

int button_open(Button *b) {
        char name[256], *p;
        struct epoll_event ev;
        int r;

        assert(b);

        if (b->fd >= 0) {
                close_nointr_nofail(b->fd);
                b->fd = -1;
        }

        p = strappend("/dev/input/", b->name);
        if (!p) {
                log_error("Out of memory");
                return -ENOMEM;
        }

        b->fd = open(p, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
        free(p);
        if (b->fd < 0) {
                log_warning("Failed to open %s: %m", b->name);
                return -errno;
        }

        if (ioctl(b->fd, EVIOCGNAME(sizeof(name)), name) < 0) {
                log_error("Failed to get input name: %m");
                r = -errno;
                goto fail;
        }

        zero(ev);
        ev.events = EPOLLIN;
        ev.data.u32 = FD_OTHER_BASE + b->fd;

        if (epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_ADD, b->fd, &ev) < 0) {
                log_error("Failed to add to epoll: %m");
                r = -errno;
                goto fail;
        }

        r = hashmap_put(b->manager->button_fds, INT_TO_PTR(b->fd + 1), b);
        if (r < 0) {
                log_error("Failed to add to hash map: %s", strerror(-r));
                assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
                goto fail;
        }

        log_info("Watching system buttons on /dev/input/%s (%s)", b->name, name);

        return 0;

fail:
        close_nointr_nofail(b->fd);
        b->fd = -1;
        return r;
}

static bool has_graphical_session(Manager *m, const char *seat) {
        Seat *s;

        assert(m);
        assert(seat);

        s = hashmap_get(m->seats, seat);
        if (!s)
                return false;

        if (!s->active)
                return false;

        return s->active->type == SESSION_X11;
}

static int button_power_off(Button *b, HandleButton handle) {
        DBusError error;
        int r;

        assert(b);

        if (handle == HANDLE_NO)
                return 0;

        if (handle != HANDLE_ALWAYS) {

                if (hashmap_size(b->manager->sessions) > 0) {
                        log_error("Refusing power-off, user is logged in.");
                        warn_melody();
                        return -EPERM;
                }

                if (manager_is_inhibited(b->manager, INHIBIT_SHUTDOWN, INHIBIT_BLOCK, NULL)) {
                        log_error("Refusing power-off, shutdown is inhibited.");
                        warn_melody();
                        return -EPERM;
                }
        }

        log_info("Powering off...");

        dbus_error_init(&error);
        r = bus_manager_shutdown_or_sleep_now_or_later(b->manager, SPECIAL_POWEROFF_TARGET, INHIBIT_SHUTDOWN, &error);
        if (r < 0) {
                log_error("Failed to power off: %s", bus_error_message(&error));
                dbus_error_free(&error);
        }

        return r;
}

static int button_suspend(Button *b, HandleButton handle) {
        DBusError error;
        int r;

        assert(b);

        if (handle == HANDLE_NO)
                return 0;

        if (handle != HANDLE_ALWAYS) {

                if (hashmap_size(b->manager->sessions) > 0) {
                        log_error("Refusing suspend, user is logged in.");
                        warn_melody();
                        return -EPERM;
                }

                if (manager_is_inhibited(b->manager, INHIBIT_SLEEP, INHIBIT_BLOCK, NULL)) {
                        log_error("Refusing suspend, sleeping is inhibited.");
                        warn_melody();
                        return -EPERM;
                }
        }

        log_info("Suspending...");

        dbus_error_init(&error);
        r = bus_manager_shutdown_or_sleep_now_or_later(b->manager, SPECIAL_SUSPEND_TARGET, INHIBIT_SLEEP, &error);
        if (r < 0) {
                log_error("Failed to suspend: %s", bus_error_message(&error));
                dbus_error_free(&error);
        }

        return r;
}

int button_process(Button *b) {
        struct input_event ev;
        ssize_t l;

        assert(b);

        l = read(b->fd, &ev, sizeof(ev));
        if (l < 0)
                return errno != EAGAIN ? -errno : 0;
        if ((size_t) l < sizeof(ev))
                return -EIO;

        /* If there's a graphical session on the seat this device
         * belongs to we ignore events, it is job of the graphical
         * session to handle the event. */
        if (has_graphical_session(b->manager, b->seat))
                return 0;

        if (ev.type == EV_KEY && ev.value > 0) {

                switch (ev.code) {

                case KEY_POWER:
                case KEY_POWER2:
                        log_info("Power key pressed.");
                        return button_power_off(b, b->manager->handle_power_key);

                case KEY_SLEEP:
                case KEY_SUSPEND:
                        log_info("Sleep key pressed.");
                        return button_suspend(b, b->manager->handle_sleep_key);

                }
        } else if (ev.type == EV_SW && ev.value > 0) {

                switch (ev.code) {

                case SW_LID:
                        log_info("Lid closed.");
                        return button_suspend(b, b->manager->handle_lid_switch);
                }
        }

        return 0;
}

static const char* const handle_button_table[_HANDLE_BUTTON_MAX] = {
        [HANDLE_YES] = "yes",
        [HANDLE_NO] = "no",
        [HANDLE_ALWAYS] = "always"
};
DEFINE_STRING_TABLE_LOOKUP(handle_button, HandleButton);
DEFINE_CONFIG_PARSE_ENUM(config_parse_handle_button, handle_button, HandleButton, "Failed to parse handle button setting");
Commit	Line	Data
e9d21f24 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2012 Lennart Poettering
	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	#include <assert.h>
	23	#include <string.h>
	24	#include <errno.h>
	25	#include <fcntl.h>
	26	#include <sys/ioctl.h>
	27	#include <unistd.h>
	28	#include <linux/input.h>
	29	#include <sys/epoll.h>
	30
	31	#include "conf-parser.h"
	32	#include "util.h"
	33	#include "logind-button.h"
	34	#include "special.h"
	35	#include "dbus-common.h"
	36
	37	Button* button_new(Manager m, const char name) {
	38	Button *b;
	39
	40	assert(m);
	41	assert(name);
	42
	43	b = new0(Button, 1);
	44	if (!b)
	45	return NULL;
	46
	47	b->name = strdup(name);
	48	if (!b->name) {
	49	free(b);
	50	return NULL;
	51	}
	52
	53	if (hashmap_put(m->buttons, b->name, b) < 0) {
	54	free(b->name);
	55	free(b);
	56	return NULL;
	57	}
	58
	59	b->manager = m;
	60	b->fd = -1;
	61
	62	return b;
	63	}
	64
65	void button_free(Button *b) {
66	assert(b);
67
68	hashmap_remove(b->manager->buttons, b->name);
69
70	if (b->fd >= 0) {
71	hashmap_remove(b->manager->button_fds, INT_TO_PTR(b->fd + 1));
72	assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
73	close_nointr_nofail(b->fd);
74	}
75
76	free(b->name);
77	free(b->seat);
78	free(b);
79	}
80
81	int button_set_seat(Button b, const char sn) {
82	char *s;
83
84	assert(b);
85	assert(sn);
86
87	s = strdup(sn);
88	if (!s)
89	return -ENOMEM;
90
91	free(b->seat);
92	b->seat = s;
93
94	return 0;
95	}
96
97	int button_open(Button *b) {
98	char name[256], *p;
99	struct epoll_event ev;
100	int r;
101
102	assert(b);
103
104	if (b->fd >= 0) {
105	close_nointr_nofail(b->fd);
106	b->fd = -1;
107	}
108
109	p = strappend("/dev/input/", b->name);
110	if (!p) {
111	log_error("Out of memory");
112	return -ENOMEM;
113	}
114
115	b->fd = open(p, O_RDWR\|O_CLOEXEC\|O_NOCTTY\|O_NONBLOCK);
116	free(p);
117	if (b->fd < 0) {
118	log_warning("Failed to open %s: %m", b->name);
119	return -errno;
120	}
121
122	if (ioctl(b->fd, EVIOCGNAME(sizeof(name)), name) < 0) {
123	log_error("Failed to get input name: %m");
124	r = -errno;
125	goto fail;
126	}
127
128	zero(ev);
129	ev.events = EPOLLIN;
130	ev.data.u32 = FD_OTHER_BASE + b->fd;
131
132	if (epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_ADD, b->fd, &ev) < 0) {
133	log_error("Failed to add to epoll: %m");
134	r = -errno;
135	goto fail;
136	}
137
138	r = hashmap_put(b->manager->button_fds, INT_TO_PTR(b->fd + 1), b);
139	if (r < 0) {
140	log_error("Failed to add to hash map: %s", strerror(-r));
141	assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
142	goto fail;
143	}
144
145	log_info("Watching system buttons on /dev/input/%s (%s)", b->name, name);
146
147	return 0;
148
149	fail:
150	close_nointr_nofail(b->fd);
151	b->fd = -1;
152	return r;
153	}
154
155	static bool has_graphical_session(Manager m, const char seat) {
156	Seat *s;
157
158	assert(m);
159	assert(seat);
160
161	s = hashmap_get(m->seats, seat);
162	if (!s)
163	return false;
164
165	if (!s->active)
166	return false;
167
168	return s->active->type == SESSION_X11;
169	}
170
171	static int button_power_off(Button *b, HandleButton handle) {
172	DBusError error;
173	int r;
174
175	assert(b);
176
177	if (handle == HANDLE_NO)
178	return 0;
179
180	if (handle != HANDLE_ALWAYS) {
181
182	if (hashmap_size(b->manager->sessions) > 0) {
183	log_error("Refusing power-off, user is logged in.");
184	warn_melody();
185	return -EPERM;
186	}
187
188	if (manager_is_inhibited(b->manager, INHIBIT_SHUTDOWN, INHIBIT_BLOCK, NULL)) {
189	log_error("Refusing power-off, shutdown is inhibited.");
190	warn_melody();
191	return -EPERM;
192	}
193	}
194
195	log_info("Powering off...");
196
197	dbus_error_init(&error);
198	r = bus_manager_shutdown_or_sleep_now_or_later(b->manager, SPECIAL_POWEROFF_TARGET, INHIBIT_SHUTDOWN, &error);
199	if (r < 0) {
200	log_error("Failed to power off: %s", bus_error_message(&error));
201	dbus_error_free(&error);
202	}
203
204	return r;
205	}
206
207	static int button_suspend(Button *b, HandleButton handle) {
208	DBusError error;
209	int r;
210
211	assert(b);
212
213	if (handle == HANDLE_NO)
214	return 0;
215
216	if (handle != HANDLE_ALWAYS) {
217
218	if (hashmap_size(b->manager->sessions) > 0) {
219	log_error("Refusing suspend, user is logged in.");
220	warn_melody();
221	return -EPERM;
222	}
223
224	if (manager_is_inhibited(b->manager, INHIBIT_SLEEP, INHIBIT_BLOCK, NULL)) {
225	log_error("Refusing suspend, sleeping is inhibited.");
226	warn_melody();
227	return -EPERM;
228	}
229	}
230
231	log_info("Suspending...");
232
233	dbus_error_init(&error);
234	r = bus_manager_shutdown_or_sleep_now_or_later(b->manager, SPECIAL_SUSPEND_TARGET, INHIBIT_SLEEP, &error);
235	if (r < 0) {
236	log_error("Failed to suspend: %s", bus_error_message(&error));
237	dbus_error_free(&error);
238	}
239
240	return r;
241	}
242
243	int button_process(Button *b) {
244	struct input_event ev;
245	ssize_t l;
246
247	assert(b);
248
249	l = read(b->fd, &ev, sizeof(ev));
250	if (l < 0)
251	return errno != EAGAIN ? -errno : 0;
252	if ((size_t) l < sizeof(ev))
253	return -EIO;
254
255	/* If there's a graphical session on the seat this device
256	* belongs to we ignore events, it is job of the graphical
257	* session to handle the event. */
258	if (has_graphical_session(b->manager, b->seat))
259	return 0;
260
261	if (ev.type == EV_KEY && ev.value > 0) {
262
263	switch (ev.code) {
264
265	case KEY_POWER:
266	case KEY_POWER2:
267	log_info("Power key pressed.");
268	return button_power_off(b, b->manager->handle_power_key);
269
270	case KEY_SLEEP:
271	case KEY_SUSPEND:
272	log_info("Sleep key pressed.");
273	return button_suspend(b, b->manager->handle_sleep_key);
274
275	}
276	} else if (ev.type == EV_SW && ev.value > 0) {
277
278	switch (ev.code) {
279
280	case SW_LID:
281	log_info("Lid closed.");
282	return button_suspend(b, b->manager->handle_lid_switch);
283	}
284	}
285
286	return 0;
287	}
288
289	static const char* const handle_button_table[_HANDLE_BUTTON_MAX] = {
290	[HANDLE_YES] = "yes",
291	[HANDLE_NO] = "no",
292	[HANDLE_ALWAYS] = "always"
293	};
294	DEFINE_STRING_TABLE_LOOKUP(handle_button, HandleButton);
295	DEFINE_CONFIG_PARSE_ENUM(config_parse_handle_button, handle_button, HandleButton, "Failed to parse handle button setting");