usb_utils.cc

// Copyright 2017 The Chromium OS 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 "hammerd/usb_utils.h"

#include <fcntl.h>
#include <linux/usbdevice_fs.h>
#include <stdio.h>
#include <sys/ioctl.h>

#include <memory>
#include <string>

#include <base/files/file_enumerator.h>
#include <base/files/file_util.h>
#include <base/logging.h>
#include <base/strings/string_number_conversions.h>
#include <base/strings/string_split.h>
#include <base/strings/string_util.h>
#include <base/strings/stringprintf.h>

namespace hammerd {
namespace {
constexpr int kError = -1;
constexpr unsigned int kTimeoutMs = 1000;  // Default timeout value.
}  // namespace

const base::FilePath GetUsbSysfsPath(const std::string& path) {
  return base::FilePath(
      base::StringPrintf("/sys/bus/usb/devices/%s", path.c_str()));
}

static bool GetUsbDevicePath(const std::string& path, base::FilePath* out) {
  // Find the line in the uevent that starts with "DEVNAME=", and replace it
  // with "/dev/".
  const std::string devname_prefix = "DEVNAME=";
  const base::FilePath uevent_path = GetUsbSysfsPath(path).Append("uevent");
  std::string content;
  if (!base::ReadFileToString(uevent_path, &content)) {
    LOG(ERROR) << "Failed to read uevent.";
    return false;
  }
  for (const auto& line : base::SplitStringPiece(
           content, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
    if (base::StartsWith(line, devname_prefix, base::CompareCase::SENSITIVE)) {
      std::string path(line.data(), line.size());
      *out = base::FilePath("/dev").Append(path.substr(devname_prefix.size()));
      return true;
    }
  }
  LOG(ERROR) << "Failed to get usbfs path.";
  return false;
}

static bool ReadFileToInt(const base::FilePath& path, int* value) {
  std::string str;
  if (!base::ReadFileToString(path, &str)) {
    return false;
  }
  base::TrimWhitespaceASCII(str, base::TRIM_ALL, &str);
  return base::HexStringToInt(str, value);
}

static bool CheckFileIntValue(const base::FilePath& path, int value) {
  int file_value;
  return ReadFileToInt(path, &file_value) && (value == file_value);
}

UsbEndpoint::UsbEndpoint(uint16_t vendor_id,
                         uint16_t product_id,
                         std::string path)
    : vendor_id_(vendor_id),
      product_id_(product_id),
      path_(path),
      fd_(-1),
      iface_num_(-1),
      ep_num_(-1),
      chunk_len_(-1) {}

UsbEndpoint::~UsbEndpoint() {
  Close();
}

bool UsbEndpoint::UsbSysfsExists() {
  const base::FilePath usb_path = GetUsbSysfsPath(path_);
  return base::DirectoryExists(usb_path);
}

UsbConnectStatus UsbEndpoint::Connect() {
  if (IsConnected()) {
    DLOG(INFO) << "Already initialized. Ignore.";
    return UsbConnectStatus::kSuccess;
  }

  // Confirm the device has valid vendor/product ID.
  // (b/70955082): Only return |kInvalidDevice| when the VID/PID files exist but
  // aren't the expected values.  This is to prevent mis-reporting an invalid
  // device on AP suspend/resume, when the files may not yet be ready.
  if (!UsbSysfsExists()) {
    LOG(ERROR) << "USB sysfs does not exist.";
    return UsbConnectStatus::kUsbPathEmpty;
  }
  const base::FilePath usb_path = GetUsbSysfsPath(path_);
  int vendor_id, product_id;
  if (!ReadFileToInt(usb_path.Append("idVendor"), &vendor_id) ||
      !ReadFileToInt(usb_path.Append("idProduct"), &product_id)) {
    LOG(ERROR) << "Failed to read VID and PID.";
    return UsbConnectStatus::kUnknownError;
  }
  if (vendor_id_ != vendor_id || product_id_ != product_id) {
    LOG(ERROR) << "Invalid VID and PID.";
    return UsbConnectStatus::kInvalidDevice;
  }
  if (!base::ReadFileToString(usb_path.Append("configuration"),
                              &configuration_string_)) {
    LOG(ERROR) << "Failed to read configuration file.";
    return UsbConnectStatus::kUnknownError;
  }
  base::TrimWhitespaceASCII(configuration_string_, base::TRIM_ALL,
                            &configuration_string_);
  // Find the interface matching class, subclass, and protocol and the endpoint
  // number. The interface should only contain one pair of endpoints with the
  // same endpoint number, one for IN and another for OUT.
  // The endpoint address is composed of:
  // - Bits 0..6: Endpoint Number
  // - Bits 7:    Direction 0 = Out, 1 = In
  bool is_found = false;
  base::FileEnumerator iface_paths(usb_path, false,
                                   base::FileEnumerator::FileType::DIRECTORIES,
                                   base::StringPrintf("%s:*", path_.c_str()));
  for (base::FilePath iface_path = iface_paths.Next(); !iface_path.empty();
       iface_path = iface_paths.Next()) {
    if (CheckFileIntValue(iface_path.Append("bInterfaceClass"),
                          kUsbClassGoogleUpdate) &&
        CheckFileIntValue(iface_path.Append("bInterfaceSubClass"),
                          kUsbSubclassGoogleUpdate) &&
        CheckFileIntValue(iface_path.Append("bInterfaceProtocol"),
                          kUsbProtocolGoogleUpdate)) {
      if (!ReadFileToInt(iface_path.Append("bInterfaceNumber"), &iface_num_)) {
        LOG(ERROR) << "Failed to read interface number.";
        return UsbConnectStatus::kUnknownError;
      }
      if (!CheckFileIntValue(iface_path.Append("bNumEndpoints"), 2)) {
        LOG(ERROR) << "Interface should only have 2 Endpoints.";
        return UsbConnectStatus::kUnknownError;
      }
      // Get endpoint number and chunk size. Two endpoints should have the same
      // endpoint number, so just calculate it by the first one.
      base::FilePath ep_path =
          base::FileEnumerator(iface_path, false,
                               base::FileEnumerator::FileType::DIRECTORIES,
                               "ep_*")
              .Next();
      if (!ReadFileToInt(ep_path.Append("bEndpointAddress"), &ep_num_) ||
          !ReadFileToInt(ep_path.Append("wMaxPacketSize"), &chunk_len_)) {
        LOG(ERROR) << "Failed to read endpoint address and chunk size.";
        return UsbConnectStatus::kUnknownError;
      }
      ep_num_ = ep_num_ & 0x7f;  // Bit mask of 0~6 bits.
      DLOG(INFO) << "found interface " << iface_num_ << ", endpoint "
                 << static_cast<int>(ep_num_) << ", chunk_len " << chunk_len_;
      is_found = true;
      break;
    }
  }
  if (!is_found) {
    LOG(ERROR) << "Failed to find a valid interface.";
    return UsbConnectStatus::kUnknownError;
  }

  // Open the usbfs file, and claim the interface.
  base::FilePath usbfs_path;
  if (!GetUsbDevicePath(path_, &usbfs_path)) {
    return UsbConnectStatus::kUnknownError;
  }
  fd_ = open(usbfs_path.value().c_str(), O_RDWR | O_CLOEXEC);
  if (fd_ < 0) {
    PLOG(ERROR) << "Failed to open usbfs file";
    Close();
    return UsbConnectStatus::kUnknownError;
  }
  if (ioctl(fd_, USBDEVFS_CLAIMINTERFACE, &iface_num_)) {
    PLOG(ERROR) << "Failed to claim interface";
    Close();
    return UsbConnectStatus::kUnknownError;
  }
  LOG(INFO) << "USB endpoint is initialized successfully.";
  return UsbConnectStatus::kSuccess;
}

// Release USB device.
void UsbEndpoint::Close() {
  if (iface_num_ >= 0) {
    ioctl(fd_, USBDEVFS_RELEASEINTERFACE, &iface_num_);
  }
  if (fd_ != -1) {
    close(fd_);
  }
  configuration_string_ = "";
  iface_num_ = -1;
  fd_ = -1;
  ep_num_ = -1;
  chunk_len_ = -1;
}

bool UsbEndpoint::IsConnected() const {
  return (fd_ != -1);
}

int UsbEndpoint::Transfer(const void* outbuf,
                          int outlen,
                          void* inbuf,
                          int inlen,
                          bool allow_less,
                          unsigned int timeout_ms) {
  if (Send(outbuf, outlen, allow_less, timeout_ms) != outlen) {
    return kError;
  }
  if (inlen == 0) {
    return 0;
  }
  return Receive(inbuf, inlen, allow_less, timeout_ms);
}

int UsbEndpoint::Send(const void* outbuf,
                      int outlen,
                      bool allow_less,
                      unsigned int timeout_ms) {
  // BulkTransfer() does not modify the buffer while using kUsbEndpointOut
  // direction mask.
  int actual = BulkTransfer(const_cast<void*>(outbuf), kUsbEndpointOut, outlen,
                            timeout_ms);
  if (!allow_less && actual != outlen) {
    LOG(ERROR) << "Failed to send the complete data.";
  }
  return actual;
}

int UsbEndpoint::Receive(void* inbuf,
                         int inlen,
                         bool allow_less,
                         unsigned int timeout_ms) {
  int actual = BulkTransfer(inbuf, kUsbEndpointIn, inlen, timeout_ms);
  if (!allow_less && actual != inlen) {
    LOG(ERROR) << "Failed to receive the complete data.";
    return kError;
  }
  return actual;
}

int UsbEndpoint::BulkTransfer(void* buf,
                              int direction_mask,
                              int len,
                              unsigned int timeout_ms) {
  if (timeout_ms == 0) {
    timeout_ms = kTimeoutMs;
  }

  struct usbdevfs_bulktransfer bulk = {
      .ep = static_cast<unsigned int>(ep_num_ | direction_mask),
      .len = static_cast<unsigned int>(len),
      .timeout = timeout_ms,
      .data = buf};
  return ioctl(fd_, USBDEVFS_BULK, &bulk);
}

}  // namespace hammerd