Parse USB interface association descriptors.

device/usb/usb_descriptors.cc

 // Copyright 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/usb/usb_descriptors.h"
 
 #include <stddef.h>
 
 #include <algorithm>
+#include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "device/usb/usb_device_handle.h"
 #include "net/base/io_buffer.h"
 
 namespace device {
 
 namespace {
 
 using IndexMap = std::map<uint8_t, base::string16>;
 using IndexMapPtr = scoped_ptr<IndexMap>;
 
 // Standard USB requests and descriptor types:
 const uint8_t kGetDescriptorRequest = 0x06;
 const uint8_t kStringDescriptorType = 0x03;
 
 const int kControlTransferTimeout = 60000;  // 1 minute
 
+struct UsbInterfaceAssociationDescriptor {
+  UsbInterfaceAssociationDescriptor(uint8_t first_interface,
+                                    uint8_t interface_count)
+      : first_interface(first_interface), interface_count(interface_count) {}
+  UsbInterfaceAssociationDescriptor() = delete;

[Ken Rockot(use gerrit already), 2016/02/12 19:25:01]

I'm fairly sure that this is implied by defining a non-zero-argument constructor

[Reilly Grant (use Gerrit), 2016/02/12 21:06:21]

You're right.

+  ~UsbInterfaceAssociationDescriptor() = default;

[Ken Rockot(use gerrit already), 2016/02/12 19:25:01]

Isn't this also implied given that the struct is only POD?

[Reilly Grant (use Gerrit), 2016/02/12 21:06:21]

Indeed. I just got overly excited about default and delete.

+
+  bool operator<(const UsbInterfaceAssociationDescriptor& other) const {
+    return first_interface < other.first_interface;
+  }
+
+  uint8_t first_interface;
+  uint8_t interface_count;
+};
+
+void ParseInterfaceAssociationDescriptors(
+    const std::vector<uint8_t>& buffer,
+    std::vector<UsbInterfaceAssociationDescriptor>* functions) {
+  const uint8_t kInterfaceAssociationDescriptorType = 11;
+  const uint8_t kInterfaceAssociationDescriptorLength = 8;
+  std::vector<uint8_t>::const_iterator it = buffer.begin();
+
+  while (it != buffer.end()) {
+    // All descriptors must be at least 2 byte which means the length and type
+    // are safe to read.
+    if (std::distance(it, buffer.end()) < 2)
+      return;
+    uint8_t length = it[0];
+    if (length > std::distance(it, buffer.end()))
+      return;
+    if (it[1] == kInterfaceAssociationDescriptorType &&
+        length == kInterfaceAssociationDescriptorLength) {
+      functions->push_back(UsbInterfaceAssociationDescriptor(it[2], it[3]));
+    }
+    std::advance(it, length);
+  }
+}
+
 void StoreStringDescriptor(IndexMap::iterator it,
                            const base::Closure& callback,
                            const base::string16& string) {
   it->second = string;
   callback.Run();
 }
 
 void OnReadStringDescriptor(
     const base::Callback<void(const base::string16&)>& callback,
     UsbTransferStatus status,
@@ skipping 67 matching lines @@
 
 UsbInterfaceDescriptor::UsbInterfaceDescriptor(uint8_t interface_number,
                                                uint8_t alternate_setting,
                                                uint8_t interface_class,
                                                uint8_t interface_subclass,
                                                uint8_t interface_protocol)
     : interface_number(interface_number),
       alternate_setting(alternate_setting),
       interface_class(interface_class),
       interface_subclass(interface_subclass),
-      interface_protocol(interface_protocol) {}
+      interface_protocol(interface_protocol),
+      first_interface(interface_number) {}
 
 UsbInterfaceDescriptor::~UsbInterfaceDescriptor() = default;
 
 UsbConfigDescriptor::UsbConfigDescriptor(uint8_t configuration_value,
                                          bool self_powered,
                                          bool remote_wakeup,
                                          uint16_t maximum_power)
     : configuration_value(configuration_value),
       self_powered(self_powered),
       remote_wakeup(remote_wakeup),
       maximum_power(maximum_power) {}
 
 UsbConfigDescriptor::~UsbConfigDescriptor() = default;
 
+void UsbConfigDescriptor::AssignFirstInterfaceNumbers() {
+  std::vector<UsbInterfaceAssociationDescriptor> functions;
+  ParseInterfaceAssociationDescriptors(extra_data, &functions);
+  for (const auto& interface : interfaces) {
+    ParseInterfaceAssociationDescriptors(interface.extra_data, &functions);
+    for (const auto& endpoint : interface.endpoints)
+      ParseInterfaceAssociationDescriptors(endpoint.extra_data, &functions);
+  }
+
+  // libusb has collected interface association descriptors in the |extra_data|
+  // fields of other descriptor types. This may have disturbed their order
+  // but sorting by the bFirstInterface should fix it.
+  std::sort(functions.begin(), functions.end());
+
+  uint8_t remaining_interfaces = 0;
+  auto function_it = functions.cbegin();
+  for (auto interface_it = interfaces.begin(); interface_it != interfaces.end();
+       ++interface_it) {
+    if (remaining_interfaces > 0) {
+      // Continuation of a previous function. Tag all alternate interfaces
+      // (which are guaranteed to be contiguous).
+      for (uint8_t interface_number = interface_it->interface_number;
+           interface_it != interfaces.end() &&
+           interface_it->interface_number == interface_number;
+           ++interface_it) {
+        interface_it->first_interface = function_it->first_interface;
+      }
+      if (--remaining_interfaces == 0)
+        ++function_it;
+    } else if (function_it != functions.end() &&
+               interface_it->interface_number == function_it->first_interface) {
+      // Start of a new function.
+      interface_it->first_interface = function_it->first_interface;
+      remaining_interfaces = function_it->interface_count - 1;
+    } else {
+      // Unassociated interfaces already have |first_interface| set to
+      // |interface_number|.
+    }
+  }
+}
+
 bool ParseUsbStringDescriptor(const std::vector<uint8_t>& descriptor,
                               base::string16* output) {
   if (descriptor.size() < 2 || descriptor[1] != kStringDescriptorType)
     return false;
 
   // Let the device return a buffer larger than the actual string but prefer the
   // length reported inside the descriptor.
   size_t length = descriptor[0];
   length = std::min(length, descriptor.size());
   if (length < 2)
@@ skipping 16 matching lines @@
     callback.Run(std::move(index_map));
     return;
   }
 
   ReadStringDescriptor(device_handle, 0, 0,
                        base::Bind(&OnReadLanguageIds, device_handle,
                                   base::Passed(&index_map), callback));
 }
 
 }  // namespace device