2 * USB descriptor handling functions for libusb
3 * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
4 * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 #define DESC_HEADER_LENGTH 2
29 #define DEVICE_DESC_LENGTH 18
30 #define CONFIG_DESC_LENGTH 9
31 #define INTERFACE_DESC_LENGTH 9
32 #define ENDPOINT_DESC_LENGTH 7
33 #define ENDPOINT_AUDIO_DESC_LENGTH 9
35 /** @defgroup desc USB descriptors
36 * This page details how to examine the various standard USB descriptors
37 * for detected devices
40 /* set host_endian if the w values are already in host endian format,
41 * as opposed to bus endian. */
42 int usbi_parse_descriptor(unsigned char *source, char *descriptor, void *dest,
45 unsigned char *sp = source, *dp = dest;
49 for (cp = descriptor; *cp; cp++) {
51 case 'b': /* 8-bit byte */
54 case 'w': /* 16-bit word, convert from little endian to CPU */
55 dp += ((uintptr_t)dp & 1); /* Align to word boundary */
60 w = (sp[1] << 8) | sp[0];
61 *((uint16_t *)dp) = w;
69 return (int) (sp - source);
72 static void clear_endpoint(struct libusb_endpoint_descriptor *endpoint)
75 free((unsigned char *) endpoint->extra);
78 static int parse_endpoint(struct libusb_context *ctx,
79 struct libusb_endpoint_descriptor *endpoint, unsigned char *buffer,
80 int size, int host_endian)
82 struct usb_descriptor_header header;
88 usbi_parse_descriptor(buffer, "bb", &header, 0);
90 /* Everything should be fine being passed into here, but we sanity */
92 if (header.bLength > size) {
93 usbi_err(ctx, "ran out of descriptors parsing");
97 if (header.bDescriptorType != LIBUSB_DT_ENDPOINT) {
98 usbi_err(ctx, "unexpected descriptor %x (expected %x)",
99 header.bDescriptorType, LIBUSB_DT_ENDPOINT);
103 if (header.bLength >= ENDPOINT_AUDIO_DESC_LENGTH)
104 usbi_parse_descriptor(buffer, "bbbbwbbb", endpoint, host_endian);
105 else if (header.bLength >= ENDPOINT_DESC_LENGTH)
106 usbi_parse_descriptor(buffer, "bbbbwb", endpoint, host_endian);
108 buffer += header.bLength;
109 size -= header.bLength;
110 parsed += header.bLength;
112 /* Skip over the rest of the Class Specific or Vendor Specific */
115 while (size >= DESC_HEADER_LENGTH) {
116 usbi_parse_descriptor(buffer, "bb", &header, 0);
118 if (header.bLength < 2) {
119 usbi_err(ctx, "invalid descriptor length %d", header.bLength);
123 /* If we find another "proper" descriptor then we're done */
124 if ((header.bDescriptorType == LIBUSB_DT_ENDPOINT) ||
125 (header.bDescriptorType == LIBUSB_DT_INTERFACE) ||
126 (header.bDescriptorType == LIBUSB_DT_CONFIG) ||
127 (header.bDescriptorType == LIBUSB_DT_DEVICE))
130 usbi_dbg("skipping descriptor %x", header.bDescriptorType);
131 buffer += header.bLength;
132 size -= header.bLength;
133 parsed += header.bLength;
136 /* Copy any unknown descriptors into a storage area for drivers */
138 len = (int)(buffer - begin);
140 endpoint->extra = NULL;
141 endpoint->extra_length = 0;
146 endpoint->extra = extra;
148 endpoint->extra_length = 0;
149 return LIBUSB_ERROR_NO_MEM;
152 memcpy(extra, begin, len);
153 endpoint->extra_length = len;
158 static void clear_interface(struct libusb_interface *usb_interface)
163 if (usb_interface->altsetting) {
164 for (i = 0; i < usb_interface->num_altsetting; i++) {
165 struct libusb_interface_descriptor *ifp =
166 (struct libusb_interface_descriptor *)
167 usb_interface->altsetting + i;
169 free((void *) ifp->extra);
171 for (j = 0; j < ifp->bNumEndpoints; j++)
172 clear_endpoint((struct libusb_endpoint_descriptor *)
174 free((void *) ifp->endpoint);
177 free((void *) usb_interface->altsetting);
178 usb_interface->altsetting = NULL;
183 static int parse_interface(libusb_context *ctx,
184 struct libusb_interface *usb_interface, unsigned char *buffer, int size,
192 struct usb_descriptor_header header;
193 struct libusb_interface_descriptor *ifp;
194 unsigned char *begin;
196 usb_interface->num_altsetting = 0;
198 while (size >= INTERFACE_DESC_LENGTH) {
199 struct libusb_interface_descriptor *altsetting =
200 (struct libusb_interface_descriptor *) usb_interface->altsetting;
201 altsetting = realloc(altsetting,
202 sizeof(struct libusb_interface_descriptor) *
203 (usb_interface->num_altsetting + 1));
205 r = LIBUSB_ERROR_NO_MEM;
208 usb_interface->altsetting = altsetting;
210 ifp = altsetting + usb_interface->num_altsetting;
211 usb_interface->num_altsetting++;
212 usbi_parse_descriptor(buffer, "bbbbbbbbb", ifp, 0);
214 ifp->extra_length = 0;
215 ifp->endpoint = NULL;
217 /* Skip over the interface */
218 buffer += ifp->bLength;
219 parsed += ifp->bLength;
220 size -= ifp->bLength;
224 /* Skip over any interface, class or vendor descriptors */
225 while (size >= DESC_HEADER_LENGTH) {
226 usbi_parse_descriptor(buffer, "bb", &header, 0);
227 if (header.bLength < 2) {
228 usbi_err(ctx, "invalid descriptor of length %d",
234 /* If we find another "proper" descriptor then we're done */
235 if ((header.bDescriptorType == LIBUSB_DT_INTERFACE) ||
236 (header.bDescriptorType == LIBUSB_DT_ENDPOINT) ||
237 (header.bDescriptorType == LIBUSB_DT_CONFIG) ||
238 (header.bDescriptorType == LIBUSB_DT_DEVICE))
241 buffer += header.bLength;
242 parsed += header.bLength;
243 size -= header.bLength;
246 /* Copy any unknown descriptors into a storage area for */
247 /* drivers to later parse */
248 len = (int)(buffer - begin);
250 ifp->extra = malloc(len);
252 r = LIBUSB_ERROR_NO_MEM;
255 memcpy((unsigned char *) ifp->extra, begin, len);
256 ifp->extra_length = len;
259 /* Did we hit an unexpected descriptor? */
260 usbi_parse_descriptor(buffer, "bb", &header, 0);
261 if ((size >= DESC_HEADER_LENGTH) &&
262 ((header.bDescriptorType == LIBUSB_DT_CONFIG) ||
263 (header.bDescriptorType == LIBUSB_DT_DEVICE)))
266 if (ifp->bNumEndpoints > USB_MAXENDPOINTS) {
267 usbi_err(ctx, "too many endpoints (%d)", ifp->bNumEndpoints);
272 if (ifp->bNumEndpoints > 0) {
273 struct libusb_endpoint_descriptor *endpoint;
274 tmp = ifp->bNumEndpoints * sizeof(struct libusb_endpoint_descriptor);
275 endpoint = malloc(tmp);
276 ifp->endpoint = endpoint;
278 r = LIBUSB_ERROR_NO_MEM;
282 memset(endpoint, 0, tmp);
283 for (i = 0; i < ifp->bNumEndpoints; i++) {
284 usbi_parse_descriptor(buffer, "bb", &header, 0);
286 if (header.bLength > size) {
287 usbi_err(ctx, "ran out of descriptors parsing");
292 r = parse_endpoint(ctx, endpoint + i, buffer, size,
303 /* We check to see if it's an alternate to this one */
304 ifp = (struct libusb_interface_descriptor *) buffer;
305 if (size < LIBUSB_DT_INTERFACE_SIZE ||
306 ifp->bDescriptorType != LIBUSB_DT_INTERFACE ||
307 !ifp->bAlternateSetting)
313 clear_interface(usb_interface);
317 static void clear_configuration(struct libusb_config_descriptor *config)
319 if (config->interface) {
321 for (i = 0; i < config->bNumInterfaces; i++)
322 clear_interface((struct libusb_interface *)
323 config->interface + i);
324 free((void *) config->interface);
327 free((void *) config->extra);
330 static int parse_configuration(struct libusb_context *ctx,
331 struct libusb_config_descriptor *config, unsigned char *buffer,
338 struct usb_descriptor_header header;
339 struct libusb_interface *usb_interface;
341 usbi_parse_descriptor(buffer, "bbwbbbbb", config, host_endian);
342 size = config->wTotalLength;
344 if (config->bNumInterfaces > USB_MAXINTERFACES) {
345 usbi_err(ctx, "too many interfaces (%d)", config->bNumInterfaces);
346 return LIBUSB_ERROR_IO;
349 tmp = config->bNumInterfaces * sizeof(struct libusb_interface);
350 usb_interface = malloc(tmp);
351 config->interface = usb_interface;
352 if (!config->interface)
353 return LIBUSB_ERROR_NO_MEM;
355 memset(usb_interface, 0, tmp);
356 buffer += config->bLength;
357 size -= config->bLength;
359 config->extra = NULL;
360 config->extra_length = 0;
362 for (i = 0; i < config->bNumInterfaces; i++) {
364 unsigned char *begin;
366 /* Skip over the rest of the Class Specific or Vendor */
367 /* Specific descriptors */
369 while (size >= DESC_HEADER_LENGTH) {
370 usbi_parse_descriptor(buffer, "bb", &header, 0);
372 if ((header.bLength > size) ||
373 (header.bLength < DESC_HEADER_LENGTH)) {
374 usbi_err(ctx, "invalid descriptor length of %d",
380 /* If we find another "proper" descriptor then we're done */
381 if ((header.bDescriptorType == LIBUSB_DT_ENDPOINT) ||
382 (header.bDescriptorType == LIBUSB_DT_INTERFACE) ||
383 (header.bDescriptorType == LIBUSB_DT_CONFIG) ||
384 (header.bDescriptorType == LIBUSB_DT_DEVICE))
387 usbi_dbg("skipping descriptor 0x%x\n", header.bDescriptorType);
388 buffer += header.bLength;
389 size -= header.bLength;
392 /* Copy any unknown descriptors into a storage area for */
393 /* drivers to later parse */
394 len = (int)(buffer - begin);
396 /* FIXME: We should realloc and append here */
397 if (!config->extra_length) {
398 config->extra = malloc(len);
399 if (!config->extra) {
400 r = LIBUSB_ERROR_NO_MEM;
404 memcpy((unsigned char *) config->extra, begin, len);
405 config->extra_length = len;
409 r = parse_interface(ctx, usb_interface + i, buffer, size, host_endian);
420 clear_configuration(config);
425 * Get the USB device descriptor for a given device.
427 * This is a non-blocking function; the device descriptor is cached in memory.
429 * \param dev the device
430 * \param desc output location for the descriptor data
431 * \returns 0 on success or a LIBUSB_ERROR code on failure
433 int API_EXPORTED libusb_get_device_descriptor(libusb_device *dev,
434 struct libusb_device_descriptor *desc)
436 unsigned char raw_desc[DEVICE_DESC_LENGTH];
441 r = usbi_backend->get_device_descriptor(dev, raw_desc, &host_endian);
445 memcpy((unsigned char *) desc, raw_desc, sizeof(raw_desc));
447 desc->bcdUSB = libusb_le16_to_cpu(desc->bcdUSB);
448 desc->idVendor = libusb_le16_to_cpu(desc->idVendor);
449 desc->idProduct = libusb_le16_to_cpu(desc->idProduct);
450 desc->bcdDevice = libusb_le16_to_cpu(desc->bcdDevice);
456 * Get the USB configuration descriptor for the currently active configuration.
457 * This is a non-blocking function which does not involve any requests being
458 * sent to the device.
460 * \param dev a device
461 * \param config output location for the USB configuration descriptor. Only
462 * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
464 * \returns 0 on success
465 * \returns LIBUSB_ERROR_NOT_FOUND if the device is in unconfigured state
466 * \returns another LIBUSB_ERROR code on error
467 * \see libusb_get_config_descriptor
469 int API_EXPORTED libusb_get_active_config_descriptor(libusb_device *dev,
470 struct libusb_config_descriptor **config)
472 struct libusb_config_descriptor *_config = malloc(sizeof(*_config));
473 unsigned char tmp[8];
474 unsigned char *buf = NULL;
480 return LIBUSB_ERROR_NO_MEM;
482 r = usbi_backend->get_active_config_descriptor(dev, tmp, sizeof(tmp),
487 usbi_parse_descriptor(tmp, "bbw", _config, host_endian);
488 buf = malloc(_config->wTotalLength);
490 r = LIBUSB_ERROR_NO_MEM;
494 r = usbi_backend->get_active_config_descriptor(dev, buf,
495 _config->wTotalLength, &host_endian);
499 r = parse_configuration(dev->ctx, _config, buf, host_endian);
501 usbi_err(dev->ctx, "parse_configuration failed with error %d", r);
504 usbi_warn(dev->ctx, "descriptor data still left");
519 * Get a USB configuration descriptor based on its index.
520 * This is a non-blocking function which does not involve any requests being
521 * sent to the device.
523 * \param dev a device
524 * \param config_index the index of the configuration you wish to retrieve
525 * \param config output location for the USB configuration descriptor. Only
526 * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
528 * \returns 0 on success
529 * \returns LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
530 * \returns another LIBUSB_ERROR code on error
531 * \see libusb_get_active_config_descriptor()
532 * \see libusb_get_config_descriptor_by_value()
534 int API_EXPORTED libusb_get_config_descriptor(libusb_device *dev,
535 uint8_t config_index, struct libusb_config_descriptor **config)
537 struct libusb_config_descriptor *_config;
538 unsigned char tmp[8];
539 unsigned char *buf = NULL;
543 usbi_dbg("index %d", config_index);
544 if (config_index >= dev->num_configurations)
545 return LIBUSB_ERROR_NOT_FOUND;
547 _config = malloc(sizeof(*_config));
549 return LIBUSB_ERROR_NO_MEM;
551 r = usbi_backend->get_config_descriptor(dev, config_index, tmp,
552 sizeof(tmp), &host_endian);
556 usbi_parse_descriptor(tmp, "bbw", _config, host_endian);
557 buf = malloc(_config->wTotalLength);
559 r = LIBUSB_ERROR_NO_MEM;
564 r = usbi_backend->get_config_descriptor(dev, config_index, buf,
565 _config->wTotalLength, &host_endian);
569 r = parse_configuration(dev->ctx, _config, buf, host_endian);
571 usbi_err(dev->ctx, "parse_configuration failed with error %d", r);
574 usbi_warn(dev->ctx, "descriptor data still left");
588 /* iterate through all configurations, returning the index of the configuration
589 * matching a specific bConfigurationValue in the idx output parameter, or -1
590 * if the config was not found.
591 * returns 0 or a LIBUSB_ERROR code
593 int usbi_get_config_index_by_value(struct libusb_device *dev,
594 uint8_t bConfigurationValue, int *idx)
598 usbi_dbg("value %d", bConfigurationValue);
599 for (i = 0; i < dev->num_configurations; i++) {
600 unsigned char tmp[6];
602 int r = usbi_backend->get_config_descriptor(dev, i, tmp, sizeof(tmp),
606 if (tmp[5] == bConfigurationValue) {
617 * Get a USB configuration descriptor with a specific bConfigurationValue.
618 * This is a non-blocking function which does not involve any requests being
619 * sent to the device.
621 * \param dev a device
622 * \param bConfigurationValue the bConfigurationValue of the configuration you
624 * \param config output location for the USB configuration descriptor. Only
625 * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
627 * \returns 0 on success
628 * \returns LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
629 * \returns another LIBUSB_ERROR code on error
630 * \see libusb_get_active_config_descriptor()
631 * \see libusb_get_config_descriptor()
633 int API_EXPORTED libusb_get_config_descriptor_by_value(libusb_device *dev,
634 uint8_t bConfigurationValue, struct libusb_config_descriptor **config)
637 int r = usbi_get_config_index_by_value(dev, bConfigurationValue, &idx);
641 return LIBUSB_ERROR_NOT_FOUND;
643 return libusb_get_config_descriptor(dev, (uint8_t) idx, config);
647 * Free a configuration descriptor obtained from
648 * libusb_get_active_config_descriptor() or libusb_get_config_descriptor().
649 * It is safe to call this function with a NULL config parameter, in which
650 * case the function simply returns.
652 * \param config the configuration descriptor to free
654 void API_EXPORTED libusb_free_config_descriptor(
655 struct libusb_config_descriptor *config)
660 clear_configuration(config);
665 * Retrieve a string descriptor in C style ASCII.
667 * Wrapper around libusb_get_string_descriptor(). Uses the first language
668 * supported by the device.
670 * \param dev a device handle
671 * \param desc_index the index of the descriptor to retrieve
672 * \param data output buffer for ASCII string descriptor
673 * \param length size of data buffer
674 * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure
676 int API_EXPORTED libusb_get_string_descriptor_ascii(libusb_device_handle *dev,
677 uint8_t desc_index, unsigned char *data, int length)
679 unsigned char tbuf[255]; /* Some devices choke on size > 255 */
683 /* Asking for the zero'th index is special - it returns a string
684 * descriptor that contains all the language IDs supported by the device.
685 * Typically there aren't many - often only one. The language IDs are 16
686 * bit numbers, and they start at the third byte in the descriptor. See
687 * USB 2.0 specification section 9.6.7 for more information. */
688 r = libusb_get_string_descriptor(dev, 0, 0, tbuf, sizeof(tbuf));
693 return LIBUSB_ERROR_IO;
695 langid = tbuf[2] | (tbuf[3] << 8);
697 r = libusb_get_string_descriptor(dev, desc_index, langid, tbuf,
702 if (tbuf[1] != LIBUSB_DT_STRING)
703 return LIBUSB_ERROR_IO;
706 return LIBUSB_ERROR_IO;
708 for (di = 0, si = 2; si < tbuf[0]; si += 2) {
709 if (di >= (length - 1))
712 if (tbuf[si + 1]) /* high byte */
715 data[di++] = tbuf[si];