1 /*
2  * Copyright (C) 2010 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "keychords.h"
18 
19 #include <dirent.h>
20 #include <fcntl.h>
21 #include <linux/input.h>
22 #include <sys/cdefs.h>
23 #include <sys/inotify.h>
24 #include <sys/ioctl.h>
25 #include <sys/types.h>
26 #include <unistd.h>
27 
28 #include <algorithm>
29 #include <functional>
30 #include <map>
31 #include <memory>
32 #include <string>
33 #include <vector>
34 
35 #include <android-base/logging.h>
36 
37 namespace android {
38 namespace init {
39 
Keychords()40 Keychords::Keychords() : epoll_(nullptr), inotify_fd_(-1) {}
41 
~Keychords()42 Keychords::~Keychords() noexcept {
43     if (inotify_fd_ >= 0) {
44         epoll_->UnregisterHandler(inotify_fd_);
45         ::close(inotify_fd_);
46     }
47     while (!registration_.empty()) GeteventCloseDevice(registration_.begin()->first);
48 }
49 
Mask(size_t bit)50 Keychords::Mask::Mask(size_t bit) : bits_((bit + sizeof(mask_t) - 1) / sizeof(mask_t), 0) {}
51 
SetBit(size_t bit,bool value)52 void Keychords::Mask::SetBit(size_t bit, bool value) {
53     auto idx = bit / (kBitsPerByte * sizeof(mask_t));
54     if (idx >= bits_.size()) return;
55     if (value) {
56         bits_[idx] |= mask_t(1) << (bit % (kBitsPerByte * sizeof(mask_t)));
57     } else {
58         bits_[idx] &= ~(mask_t(1) << (bit % (kBitsPerByte * sizeof(mask_t))));
59     }
60 }
61 
GetBit(size_t bit) const62 bool Keychords::Mask::GetBit(size_t bit) const {
63     auto idx = bit / (kBitsPerByte * sizeof(mask_t));
64     return bits_[idx] & (mask_t(1) << (bit % (kBitsPerByte * sizeof(mask_t))));
65 }
66 
bytesize() const67 size_t Keychords::Mask::bytesize() const {
68     return bits_.size() * sizeof(mask_t);
69 }
70 
data()71 void* Keychords::Mask::data() {
72     return bits_.data();
73 }
74 
size() const75 size_t Keychords::Mask::size() const {
76     return bits_.size() * sizeof(mask_t) * kBitsPerByte;
77 }
78 
resize(size_t bit)79 void Keychords::Mask::resize(size_t bit) {
80     auto idx = bit / (kBitsPerByte * sizeof(mask_t));
81     if (idx >= bits_.size()) {
82         bits_.resize(idx + 1, 0);
83     }
84 }
85 
operator bool() const86 Keychords::Mask::operator bool() const {
87     for (size_t i = 0; i < bits_.size(); ++i) {
88         if (bits_[i]) return true;
89     }
90     return false;
91 }
92 
operator &(const Keychords::Mask & rval) const93 Keychords::Mask Keychords::Mask::operator&(const Keychords::Mask& rval) const {
94     auto len = std::min(bits_.size(), rval.bits_.size());
95     Keychords::Mask ret;
96     ret.bits_.resize(len);
97     for (size_t i = 0; i < len; ++i) {
98         ret.bits_[i] = bits_[i] & rval.bits_[i];
99     }
100     return ret;
101 }
102 
operator |=(const Keychords::Mask & rval)103 void Keychords::Mask::operator|=(const Keychords::Mask& rval) {
104     auto len = rval.bits_.size();
105     bits_.resize(len);
106     for (size_t i = 0; i < len; ++i) {
107         bits_[i] |= rval.bits_[i];
108     }
109 }
110 
Entry()111 Keychords::Entry::Entry() : notified(false) {}
112 
LambdaCheck()113 void Keychords::LambdaCheck() {
114     for (auto& [keycodes, entry] : entries_) {
115         auto found = true;
116         for (auto& code : keycodes) {
117             if (!current_.GetBit(code)) {
118                 entry.notified = false;
119                 found = false;
120                 break;
121             }
122         }
123         if (!found) continue;
124         if (entry.notified) continue;
125         entry.notified = true;
126         handler_(keycodes);
127     }
128 }
129 
LambdaHandler(int fd)130 void Keychords::LambdaHandler(int fd) {
131     input_event event;
132     auto res = TEMP_FAILURE_RETRY(::read(fd, &event, sizeof(event)));
133     if ((res != sizeof(event)) || (event.type != EV_KEY)) return;
134     current_.SetBit(event.code, event.value);
135     LambdaCheck();
136 }
137 
GeteventEnable(int fd)138 bool Keychords::GeteventEnable(int fd) {
139     // Make sure it is an event channel, should pass this ioctl call
140     int version;
141     if (::ioctl(fd, EVIOCGVERSION, &version)) return false;
142 
143 #ifdef EVIOCSMASK
144     static auto EviocsmaskSupported = true;
145     if (EviocsmaskSupported) {
146         Keychords::Mask mask(EV_KEY);
147         mask.SetBit(EV_KEY);
148         input_mask msg = {};
149         msg.type = EV_SYN;
150         msg.codes_size = mask.bytesize();
151         msg.codes_ptr = reinterpret_cast<uintptr_t>(mask.data());
152         if (::ioctl(fd, EVIOCSMASK, &msg) == -1) {
153             PLOG(WARNING) << "EVIOCSMASK not supported";
154             EviocsmaskSupported = false;
155         }
156     }
157 #endif
158 
159     Keychords::Mask mask;
160     for (auto& [keycodes, entry] : entries_) {
161         for (auto& code : keycodes) {
162             mask.resize(code);
163             mask.SetBit(code);
164         }
165     }
166 
167     current_.resize(mask.size());
168     Keychords::Mask available(mask.size());
169     auto res = ::ioctl(fd, EVIOCGBIT(EV_KEY, available.bytesize()), available.data());
170     if (res == -1) return false;
171     if (!(available & mask)) return false;
172 
173 #ifdef EVIOCSMASK
174     if (EviocsmaskSupported) {
175         input_mask msg = {};
176         msg.type = EV_KEY;
177         msg.codes_size = mask.bytesize();
178         msg.codes_ptr = reinterpret_cast<uintptr_t>(mask.data());
179         ::ioctl(fd, EVIOCSMASK, &msg);
180     }
181 #endif
182 
183     Keychords::Mask set(mask.size());
184     res = ::ioctl(fd, EVIOCGKEY(res), set.data());
185     if (res > 0) {
186         current_ |= mask & available & set;
187         LambdaCheck();
188     }
189     if (auto result = epoll_->RegisterHandler(fd, [this, fd]() { this->LambdaHandler(fd); });
190         !result.ok()) {
191         LOG(WARNING) << "Could not register keychord epoll handler: " << result.error();
192         return false;
193     }
194     return true;
195 }
196 
GeteventOpenDevice(const std::string & device)197 void Keychords::GeteventOpenDevice(const std::string& device) {
198     if (registration_.count(device)) return;
199     auto fd = TEMP_FAILURE_RETRY(::open(device.c_str(), O_RDONLY | O_CLOEXEC));
200     if (fd == -1) {
201         PLOG(ERROR) << "Can not open " << device;
202         return;
203     }
204     if (!GeteventEnable(fd)) {
205         ::close(fd);
206     } else {
207         registration_.emplace(device, fd);
208     }
209 }
210 
GeteventCloseDevice(const std::string & device)211 void Keychords::GeteventCloseDevice(const std::string& device) {
212     auto it = registration_.find(device);
213     if (it == registration_.end()) return;
214     auto fd = (*it).second;
215     epoll_->UnregisterHandler(fd);
216     registration_.erase(it);
217     ::close(fd);
218 }
219 
InotifyHandler()220 void Keychords::InotifyHandler() {
221     unsigned char buf[512];  // History shows 32-64 bytes typical
222 
223     auto res = TEMP_FAILURE_RETRY(::read(inotify_fd_, buf, sizeof(buf)));
224     if (res < 0) {
225         PLOG(WARNING) << "could not get event";
226         return;
227     }
228 
229     auto event_buf = buf;
230     while (static_cast<size_t>(res) >= sizeof(inotify_event)) {
231         auto event = reinterpret_cast<inotify_event*>(event_buf);
232         auto event_size = sizeof(inotify_event) + event->len;
233         if (static_cast<size_t>(res) < event_size) break;
234         if (event->len) {
235             std::string devname(kDevicePath);
236             devname += '/';
237             devname += event->name;
238             if (event->mask & IN_CREATE) {
239                 GeteventOpenDevice(devname);
240             } else {
241                 GeteventCloseDevice(devname);
242             }
243         }
244         res -= event_size;
245         event_buf += event_size;
246     }
247 }
248 
GeteventOpenDevice()249 void Keychords::GeteventOpenDevice() {
250     inotify_fd_ = ::inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
251     if (inotify_fd_ < 0) {
252         PLOG(WARNING) << "Could not instantiate inotify for " << kDevicePath;
253     } else if (::inotify_add_watch(inotify_fd_, kDevicePath, IN_DELETE | IN_CREATE | IN_ONLYDIR) <
254                0) {
255         PLOG(WARNING) << "Could not add watch for " << kDevicePath;
256         ::close(inotify_fd_);
257         inotify_fd_ = -1;
258     }
259 
260     std::unique_ptr<DIR, decltype(&closedir)> device(opendir(kDevicePath), closedir);
261     if (device) {
262         dirent* entry;
263         while ((entry = readdir(device.get()))) {
264             if (entry->d_name[0] == '.') continue;
265             std::string devname(kDevicePath);
266             devname += '/';
267             devname += entry->d_name;
268             GeteventOpenDevice(devname);
269         }
270     }
271 
272     if (inotify_fd_ >= 0) {
273         if (auto result =
274                     epoll_->RegisterHandler(inotify_fd_, [this]() { this->InotifyHandler(); });
275             !result.ok()) {
276             LOG(WARNING) << "Could not register keychord epoll handler: " << result.error();
277         }
278     }
279 }
280 
Register(const std::vector<int> & keycodes)281 void Keychords::Register(const std::vector<int>& keycodes) {
282     if (keycodes.empty()) return;
283     entries_.try_emplace(keycodes, Entry());
284 }
285 
Start(Epoll * epoll,std::function<void (const std::vector<int> &)> handler)286 void Keychords::Start(Epoll* epoll, std::function<void(const std::vector<int>&)> handler) {
287     epoll_ = epoll;
288     handler_ = std::move(handler);
289     if (entries_.size()) GeteventOpenDevice();
290 }
291 
292 }  // namespace init
293 }  // namespace android
294