1 /* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
2 /*
3 * USB descriptor handling functions for libusb
4 * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
5 * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include "libusbi.h"
23
24 #include <string.h>
25
26 #define DESC_HEADER_LENGTH 2
27
28 /** @defgroup libusb_desc USB descriptors
29 * This page details how to examine the various standard USB descriptors
30 * for detected devices
31 */
32
33 #define READ_LE16(p) ((uint16_t) \
34 (((uint16_t)((p)[1]) << 8) | \
35 ((uint16_t)((p)[0]))))
36
37 #define READ_LE32(p) ((uint32_t) \
38 (((uint32_t)((p)[3]) << 24) | \
39 ((uint32_t)((p)[2]) << 16) | \
40 ((uint32_t)((p)[1]) << 8) | \
41 ((uint32_t)((p)[0]))))
42
parse_descriptor(const void * source,const char * descriptor,void * dest)43 static void parse_descriptor(const void *source, const char *descriptor, void *dest)
44 {
45 const uint8_t *sp = source;
46 uint8_t *dp = dest;
47 char field_type;
48
49 while (*descriptor) {
50 field_type = *descriptor++;
51 switch (field_type) {
52 case 'b': /* 8-bit byte */
53 *dp++ = *sp++;
54 break;
55 case 'w': /* 16-bit word, convert from little endian to CPU */
56 dp += ((uintptr_t)dp & 1); /* Align to 16-bit word boundary */
57
58 *((uint16_t *)dp) = READ_LE16(sp);
59 sp += 2;
60 dp += 2;
61 break;
62 case 'd': /* 32-bit word, convert from little endian to CPU */
63 dp += 4 - ((uintptr_t)dp & 3); /* Align to 32-bit word boundary */
64
65 *((uint32_t *)dp) = READ_LE32(sp);
66 sp += 4;
67 dp += 4;
68 break;
69 case 'u': /* 16 byte UUID */
70 memcpy(dp, sp, 16);
71 sp += 16;
72 dp += 16;
73 break;
74 }
75 }
76 }
77
clear_endpoint(struct libusb_endpoint_descriptor * endpoint)78 static void clear_endpoint(struct libusb_endpoint_descriptor *endpoint)
79 {
80 free((void *)endpoint->extra);
81 }
82
parse_endpoint(struct libusb_context * ctx,struct libusb_endpoint_descriptor * endpoint,const uint8_t * buffer,int size)83 static int parse_endpoint(struct libusb_context *ctx,
84 struct libusb_endpoint_descriptor *endpoint, const uint8_t *buffer, int size)
85 {
86 const struct usbi_descriptor_header *header;
87 const uint8_t *begin;
88 void *extra;
89 int parsed = 0;
90 int len;
91
92 if (size < DESC_HEADER_LENGTH) {
93 usbi_err(ctx, "short endpoint descriptor read %d/%d",
94 size, DESC_HEADER_LENGTH);
95 return LIBUSB_ERROR_IO;
96 }
97
98 header = (const struct usbi_descriptor_header *)buffer;
99 if (header->bDescriptorType != LIBUSB_DT_ENDPOINT) {
100 usbi_err(ctx, "unexpected descriptor 0x%x (expected 0x%x)",
101 header->bDescriptorType, LIBUSB_DT_ENDPOINT);
102 return parsed;
103 } else if (header->bLength < LIBUSB_DT_ENDPOINT_SIZE) {
104 usbi_err(ctx, "invalid endpoint bLength (%u)", header->bLength);
105 return LIBUSB_ERROR_IO;
106 } else if (header->bLength > size) {
107 usbi_warn(ctx, "short endpoint descriptor read %d/%u",
108 size, header->bLength);
109 return parsed;
110 }
111
112 if (header->bLength >= LIBUSB_DT_ENDPOINT_AUDIO_SIZE)
113 parse_descriptor(buffer, "bbbbwbbb", endpoint);
114 else
115 parse_descriptor(buffer, "bbbbwb", endpoint);
116
117 buffer += header->bLength;
118 size -= header->bLength;
119 parsed += header->bLength;
120
121 /* Skip over the rest of the Class Specific or Vendor Specific */
122 /* descriptors */
123 begin = buffer;
124 while (size >= DESC_HEADER_LENGTH) {
125 header = (const struct usbi_descriptor_header *)buffer;
126 if (header->bLength < DESC_HEADER_LENGTH) {
127 usbi_err(ctx, "invalid extra ep desc len (%u)",
128 header->bLength);
129 return LIBUSB_ERROR_IO;
130 } else if (header->bLength > size) {
131 usbi_warn(ctx, "short extra ep desc read %d/%u",
132 size, header->bLength);
133 return parsed;
134 }
135
136 /* If we find another "proper" descriptor then we're done */
137 if (header->bDescriptorType == LIBUSB_DT_ENDPOINT ||
138 header->bDescriptorType == LIBUSB_DT_INTERFACE ||
139 header->bDescriptorType == LIBUSB_DT_CONFIG ||
140 header->bDescriptorType == LIBUSB_DT_DEVICE)
141 break;
142
143 usbi_dbg("skipping descriptor 0x%x", header->bDescriptorType);
144 buffer += header->bLength;
145 size -= header->bLength;
146 parsed += header->bLength;
147 }
148
149 /* Copy any unknown descriptors into a storage area for drivers */
150 /* to later parse */
151 len = (int)(buffer - begin);
152 if (len <= 0)
153 return parsed;
154
155 extra = malloc((size_t)len);
156 if (!extra)
157 return LIBUSB_ERROR_NO_MEM;
158
159 memcpy(extra, begin, len);
160 endpoint->extra = extra;
161 endpoint->extra_length = len;
162
163 return parsed;
164 }
165
clear_interface(struct libusb_interface * usb_interface)166 static void clear_interface(struct libusb_interface *usb_interface)
167 {
168 int i;
169
170 if (usb_interface->altsetting) {
171 for (i = 0; i < usb_interface->num_altsetting; i++) {
172 struct libusb_interface_descriptor *ifp =
173 (struct libusb_interface_descriptor *)
174 usb_interface->altsetting + i;
175
176 free((void *)ifp->extra);
177 if (ifp->endpoint) {
178 uint8_t j;
179
180 for (j = 0; j < ifp->bNumEndpoints; j++)
181 clear_endpoint((struct libusb_endpoint_descriptor *)
182 ifp->endpoint + j);
183 }
184 free((void *)ifp->endpoint);
185 }
186 }
187 free((void *)usb_interface->altsetting);
188 usb_interface->altsetting = NULL;
189 }
190
parse_interface(libusb_context * ctx,struct libusb_interface * usb_interface,const uint8_t * buffer,int size)191 static int parse_interface(libusb_context *ctx,
192 struct libusb_interface *usb_interface, const uint8_t *buffer, int size)
193 {
194 int len;
195 int r;
196 int parsed = 0;
197 int interface_number = -1;
198 const struct usbi_descriptor_header *header;
199 const struct usbi_interface_descriptor *if_desc;
200 struct libusb_interface_descriptor *ifp;
201 const uint8_t *begin;
202
203 while (size >= LIBUSB_DT_INTERFACE_SIZE) {
204 struct libusb_interface_descriptor *altsetting;
205
206 altsetting = realloc((void *)usb_interface->altsetting,
207 sizeof(*altsetting) * (size_t)(usb_interface->num_altsetting + 1));
208 if (!altsetting) {
209 r = LIBUSB_ERROR_NO_MEM;
210 goto err;
211 }
212 usb_interface->altsetting = altsetting;
213
214 ifp = altsetting + usb_interface->num_altsetting;
215 parse_descriptor(buffer, "bbbbbbbbb", ifp);
216 if (ifp->bDescriptorType != LIBUSB_DT_INTERFACE) {
217 usbi_err(ctx, "unexpected descriptor 0x%x (expected 0x%x)",
218 ifp->bDescriptorType, LIBUSB_DT_INTERFACE);
219 return parsed;
220 } else if (ifp->bLength < LIBUSB_DT_INTERFACE_SIZE) {
221 usbi_err(ctx, "invalid interface bLength (%u)",
222 ifp->bLength);
223 r = LIBUSB_ERROR_IO;
224 goto err;
225 } else if (ifp->bLength > size) {
226 usbi_warn(ctx, "short intf descriptor read %d/%u",
227 size, ifp->bLength);
228 return parsed;
229 } else if (ifp->bNumEndpoints > USB_MAXENDPOINTS) {
230 usbi_err(ctx, "too many endpoints (%u)", ifp->bNumEndpoints);
231 r = LIBUSB_ERROR_IO;
232 goto err;
233 }
234
235 usb_interface->num_altsetting++;
236 ifp->extra = NULL;
237 ifp->extra_length = 0;
238 ifp->endpoint = NULL;
239
240 if (interface_number == -1)
241 interface_number = ifp->bInterfaceNumber;
242
243 /* Skip over the interface */
244 buffer += ifp->bLength;
245 parsed += ifp->bLength;
246 size -= ifp->bLength;
247
248 begin = buffer;
249
250 /* Skip over any interface, class or vendor descriptors */
251 while (size >= DESC_HEADER_LENGTH) {
252 header = (const struct usbi_descriptor_header *)buffer;
253 if (header->bLength < DESC_HEADER_LENGTH) {
254 usbi_err(ctx,
255 "invalid extra intf desc len (%u)",
256 header->bLength);
257 r = LIBUSB_ERROR_IO;
258 goto err;
259 } else if (header->bLength > size) {
260 usbi_warn(ctx,
261 "short extra intf desc read %d/%u",
262 size, header->bLength);
263 return parsed;
264 }
265
266 /* If we find another "proper" descriptor then we're done */
267 if (header->bDescriptorType == LIBUSB_DT_INTERFACE ||
268 header->bDescriptorType == LIBUSB_DT_ENDPOINT ||
269 header->bDescriptorType == LIBUSB_DT_CONFIG ||
270 header->bDescriptorType == LIBUSB_DT_DEVICE)
271 break;
272
273 buffer += header->bLength;
274 parsed += header->bLength;
275 size -= header->bLength;
276 }
277
278 /* Copy any unknown descriptors into a storage area for */
279 /* drivers to later parse */
280 len = (int)(buffer - begin);
281 if (len > 0) {
282 void *extra = malloc((size_t)len);
283
284 if (!extra) {
285 r = LIBUSB_ERROR_NO_MEM;
286 goto err;
287 }
288
289 memcpy(extra, begin, len);
290 ifp->extra = extra;
291 ifp->extra_length = len;
292 }
293
294 if (ifp->bNumEndpoints > 0) {
295 struct libusb_endpoint_descriptor *endpoint;
296 uint8_t i;
297
298 endpoint = calloc(ifp->bNumEndpoints, sizeof(*endpoint));
299 if (!endpoint) {
300 r = LIBUSB_ERROR_NO_MEM;
301 goto err;
302 }
303
304 ifp->endpoint = endpoint;
305 for (i = 0; i < ifp->bNumEndpoints; i++) {
306 r = parse_endpoint(ctx, endpoint + i, buffer, size);
307 if (r < 0)
308 goto err;
309 if (r == 0) {
310 ifp->bNumEndpoints = i;
311 break;
312 }
313
314 buffer += r;
315 parsed += r;
316 size -= r;
317 }
318 }
319
320 /* We check to see if it's an alternate to this one */
321 if_desc = (const struct usbi_interface_descriptor *)buffer;
322 if (size < LIBUSB_DT_INTERFACE_SIZE ||
323 if_desc->bDescriptorType != LIBUSB_DT_INTERFACE ||
324 if_desc->bInterfaceNumber != interface_number)
325 return parsed;
326 }
327
328 return parsed;
329 err:
330 clear_interface(usb_interface);
331 return r;
332 }
333
clear_configuration(struct libusb_config_descriptor * config)334 static void clear_configuration(struct libusb_config_descriptor *config)
335 {
336 uint8_t i;
337
338 if (config->interface) {
339 for (i = 0; i < config->bNumInterfaces; i++)
340 clear_interface((struct libusb_interface *)
341 config->interface + i);
342 }
343 free((void *)config->interface);
344 free((void *)config->extra);
345 }
346
parse_configuration(struct libusb_context * ctx,struct libusb_config_descriptor * config,const uint8_t * buffer,int size)347 static int parse_configuration(struct libusb_context *ctx,
348 struct libusb_config_descriptor *config, const uint8_t *buffer, int size)
349 {
350 uint8_t i;
351 int r;
352 const struct usbi_descriptor_header *header;
353 struct libusb_interface *usb_interface;
354
355 if (size < LIBUSB_DT_CONFIG_SIZE) {
356 usbi_err(ctx, "short config descriptor read %d/%d",
357 size, LIBUSB_DT_CONFIG_SIZE);
358 return LIBUSB_ERROR_IO;
359 }
360
361 parse_descriptor(buffer, "bbwbbbbb", config);
362 if (config->bDescriptorType != LIBUSB_DT_CONFIG) {
363 usbi_err(ctx, "unexpected descriptor 0x%x (expected 0x%x)",
364 config->bDescriptorType, LIBUSB_DT_CONFIG);
365 return LIBUSB_ERROR_IO;
366 } else if (config->bLength < LIBUSB_DT_CONFIG_SIZE) {
367 usbi_err(ctx, "invalid config bLength (%u)", config->bLength);
368 return LIBUSB_ERROR_IO;
369 } else if (config->bLength > size) {
370 usbi_err(ctx, "short config descriptor read %d/%u",
371 size, config->bLength);
372 return LIBUSB_ERROR_IO;
373 } else if (config->bNumInterfaces > USB_MAXINTERFACES) {
374 usbi_err(ctx, "too many interfaces (%u)", config->bNumInterfaces);
375 return LIBUSB_ERROR_IO;
376 }
377
378 usb_interface = calloc(config->bNumInterfaces, sizeof(*usb_interface));
379 if (!usb_interface)
380 return LIBUSB_ERROR_NO_MEM;
381
382 config->interface = usb_interface;
383
384 buffer += config->bLength;
385 size -= config->bLength;
386
387 for (i = 0; i < config->bNumInterfaces; i++) {
388 int len;
389 const uint8_t *begin;
390
391 /* Skip over the rest of the Class Specific or Vendor */
392 /* Specific descriptors */
393 begin = buffer;
394 while (size >= DESC_HEADER_LENGTH) {
395 header = (const struct usbi_descriptor_header *)buffer;
396 if (header->bLength < DESC_HEADER_LENGTH) {
397 usbi_err(ctx,
398 "invalid extra config desc len (%u)",
399 header->bLength);
400 r = LIBUSB_ERROR_IO;
401 goto err;
402 } else if (header->bLength > size) {
403 usbi_warn(ctx,
404 "short extra config desc read %d/%u",
405 size, header->bLength);
406 config->bNumInterfaces = i;
407 return size;
408 }
409
410 /* If we find another "proper" descriptor then we're done */
411 if (header->bDescriptorType == LIBUSB_DT_ENDPOINT ||
412 header->bDescriptorType == LIBUSB_DT_INTERFACE ||
413 header->bDescriptorType == LIBUSB_DT_CONFIG ||
414 header->bDescriptorType == LIBUSB_DT_DEVICE)
415 break;
416
417 usbi_dbg("skipping descriptor 0x%x", header->bDescriptorType);
418 buffer += header->bLength;
419 size -= header->bLength;
420 }
421
422 /* Copy any unknown descriptors into a storage area for */
423 /* drivers to later parse */
424 len = (int)(buffer - begin);
425 if (len > 0) {
426 uint8_t *extra = realloc((void *)config->extra,
427 (size_t)(config->extra_length + len));
428
429 if (!extra) {
430 r = LIBUSB_ERROR_NO_MEM;
431 goto err;
432 }
433
434 memcpy(extra + config->extra_length, begin, len);
435 config->extra = extra;
436 config->extra_length += len;
437 }
438
439 r = parse_interface(ctx, usb_interface + i, buffer, size);
440 if (r < 0)
441 goto err;
442 if (r == 0) {
443 config->bNumInterfaces = i;
444 break;
445 }
446
447 buffer += r;
448 size -= r;
449 }
450
451 return size;
452
453 err:
454 clear_configuration(config);
455 return r;
456 }
457
raw_desc_to_config(struct libusb_context * ctx,const uint8_t * buf,int size,struct libusb_config_descriptor ** config)458 static int raw_desc_to_config(struct libusb_context *ctx,
459 const uint8_t *buf, int size, struct libusb_config_descriptor **config)
460 {
461 struct libusb_config_descriptor *_config = calloc(1, sizeof(*_config));
462 int r;
463
464 if (!_config)
465 return LIBUSB_ERROR_NO_MEM;
466
467 r = parse_configuration(ctx, _config, buf, size);
468 if (r < 0) {
469 usbi_err(ctx, "parse_configuration failed with error %d", r);
470 free(_config);
471 return r;
472 } else if (r > 0) {
473 usbi_warn(ctx, "still %d bytes of descriptor data left", r);
474 }
475
476 *config = _config;
477 return LIBUSB_SUCCESS;
478 }
479
get_active_config_descriptor(struct libusb_device * dev,uint8_t * buffer,size_t size)480 static int get_active_config_descriptor(struct libusb_device *dev,
481 uint8_t *buffer, size_t size)
482 {
483 int r = usbi_backend.get_active_config_descriptor(dev, buffer, size);
484
485 if (r < 0)
486 return r;
487
488 if (r < LIBUSB_DT_CONFIG_SIZE) {
489 usbi_err(DEVICE_CTX(dev), "short config descriptor read %d/%d",
490 r, LIBUSB_DT_CONFIG_SIZE);
491 return LIBUSB_ERROR_IO;
492 } else if (r != (int)size) {
493 usbi_warn(DEVICE_CTX(dev), "short config descriptor read %d/%d",
494 r, (int)size);
495 }
496
497 return r;
498 }
499
get_config_descriptor(struct libusb_device * dev,uint8_t config_idx,uint8_t * buffer,size_t size)500 static int get_config_descriptor(struct libusb_device *dev, uint8_t config_idx,
501 uint8_t *buffer, size_t size)
502 {
503 int r = usbi_backend.get_config_descriptor(dev, config_idx, buffer, size);
504
505 if (r < 0)
506 return r;
507 if (r < LIBUSB_DT_CONFIG_SIZE) {
508 usbi_err(DEVICE_CTX(dev), "short config descriptor read %d/%d",
509 r, LIBUSB_DT_CONFIG_SIZE);
510 return LIBUSB_ERROR_IO;
511 } else if (r != (int)size) {
512 usbi_warn(DEVICE_CTX(dev), "short config descriptor read %d/%d",
513 r, (int)size);
514 }
515
516 return r;
517 }
518
519 /** \ingroup libusb_desc
520 * Get the USB device descriptor for a given device.
521 *
522 * This is a non-blocking function; the device descriptor is cached in memory.
523 *
524 * Note since libusb-1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102, this
525 * function always succeeds.
526 *
527 * \param dev the device
528 * \param desc output location for the descriptor data
529 * \returns 0 on success or a LIBUSB_ERROR code on failure
530 */
libusb_get_device_descriptor(libusb_device * dev,struct libusb_device_descriptor * desc)531 int API_EXPORTED libusb_get_device_descriptor(libusb_device *dev,
532 struct libusb_device_descriptor *desc)
533 {
534 usbi_dbg(" ");
535 static_assert(sizeof(dev->device_descriptor) == LIBUSB_DT_DEVICE_SIZE,
536 "struct libusb_device_descriptor is not expected size");
537 *desc = dev->device_descriptor;
538 return 0;
539 }
540
541 /** \ingroup libusb_desc
542 * Get the USB configuration descriptor for the currently active configuration.
543 * This is a non-blocking function which does not involve any requests being
544 * sent to the device.
545 *
546 * \param dev a device
547 * \param config output location for the USB configuration descriptor. Only
548 * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
549 * after use.
550 * \returns 0 on success
551 * \returns LIBUSB_ERROR_NOT_FOUND if the device is in unconfigured state
552 * \returns another LIBUSB_ERROR code on error
553 * \see libusb_get_config_descriptor
554 */
libusb_get_active_config_descriptor(libusb_device * dev,struct libusb_config_descriptor ** config)555 int API_EXPORTED libusb_get_active_config_descriptor(libusb_device *dev,
556 struct libusb_config_descriptor **config)
557 {
558 union usbi_config_desc_buf _config;
559 uint16_t config_len;
560 uint8_t *buf;
561 int r;
562
563 r = get_active_config_descriptor(dev, _config.buf, sizeof(_config.buf));
564 if (r < 0)
565 return r;
566
567 config_len = libusb_le16_to_cpu(_config.desc.wTotalLength);
568 buf = malloc(config_len);
569 if (!buf)
570 return LIBUSB_ERROR_NO_MEM;
571
572 r = get_active_config_descriptor(dev, buf, config_len);
573 if (r >= 0)
574 r = raw_desc_to_config(DEVICE_CTX(dev), buf, r, config);
575
576 free(buf);
577 return r;
578 }
579
580 /** \ingroup libusb_desc
581 * Get a USB configuration descriptor based on its index.
582 * This is a non-blocking function which does not involve any requests being
583 * sent to the device.
584 *
585 * \param dev a device
586 * \param config_index the index of the configuration you wish to retrieve
587 * \param config output location for the USB configuration descriptor. Only
588 * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
589 * after use.
590 * \returns 0 on success
591 * \returns LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
592 * \returns another LIBUSB_ERROR code on error
593 * \see libusb_get_active_config_descriptor()
594 * \see libusb_get_config_descriptor_by_value()
595 */
libusb_get_config_descriptor(libusb_device * dev,uint8_t config_index,struct libusb_config_descriptor ** config)596 int API_EXPORTED libusb_get_config_descriptor(libusb_device *dev,
597 uint8_t config_index, struct libusb_config_descriptor **config)
598 {
599 union usbi_config_desc_buf _config;
600 uint16_t config_len;
601 uint8_t *buf;
602 int r;
603
604 usbi_dbg("index %u", config_index);
605 if (config_index >= dev->device_descriptor.bNumConfigurations)
606 return LIBUSB_ERROR_NOT_FOUND;
607
608 r = get_config_descriptor(dev, config_index, _config.buf, sizeof(_config.buf));
609 if (r < 0)
610 return r;
611
612 config_len = libusb_le16_to_cpu(_config.desc.wTotalLength);
613 buf = malloc(config_len);
614 if (!buf)
615 return LIBUSB_ERROR_NO_MEM;
616
617 r = get_config_descriptor(dev, config_index, buf, config_len);
618 if (r >= 0)
619 r = raw_desc_to_config(DEVICE_CTX(dev), buf, r, config);
620
621 free(buf);
622 return r;
623 }
624
625 /** \ingroup libusb_desc
626 * Get a USB configuration descriptor with a specific bConfigurationValue.
627 * This is a non-blocking function which does not involve any requests being
628 * sent to the device.
629 *
630 * \param dev a device
631 * \param bConfigurationValue the bConfigurationValue of the configuration you
632 * wish to retrieve
633 * \param config output location for the USB configuration descriptor. Only
634 * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
635 * after use.
636 * \returns 0 on success
637 * \returns LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
638 * \returns another LIBUSB_ERROR code on error
639 * \see libusb_get_active_config_descriptor()
640 * \see libusb_get_config_descriptor()
641 */
libusb_get_config_descriptor_by_value(libusb_device * dev,uint8_t bConfigurationValue,struct libusb_config_descriptor ** config)642 int API_EXPORTED libusb_get_config_descriptor_by_value(libusb_device *dev,
643 uint8_t bConfigurationValue, struct libusb_config_descriptor **config)
644 {
645 uint8_t idx;
646 int r;
647
648 if (usbi_backend.get_config_descriptor_by_value) {
649 void *buf;
650
651 r = usbi_backend.get_config_descriptor_by_value(dev,
652 bConfigurationValue, &buf);
653 if (r < 0)
654 return r;
655
656 return raw_desc_to_config(DEVICE_CTX(dev), buf, r, config);
657 }
658
659 usbi_dbg("value %u", bConfigurationValue);
660 for (idx = 0; idx < dev->device_descriptor.bNumConfigurations; idx++) {
661 union usbi_config_desc_buf _config;
662
663 r = get_config_descriptor(dev, idx, _config.buf, sizeof(_config.buf));
664 if (r < 0)
665 return r;
666
667 if (_config.desc.bConfigurationValue == bConfigurationValue)
668 return libusb_get_config_descriptor(dev, idx, config);
669 }
670
671 return LIBUSB_ERROR_NOT_FOUND;
672 }
673
674 /** \ingroup libusb_desc
675 * Free a configuration descriptor obtained from
676 * libusb_get_active_config_descriptor() or libusb_get_config_descriptor().
677 * It is safe to call this function with a NULL config parameter, in which
678 * case the function simply returns.
679 *
680 * \param config the configuration descriptor to free
681 */
libusb_free_config_descriptor(struct libusb_config_descriptor * config)682 void API_EXPORTED libusb_free_config_descriptor(
683 struct libusb_config_descriptor *config)
684 {
685 if (!config)
686 return;
687
688 clear_configuration(config);
689 free(config);
690 }
691
692 /** \ingroup libusb_desc
693 * Get an endpoints superspeed endpoint companion descriptor (if any)
694 *
695 * \param ctx the context to operate on, or NULL for the default context
696 * \param endpoint endpoint descriptor from which to get the superspeed
697 * endpoint companion descriptor
698 * \param ep_comp output location for the superspeed endpoint companion
699 * descriptor. Only valid if 0 was returned. Must be freed with
700 * libusb_free_ss_endpoint_companion_descriptor() after use.
701 * \returns 0 on success
702 * \returns LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
703 * \returns another LIBUSB_ERROR code on error
704 */
libusb_get_ss_endpoint_companion_descriptor(libusb_context * ctx,const struct libusb_endpoint_descriptor * endpoint,struct libusb_ss_endpoint_companion_descriptor ** ep_comp)705 int API_EXPORTED libusb_get_ss_endpoint_companion_descriptor(
706 libusb_context *ctx,
707 const struct libusb_endpoint_descriptor *endpoint,
708 struct libusb_ss_endpoint_companion_descriptor **ep_comp)
709 {
710 struct usbi_descriptor_header *header;
711 const uint8_t *buffer = endpoint->extra;
712 int size = endpoint->extra_length;
713
714 *ep_comp = NULL;
715
716 while (size >= DESC_HEADER_LENGTH) {
717 header = (struct usbi_descriptor_header *)buffer;
718 if (header->bDescriptorType != LIBUSB_DT_SS_ENDPOINT_COMPANION) {
719 if (header->bLength < DESC_HEADER_LENGTH) {
720 usbi_err(ctx, "invalid descriptor length %u",
721 header->bLength);
722 return LIBUSB_ERROR_IO;
723 }
724 buffer += header->bLength;
725 size -= header->bLength;
726 continue;
727 } else if (header->bLength < LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE) {
728 usbi_err(ctx, "invalid ss-ep-comp-desc length %u",
729 header->bLength);
730 return LIBUSB_ERROR_IO;
731 } else if (header->bLength > size) {
732 usbi_err(ctx, "short ss-ep-comp-desc read %d/%u",
733 size, header->bLength);
734 return LIBUSB_ERROR_IO;
735 }
736
737 *ep_comp = malloc(sizeof(**ep_comp));
738 if (!*ep_comp)
739 return LIBUSB_ERROR_NO_MEM;
740 parse_descriptor(buffer, "bbbbw", *ep_comp);
741 return LIBUSB_SUCCESS;
742 }
743 return LIBUSB_ERROR_NOT_FOUND;
744 }
745
746 /** \ingroup libusb_desc
747 * Free a superspeed endpoint companion descriptor obtained from
748 * libusb_get_ss_endpoint_companion_descriptor().
749 * It is safe to call this function with a NULL ep_comp parameter, in which
750 * case the function simply returns.
751 *
752 * \param ep_comp the superspeed endpoint companion descriptor to free
753 */
libusb_free_ss_endpoint_companion_descriptor(struct libusb_ss_endpoint_companion_descriptor * ep_comp)754 void API_EXPORTED libusb_free_ss_endpoint_companion_descriptor(
755 struct libusb_ss_endpoint_companion_descriptor *ep_comp)
756 {
757 free(ep_comp);
758 }
759
parse_bos(struct libusb_context * ctx,struct libusb_bos_descriptor ** bos,const uint8_t * buffer,int size)760 static int parse_bos(struct libusb_context *ctx,
761 struct libusb_bos_descriptor **bos,
762 const uint8_t *buffer, int size)
763 {
764 struct libusb_bos_descriptor *_bos;
765 const struct usbi_bos_descriptor *bos_desc;
766 const struct usbi_descriptor_header *header;
767 uint8_t i;
768
769 if (size < LIBUSB_DT_BOS_SIZE) {
770 usbi_err(ctx, "short bos descriptor read %d/%d",
771 size, LIBUSB_DT_BOS_SIZE);
772 return LIBUSB_ERROR_IO;
773 }
774
775 bos_desc = (const struct usbi_bos_descriptor *)buffer;
776 if (bos_desc->bDescriptorType != LIBUSB_DT_BOS) {
777 usbi_err(ctx, "unexpected descriptor 0x%x (expected 0x%x)",
778 bos_desc->bDescriptorType, LIBUSB_DT_BOS);
779 return LIBUSB_ERROR_IO;
780 } else if (bos_desc->bLength < LIBUSB_DT_BOS_SIZE) {
781 usbi_err(ctx, "invalid bos bLength (%u)", bos_desc->bLength);
782 return LIBUSB_ERROR_IO;
783 } else if (bos_desc->bLength > size) {
784 usbi_err(ctx, "short bos descriptor read %d/%u",
785 size, bos_desc->bLength);
786 return LIBUSB_ERROR_IO;
787 }
788
789 _bos = calloc(1, sizeof(*_bos) + bos_desc->bNumDeviceCaps * sizeof(void *));
790 if (!_bos)
791 return LIBUSB_ERROR_NO_MEM;
792
793 parse_descriptor(buffer, "bbwb", _bos);
794 buffer += _bos->bLength;
795 size -= _bos->bLength;
796
797 /* Get the device capability descriptors */
798 for (i = 0; i < _bos->bNumDeviceCaps; i++) {
799 if (size < LIBUSB_DT_DEVICE_CAPABILITY_SIZE) {
800 usbi_warn(ctx, "short dev-cap descriptor read %d/%d",
801 size, LIBUSB_DT_DEVICE_CAPABILITY_SIZE);
802 break;
803 }
804 header = (const struct usbi_descriptor_header *)buffer;
805 if (header->bDescriptorType != LIBUSB_DT_DEVICE_CAPABILITY) {
806 usbi_warn(ctx, "unexpected descriptor 0x%x (expected 0x%x)",
807 header->bDescriptorType, LIBUSB_DT_DEVICE_CAPABILITY);
808 break;
809 } else if (header->bLength < LIBUSB_DT_DEVICE_CAPABILITY_SIZE) {
810 usbi_err(ctx, "invalid dev-cap bLength (%u)",
811 header->bLength);
812 libusb_free_bos_descriptor(_bos);
813 return LIBUSB_ERROR_IO;
814 } else if (header->bLength > size) {
815 usbi_warn(ctx, "short dev-cap descriptor read %d/%u",
816 size, header->bLength);
817 break;
818 }
819
820 _bos->dev_capability[i] = malloc(header->bLength);
821 if (!_bos->dev_capability[i]) {
822 libusb_free_bos_descriptor(_bos);
823 return LIBUSB_ERROR_NO_MEM;
824 }
825 memcpy(_bos->dev_capability[i], buffer, header->bLength);
826 buffer += header->bLength;
827 size -= header->bLength;
828 }
829 _bos->bNumDeviceCaps = i;
830 *bos = _bos;
831
832 return LIBUSB_SUCCESS;
833 }
834
835 /** \ingroup libusb_desc
836 * Get a Binary Object Store (BOS) descriptor
837 * This is a BLOCKING function, which will send requests to the device.
838 *
839 * \param dev_handle the handle of an open libusb device
840 * \param bos output location for the BOS descriptor. Only valid if 0 was returned.
841 * Must be freed with \ref libusb_free_bos_descriptor() after use.
842 * \returns 0 on success
843 * \returns LIBUSB_ERROR_NOT_FOUND if the device doesn't have a BOS descriptor
844 * \returns another LIBUSB_ERROR code on error
845 */
libusb_get_bos_descriptor(libusb_device_handle * dev_handle,struct libusb_bos_descriptor ** bos)846 int API_EXPORTED libusb_get_bos_descriptor(libusb_device_handle *dev_handle,
847 struct libusb_bos_descriptor **bos)
848 {
849 union usbi_bos_desc_buf _bos;
850 uint16_t bos_len;
851 uint8_t *bos_data;
852 int r;
853
854 /* Read the BOS. This generates 2 requests on the bus,
855 * one for the header, and one for the full BOS */
856 r = libusb_get_descriptor(dev_handle, LIBUSB_DT_BOS, 0, _bos.buf, sizeof(_bos.buf));
857 if (r < 0) {
858 if (r != LIBUSB_ERROR_PIPE)
859 usbi_err(HANDLE_CTX(dev_handle), "failed to read BOS (%d)", r);
860 return r;
861 }
862 if (r < LIBUSB_DT_BOS_SIZE) {
863 usbi_err(HANDLE_CTX(dev_handle), "short BOS read %d/%d",
864 r, LIBUSB_DT_BOS_SIZE);
865 return LIBUSB_ERROR_IO;
866 }
867
868 bos_len = libusb_le16_to_cpu(_bos.desc.wTotalLength);
869 usbi_dbg("found BOS descriptor: size %u bytes, %u capabilities",
870 bos_len, _bos.desc.bNumDeviceCaps);
871 bos_data = calloc(1, bos_len);
872 if (!bos_data)
873 return LIBUSB_ERROR_NO_MEM;
874
875 r = libusb_get_descriptor(dev_handle, LIBUSB_DT_BOS, 0, bos_data, bos_len);
876 if (r >= 0) {
877 if (r != (int)bos_len)
878 usbi_warn(HANDLE_CTX(dev_handle), "short BOS read %d/%u",
879 r, bos_len);
880 r = parse_bos(HANDLE_CTX(dev_handle), bos, bos_data, r);
881 } else {
882 usbi_err(HANDLE_CTX(dev_handle), "failed to read BOS (%d)", r);
883 }
884
885 free(bos_data);
886 return r;
887 }
888
889 /** \ingroup libusb_desc
890 * Free a BOS descriptor obtained from libusb_get_bos_descriptor().
891 * It is safe to call this function with a NULL bos parameter, in which
892 * case the function simply returns.
893 *
894 * \param bos the BOS descriptor to free
895 */
libusb_free_bos_descriptor(struct libusb_bos_descriptor * bos)896 void API_EXPORTED libusb_free_bos_descriptor(struct libusb_bos_descriptor *bos)
897 {
898 uint8_t i;
899
900 if (!bos)
901 return;
902
903 for (i = 0; i < bos->bNumDeviceCaps; i++)
904 free(bos->dev_capability[i]);
905 free(bos);
906 }
907
908 /** \ingroup libusb_desc
909 * Get an USB 2.0 Extension descriptor
910 *
911 * \param ctx the context to operate on, or NULL for the default context
912 * \param dev_cap Device Capability descriptor with a bDevCapabilityType of
913 * \ref libusb_capability_type::LIBUSB_BT_USB_2_0_EXTENSION
914 * LIBUSB_BT_USB_2_0_EXTENSION
915 * \param usb_2_0_extension output location for the USB 2.0 Extension
916 * descriptor. Only valid if 0 was returned. Must be freed with
917 * libusb_free_usb_2_0_extension_descriptor() after use.
918 * \returns 0 on success
919 * \returns a LIBUSB_ERROR code on error
920 */
libusb_get_usb_2_0_extension_descriptor(libusb_context * ctx,struct libusb_bos_dev_capability_descriptor * dev_cap,struct libusb_usb_2_0_extension_descriptor ** usb_2_0_extension)921 int API_EXPORTED libusb_get_usb_2_0_extension_descriptor(
922 libusb_context *ctx,
923 struct libusb_bos_dev_capability_descriptor *dev_cap,
924 struct libusb_usb_2_0_extension_descriptor **usb_2_0_extension)
925 {
926 struct libusb_usb_2_0_extension_descriptor *_usb_2_0_extension;
927
928 if (dev_cap->bDevCapabilityType != LIBUSB_BT_USB_2_0_EXTENSION) {
929 usbi_err(ctx, "unexpected bDevCapabilityType 0x%x (expected 0x%x)",
930 dev_cap->bDevCapabilityType,
931 LIBUSB_BT_USB_2_0_EXTENSION);
932 return LIBUSB_ERROR_INVALID_PARAM;
933 } else if (dev_cap->bLength < LIBUSB_BT_USB_2_0_EXTENSION_SIZE) {
934 usbi_err(ctx, "short dev-cap descriptor read %u/%d",
935 dev_cap->bLength, LIBUSB_BT_USB_2_0_EXTENSION_SIZE);
936 return LIBUSB_ERROR_IO;
937 }
938
939 _usb_2_0_extension = malloc(sizeof(*_usb_2_0_extension));
940 if (!_usb_2_0_extension)
941 return LIBUSB_ERROR_NO_MEM;
942
943 parse_descriptor(dev_cap, "bbbd", _usb_2_0_extension);
944
945 *usb_2_0_extension = _usb_2_0_extension;
946 return LIBUSB_SUCCESS;
947 }
948
949 /** \ingroup libusb_desc
950 * Free a USB 2.0 Extension descriptor obtained from
951 * libusb_get_usb_2_0_extension_descriptor().
952 * It is safe to call this function with a NULL usb_2_0_extension parameter,
953 * in which case the function simply returns.
954 *
955 * \param usb_2_0_extension the USB 2.0 Extension descriptor to free
956 */
libusb_free_usb_2_0_extension_descriptor(struct libusb_usb_2_0_extension_descriptor * usb_2_0_extension)957 void API_EXPORTED libusb_free_usb_2_0_extension_descriptor(
958 struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension)
959 {
960 free(usb_2_0_extension);
961 }
962
963 /** \ingroup libusb_desc
964 * Get a SuperSpeed USB Device Capability descriptor
965 *
966 * \param ctx the context to operate on, or NULL for the default context
967 * \param dev_cap Device Capability descriptor with a bDevCapabilityType of
968 * \ref libusb_capability_type::LIBUSB_BT_SS_USB_DEVICE_CAPABILITY
969 * LIBUSB_BT_SS_USB_DEVICE_CAPABILITY
970 * \param ss_usb_device_cap output location for the SuperSpeed USB Device
971 * Capability descriptor. Only valid if 0 was returned. Must be freed with
972 * libusb_free_ss_usb_device_capability_descriptor() after use.
973 * \returns 0 on success
974 * \returns a LIBUSB_ERROR code on error
975 */
libusb_get_ss_usb_device_capability_descriptor(libusb_context * ctx,struct libusb_bos_dev_capability_descriptor * dev_cap,struct libusb_ss_usb_device_capability_descriptor ** ss_usb_device_cap)976 int API_EXPORTED libusb_get_ss_usb_device_capability_descriptor(
977 libusb_context *ctx,
978 struct libusb_bos_dev_capability_descriptor *dev_cap,
979 struct libusb_ss_usb_device_capability_descriptor **ss_usb_device_cap)
980 {
981 struct libusb_ss_usb_device_capability_descriptor *_ss_usb_device_cap;
982
983 if (dev_cap->bDevCapabilityType != LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) {
984 usbi_err(ctx, "unexpected bDevCapabilityType 0x%x (expected 0x%x)",
985 dev_cap->bDevCapabilityType,
986 LIBUSB_BT_SS_USB_DEVICE_CAPABILITY);
987 return LIBUSB_ERROR_INVALID_PARAM;
988 } else if (dev_cap->bLength < LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE) {
989 usbi_err(ctx, "short dev-cap descriptor read %u/%d",
990 dev_cap->bLength, LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE);
991 return LIBUSB_ERROR_IO;
992 }
993
994 _ss_usb_device_cap = malloc(sizeof(*_ss_usb_device_cap));
995 if (!_ss_usb_device_cap)
996 return LIBUSB_ERROR_NO_MEM;
997
998 parse_descriptor(dev_cap, "bbbbwbbw", _ss_usb_device_cap);
999
1000 *ss_usb_device_cap = _ss_usb_device_cap;
1001 return LIBUSB_SUCCESS;
1002 }
1003
1004 /** \ingroup libusb_desc
1005 * Free a SuperSpeed USB Device Capability descriptor obtained from
1006 * libusb_get_ss_usb_device_capability_descriptor().
1007 * It is safe to call this function with a NULL ss_usb_device_cap
1008 * parameter, in which case the function simply returns.
1009 *
1010 * \param ss_usb_device_cap the SuperSpeed USB Device Capability descriptor
1011 * to free
1012 */
libusb_free_ss_usb_device_capability_descriptor(struct libusb_ss_usb_device_capability_descriptor * ss_usb_device_cap)1013 void API_EXPORTED libusb_free_ss_usb_device_capability_descriptor(
1014 struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_cap)
1015 {
1016 free(ss_usb_device_cap);
1017 }
1018
1019 /** \ingroup libusb_desc
1020 * Get a Container ID descriptor
1021 *
1022 * \param ctx the context to operate on, or NULL for the default context
1023 * \param dev_cap Device Capability descriptor with a bDevCapabilityType of
1024 * \ref libusb_capability_type::LIBUSB_BT_CONTAINER_ID
1025 * LIBUSB_BT_CONTAINER_ID
1026 * \param container_id output location for the Container ID descriptor.
1027 * Only valid if 0 was returned. Must be freed with
1028 * libusb_free_container_id_descriptor() after use.
1029 * \returns 0 on success
1030 * \returns a LIBUSB_ERROR code on error
1031 */
libusb_get_container_id_descriptor(libusb_context * ctx,struct libusb_bos_dev_capability_descriptor * dev_cap,struct libusb_container_id_descriptor ** container_id)1032 int API_EXPORTED libusb_get_container_id_descriptor(libusb_context *ctx,
1033 struct libusb_bos_dev_capability_descriptor *dev_cap,
1034 struct libusb_container_id_descriptor **container_id)
1035 {
1036 struct libusb_container_id_descriptor *_container_id;
1037
1038 if (dev_cap->bDevCapabilityType != LIBUSB_BT_CONTAINER_ID) {
1039 usbi_err(ctx, "unexpected bDevCapabilityType 0x%x (expected 0x%x)",
1040 dev_cap->bDevCapabilityType,
1041 LIBUSB_BT_CONTAINER_ID);
1042 return LIBUSB_ERROR_INVALID_PARAM;
1043 } else if (dev_cap->bLength < LIBUSB_BT_CONTAINER_ID_SIZE) {
1044 usbi_err(ctx, "short dev-cap descriptor read %u/%d",
1045 dev_cap->bLength, LIBUSB_BT_CONTAINER_ID_SIZE);
1046 return LIBUSB_ERROR_IO;
1047 }
1048
1049 _container_id = malloc(sizeof(*_container_id));
1050 if (!_container_id)
1051 return LIBUSB_ERROR_NO_MEM;
1052
1053 parse_descriptor(dev_cap, "bbbbu", _container_id);
1054
1055 *container_id = _container_id;
1056 return LIBUSB_SUCCESS;
1057 }
1058
1059 /** \ingroup libusb_desc
1060 * Free a Container ID descriptor obtained from
1061 * libusb_get_container_id_descriptor().
1062 * It is safe to call this function with a NULL container_id parameter,
1063 * in which case the function simply returns.
1064 *
1065 * \param container_id the Container ID descriptor to free
1066 */
libusb_free_container_id_descriptor(struct libusb_container_id_descriptor * container_id)1067 void API_EXPORTED libusb_free_container_id_descriptor(
1068 struct libusb_container_id_descriptor *container_id)
1069 {
1070 free(container_id);
1071 }
1072
1073 /** \ingroup libusb_desc
1074 * Retrieve a string descriptor in C style ASCII.
1075 *
1076 * Wrapper around libusb_get_string_descriptor(). Uses the first language
1077 * supported by the device.
1078 *
1079 * \param dev_handle a device handle
1080 * \param desc_index the index of the descriptor to retrieve
1081 * \param data output buffer for ASCII string descriptor
1082 * \param length size of data buffer
1083 * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure
1084 */
libusb_get_string_descriptor_ascii(libusb_device_handle * dev_handle,uint8_t desc_index,unsigned char * data,int length)1085 int API_EXPORTED libusb_get_string_descriptor_ascii(libusb_device_handle *dev_handle,
1086 uint8_t desc_index, unsigned char *data, int length)
1087 {
1088 union usbi_string_desc_buf str;
1089 int r, si, di;
1090 uint16_t langid, wdata;
1091
1092 /* Asking for the zero'th index is special - it returns a string
1093 * descriptor that contains all the language IDs supported by the
1094 * device. Typically there aren't many - often only one. Language
1095 * IDs are 16 bit numbers, and they start at the third byte in the
1096 * descriptor. There's also no point in trying to read descriptor 0
1097 * with this function. See USB 2.0 specification section 9.6.7 for
1098 * more information.
1099 */
1100
1101 if (desc_index == 0)
1102 return LIBUSB_ERROR_INVALID_PARAM;
1103
1104 r = libusb_get_string_descriptor(dev_handle, 0, 0, str.buf, 4);
1105 if (r < 0)
1106 return r;
1107 else if (r != 4 || str.desc.bLength < 4)
1108 return LIBUSB_ERROR_IO;
1109 else if (str.desc.bDescriptorType != LIBUSB_DT_STRING)
1110 return LIBUSB_ERROR_IO;
1111 else if (str.desc.bLength & 1)
1112 usbi_warn(HANDLE_CTX(dev_handle), "suspicious bLength %u for string descriptor", str.desc.bLength);
1113
1114 langid = libusb_le16_to_cpu(str.desc.wData[0]);
1115 r = libusb_get_string_descriptor(dev_handle, desc_index, langid, str.buf, sizeof(str.buf));
1116 if (r < 0)
1117 return r;
1118 else if (r < DESC_HEADER_LENGTH || str.desc.bLength > r)
1119 return LIBUSB_ERROR_IO;
1120 else if (str.desc.bDescriptorType != LIBUSB_DT_STRING)
1121 return LIBUSB_ERROR_IO;
1122 else if ((str.desc.bLength & 1) || str.desc.bLength != r)
1123 usbi_warn(HANDLE_CTX(dev_handle), "suspicious bLength %u for string descriptor", str.desc.bLength);
1124
1125 di = 0;
1126 for (si = 2; si < str.desc.bLength; si += 2) {
1127 if (di >= (length - 1))
1128 break;
1129
1130 wdata = libusb_le16_to_cpu(str.desc.wData[di]);
1131 if (wdata < 0x80)
1132 data[di++] = (unsigned char)wdata;
1133 else
1134 data[di++] = '?'; /* non-ASCII */
1135 }
1136
1137 data[di] = 0;
1138 return di;
1139 }
1140