libteeui/src/evdev.cpp - platform/system/teeui - Git at Google

 /*
  *
  * Copyright 2018, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <secure_input/evdev.h>

 #include <android-base/logging.h>
 #include <dirent.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <poll.h>
 #include <signal.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <teeui/msg_formatting.h>
 #include <time.h>

 #include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
 #include <list>
 #include <mutex>
 #include <string>
 #include <thread>
 #include <tuple>

 namespace secure_input {

 bool EventLoop::timerOrder(const Timer& a, const Timer& b) {
     return a.next > b.next;
 }

 void EventLoop::processNewTimers() {
     for (auto& timer : newTimers_) {
         timers_.push_back(std::move(timer));
         std::push_heap(timers_.begin(), timers_.end(), timerOrder);
     }
     newTimers_.clear();
 }

 int EventLoop::runTimers() {
     using namespace std::chrono_literals;
     auto now = std::chrono::steady_clock::now();
     while (!timers_.empty() && timers_[0].next <= now) {
         std::pop_heap(timers_.begin(), timers_.end(), timerOrder);
         auto& current = *timers_.rbegin();
         current.handleTimer();
         if (!current.oneShot) {
             auto diff = now - current.next;
             current.next += ((diff / current.duration) + 1) * current.duration;
             std::push_heap(timers_.begin(), timers_.end(), timerOrder);
         } else {
             timers_.pop_back();
         }
     }
     if (timers_.empty()) return -1;
     auto& next = *timers_.begin();
     auto diff = next.next - now;
     if (diff > 60s) {
         return 60000;
     } else {
         return std::chrono::duration_cast<std::chrono::milliseconds>(diff).count();
     }
 }

 void EventLoop::processNewReceivers() {
     for (auto& receiver : newReceivers_) {
         receivers_.push_back(std::move(receiver));
     }
     newReceivers_.clear();
 }

 void EventLoop::addEventReceiver(NonCopyableFunction<void(short)> handler, int eventFd,
                                  short flags) {
     std::unique_lock<std::mutex> lock(mutex_);
     newReceivers_.emplace_back(eventFd, flags, std::move(handler));
     if (eventFd_ != -1) {
         eventfd_write(eventFd_, 1);
     }
 }

 void EventLoop::addTimer(NonCopyableFunction<void()> handler,
                          std::chrono::steady_clock::duration duration, bool oneShot) {
     std::unique_lock<std::mutex> lock(mutex_);
     std::chrono::steady_clock::time_point next = std::chrono::steady_clock::now() + duration;
     newTimers_.emplace_back(next, duration, std::move(handler), oneShot);
     if (eventFd_ != -1) {
         eventfd_write(eventFd_, 1);
     }
 }

 bool EventLoop::start() {
     std::unique_lock<std::mutex> lock(mutex_);
     if (state_ != ThreadState::JOINED) return false;
     eventFd_ = eventfd(0, EFD_CLOEXEC);
     if (eventFd_ == -1) return false;
     state_ = ThreadState::STARTING;

     thread_ = std::thread([this]() {
         std::unique_lock<std::mutex> lock(mutex_);
         state_ = ThreadState::RUNNING;
         lock.unlock();
         condVar_.notify_all();
         lock.lock();
         while (state_ == ThreadState::RUNNING) {
             processNewTimers();
             processNewReceivers();  // must be called while locked
             lock.unlock();
             std::vector<pollfd> fds(receivers_.size() + 1);
             fds[0] = {eventFd_, POLLIN, 0};
             unsigned i = 1;
             for (auto& receiver : receivers_) {
                 fds[i] = {receiver.eventFd, receiver.eventFlags, 0};
                 ++i;
             }
             auto rc = poll(fds.data(), fds.size(), runTimers());
             if (state_ != ThreadState::RUNNING) {
                 lock.lock();
                 break;
             }
             if (rc > 0) {
                 // don't handle eventFd_ explicitly
                 i = 1;
                 for (auto& receiver : receivers_) {
                     if (fds[i].revents & receiver.eventFlags) {
                         receiver.handleEvent(fds[i].revents);
                     }
                     ++i;
                 }
             } else if (rc < 0) {
                 LOG(ERROR) << __func__ << " poll failed with errno: " << strerror(errno);
             }
             lock.lock();
         }
         state_ = ThreadState::TERMINATING;
         lock.unlock();
         condVar_.notify_all();
     });
     condVar_.wait(lock, [this]() -> bool { return state_ != ThreadState::STARTING; });
     return state_ == ThreadState::RUNNING;
 }

 void EventLoop::stop() {
     std::unique_lock<std::mutex> lock(mutex_);
     if (state_ == ThreadState::JOINED) return;
     if (state_ == ThreadState::RUNNING) {
         state_ = ThreadState::STOP_REQUESTED;
         eventfd_write(eventFd_, 1);
     }
     condVar_.wait(lock, [this]() -> bool { return state_ == ThreadState::TERMINATING; });
     thread_.join();
     close(eventFd_);
     state_ = ThreadState::JOINED;
     LOG(DEBUG) << "Done ending event polling";
 }

 EventLoop::~EventLoop() {
     stop();
 }

 EventDev::EventDev() : fd_(-1), path_("") {}
 EventDev::EventDev(const std::string& path) : fd_(-1), path_(path) {}
 EventDev::EventDev(EventDev&& other) : fd_(other.fd_), path_(std::move(other.path_)) {
     other.fd_ = -1;
 }
 EventDev& EventDev::operator=(EventDev&& other) {
     if (&other == this) return *this;
     fd_ = other.fd_;
     path_ = std::move(other.path_);
     other.fd_ = -1;
     return *this;
 }
 bool EventDev::grab() {
     if (fd_ >= 0) {
         return true;
     }
     fd_ = TEMP_FAILURE_RETRY(open(path_.c_str(), O_RDWR | O_NONBLOCK));
     if (fd_ < 0) {
         LOG(ERROR) << "failed to open event device \"" << path_ << "\"";
         return false;
     }
     int error = ioctl(fd_, EVIOCGRAB, 1);
     if (error) {
         LOG(ERROR) << "failed to grab event device " << path_ << " exclusively EVIOCGRAB returned "
                    << error << " " << strerror(errno);
         close(fd_);
         fd_ = -1;
         return false;
     }
     return true;
 }

 void EventDev::ungrab() {
     if (fd_ < 0) {
         return;
     }
     int error = ioctl(fd_, EVIOCGRAB, 0);
     if (error) {
         LOG(ERROR) << "failed to ungrab \"" << path_ << "\" EVIOCGRAB returned " << error;
     }
     close(fd_);
     fd_ = -1;
 }

 std::tuple<bool, input_event> EventDev::readEvent() const {
     std::tuple<bool, input_event> result{false, {}};
     ssize_t rc;
     rc = TEMP_FAILURE_RETRY(read(fd_, &std::get<1>(result), sizeof std::get<1>(result)));
     std::get<0>(result) = rc == sizeof std::get<1>(result);
     return result;
 }

 int EventDev::fd() const {
     return fd_;
 }

 bool grabAllEvDevsAndRegisterCallbacks(EventLoop* eventloop,
                                        std::function<void(short, const EventDev&)> handler) {
     if (!eventloop) return false;
     dirent** dirs = nullptr;
     int n = scandir(
         "/dev/input", &dirs,
         [](const dirent* dir) -> int {
             return (dir->d_type & DT_CHR) && !strncmp("event", dir->d_name, 5);
         },
         alphasort);
     if (n < 0) {
         LOG(WARNING) << "Unable to enumerate input devices " << strerror(errno);
         return true;
     }

     bool result = true;
     for (int i = 0; i < n; ++i) {
         EventDev evDev(std::string("/dev/input/") + dirs[i]->d_name);
         result = result && evDev.grab();
         int fd = evDev.fd();
         eventloop->addEventReceiver(
             [&, handler, evDev = std::move(evDev)](short flags) { handler(flags, evDev); }, fd,
             POLLIN);
         free(dirs[i]);
     }
     free(dirs);
     // true if all devices where grabbed successfully
     return result;
 }

 }  // namespace secure_input
	/*
	*
	* Copyright 2018, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <secure_input/evdev.h>

	#include <android-base/logging.h>
	#include <dirent.h>
	#include <fcntl.h>
	#include <linux/input.h>
	#include <poll.h>
	#include <signal.h>
	#include <sys/eventfd.h>
	#include <sys/ioctl.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <teeui/msg_formatting.h>
	#include <time.h>

	#include <algorithm>
	#include <atomic>
	#include <chrono>
	#include <condition_variable>
	#include <list>
	#include <mutex>
	#include <string>
	#include <thread>
	#include <tuple>

	namespace secure_input {

	bool EventLoop::timerOrder(const Timer& a, const Timer& b) {
	return a.next > b.next;
	}

	void EventLoop::processNewTimers() {
	for (auto& timer : newTimers_) {
	timers_.push_back(std::move(timer));
	std::push_heap(timers_.begin(), timers_.end(), timerOrder);
	}
	newTimers_.clear();
	}

	int EventLoop::runTimers() {
	using namespace std::chrono_literals;
	auto now = std::chrono::steady_clock::now();
	while (!timers_.empty() && timers_[0].next <= now) {
	std::pop_heap(timers_.begin(), timers_.end(), timerOrder);
	auto& current = *timers_.rbegin();
	current.handleTimer();
	if (!current.oneShot) {
	auto diff = now - current.next;
	current.next += ((diff / current.duration) + 1) * current.duration;
	std::push_heap(timers_.begin(), timers_.end(), timerOrder);
	} else {
	timers_.pop_back();
	}
	}
	if (timers_.empty()) return -1;
	auto& next = *timers_.begin();
	auto diff = next.next - now;
	if (diff > 60s) {
	return 60000;
	} else {
	return std::chrono::duration_cast<std::chrono::milliseconds>(diff).count();
	}
	}

	void EventLoop::processNewReceivers() {
	for (auto& receiver : newReceivers_) {
	receivers_.push_back(std::move(receiver));
	}
	newReceivers_.clear();
	}

	void EventLoop::addEventReceiver(NonCopyableFunction<void(short)> handler, int eventFd,
	short flags) {
	std::unique_lock<std::mutex> lock(mutex_);
	newReceivers_.emplace_back(eventFd, flags, std::move(handler));
	if (eventFd_ != -1) {
	eventfd_write(eventFd_, 1);
	}
	}

	void EventLoop::addTimer(NonCopyableFunction<void()> handler,
	std::chrono::steady_clock::duration duration, bool oneShot) {
	std::unique_lock<std::mutex> lock(mutex_);
	std::chrono::steady_clock::time_point next = std::chrono::steady_clock::now() + duration;
	newTimers_.emplace_back(next, duration, std::move(handler), oneShot);
	if (eventFd_ != -1) {
	eventfd_write(eventFd_, 1);
	}
	}

	bool EventLoop::start() {
	std::unique_lock<std::mutex> lock(mutex_);
	if (state_ != ThreadState::JOINED) return false;
	eventFd_ = eventfd(0, EFD_CLOEXEC);
	if (eventFd_ == -1) return false;
	state_ = ThreadState::STARTING;

	thread_ = std::thread([this]() {
	std::unique_lock<std::mutex> lock(mutex_);
	state_ = ThreadState::RUNNING;
	lock.unlock();
	condVar_.notify_all();
	lock.lock();
	while (state_ == ThreadState::RUNNING) {
	processNewTimers();
	processNewReceivers(); // must be called while locked
	lock.unlock();
	std::vector<pollfd> fds(receivers_.size() + 1);
	fds[0] = {eventFd_, POLLIN, 0};
	unsigned i = 1;
	for (auto& receiver : receivers_) {
	fds[i] = {receiver.eventFd, receiver.eventFlags, 0};
	++i;
	}
	auto rc = poll(fds.data(), fds.size(), runTimers());
	if (state_ != ThreadState::RUNNING) {
	lock.lock();
	break;
	}
	if (rc > 0) {
	// don't handle eventFd_ explicitly
	i = 1;
	for (auto& receiver : receivers_) {
	if (fds[i].revents & receiver.eventFlags) {
	receiver.handleEvent(fds[i].revents);
	}
	++i;
	}
	} else if (rc < 0) {
	LOG(ERROR) << __func__ << " poll failed with errno: " << strerror(errno);
	}
	lock.lock();
	}
	state_ = ThreadState::TERMINATING;
	lock.unlock();
	condVar_.notify_all();
	});
	condVar_.wait(lock, [this]() -> bool { return state_ != ThreadState::STARTING; });
	return state_ == ThreadState::RUNNING;
	}

	void EventLoop::stop() {
	std::unique_lock<std::mutex> lock(mutex_);
	if (state_ == ThreadState::JOINED) return;
	if (state_ == ThreadState::RUNNING) {
	state_ = ThreadState::STOP_REQUESTED;
	eventfd_write(eventFd_, 1);
	}
	condVar_.wait(lock, [this]() -> bool { return state_ == ThreadState::TERMINATING; });
	thread_.join();
	close(eventFd_);
	state_ = ThreadState::JOINED;
	LOG(DEBUG) << "Done ending event polling";
	}

	EventLoop::~EventLoop() {
	stop();
	}

	EventDev::EventDev() : fd_(-1), path_("") {}
	EventDev::EventDev(const std::string& path) : fd_(-1), path_(path) {}
	EventDev::EventDev(EventDev&& other) : fd_(other.fd_), path_(std::move(other.path_)) {
	other.fd_ = -1;
	}
	EventDev& EventDev::operator=(EventDev&& other) {
	if (&other == this) return *this;
	fd_ = other.fd_;
	path_ = std::move(other.path_);
	other.fd_ = -1;
	return *this;
	}
	bool EventDev::grab() {
	if (fd_ >= 0) {
	return true;
	}
	fd_ = TEMP_FAILURE_RETRY(open(path_.c_str(), O_RDWR \| O_NONBLOCK));
	if (fd_ < 0) {
	LOG(ERROR) << "failed to open event device \"" << path_ << "\"";
	return false;
	}
	int error = ioctl(fd_, EVIOCGRAB, 1);
	if (error) {
	LOG(ERROR) << "failed to grab event device " << path_ << " exclusively EVIOCGRAB returned "
	<< error << " " << strerror(errno);
	close(fd_);
	fd_ = -1;
	return false;
	}
	return true;
	}

	void EventDev::ungrab() {
	if (fd_ < 0) {
	return;
	}
	int error = ioctl(fd_, EVIOCGRAB, 0);
	if (error) {
	LOG(ERROR) << "failed to ungrab \"" << path_ << "\" EVIOCGRAB returned " << error;
	}
	close(fd_);
	fd_ = -1;
	}

	std::tuple<bool, input_event> EventDev::readEvent() const {
	std::tuple<bool, input_event> result{false, {}};
	ssize_t rc;
	rc = TEMP_FAILURE_RETRY(read(fd_, &std::get<1>(result), sizeof std::get<1>(result)));
	std::get<0>(result) = rc == sizeof std::get<1>(result);
	return result;
	}

	int EventDev::fd() const {
	return fd_;
	}

	bool grabAllEvDevsAndRegisterCallbacks(EventLoop* eventloop,
	std::function<void(short, const EventDev&)> handler) {
	if (!eventloop) return false;
	dirent** dirs = nullptr;
	int n = scandir(
	"/dev/input", &dirs,
	[](const dirent* dir) -> int {
	return (dir->d_type & DT_CHR) && !strncmp("event", dir->d_name, 5);
	},
	alphasort);
	if (n < 0) {
	LOG(WARNING) << "Unable to enumerate input devices " << strerror(errno);
	return true;
	}

	bool result = true;
	for (int i = 0; i < n; ++i) {
	EventDev evDev(std::string("/dev/input/") + dirs[i]->d_name);
	result = result && evDev.grab();
	int fd = evDev.fd();
	eventloop->addEventReceiver(
	[&, handler, evDev = std::move(evDev)](short flags) { handler(flags, evDev); }, fd,
	POLLIN);
	free(dirs[i]);
	}
	free(dirs);
	// true if all devices where grabbed successfully
	return result;
	}

	} // namespace secure_input