| // Copyright 2018 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 "permission_broker/libusb_wrapper.h" |
| |
| #include <string> |
| #include <utility> |
| |
| #include <base/logging.h> |
| #include <base/time/time.h> |
| |
| namespace { |
| |
| constexpr base::TimeDelta kUsbControlTimeout = base::TimeDelta::FromSeconds(5); |
| |
| const int kLibusbUnrefDevices = 1; |
| |
| } // namespace |
| |
| namespace permission_broker { |
| |
| UsbDevice::UsbDevice(libusb_device* device) |
| : device_(device, libusb_unref_device) { |
| // Increase the ref count to gain ownership of the libusb device object. |
| libusb_ref_device(device_.get()); |
| |
| // Try to obtain information regarding the device VID/PID from the device |
| // itself. |
| // NB: in the repositories we only depend on versions of libusb which are |
| // newer than 1.0.16. This means that we can ignore the return value |
| // as this API always suceeds in such a case. |
| libusb_device_descriptor descriptor; |
| libusb_get_device_descriptor(device_.get(), &descriptor); |
| info_.vid = descriptor.idVendor; |
| info_.pid = descriptor.idProduct; |
| info_.device_class = descriptor.bDeviceClass; |
| } |
| |
| UsbDevice::~UsbDevice() = default; |
| |
| UsbDeviceInfo UsbDevice::GetInfo() const { |
| return info_; |
| } |
| |
| std::unique_ptr<UsbDeviceInterface> UsbDevice::GetParent() const { |
| libusb_device* parent_device = libusb_get_parent(device_.get()); |
| if (parent_device == nullptr) { |
| LOG(ERROR) << "Unable to find the device parent for '" << info_ << "'"; |
| return nullptr; |
| } |
| auto parent = std::unique_ptr<UsbDeviceInterface>( |
| new UsbDevice(parent_device)); |
| |
| UsbDeviceInfo parent_info = parent->GetInfo(); |
| if (parent_info.device_class != LIBUSB_CLASS_HUB) { |
| LOG(ERROR) << "The parent device found for this USB device is not a hub (" |
| << parent_info << ")"; |
| return nullptr; |
| } |
| |
| return parent; |
| } |
| |
| uint8_t UsbDevice::GetPort() const { |
| return libusb_get_port_number(device_.get()); |
| } |
| |
| bool UsbDevice::SetPowerState(bool enabled, uint16_t port) const { |
| if (info_.device_class != LIBUSB_CLASS_HUB) { |
| LOG(ERROR) << "Unable to set power on a port if the device is not a hub " |
| << "(device '" << info_ << "')"; |
| return false; |
| } |
| |
| libusb_device_handle* handle; |
| int result = libusb_open(device_.get(), &handle); |
| if (result != LIBUSB_SUCCESS) { |
| LOG(ERROR) << "Unable to open the USB device. (error: " |
| << libusb_error_name(result) << ")"; |
| return false; |
| } |
| |
| uint8_t request = |
| enabled ? LIBUSB_REQUEST_SET_FEATURE : LIBUSB_REQUEST_CLEAR_FEATURE; |
| result = libusb_control_transfer( |
| handle, LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_OTHER, request, |
| USB_PORT_FEAT_POWER, port, NULL, 0, kUsbControlTimeout.InMilliseconds()); |
| libusb_close(handle); |
| |
| if (result < 0) { |
| std::string status = enabled ? "on" : "off"; |
| LOG(WARNING) << "Unable to power " << status << " device '" << info_ |
| << "' (error: " << libusb_error_name(result) << ")"; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| UsbDeviceManager::UsbDeviceManager() { |
| libusb_context* ctx; |
| int status = libusb_init(&ctx); |
| if (status != LIBUSB_SUCCESS) { |
| LOG(ERROR) << "Unable to initialize the libusb context. (error: " |
| << libusb_error_name(status) << ")"; |
| return; |
| } |
| context_.reset(ctx); |
| } |
| |
| UsbDeviceManager::~UsbDeviceManager() = default; |
| |
| std::vector<std::unique_ptr<UsbDeviceInterface>> |
| UsbDeviceManager::GetDevicesByVidPid(uint16_t vid, uint16_t pid) { |
| libusb_device** device_list; |
| std::vector<std::unique_ptr<UsbDeviceInterface>> devices; |
| |
| int num_of_devices = libusb_get_device_list(context_.get(), &device_list); |
| if (num_of_devices < 0) { |
| LOG(ERROR) << "Unable to access the libusb device list. (error: " |
| << libusb_error_name(num_of_devices) << ")"; |
| return devices; |
| } |
| |
| for (int i = 0; i < num_of_devices; ++i) { |
| auto device = std::make_unique<UsbDevice>(device_list[i]); |
| UsbDeviceInfo info = device->GetInfo(); |
| |
| if (info.vid == vid && info.pid == pid) { |
| devices.push_back(std::move(device)); |
| } |
| } |
| |
| // Free the list of devices previously retrieved. |
| libusb_free_device_list(device_list, kLibusbUnrefDevices); |
| return devices; |
| } |
| |
| } // namespace permission_broker |