device/hid/hid_connection_linux.cc

   1 // Copyright (c) 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "device/hid/hid_connection_linux.h"
   6
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <libudev.h>
  10 #include <linux/hidraw.h>
  11 #include <sys/ioctl.h>
  12
  13 #include <string>
  14
  15 #include "base/files/file_path.h"
  16 #include "base/posix/eintr_wrapper.h"
  17 #include "base/threading/thread_restrictions.h"
  18 #include "base/tuple.h"
  19 #include "device/hid/hid_service.h"
  20 #include "device/hid/hid_service_linux.h"
  21
  22 // These are already defined in newer versions of linux/hidraw.h.
  23 #ifndef HIDIOCSFEATURE
  24 #define HIDIOCSFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x06, len)
  25 #endif
  26 #ifndef HIDIOCGFEATURE
  27 #define HIDIOCGFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x07, len)
  28 #endif
  29
  30 namespace device {
  31
  32 namespace {
  33
  34 // Copies a buffer into a new one with a report ID byte inserted at the front.
  35 scoped_refptr<net::IOBufferWithSize> CopyBufferWithReportId(
  36     scoped_refptr<net::IOBufferWithSize> buffer,
  37     uint8_t report_id) {
  38   scoped_refptr<net::IOBufferWithSize> new_buffer(
  39       new net::IOBufferWithSize(buffer->size() + 1));
  40   new_buffer->data()[0] = report_id;
  41   memcpy(new_buffer->data() + 1, buffer->data(), buffer->size());
  42   return new_buffer;
  43 }
  44
  45 const char kHidrawSubsystem[] = "hidraw";
  46
  47 }  // namespace
  48
  49 HidConnectionLinux::HidConnectionLinux(HidDeviceInfo device_info,
  50                                        ScopedUdevDevicePtr udev_raw_device)
  51     : HidConnection(device_info) {
  52   DCHECK(thread_checker_.CalledOnValidThread());
  53
  54   udev_device* dev = udev_raw_device.get();
  55   std::string dev_node;
  56   if (!FindHidrawDevNode(dev, &dev_node)) {
  57     LOG(ERROR) << "Cannot open HID device as hidraw device.";
  58     return;
  59   }
  60
  61   int flags = base::File::FLAG_OPEN |
  62               base::File::FLAG_READ |
  63               base::File::FLAG_WRITE;
  64
  65   base::File device_file(base::FilePath(dev_node), flags);
  66   if (!device_file.IsValid()) {
  67     LOG(ERROR) << device_file.error_details();
  68     return;
  69   }
  70   if (fcntl(device_file.GetPlatformFile(), F_SETFL,
  71             fcntl(device_file.GetPlatformFile(), F_GETFL) | O_NONBLOCK)) {
  72     PLOG(ERROR) << "Failed to set non-blocking flag to device file.";
  73     return;
  74   }
  75   device_file_ = device_file.Pass();
  76
  77   if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
  78       device_file_.GetPlatformFile(),
  79       true,
  80       base::MessageLoopForIO::WATCH_READ_WRITE,
  81       &device_file_watcher_,
  82       this)) {
  83     LOG(ERROR) << "Failed to start watching device file.";
  84   }
  85 }
  86
  87 HidConnectionLinux::~HidConnectionLinux() {
  88   DCHECK(thread_checker_.CalledOnValidThread());
  89   Disconnect();
  90 }
  91
  92 void HidConnectionLinux::OnFileCanReadWithoutBlocking(int fd) {
  93   DCHECK(thread_checker_.CalledOnValidThread());
  94   DCHECK_EQ(fd, device_file_.GetPlatformFile());
  95
  96   uint8 buffer[1024] = {0};
  97   int bytes_read =
  98       HANDLE_EINTR(read(device_file_.GetPlatformFile(), buffer, 1024));
  99   if (bytes_read < 0) {
 100     if (errno == EAGAIN) {
 101       return;
 102     }
 103     Disconnect();
 104     return;
 105   }
 106
 107   PendingHidReport report;
 108   report.buffer = new net::IOBufferWithSize(bytes_read);
 109   memcpy(report.buffer->data(), buffer, bytes_read);
 110   pending_reports_.push(report);
 111   ProcessReadQueue();
 112 }
 113
 114 void HidConnectionLinux::OnFileCanWriteWithoutBlocking(int fd) {}
 115
 116 void HidConnectionLinux::Disconnect() {
 117   DCHECK(thread_checker_.CalledOnValidThread());
 118   device_file_watcher_.StopWatchingFileDescriptor();
 119   device_file_.Close();
 120   while (!pending_reads_.empty()) {
 121     PendingHidRead pending_read = pending_reads_.front();
 122     pending_reads_.pop();
 123     pending_read.callback.Run(false, 0);
 124   }
 125 }
 126
 127 void HidConnectionLinux::Read(scoped_refptr<net::IOBufferWithSize> buffer,
 128                               const IOCallback& callback) {
 129   DCHECK(thread_checker_.CalledOnValidThread());
 130   PendingHidRead pending_read;
 131   pending_read.buffer = buffer;
 132   pending_read.callback = callback;
 133   pending_reads_.push(pending_read);
 134   ProcessReadQueue();
 135 }
 136
 137 void HidConnectionLinux::Write(uint8_t report_id,
 138                                scoped_refptr<net::IOBufferWithSize> buffer,
 139                                const IOCallback& callback) {
 140   DCHECK(thread_checker_.CalledOnValidThread());
 141   // If report ID is non-zero, insert it into a new copy of the buffer.
 142   if (report_id != 0)
 143     buffer = CopyBufferWithReportId(buffer, report_id);
 144   int bytes_written = HANDLE_EINTR(
 145       write(device_file_.GetPlatformFile(), buffer->data(), buffer->size()));
 146   if (bytes_written < 0) {
 147     Disconnect();
 148     callback.Run(false, 0);
 149   } else {
 150     callback.Run(true, bytes_written);
 151   }
 152 }
 153
 154 void HidConnectionLinux::GetFeatureReport(
 155     uint8_t report_id,
 156     scoped_refptr<net::IOBufferWithSize> buffer,
 157     const IOCallback& callback) {
 158   DCHECK(thread_checker_.CalledOnValidThread());
 159
 160   if (buffer->size() == 0) {
 161     callback.Run(false, 0);
 162     return;
 163   }
 164
 165   // The first byte of the destination buffer is the report ID being requested.
 166   buffer->data()[0] = report_id;
 167   int result = ioctl(device_file_.GetPlatformFile(),
 168                      HIDIOCGFEATURE(buffer->size()),
 169                      buffer->data());
 170   if (result < 0)
 171     callback.Run(false, 0);
 172   else
 173     callback.Run(true, result);
 174 }
 175
 176 void HidConnectionLinux::SendFeatureReport(
 177     uint8_t report_id,
 178     scoped_refptr<net::IOBufferWithSize> buffer,
 179     const IOCallback& callback) {
 180   DCHECK(thread_checker_.CalledOnValidThread());
 181   if (report_id != 0)
 182     buffer = CopyBufferWithReportId(buffer, report_id);
 183   int result = ioctl(device_file_.GetPlatformFile(),
 184                      HIDIOCSFEATURE(buffer->size()),
 185                      buffer->data());
 186   if (result < 0)
 187     callback.Run(false, 0);
 188   else
 189     callback.Run(true, result);
 190 }
 191
 192 void HidConnectionLinux::ProcessReadQueue() {
 193   while (pending_reads_.size() && pending_reports_.size()) {
 194     PendingHidRead read = pending_reads_.front();
 195     pending_reads_.pop();
 196     PendingHidReport report = pending_reports_.front();
 197     if (report.buffer->size() > read.buffer->size()) {
 198       read.callback.Run(false, report.buffer->size());
 199     } else {
 200       memcpy(read.buffer->data(), report.buffer->data(), report.buffer->size());
 201       pending_reports_.pop();
 202       read.callback.Run(true, report.buffer->size());
 203     }
 204   }
 205 }
 206
 207 bool HidConnectionLinux::FindHidrawDevNode(udev_device* parent,
 208                                            std::string* result) {
 209   udev* udev = udev_device_get_udev(parent);
 210   if (!udev) {
 211       return false;
 212   }
 213   ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev));
 214   if (!enumerate) {
 215     return false;
 216   }
 217   if (udev_enumerate_add_match_subsystem(enumerate.get(), kHidrawSubsystem)) {
 218     return false;
 219   }
 220   if (udev_enumerate_scan_devices(enumerate.get())) {
 221     return false;
 222   }
 223   std::string parent_path(udev_device_get_devpath(parent));
 224   if (parent_path.length() == 0 || *parent_path.rbegin() != '/')
 225     parent_path += '/';
 226   udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate.get());
 227   for (udev_list_entry* i = devices; i != NULL;
 228        i = udev_list_entry_get_next(i)) {
 229     ScopedUdevDevicePtr hid_dev(
 230         udev_device_new_from_syspath(udev, udev_list_entry_get_name(i)));
 231     const char* raw_path = udev_device_get_devnode(hid_dev.get());
 232     std::string device_path = udev_device_get_devpath(hid_dev.get());
 233     if (raw_path &&
 234         !device_path.compare(0, parent_path.length(), parent_path)) {
 235       *result = raw_path;
 236       return true;
 237     }
 238   }
 239
 240   return false;
 241 }
 242
 243 }  // namespace device