[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"
#include "sd-messages.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);

                /* If the device has been unplugged close() returns
                 * ENODEV, let's ignore this, hence we don't use
                 * close_nointr_nofail() */
                close(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(b->fd);
                b->fd = -1;
        }

        p = strappend("/dev/input/", b->name);
        if (!p)
                return log_oom();

        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(b->fd);
        b->fd = -1;
        return r;
}

static int button_handle(
                Button *b,
                InhibitWhat inhibit_key,
                HandleAction handle,
                bool ignore_inhibited,
                bool is_edge) {

        int r;

        assert(b);

        r = manager_handle_action(b->manager, inhibit_key, handle, ignore_inhibited, is_edge);
        if (r > 0)
                /* We are executing the operation, so make sure we don't
                 * execute another one until the lid is opened/closed again */
                b->lid_close_queued = false;

        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 (ev.type == EV_KEY && ev.value > 0) {

                switch (ev.code) {

                case KEY_POWER:
                case KEY_POWER2:
                        log_struct(LOG_INFO,
                                   "MESSAGE=Power key pressed.",
                                   MESSAGE_ID(SD_MESSAGE_POWER_KEY),
                                   NULL);
                        return button_handle(b, INHIBIT_HANDLE_POWER_KEY, b->manager->handle_power_key, b->manager->power_key_ignore_inhibited, true);

                /* The kernel is a bit confused here:

                   KEY_SLEEP   = suspend-to-ram, which everybody else calls "suspend"
                   KEY_SUSPEND = suspend-to-disk, which everybody else calls "hibernate"
                */

                case KEY_SLEEP:
                        log_struct(LOG_INFO,
                                   "MESSAGE=Suspend key pressed.",
                                   MESSAGE_ID(SD_MESSAGE_SUSPEND_KEY),
                                   NULL);
                        return button_handle(b, INHIBIT_HANDLE_SUSPEND_KEY, b->manager->handle_suspend_key, b->manager->suspend_key_ignore_inhibited, true);

                case KEY_SUSPEND:
                        log_struct(LOG_INFO,
                                   "MESSAGE=Hibernate key pressed.",
                                   MESSAGE_ID(SD_MESSAGE_HIBERNATE_KEY),
                                   NULL);
                        return button_handle(b, INHIBIT_HANDLE_HIBERNATE_KEY, b->manager->handle_hibernate_key, b->manager->hibernate_key_ignore_inhibited, true);
                }

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

                switch (ev.code) {

                case SW_LID:
                        log_struct(LOG_INFO,
                                   "MESSAGE=Lid closed.",
                                   MESSAGE_ID(SD_MESSAGE_LID_CLOSED),
                                   NULL);
                        b->lid_close_queued = true;

                        return button_handle(b, INHIBIT_HANDLE_LID_SWITCH, b->manager->handle_lid_switch, b->manager->lid_switch_ignore_inhibited, true);
                }

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

                switch (ev.code) {

                case SW_LID:
                        log_struct(LOG_INFO,
                                   "MESSAGE=Lid opened.",
                                   MESSAGE_ID(SD_MESSAGE_LID_OPENED),
                                   NULL);
                        b->lid_close_queued = false;
                        break;
                }
        }

        return 0;
}

int button_recheck(Button *b) {
        assert(b);

        if (!b->lid_close_queued)
                return 0;

        return button_handle(b, INHIBIT_HANDLE_LID_SWITCH, b->manager->handle_lid_switch, b->manager->lid_switch_ignore_inhibited, false);
}
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"
c485437f	36	#include "sd-messages.h"
e9d21f24 LP	37
	38	Button* button_new(Manager m, const char name) {
	39	Button *b;
	40
	41	assert(m);
	42	assert(name);
	43
	44	b = new0(Button, 1);
	45	if (!b)
	46	return NULL;
	47
	48	b->name = strdup(name);
	49	if (!b->name) {
	50	free(b);
	51	return NULL;
	52	}
	53
	54	if (hashmap_put(m->buttons, b->name, b) < 0) {
	55	free(b->name);
	56	free(b);
	57	return NULL;
	58	}
	59
	60	b->manager = m;
	61	b->fd = -1;
	62
	63	return b;
	64	}
	65
	66	void button_free(Button *b) {
	67	assert(b);
	68
	69	hashmap_remove(b->manager->buttons, b->name);
	70
	71	if (b->fd >= 0) {
	72	hashmap_remove(b->manager->button_fds, INT_TO_PTR(b->fd + 1));
	73	assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
c30a0c62 LP	74
	75	/* If the device has been unplugged close() returns
	76	* ENODEV, let's ignore this, hence we don't use
	77	* close_nointr_nofail() */
	78	close(b->fd);
e9d21f24 LP	79	}
	80
	81	free(b->name);
	82	free(b->seat);
	83	free(b);
	84	}
	85
	86	int button_set_seat(Button b, const char sn) {
	87	char *s;
	88
	89	assert(b);
	90	assert(sn);
	91
	92	s = strdup(sn);
	93	if (!s)
	94	return -ENOMEM;
	95
	96	free(b->seat);
	97	b->seat = s;
	98
	99	return 0;
	100	}
	101
	102	int button_open(Button *b) {
	103	char name[256], *p;
	104	struct epoll_event ev;
	105	int r;
	106
	107	assert(b);
	108
	109	if (b->fd >= 0) {
c30a0c62	110	close(b->fd);
e9d21f24 LP	111	b->fd = -1;
	112	}
	113
	114	p = strappend("/dev/input/", b->name);
0d0f0c50 SL	115	if (!p)
0d0f0c50 SL	116	return log_oom();
e9d21f24 LP	117
	118	b->fd = open(p, O_RDWR\|O_CLOEXEC\|O_NOCTTY\|O_NONBLOCK);
	119	free(p);
	120	if (b->fd < 0) {
	121	log_warning("Failed to open %s: %m", b->name);
	122	return -errno;
	123	}
	124
	125	if (ioctl(b->fd, EVIOCGNAME(sizeof(name)), name) < 0) {
	126	log_error("Failed to get input name: %m");
	127	r = -errno;
	128	goto fail;
	129	}
	130
	131	zero(ev);
	132	ev.events = EPOLLIN;
	133	ev.data.u32 = FD_OTHER_BASE + b->fd;
	134
	135	if (epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_ADD, b->fd, &ev) < 0) {
	136	log_error("Failed to add to epoll: %m");
	137	r = -errno;
	138	goto fail;
	139	}
	140
	141	r = hashmap_put(b->manager->button_fds, INT_TO_PTR(b->fd + 1), b);
	142	if (r < 0) {
	143	log_error("Failed to add to hash map: %s", strerror(-r));
	144	assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
	145	goto fail;
	146	}
	147
	148	log_info("Watching system buttons on /dev/input/%s (%s)", b->name, name);
	149
	150	return 0;
	151
	152	fail:
c30a0c62	153	close(b->fd);
e9d21f24 LP	154	b->fd = -1;
	155	return r;
	156	}
	157
65b51162 LP	158	static int button_handle(
	159	Button *b,
	160	InhibitWhat inhibit_key,
23406ce5	161	HandleAction handle,
65b51162 LP	162	bool ignore_inhibited,
65b51162 LP	163	bool is_edge) {
beaafb2e	164
e9d21f24 LP	165	int r;
	166
	167	assert(b);
	168
23406ce5 LP	169	r = manager_handle_action(b->manager, inhibit_key, handle, ignore_inhibited, is_edge);
	170	if (r > 0)
	171	/* We are executing the operation, so make sure we don't
	172	* execute another one until the lid is opened/closed again */
	173	b->lid_close_queued = false;
6de0e0e5	174
23406ce5	175	return r;
e9d21f24 LP	176	}
	177
	178	int button_process(Button *b) {
	179	struct input_event ev;
	180	ssize_t l;
	181
	182	assert(b);
	183
	184	l = read(b->fd, &ev, sizeof(ev));
	185	if (l < 0)
	186	return errno != EAGAIN ? -errno : 0;
	187	if ((size_t) l < sizeof(ev))
	188	return -EIO;
	189
e9d21f24 LP	190	if (ev.type == EV_KEY && ev.value > 0) {
	191
	192	switch (ev.code) {
	193
	194	case KEY_POWER:
	195	case KEY_POWER2:
c485437f ZJS	196	log_struct(LOG_INFO,
	197	"MESSAGE=Power key pressed.",
	198	MESSAGE_ID(SD_MESSAGE_POWER_KEY),
	199	NULL);
65b51162	200	return button_handle(b, INHIBIT_HANDLE_POWER_KEY, b->manager->handle_power_key, b->manager->power_key_ignore_inhibited, true);
e9d21f24	201
8e7fd6ad LP	202	/* The kernel is a bit confused here:
	203
	204	KEY_SLEEP = suspend-to-ram, which everybody else calls "suspend"
	205	KEY_SUSPEND = suspend-to-disk, which everybody else calls "hibernate"
	206	*/
	207
e9d21f24	208	case KEY_SLEEP:
c485437f ZJS	209	log_struct(LOG_INFO,
	210	"MESSAGE=Suspend key pressed.",
	211	MESSAGE_ID(SD_MESSAGE_SUSPEND_KEY),
	212	NULL);
8e7fd6ad	213	return button_handle(b, INHIBIT_HANDLE_SUSPEND_KEY, b->manager->handle_suspend_key, b->manager->suspend_key_ignore_inhibited, true);
e9d21f24	214
8e7fd6ad	215	case KEY_SUSPEND:
c485437f ZJS	216	log_struct(LOG_INFO,
	217	"MESSAGE=Hibernate key pressed.",
	218	MESSAGE_ID(SD_MESSAGE_HIBERNATE_KEY),
	219	NULL);
8e7fd6ad	220	return button_handle(b, INHIBIT_HANDLE_HIBERNATE_KEY, b->manager->handle_hibernate_key, b->manager->hibernate_key_ignore_inhibited, true);
e9d21f24	221	}
8e7fd6ad	222
e9d21f24 LP	223	} else if (ev.type == EV_SW && ev.value > 0) {
	224
	225	switch (ev.code) {
	226
	227	case SW_LID:
c485437f ZJS	228	log_struct(LOG_INFO,
	229	"MESSAGE=Lid closed.",
	230	MESSAGE_ID(SD_MESSAGE_LID_CLOSED),
	231	NULL);
65b51162 LP	232	b->lid_close_queued = true;
	233
	234	return button_handle(b, INHIBIT_HANDLE_LID_SWITCH, b->manager->handle_lid_switch, b->manager->lid_switch_ignore_inhibited, true);
	235	}
	236
	237	} else if (ev.type == EV_SW && ev.value == 0) {
	238
	239	switch (ev.code) {
	240
	241	case SW_LID:
c485437f ZJS	242	log_struct(LOG_INFO,
	243	"MESSAGE=Lid opened.",
	244	MESSAGE_ID(SD_MESSAGE_LID_OPENED),
	245	NULL);
65b51162 LP	246	b->lid_close_queued = false;
65b51162 LP	247	break;
e9d21f24 LP	248	}
	249	}
	250
	251	return 0;
	252	}
	253
65b51162 LP	254	int button_recheck(Button *b) {
	255	assert(b);
	256
	257	if (!b->lid_close_queued)
	258	return 0;
	259
	260	return button_handle(b, INHIBIT_HANDLE_LID_SWITCH, b->manager->handle_lid_switch, b->manager->lid_switch_ignore_inhibited, false);
	261	}