usb 2.17.0 → 2.18.0

package/libusb/libusb/core.c

@@ -382,6 +382,8 @@ if (cfg != desired)
   * - libusb_detach_kernel_driver()
   * - libusb_dev_mem_alloc()
   * - libusb_dev_mem_free()
+  * - libusb_endpoint_set_raw_io()
+  * - libusb_endpoint_supports_raw_io()
   * - libusb_error_name()
   * - libusb_event_handler_active()
   * - libusb_event_handling_ok()
@@ -404,6 +406,7 @@ if (cfg != desired)
   * - libusb_free_usb_2_0_extension_descriptor()
   * - libusb_get_active_config_descriptor()
   * - libusb_get_bos_descriptor()
+  * - libusb_get_session_data()
   * - libusb_get_bus_number()
   * - libusb_get_config_descriptor()
   * - libusb_get_config_descriptor_by_value()
@@ -415,10 +418,12 @@ if (cfg != desired)
   * - libusb_get_device_descriptor()
   * - libusb_get_device_list()
   * - libusb_get_device_speed()
+  * - libusb_get_device_string()
   * - libusb_get_iso_packet_buffer()
   * - libusb_get_iso_packet_buffer_simple()
   * - libusb_get_max_alt_packet_size()
   * - libusb_get_max_iso_packet_size()
+  * - libusb_get_max_raw_io_transfer_size()
   * - libusb_get_max_packet_size()
   * - libusb_get_next_timeout()
   * - libusb_get_parent()
@@ -499,6 +504,7 @@ if (cfg != desired)
   * - \ref libusb_capability
   * - \ref libusb_class_code
   * - \ref libusb_descriptor_type
+  * - \ref libusb_device_string_type
   * - \ref libusb_endpoint_direction
   * - \ref libusb_endpoint_transfer_type
   * - \ref libusb_error
@@ -722,26 +728,33 @@ struct libusb_device *usbi_alloc_device(struct libusb_context *ctx,
 	dev->session_data = session_id;
 	dev->speed = LIBUSB_SPEED_UNKNOWN;
 
-	if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
-		usbi_connect_device(dev);
+	/* Note: the device is NOT added to ctx->usb_devs here. The caller
+	 * (backend) must call usbi_connect_device() after fully initializing
+	 * the device's private data. This prevents a concurrent
+	 * usbi_get_device_by_session_id() from finding a half-initialized
+	 * device. */
 
 	return dev;
 }
 
-void usbi_connect_device(struct libusb_device *dev)
+void usbi_attach_device(struct libusb_device *dev)
 {
 	struct libusb_context *ctx = DEVICE_CTX(dev);
 
 	usbi_atomic_store(&dev->attached, 1);
 
-	usbi_mutex_lock(&dev->ctx->usb_devs_lock);
-	list_add(&dev->list, &dev->ctx->usb_devs);
-	usbi_mutex_unlock(&dev->ctx->usb_devs_lock);
+	usbi_mutex_lock(&ctx->usb_devs_lock);
+	list_add(&dev->list, &ctx->usb_devs);
+	usbi_mutex_unlock(&ctx->usb_devs_lock);
+}
 
-	usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
+void usbi_connect_device(struct libusb_device *dev)
+{
+	usbi_attach_device(dev);
+	usbi_hotplug_notification(DEVICE_CTX(dev), dev, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
 }
 
-void usbi_disconnect_device(struct libusb_device *dev)
+void usbi_detach_device(struct libusb_device *dev)
 {
 	struct libusb_context *ctx = DEVICE_CTX(dev);
 
@@ -750,8 +763,12 @@ void usbi_disconnect_device(struct libusb_device *dev)
 	usbi_mutex_lock(&ctx->usb_devs_lock);
 	list_del(&dev->list);
 	usbi_mutex_unlock(&ctx->usb_devs_lock);
+}
 
-	usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT);
+void usbi_disconnect_device(struct libusb_device *dev)
+{
+	usbi_detach_device(dev);
+	usbi_hotplug_notification(DEVICE_CTX(dev), dev, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT);
 }
 
 /* Perform some final sanity checks on a newly discovered device. If this
@@ -905,6 +922,26 @@ void API_EXPORTED libusb_free_device_list(libusb_device **list,
 	free(list);
 }
 
+/** \ingroup libusb_dev
+ * Returns the backend-specific identifier of the underlying system device tree
+ * node. Can be used to find the corresponding system device and directly query
+ * it (or access it otherwise) when and if necessary.
+ *
+ * Relevant backends:
+ * - Darwin: IOKit `sessionID`
+ * - Windows WinUSB: `DEVINST`
+ * - Linux, BSD: `busnum << 8 | devnum`
+ *
+ * Since version 1.0.30, \ref LIBUSB_API_VERSION >= 0x0100010C
+ *
+ * \param dev a device (must not be null)
+ * \returns the backend-specific device identifier
+ */
+unsigned long API_EXPORTED libusb_get_session_data(libusb_device *dev)
+{
+    return dev->session_data;
+}
+
 /** \ingroup libusb_dev
  * Get the number of the bus that a device is connected to.
  * \param dev a device
@@ -1276,6 +1313,7 @@ libusb_device * LIBUSB_CALL libusb_ref_device(libusb_device *dev)
 
 	refcnt = usbi_atomic_inc(&dev->refcnt);
 	assert(refcnt >= 2);
+	UNUSED(refcnt);
 
 	return dev;
 }
@@ -1292,8 +1330,27 @@ void API_EXPORTED libusb_unref_device(libusb_device *dev)
 	if (!dev)
 		return;
 
-	refcnt = usbi_atomic_dec(&dev->refcnt);
-	assert(refcnt >= 0);
+	if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+		/* Non-hotplug path: the decrement and conditional list removal
+		 * must be atomic with respect to usbi_get_device_by_session_id(),
+		 * which searches the list and refs the device under the same lock.
+		 * Without this, a concurrent search could find a device whose
+		 * refcnt has already reached zero and hit the assert in
+		 * libusb_ref_device(). */
+		struct libusb_context *ctx = DEVICE_CTX(dev);
+
+		usbi_mutex_lock(&ctx->usb_devs_lock);
+		refcnt = usbi_atomic_dec(&dev->refcnt);
+		assert(refcnt >= 0);
+		if (refcnt == 0 && usbi_atomic_load(&dev->attached)) {
+			list_del(&dev->list);
+			usbi_atomic_store(&dev->attached, 0);
+		}
+		usbi_mutex_unlock(&ctx->usb_devs_lock);
+	} else {
+		refcnt = usbi_atomic_dec(&dev->refcnt);
+		assert(refcnt >= 0);
+	}
 
 	if (refcnt == 0) {
 		usbi_dbg(DEVICE_CTX(dev), "destroy device %d.%d", dev->bus_number, dev->device_address);
@@ -1303,9 +1360,8 @@ void API_EXPORTED libusb_unref_device(libusb_device *dev)
 		if (usbi_backend.destroy_device)
 			usbi_backend.destroy_device(dev);
 
-		if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
-			/* backend does not support hotplug */
-			usbi_disconnect_device(dev);
+		for (int idx = 0; idx < LIBUSB_DEVICE_STRING_COUNT; ++idx) {
+			free(dev->device_strings_utf8[idx]);
 		}
 
 		free(dev);
@@ -2204,6 +2260,111 @@ int API_EXPORTED libusb_set_auto_detach_kernel_driver(
 	return LIBUSB_SUCCESS;
 }
 
+/** \ingroup libusb_dev
+ * Check if the endpoint supports RAW_IO.
+ * \param dev_handle a device handle
+ * \param endpoint the endpoint to check
+ *
+ * \returns 1 if the endpoint supports RAW_IO
+ * \returns 0 if the endpoint does not support RAW_IO
+ * \returns a LIBUSB_ERROR code on failure
+ *
+ * Only endpoints using the WinUSB driver support RAW_IO,
+ * for all other backends/drivers this function will return 0.
+ *
+ * Fails if the interface the endpoint belongs to isn't claimed,
+ * \see libusb_claim_interface().
+ *
+ * \see libusb_endpoint_set_raw_io()
+ *
+ * Since version 1.0.30, \ref LIBUSB_API_VERSION >= 0x0100010C
+ */
+int API_EXPORTED libusb_endpoint_supports_raw_io(libusb_device_handle* dev_handle,
+	uint8_t endpoint)
+{
+	if (usbi_backend.endpoint_supports_raw_io == NULL)
+	{
+		return 0;
+	}
+
+	// If the `endpoint_supports_raw_io` function is present, these two should be too:
+	assert(usbi_backend.endpoint_set_raw_io != NULL);
+	assert(usbi_backend.get_max_raw_io_transfer_size != NULL);
+
+	return usbi_backend.endpoint_supports_raw_io(dev_handle, endpoint);
+}
+
+/** \ingroup libusb_dev
+ * Enable/disable RAW_IO for an endpoint on an open device.
+ *
+ * Only endpoints using the WinUSB driver support RAW_IO,
+ * for all other backends/drivers this function will return an error code.
+ *
+ * Using RAW_IO can greatly improve USB throughput by directly passing
+ * transfer requests to the underlying USB driver instead of queuing them
+ * in WinUSB. This can be particularly useful for high-throughput devices
+ * like cameras or oscilloscopes.
+ *
+ * Transfers submitted to the endpoint while RAW_IO is enabled will fail unless
+ * they adhere to the following rules :
+ * - The buffer length must be a multiple of the maximum endpoint packet size
+ *   \see libusb_get_max_packet_size.
+ * - The buffer length must be less than or equal to the value returned by
+ *   \ref libusb_get_max_raw_io_transfer_size.
+ *
+ * This option should not be changed when any transfer is in progress on
+ * the specified endpoint.
+ *
+ * Fails if the interface the endpoint belongs to isn't claimed,
+ * \see libusb_claim_interface().
+ *
+ * \param dev_handle a device handle
+ * \param endpoint the endpoint to set RAW_IO for
+ * \param enable 1 to enable RAW_IO, 0 to disable it
+ *
+ * \returns \ref LIBUSB_SUCCESS on success
+ * \returns \ref LIBUSB_ERROR_NOT_SUPPORTED if the backend does not support RAW_IO.
+ * \returns another LIBUSB_ERROR code on other failure
+ *
+ * \see libusb_endpoint_supports_raw_io()
+ * \see https://learn.microsoft.com/en-us/windows-hardware/drivers/usbcon/winusb-functions-for-pipe-policy-modification
+ *
+ * Since version 1.0.30, \ref LIBUSB_API_VERSION >= 0x0100010C
+ */
+int API_EXPORTED libusb_endpoint_set_raw_io(libusb_device_handle* dev_handle,
+	uint8_t endpoint, int enable)
+{
+	if (!usbi_backend.endpoint_set_raw_io)
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+
+	return usbi_backend.endpoint_set_raw_io(dev_handle, endpoint, enable);
+}
+
+/** \ingroup libusb_dev
+ * Retrieve the maximum transfer size in bytes supported for WinUSB RAW_IO
+ * for an inbound bulk or interrupt endpoint on an open device.
+ *
+ * Returns a maximum transfer size in bytes, or a negative error code.
+ * If the backend does not support WinUSB RAW_IO, returns
+ * \ref LIBUSB_ERROR_NOT_SUPPORTED.
+ *
+ * Fails if the interface the endpoint belongs to isn't claimed,
+ * \see libusb_claim_interface().
+ *
+ * \see libusb_endpoint_set_raw_io()
+ *
+ * Since version 1.0.30, \ref LIBUSB_API_VERSION >= 0x0100010C
+ */
+int API_EXPORTED libusb_get_max_raw_io_transfer_size(
+	libusb_device_handle *dev_handle, uint8_t endpoint)
+{
+	if (!usbi_backend.get_max_raw_io_transfer_size)
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+
+	return usbi_backend.get_max_raw_io_transfer_size(
+		dev_handle, endpoint);
+}
+
 /** \ingroup libusb_lib
  * Deprecated. Use libusb_set_option() or libusb_init_context() instead,
  * with the \ref LIBUSB_OPTION_LOG_LEVEL option.

package/libusb/libusb/descriptor.c

@@ -38,10 +38,10 @@ static inline uint16_t ReadLittleEndian16(const uint8_t p[2])
 
 static inline uint32_t ReadLittleEndian32(const uint8_t p[4])
 {
-	return (uint32_t)((uint32_t)p[3] << 24 |
-			  (uint32_t)p[2] << 16 |
-			  (uint32_t)p[1] << 8 |
-			  (uint32_t)p[0]);
+	return ((uint32_t)p[3] << 24 |
+			(uint32_t)p[2] << 16 |
+			(uint32_t)p[1] << 8 |
+			(uint32_t)p[0]);
 }
 
 static void clear_endpoint(struct libusb_endpoint_descriptor *endpoint)
@@ -148,6 +148,8 @@ static void clear_interface(struct libusb_interface *usb_interface)
 				usb_interface->altsetting + i;
 
 			free((void *)ifp->extra);
+			ifp->extra = NULL;
+			ifp->extra_length = 0;
 			if (ifp->endpoint) {
 				uint8_t j;
 
@@ -156,10 +158,13 @@ static void clear_interface(struct libusb_interface *usb_interface)
 						       ifp->endpoint + j);
 			}
 			free((void *)ifp->endpoint);
+			ifp->endpoint = NULL;
+			ifp->bNumEndpoints = 0;
 		}
 	}
 	free((void *)usb_interface->altsetting);
 	usb_interface->altsetting = NULL;
+	usb_interface->num_altsetting = 0;
 }
 
 static int parse_interface(libusb_context *ctx,
@@ -241,6 +246,10 @@ static int parse_interface(libusb_context *ctx,
 				usbi_warn(ctx,
 					  "short extra intf desc read %d/%u",
 					  size, header->bLength);
+				/* Keep the invariant: bNumEndpoints > 0 implies
+				 * endpoint != NULL. The endpoint array isn't
+				 * allocated yet on this early return. */
+				ifp->bNumEndpoints = 0;
 				return parsed;
 			}
 
@@ -322,7 +331,11 @@ static void clear_configuration(struct libusb_config_descriptor *config)
 					config->interface + i);
 	}
 	free((void *)config->interface);
+	config->interface = NULL;
+	config->bNumInterfaces = 0;
 	free((void *)config->extra);
+	config->extra = NULL;
+	config->extra_length = 0;
 }
 
 static int parse_configuration(struct libusb_context *ctx,
@@ -423,7 +436,7 @@ static int parse_configuration(struct libusb_context *ctx,
 			config->extra_length += (int)len;
 		}
 
-		r = parse_interface(ctx, usb_interface + i, buffer, (int)size);
+		r = parse_interface(ctx, usb_interface + i, buffer, size);
 		if (r < 0)
 			goto err;
 		if (r == 0) {
@@ -777,7 +790,7 @@ static int parse_bos(struct libusb_context *ctx,
 		return LIBUSB_ERROR_IO;
 	}
 
-	_bos = calloc(1, sizeof(*_bos) + bos_desc->bNumDeviceCaps * sizeof(void *));
+	_bos = calloc(1, sizeof(*_bos) + (bos_desc->bNumDeviceCaps * sizeof(void *)));
 	if (!_bos)
 		return LIBUSB_ERROR_NO_MEM;
 
@@ -1082,7 +1095,7 @@ int API_EXPORTED libusb_get_ssplus_usb_device_capability_descriptor(
 	parsedDescriptor.wReserved = ReadLittleEndian16(&dev_capability_data[7]);
 
 	uint8_t numSublikSpeedAttributes = (parsedDescriptor.bmAttributes & 0xF) + 1;
-	_ssplus_cap = malloc(sizeof(struct libusb_ssplus_usb_device_capability_descriptor) + numSublikSpeedAttributes * sizeof(struct libusb_ssplus_sublink_attribute));
+	_ssplus_cap = malloc(sizeof(struct libusb_ssplus_usb_device_capability_descriptor) + (numSublikSpeedAttributes * sizeof(struct libusb_ssplus_sublink_attribute)));
 	if (!_ssplus_cap)
 		return LIBUSB_ERROR_NO_MEM;
 
@@ -1096,7 +1109,8 @@ int API_EXPORTED libusb_get_ssplus_usb_device_capability_descriptor(
 	_ssplus_cap->minTxLaneCount = (parsedDescriptor.wFunctionalitySupport & 0xF000) >> 12;
 
 	/* Check that we have enough to read all the sublink attributes */
-	if (dev_cap->bLength < LIBUSB_BT_SSPLUS_USB_DEVICE_CAPABILITY_SIZE + _ssplus_cap->numSublinkSpeedAttributes * sizeof(uint32_t)) {
+	if (dev_cap->bLength < LIBUSB_BT_SSPLUS_USB_DEVICE_CAPABILITY_SIZE + (_ssplus_cap->numSublinkSpeedAttributes * sizeof(uint32_t))) {
+		free(_ssplus_cap);
 		usbi_err(ctx, "short ssplus capability descriptor, unable to read sublinks: Not enough data");
 		return LIBUSB_ERROR_IO;
 	}
@@ -1104,7 +1118,7 @@ int API_EXPORTED libusb_get_ssplus_usb_device_capability_descriptor(
 	/* Read the attributes */
 	uint8_t* base = ((uint8_t*)dev_cap) + LIBUSB_BT_SSPLUS_USB_DEVICE_CAPABILITY_SIZE;
 	for(uint8_t i = 0 ; i < _ssplus_cap->numSublinkSpeedAttributes ; i++) {
-		uint32_t attr = ReadLittleEndian32(base + i * sizeof(uint32_t));
+		uint32_t attr = ReadLittleEndian32(base + (i * sizeof(uint32_t)));
 		_ssplus_cap->sublinkSpeedAttributes[i].ssid = attr & 0x0f;
 		_ssplus_cap->sublinkSpeedAttributes[i].mantissa = attr >> 16;
 		_ssplus_cap->sublinkSpeedAttributes[i].exponent = (attr >> 4) & 0x3 ;
@@ -1311,9 +1325,10 @@ int API_EXPORTED libusb_get_string_descriptor_ascii(libusb_device_handle *dev_ha
 	r = libusb_get_string_descriptor(dev_handle, 0, 0, str.buf, 4);
 	if (r < 0)
 		return r;
-	else if (r != 4 || str.desc.bLength < 4 || str.desc.bDescriptorType != LIBUSB_DT_STRING)
+	else if (r != 4 || str.desc.bLength < 4 || str.desc.bDescriptorType != LIBUSB_DT_STRING) {
+		usbi_warn(HANDLE_CTX(dev_handle), "invalid language ID string descriptor");
 		return LIBUSB_ERROR_IO;
-	else if (str.desc.bLength & 1)
+	} else if (str.desc.bLength & 1)
 		usbi_warn(HANDLE_CTX(dev_handle), "suspicious bLength %u for language ID string descriptor", str.desc.bLength);
 
 	langid = libusb_le16_to_cpu(str.desc.wData[0]);
@@ -1365,7 +1380,7 @@ static int parse_iad_array(struct libusb_context *ctx,
 
 	/* First pass: Iterate through desc list, count number of IADs */
 	iad_array->length = 0;
-	while (consumed < size) {
+	while (size - consumed >= DESC_HEADER_LENGTH) {
 		header.bLength = buf[0];
 		header.bDescriptorType = buf[1];
 		if (header.bLength < DESC_HEADER_LENGTH) {
@@ -1373,9 +1388,9 @@ static int parse_iad_array(struct libusb_context *ctx,
 				 header.bLength);
 			return LIBUSB_ERROR_IO;
 		}
-		else if (header.bLength > size) {
+		else if (header.bLength > size - consumed) {
 			usbi_warn(ctx, "short config descriptor read %d/%u",
-					  size, header.bLength);
+					  size - consumed, header.bLength);
 			return LIBUSB_ERROR_IO;
 		}
 		if (header.bDescriptorType == LIBUSB_DT_INTERFACE_ASSOCIATION)
@@ -1556,3 +1571,137 @@ void API_EXPORTED libusb_free_interface_association_descriptors(
 		free((void*)iad_array->iad);
 	free(iad_array);
 }
+
+/*
+ * \brief Copy a UTF-8 string with proper truncation if needed.
+ *
+ * \param tgt The target utf-8 string.  If NULL, then tgt is ignored,
+ *            tgt_size is forced to 0, and this function returns the
+ *            required tgt_size for a subsequent call to this function.
+ * \param src The source utf-8 string.  If NULL, then
+ *            the source string is empty, the return length is 1,
+ *            and, if tgt is not NULL, this function
+ *            sets tgt[0] to the null terminator.
+ * \param tgt_size The size of target in bytes.
+ * \return the length of src in bytes, including the null terminator.
+ *
+ * utf8_copy(NULL, src, 0) is equivalent to strlen(src) + 1.
+ */
+static int usbi_utf8_copy(char *tgt, char const *src, int tgt_size) {
+	uint8_t* t = (uint8_t*)tgt;
+	uint8_t const* s = (uint8_t const*)src;
+
+	if (NULL == src) {
+		if ((NULL != tgt) && (tgt_size > 0)) {
+			tgt[0] = 0;
+		}
+		return 1;
+	}
+
+	if ((NULL == tgt) || (tgt_size <= 0)) {
+		return (int)(strlen(src) + 1);
+	}
+
+	// copy UTF-8 string and compute length
+	int k = 0;
+	for (k = 0; s[k]; ++k) {
+		if (k < tgt_size) {
+			t[k] = s[k];
+		} else {
+			break;
+		}
+	}
+
+	if (k >= tgt_size) {
+		// truncate respecting UTF-8 character boundaries
+		int idx = tgt_size - 1;
+		while (idx && (0x80 == (t[idx] & 0xC0))) {  // utf-8 continuation byte
+			--idx;
+		}
+		t[idx] = 0;
+		return (int)(strlen(src) + 1);
+	} else {
+		t[k++] = 0;
+		return k;
+	}
+}
+
+/** \ingroup libusb_desc
+ * Retrieve a device string without needing to open the device.
+ *
+ * Since version v1.0.30 \ref LIBUSB_API_VERSION >= 0x0100010C
+ *
+ * \param dev the target device
+ * \param string_type the string type to retrieve
+ * \param data the data buffer for the UTF-8 encoded string.
+ * \param length the size of the data buffer in bytes.  
+ *      USB string descriptors cannot be longer than 
+ *      LIBUSB_DEVICE_STRING_BYTES_MAX.
+ * \returns a negative error code or
+ *      the actual string length in bytes including the null terminator.
+ * \see libusb_get_string_descriptor()
+ * \see libusb_get_string_descriptor_ascii()
+ * 
+ * This function works when the device is still closed since it relies
+ * on the operating system to provide the string.  The operating system
+ * normally reads and caches the common string descriptors during
+ * USB enumeration.
+ *
+ * Since the USB string descriptor could be processed by the OS,
+ * this function returns a UTF-8 encoded string.
+ *
+ * The string will be returned untranslated or in the default OS language
+ * when supported by the OS and USB device.
+ * 
+ * One way to call this function is using a buffer on the stack:
+ * 
+ *     char buffer[LIBUSB_DEVICE_STRING_BYTES_MAX];
+ *     int ret = libusb_get_device_string(dev, LIBUSB_DEVICE_STRING_SERIAL_NUMBER, buffer, sizeof(buffer));
+ *     if (ret < 0) {
+ *         // handle error
+ *     }
+ * 
+ * This function is commonly used to get the serial number to allow
+ * for device selection before opening the selected device.
+ */
+int API_EXPORTED libusb_get_device_string(libusb_device *dev,
+	enum libusb_device_string_type string_type, char *data, int length) {
+	char * s;
+	if (NULL == dev) {
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+	if ((string_type < 0) || (string_type >= LIBUSB_DEVICE_STRING_COUNT)) {
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+	if (length <= 0) {
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+	if (NULL == data) {
+		length = 0;
+		data = NULL;
+	} else if (length > 0) {
+		*data = 0;  // return an empty string on errors when possible
+	}
+
+	if (NULL == dev->device_strings_utf8[string_type]) {
+		if (usbi_backend.get_device_string) {
+			s = malloc(LIBUSB_DEVICE_STRING_BYTES_MAX);
+			int rv = usbi_backend.get_device_string(dev, string_type, s, LIBUSB_DEVICE_STRING_BYTES_MAX);
+			if (rv < 0) {
+				free(s);
+				return rv;
+			} else {
+				dev->device_strings_utf8[string_type] = s;
+			}
+		} else {
+			return LIBUSB_ERROR_NOT_SUPPORTED;
+		}
+	}
+
+	s = dev->device_strings_utf8[string_type];
+	if (NULL == s) {
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	}
+
+	return usbi_utf8_copy(data, s, length);
+}

package/libusb/libusb/io.c

@@ -1303,7 +1303,6 @@ struct libusb_transfer * LIBUSB_CALL libusb_alloc_transfer(
 		return NULL;
 
 	struct usbi_transfer *itransfer = (struct usbi_transfer *)(ptr + priv_size);
-	itransfer->num_iso_packets = iso_packets;
 	itransfer->priv = ptr;
 	usbi_mutex_init(&itransfer->lock);
 	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
@@ -1370,8 +1369,10 @@ static int arm_timer_for_next_timeout(struct libusb_context *ctx)
 
 		/* act on first transfer that has not already been handled */
 		if (!(itransfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))) {
+#ifdef ENABLE_LOGGING
 			struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 			usbi_dbg(ctx, "next timeout originally %ums", transfer->timeout);
+#endif
 			return usbi_arm_timer(&ctx->timer, cur_ts);
 		}
 	}
@@ -1434,9 +1435,11 @@ out:
 	if (first && usbi_using_timer(ctx) && TIMESPEC_IS_SET(timeout)) {
 		/* if this transfer has the lowest timeout of all active transfers,
 		 * rearm the timer with this transfer's timeout */
+#ifdef ENABLE_LOGGING
 		struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 		usbi_dbg(ctx, "arm timer for timeout in %ums (first in line)",
 			transfer->timeout);
+#endif
 		r = usbi_arm_timer(&ctx->timer, timeout);
 	}
 #else
@@ -2811,9 +2814,8 @@ void API_EXPORTED libusb_free_pollfds(const struct libusb_pollfd **pollfds)
  * device. This function ensures transfers get cancelled appropriately.
  * Callers of this function must hold the events_lock.
  */
-void usbi_handle_disconnect(struct libusb_device_handle *dev_handle)
+void usbi_handle_disconnect(struct libusb_context *ctx, struct libusb_device_handle *dev_handle)
 {
-	struct libusb_context *ctx = HANDLE_CTX(dev_handle);
 	struct usbi_transfer *cur;
 	struct usbi_transfer *to_cancel;
 
@@ -2853,9 +2855,11 @@ void usbi_handle_disconnect(struct libusb_device_handle *dev_handle)
 		if (!to_cancel)
 			break;
 
+#ifdef ENABLE_LOGGING
 		struct libusb_transfer *transfer_to_cancel = USBI_TRANSFER_TO_LIBUSB_TRANSFER(to_cancel);
 		usbi_dbg(ctx, "cancelling transfer %p from disconnect",
 			 (void *) transfer_to_cancel);
+#endif
 
 		usbi_mutex_lock(&to_cancel->lock);
 		usbi_backend.clear_transfer_priv(to_cancel);

package/libusb/libusb/libusb-1.0.def

@@ -24,6 +24,10 @@ EXPORTS
   libusb_dev_mem_alloc@8 = libusb_dev_mem_alloc
   libusb_dev_mem_free
   libusb_dev_mem_free@12 = libusb_dev_mem_free
+  libusb_endpoint_set_raw_io
+  libusb_endpoint_set_raw_io@12 = libusb_endpoint_set_raw_io
+  libusb_endpoint_supports_raw_io
+  libusb_endpoint_supports_raw_io@8 = libusb_endpoint_supports_raw_io
   libusb_error_name
   libusb_error_name@4 = libusb_error_name
   libusb_event_handler_active
@@ -84,6 +88,8 @@ EXPORTS
   libusb_get_device_list@8 = libusb_get_device_list
   libusb_get_device_speed
   libusb_get_device_speed@4 = libusb_get_device_speed
+  libusb_get_device_string
+  libusb_get_device_string@16 = libusb_get_device_string
   libusb_get_interface_association_descriptors
   libusb_get_interface_association_descriptors@12 = libusb_get_interface_association_descriptors
   libusb_get_max_alt_packet_size
@@ -92,6 +98,8 @@ EXPORTS
   libusb_get_max_iso_packet_size@8 = libusb_get_max_iso_packet_size
   libusb_get_max_packet_size
   libusb_get_max_packet_size@8 = libusb_get_max_packet_size
+  libusb_get_max_raw_io_transfer_size
+  libusb_get_max_raw_io_transfer_size@8 = libusb_get_max_raw_io_transfer_size
   libusb_get_next_timeout
   libusb_get_next_timeout@8 = libusb_get_next_timeout
   libusb_get_parent
@@ -106,6 +114,8 @@ EXPORTS
   libusb_get_port_numbers@12 = libusb_get_port_numbers
   libusb_get_port_path
   libusb_get_port_path@16 = libusb_get_port_path
+  libusb_get_session_data
+  libusb_get_session_data@4 = libusb_get_session_data
   libusb_get_ss_endpoint_companion_descriptor
   libusb_get_ss_endpoint_companion_descriptor@12 = libusb_get_ss_endpoint_companion_descriptor
   libusb_get_ss_usb_device_capability_descriptor