usb_descriptors.cc | Explore in Territory

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "services/device/usb/usb_descriptors.h"

#include <stddef.h>

#include <algorithm>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "base/barrier_closure.h"
#include "base/functional/bind.h"
#include "base/memory/ref_counted_memory.h"
#include "services/device/public/cpp/usb/usb_utils.h"
#include "services/device/usb/usb_device_handle.h"

namespace device {

UsbAlternateInterfaceInfoPtr;
UsbConfigurationInfoPtr;
UsbControlTransferRecipient;
UsbControlTransferType;
UsbDeviceInfoPtr;
UsbEndpointInfoPtr;
UsbInterfaceInfoPtr;
UsbSynchronizationType;
UsbTransferDirection;
UsbTransferStatus;
UsbTransferType;
UsbUsageType;

namespace {

IndexMap;
IndexMapPtr;

// Standard USB requests and descriptor types:
const uint8_t kGetDescriptorRequest = …;

const uint8_t kDeviceDescriptorType = …;
const uint8_t kConfigurationDescriptorType = …;
const uint8_t kStringDescriptorType = …;
const uint8_t kInterfaceDescriptorType = …;
const uint8_t kEndpointDescriptorType = …;
const uint8_t kInterfaceAssociationDescriptorType = …;

const uint8_t kDeviceDescriptorLength = …;
const uint8_t kConfigurationDescriptorLength = …;
const uint8_t kInterfaceDescriptorLength = …;
const uint8_t kEndpointDescriptorLength = …;
const uint8_t kInterfaceAssociationDescriptorLength = …;

const int kControlTransferTimeoutMs = …;  // 2 seconds

struct UsbInterfaceAssociationDescriptor { … };

void ParseInterfaceAssociationDescriptors(
    const std::vector<uint8_t>& buffer,
    std::vector<UsbInterfaceAssociationDescriptor>* functions) { … }

void OnDoneReadingConfigDescriptors(
    scoped_refptr<UsbDeviceHandle> device_handle,
    std::unique_ptr<UsbDeviceDescriptor> desc,
    base::OnceCallback<void(std::unique_ptr<UsbDeviceDescriptor>)> callback) { … }

void OnReadConfigDescriptor(UsbDeviceDescriptor* desc,
                            base::OnceClosure closure,
                            UsbTransferStatus status,
                            scoped_refptr<base::RefCountedBytes> buffer,
                            size_t length) { … }

void OnReadConfigDescriptorHeader(scoped_refptr<UsbDeviceHandle> device_handle,
                                  UsbDeviceDescriptor* desc,
                                  uint8_t index,
                                  base::OnceClosure closure,
                                  UsbTransferStatus status,
                                  scoped_refptr<base::RefCountedBytes> header,
                                  size_t length) { … }

void OnReadDeviceDescriptor(
    scoped_refptr<UsbDeviceHandle> device_handle,
    base::OnceCallback<void(std::unique_ptr<UsbDeviceDescriptor>)> callback,
    UsbTransferStatus status,
    scoped_refptr<base::RefCountedBytes> buffer,
    size_t length) { … }

void StoreStringDescriptor(IndexMap::iterator it,
                           base::OnceClosure callback,
                           const std::u16string& string) { … }

void OnReadStringDescriptor(
    base::OnceCallback<void(const std::u16string&)> callback,
    UsbTransferStatus status,
    scoped_refptr<base::RefCountedBytes> buffer,
    size_t length) { … }

void ReadStringDescriptor(
    scoped_refptr<UsbDeviceHandle> device_handle,
    uint8_t index,
    uint16_t language_id,
    base::OnceCallback<void(const std::u16string&)> callback) { … }

void OnReadLanguageIds(scoped_refptr<UsbDeviceHandle> device_handle,
                       IndexMapPtr index_map,
                       base::OnceCallback<void(IndexMapPtr)> callback,
                       const std::u16string& languages) { … }

}  // namespace

CombinedInterfaceInfo::CombinedInterfaceInfo(
    const mojom::UsbInterfaceInfo* interface,
    const mojom::UsbAlternateInterfaceInfo* alternate)
    : … { … }

bool CombinedInterfaceInfo::IsValid() const { … }

UsbDeviceDescriptor::UsbDeviceDescriptor()
    : … { … }

UsbDeviceDescriptor::~UsbDeviceDescriptor() = default;

bool UsbDeviceDescriptor::Parse(base::span<const uint8_t> buffer) { … }

void ReadUsbDescriptors(
    scoped_refptr<UsbDeviceHandle> device_handle,
    base::OnceCallback<void(std::unique_ptr<UsbDeviceDescriptor>)> callback) { … }

bool ParseUsbStringDescriptor(base::span<const uint8_t> descriptor,
                              std::u16string* output) { … }

// For each key in |index_map| this function reads that string descriptor from
// |device_handle| and updates the value in in |index_map|.
void ReadUsbStringDescriptors(scoped_refptr<UsbDeviceHandle> device_handle,
                              IndexMapPtr index_map,
                              base::OnceCallback<void(IndexMapPtr)> callback) { … }

UsbEndpointInfoPtr BuildUsbEndpointInfoPtr(const uint8_t* data) { … }

UsbEndpointInfoPtr BuildUsbEndpointInfoPtr(uint8_t address,
                                           uint8_t attributes,
                                           uint16_t maximum_packet_size,
                                           uint8_t polling_interval) { … }

UsbInterfaceInfoPtr BuildUsbInterfaceInfoPtr(const uint8_t* data) { … }

UsbInterfaceInfoPtr BuildUsbInterfaceInfoPtr(uint8_t interface_number,
                                             uint8_t alternate_setting,
                                             uint8_t interface_class,
                                             uint8_t interface_subclass,
                                             uint8_t interface_protocol) { … }

// Aggregate each alternate setting into an InterfaceInfo corresponding to its
// interface number.
void AggregateInterfacesForConfig(mojom::UsbConfigurationInfo* config) { … }

CombinedInterfaceInfo FindInterfaceInfoFromConfig(
    const mojom::UsbConfigurationInfo* config,
    uint8_t interface_number,
    uint8_t alternate_setting) { … }

UsbConfigurationInfoPtr BuildUsbConfigurationInfoPtr(const uint8_t* data) { … }

UsbConfigurationInfoPtr BuildUsbConfigurationInfoPtr(
    uint8_t configuration_value,
    bool self_powered,
    bool remote_wakeup,
    uint8_t maximum_power) { … }

void AssignFirstInterfaceNumbers(mojom::UsbConfigurationInfo* config) { … }

}  // namespace device
chromium/services/device/usb/usb_descriptors.cc
