blob: fd5fc01ee402620be842a5ed65d2c35dd3330f1a [file] [log] [blame]
// Copyright (c) 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/hid/hid_connection_linux.h"
#include <errno.h>
#include <linux/hidraw.h>
#include <sys/ioctl.h>
#include <memory>
#include <string>
#include <utility>
#include "base/bind.h"
#include "base/files/file_descriptor_watcher_posix.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/posix/eintr_wrapper.h"
#include "base/threading/thread_restrictions.h"
#include "base/threading/thread_task_runner_handle.h"
#include "components/device_event_log/device_event_log.h"
#include "device/hid/hid_service.h"
// These are already defined in newer versions of linux/hidraw.h.
#ifndef HIDIOCSFEATURE
#define HIDIOCSFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x06, len)
#endif
#ifndef HIDIOCGFEATURE
#define HIDIOCGFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x07, len)
#endif
namespace device {
class HidConnectionLinux::BlockingTaskHelper {
public:
BlockingTaskHelper(base::ScopedFD fd,
scoped_refptr<HidDeviceInfo> device_info,
base::WeakPtr<HidConnectionLinux> connection)
: fd_(std::move(fd)),
connection_(connection),
origin_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
DETACH_FROM_SEQUENCE(sequence_checker_);
// Report buffers must always have room for the report ID.
report_buffer_size_ = device_info->max_input_report_size() + 1;
has_report_id_ = device_info->has_report_id();
}
~BlockingTaskHelper() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); }
// Starts the FileDescriptorWatcher that reads input events from the device.
// Must be called on a thread that has a base::MessageLoopForIO.
void Start() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
base::ThreadRestrictions::AssertIOAllowed();
file_watcher_ = base::FileDescriptorWatcher::WatchReadable(
fd_.get(), base::Bind(&BlockingTaskHelper::OnFileCanReadWithoutBlocking,
base::Unretained(this)));
}
void Write(scoped_refptr<net::IOBuffer> buffer,
size_t size,
const WriteCallback& callback) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
ssize_t result = HANDLE_EINTR(write(fd_.get(), buffer->data(), size));
if (result < 0) {
HID_PLOG(EVENT) << "Write failed";
origin_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
} else {
if (static_cast<size_t>(result) != size)
HID_LOG(EVENT) << "Incomplete HID write: " << result << " != " << size;
origin_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
}
}
void GetFeatureReport(uint8_t report_id,
scoped_refptr<net::IOBufferWithSize> buffer,
const ReadCallback& callback) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
int result = HANDLE_EINTR(
ioctl(fd_.get(), HIDIOCGFEATURE(buffer->size()), buffer->data()));
if (result < 0) {
HID_PLOG(EVENT) << "Failed to get feature report";
origin_task_runner_->PostTask(FROM_HERE,
base::Bind(callback, false, nullptr, 0));
} else if (result == 0) {
HID_LOG(EVENT) << "Get feature result too short.";
origin_task_runner_->PostTask(FROM_HERE,
base::Bind(callback, false, nullptr, 0));
} else if (report_id == 0) {
// Linux adds a 0 to the beginning of the data received from the device.
scoped_refptr<net::IOBuffer> copied_buffer(new net::IOBuffer(result - 1));
memcpy(copied_buffer->data(), buffer->data() + 1, result - 1);
origin_task_runner_->PostTask(
FROM_HERE, base::Bind(callback, true, copied_buffer, result - 1));
} else {
origin_task_runner_->PostTask(FROM_HERE,
base::Bind(callback, true, buffer, result));
}
}
void SendFeatureReport(scoped_refptr<net::IOBuffer> buffer,
size_t size,
const WriteCallback& callback) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
int result =
HANDLE_EINTR(ioctl(fd_.get(), HIDIOCSFEATURE(size), buffer->data()));
if (result < 0) {
HID_PLOG(EVENT) << "Failed to send feature report";
origin_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
} else {
origin_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
}
}
private:
void OnFileCanReadWithoutBlocking() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(report_buffer_size_));
char* data = buffer->data();
size_t length = report_buffer_size_;
if (!has_report_id_) {
// Linux will not prefix the buffer with a report ID if report IDs are not
// used by the device. Prefix the buffer with 0.
*data++ = 0;
length--;
}
ssize_t bytes_read = HANDLE_EINTR(read(fd_.get(), data, length));
if (bytes_read < 0) {
if (errno != EAGAIN) {
HID_PLOG(EVENT) << "Read failed";
// This assumes that the error is unrecoverable and disables reading
// from the device until it has been re-opened.
// TODO(reillyg): Investigate starting and stopping the file descriptor
// watcher in response to pending read requests so that per-request
// errors can be returned to the client.
file_watcher_.reset();
}
return;
}
if (!has_report_id_) {
// Behave as if the byte prefixed above as the the report ID was read.
bytes_read++;
}
origin_task_runner_->PostTask(
FROM_HERE, base::Bind(&HidConnectionLinux::ProcessInputReport,
connection_, buffer, bytes_read));
}
SEQUENCE_CHECKER(sequence_checker_);
base::ScopedFD fd_;
size_t report_buffer_size_;
bool has_report_id_;
base::WeakPtr<HidConnectionLinux> connection_;
const scoped_refptr<base::SequencedTaskRunner> origin_task_runner_;
std::unique_ptr<base::FileDescriptorWatcher::Controller> file_watcher_;
DISALLOW_COPY_AND_ASSIGN(BlockingTaskHelper);
};
HidConnectionLinux::HidConnectionLinux(
scoped_refptr<HidDeviceInfo> device_info,
base::ScopedFD fd,
scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
: HidConnection(device_info),
blocking_task_runner_(std::move(blocking_task_runner)),
weak_factory_(this) {
helper_ = base::MakeUnique<BlockingTaskHelper>(std::move(fd), device_info,
weak_factory_.GetWeakPtr());
blocking_task_runner_->PostTask(
FROM_HERE,
base::Bind(&BlockingTaskHelper::Start, base::Unretained(helper_.get())));
}
HidConnectionLinux::~HidConnectionLinux() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}
void HidConnectionLinux::PlatformClose() {
// By closing the device on the blocking task runner 1) the requirement that
// base::ScopedFD is destroyed on a thread where I/O is allowed is satisfied
// and 2) any tasks posted to this task runner that refer to this file will
// complete before it is closed.
blocking_task_runner_->DeleteSoon(FROM_HERE, helper_.release());
while (!pending_reads_.empty()) {
pending_reads_.front().callback.Run(false, NULL, 0);
pending_reads_.pop();
}
}
void HidConnectionLinux::PlatformRead(const ReadCallback& callback) {
PendingHidRead pending_read;
pending_read.callback = callback;
pending_reads_.push(pending_read);
ProcessReadQueue();
}
void HidConnectionLinux::PlatformWrite(scoped_refptr<net::IOBuffer> buffer,
size_t size,
const WriteCallback& callback) {
// Linux expects the first byte of the buffer to always be a report ID so the
// buffer can be used directly.
blocking_task_runner_->PostTask(
FROM_HERE,
base::Bind(&BlockingTaskHelper::Write, base::Unretained(helper_.get()),
buffer, size, callback));
}
void HidConnectionLinux::PlatformGetFeatureReport(
uint8_t report_id,
const ReadCallback& callback) {
// The first byte of the destination buffer is the report ID being requested
// and is overwritten by the feature report.
DCHECK_GT(device_info()->max_feature_report_size(), 0u);
scoped_refptr<net::IOBufferWithSize> buffer(
new net::IOBufferWithSize(device_info()->max_feature_report_size() + 1));
buffer->data()[0] = report_id;
blocking_task_runner_->PostTask(
FROM_HERE,
base::Bind(&BlockingTaskHelper::GetFeatureReport,
base::Unretained(helper_.get()), report_id, buffer, callback));
}
void HidConnectionLinux::PlatformSendFeatureReport(
scoped_refptr<net::IOBuffer> buffer,
size_t size,
const WriteCallback& callback) {
// Linux expects the first byte of the buffer to always be a report ID so the
// buffer can be used directly.
blocking_task_runner_->PostTask(
FROM_HERE,
base::Bind(&BlockingTaskHelper::SendFeatureReport,
base::Unretained(helper_.get()), buffer, size, callback));
}
void HidConnectionLinux::ProcessInputReport(scoped_refptr<net::IOBuffer> buffer,
size_t size) {
DCHECK(thread_checker().CalledOnValidThread());
DCHECK_GE(size, 1u);
uint8_t report_id = buffer->data()[0];
if (IsReportIdProtected(report_id))
return;
PendingHidReport report;
report.buffer = buffer;
report.size = size;
pending_reports_.push(report);
ProcessReadQueue();
}
void HidConnectionLinux::ProcessReadQueue() {
DCHECK(thread_checker().CalledOnValidThread());
// Hold a reference to |this| to prevent a callback from freeing this object
// during the loop.
scoped_refptr<HidConnectionLinux> self(this);
while (pending_reads_.size() && pending_reports_.size()) {
PendingHidRead read = pending_reads_.front();
PendingHidReport report = pending_reports_.front();
pending_reads_.pop();
pending_reports_.pop();
read.callback.Run(true, report.buffer, report.size);
}
}
} // namespace device