usb 1.7.2 → 1.8.1-libusb.4

package/libusb/examples/Makefile.am

@@ -1,7 +1,7 @@
 AM_CPPFLAGS = -I$(top_srcdir)/libusb
 LDADD = ../libusb/libusb-1.0.la
 
-noinst_PROGRAMS = listdevs xusb fxload hotplugtest
+noinst_PROGRAMS = listdevs xusb fxload hotplugtest testlibusb
 
 if HAVE_SIGACTION
 noinst_PROGRAMS += dpfp

package/libusb/examples/dpfp.c

@@ -411,13 +411,15 @@ static int alloc_transfers(void)
 
 static void sighandler(int signum)
 {
+	(void)signum;
+
 	do_exit = 1;
 }
 
 int main(void)
 {
 	struct sigaction sigact;
-	int r = 1;
+	int r;
 
 	r = libusb_init(NULL);
 	if (r < 0) {

package/libusb/examples/dpfp_threaded.c

@@ -1,6 +1,7 @@
 /*
  * libusb example program to manipulate U.are.U 4000B fingerprint scanner.
  * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2016 Nathan Hjelm <hjelmn@mac.com>
  *
  * Basic image capture program only, does not consider the powerup quirks or
  * the fact that image encryption may be enabled. Not expected to work
@@ -23,10 +24,12 @@
 
 #include <errno.h>
 #include <pthread.h>
+#include <semaphore.h>
 #include <signal.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <fcntl.h>
 
 #include "libusb.h"
 
@@ -36,6 +39,7 @@
 #define CTRL_OUT		(LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT)
 #define USB_RQ			0x04
 #define INTR_LENGTH		64
+#define SEM_NAME                "/org.libusb.example.dpfp_threaded"
 
 enum {
 	MODE_INIT = 0x00,
@@ -64,16 +68,15 @@ static unsigned char irqbuf[INTR_LENGTH];
 static struct libusb_transfer *img_transfer = NULL;
 static struct libusb_transfer *irq_transfer = NULL;
 static int img_idx = 0;
-static int do_exit = 0;
+static volatile sig_atomic_t do_exit = 0;
 
 static pthread_t poll_thread;
-static pthread_cond_t exit_cond = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t exit_cond_lock = PTHREAD_MUTEX_INITIALIZER;
+static sem_t *exit_sem;
 
-static void request_exit(int code)
+static void request_exit(sig_atomic_t code)
 {
 	do_exit = code;
-	pthread_cond_signal(&exit_cond);
+	sem_post(exit_sem);
 }
 
 static void *poll_thread_main(void *arg)
@@ -81,6 +84,8 @@ static void *poll_thread_main(void *arg)
 	int r = 0;
 	printf("poll thread running\n");
 
+	(void)arg;
+
 	while (!do_exit) {
 		struct timeval tv = { 1, 0 };
 		r = libusb_handle_events_timeout(NULL, &tv);
@@ -438,6 +443,8 @@ static int alloc_transfers(void)
 
 static void sighandler(int signum)
 {
+	(void)signum;
+
 	request_exit(1);
 }
 
@@ -446,6 +453,15 @@ int main(void)
 	struct sigaction sigact;
 	int r = 1;
 
+	exit_sem = sem_open (SEM_NAME, O_CREAT, 0);
+	if (!exit_sem) {
+		fprintf(stderr, "failed to initialise semaphore error %d", errno);
+		exit(1);
+	}
+
+	/* only using this semaphore in this process so go ahead and unlink it now */
+	sem_unlink (SEM_NAME);
+
 	r = libusb_init(NULL);
 	if (r < 0) {
 		fprintf(stderr, "failed to initialise libusb\n");
@@ -500,11 +516,8 @@ int main(void)
 		goto out_deinit;
 	}
 
-	while (!do_exit) {
-		pthread_mutex_lock(&exit_cond_lock);
-		pthread_cond_wait(&exit_cond, &exit_cond_lock);
-		pthread_mutex_unlock(&exit_cond_lock);
-	}
+	while (!do_exit)
+		sem_wait(exit_sem);
 
 	printf("shutting down...\n");
 	pthread_join(poll_thread, NULL);

package/libusb/examples/ezusb.c

@@ -133,7 +133,7 @@ static int ezusb_write(libusb_device_handle *device, const char *label,
 		LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
 		opcode, addr & 0xFFFF, addr >> 16,
 		(unsigned char*)data, (uint16_t)len, 1000);
-	if (status != len) {
+	if (status != (signed)len) {
 		if (status < 0)
 			logerror("%s: %s\n", label, libusb_error_name(status));
 		else
@@ -156,7 +156,7 @@ static int ezusb_read(libusb_device_handle *device, const char *label,
 		LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
 		opcode, addr & 0xFFFF, addr >> 16,
 		(unsigned char*)data, (uint16_t)len, 1000);
-	if (status != len) {
+	if (status != (signed)len) {
 		if (status < 0)
 			logerror("%s: %s\n", label, libusb_error_name(status));
 		else
@@ -299,7 +299,7 @@ static int parse_ihex(FILE *image, void *context,
 		/* Read the target offset (address up to 64KB) */
 		tmp = buf[7];
 		buf[7] = 0;
-		off = (int)strtoul(buf+3, NULL, 16);
+		off = (unsigned int)strtoul(buf+3, NULL, 16);
 		buf[7] = tmp;
 
 		/* Initialize data_addr */

package/libusb/examples/ezusb.h

@@ -1,5 +1,5 @@
-#ifndef __ezusb_H
-#define __ezusb_H
+#ifndef ezusb_H
+#define ezusb_H
 /*
  * Copyright © 2001 Stephen Williams (steve@icarus.com)
  * Copyright © 2002 David Brownell (dbrownell@users.sourceforge.net)

package/libusb/examples/fxload.c

@@ -65,8 +65,9 @@ void logerror(const char *format, ...)
 }
 
 static int print_usage(int error_code) {
-	fprintf(stderr, "\nUsage: fxload [-v] [-V] [-t type] [-d vid:pid] [-p bus,addr] -i firmware\n");
+	fprintf(stderr, "\nUsage: fxload [-v] [-V] [-t type] [-d vid:pid] [-p bus,addr] [-s loader] -i firmware\n");
 	fprintf(stderr, "  -i <path>       -- Firmware to upload\n");
+	fprintf(stderr, "  -s <path>       -- Second stage loader\n");
 	fprintf(stderr, "  -t <type>       -- Target type: an21, fx, fx2, fx2lp, fx3\n");
 	fprintf(stderr, "  -d <vid:pid>    -- Target device, as an USB VID:PID\n");
 	fprintf(stderr, "  -p <bus,addr>   -- Target device, as a libusb bus number and device address path\n");
@@ -88,14 +89,15 @@ int main(int argc, char*argv[])
 	const char *fx_name[FX_TYPE_MAX] = FX_TYPE_NAMES;
 	const char *ext, *img_name[] = IMG_TYPE_NAMES;
 	int fx_type = FX_TYPE_UNDEFINED, img_type[ARRAYSIZE(path)];
-	int i, j, opt, status;
+	int opt, status;
+	unsigned int i, j;
 	unsigned vid = 0, pid = 0;
 	unsigned busnum = 0, devaddr = 0, _busnum, _devaddr;
 	libusb_device *dev, **devs;
 	libusb_device_handle *device = NULL;
 	struct libusb_device_descriptor desc;
 
-	while ((opt = getopt(argc, argv, "qvV?hd:p:i:I:t:")) != EOF)
+	while ((opt = getopt(argc, argv, "qvV?hd:p:i:I:s:S:t:")) != EOF)
 		switch (opt) {
 
 		case 'd':
@@ -119,6 +121,11 @@ int main(int argc, char*argv[])
 			path[FIRMWARE] = optarg;
 			break;
 
+		case 's':
+		case 'S':
+			path[LOADER] = optarg;
+			break;
+
 		case 'V':
 			puts(FXLOAD_VERSION);
 			return 0;
@@ -171,7 +178,7 @@ int main(int argc, char*argv[])
 		logerror("libusb_init() failed: %s\n", libusb_error_name(status));
 		return -1;
 	}
-	libusb_set_debug(NULL, verbose);
+	libusb_set_option(NULL, LIBUSB_OPTION_LOG_LEVEL, verbose);
 
 	/* try to pick up missing parameters from known devices */
 	if ((type == NULL) || (device_id == NULL) || (device_path != NULL)) {
@@ -224,15 +231,16 @@ int main(int argc, char*argv[])
 		}
 		if (dev == NULL) {
 			libusb_free_device_list(devs, 1);
+			libusb_exit(NULL);
 			logerror("could not find a known device - please specify type and/or vid:pid and/or bus,dev\n");
 			return print_usage(-1);
 		}
 		status = libusb_open(dev, &device);
+		libusb_free_device_list(devs, 1);
 		if (status < 0) {
 			logerror("libusb_open() failed: %s\n", libusb_error_name(status));
 			goto err;
 		}
-		libusb_free_device_list(devs, 1);
 	} else if (device_id != NULL) {
 		device = libusb_open_device_with_vid_pid(NULL, (uint16_t)vid, (uint16_t)pid);
 		if (device == NULL) {
@@ -245,6 +253,7 @@ int main(int argc, char*argv[])
 	libusb_set_auto_detach_kernel_driver(device, 1);
 	status = libusb_claim_interface(device, 0);
 	if (status != LIBUSB_SUCCESS) {
+		libusb_close(device);
 		logerror("libusb_claim_interface failed: %s\n", libusb_error_name(status));
 		goto err;
 	}
@@ -272,10 +281,23 @@ int main(int argc, char*argv[])
 			logerror("%s: type %s\n", path[i], img_name[img_type[i]]);
 	}
 
-	/* single stage, put into internal memory */
-	if (verbose > 1)
-		logerror("single stage: load on-chip memory\n");
-	status = ezusb_load_ram(device, path[FIRMWARE], fx_type, img_type[FIRMWARE], 0);
+	if (path[LOADER] == NULL) {
+		/* single stage, put into internal memory */
+		if (verbose > 1)
+			logerror("single stage: load on-chip memory\n");
+		status = ezusb_load_ram(device, path[FIRMWARE], fx_type, img_type[FIRMWARE], 0);
+	} else {
+		/* two-stage, put loader into internal memory */
+		if (verbose > 1)
+			logerror("1st stage: load 2nd stage loader\n");
+		status = ezusb_load_ram(device, path[LOADER], fx_type, img_type[LOADER], 0);
+		if (status == 0) {
+			/* two-stage, put firmware into internal memory */
+			if (verbose > 1)
+				logerror("2nd state: load on-chip memory\n");
+			status = ezusb_load_ram(device, path[FIRMWARE], fx_type, img_type[FIRMWARE], 1);
+		}
+	}
 
 	libusb_release_interface(device, 0);
 	libusb_close(device);

package/libusb/examples/hotplugtest.c

@@ -1,7 +1,7 @@
 /* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
 /*
  * libusb example program for hotplug API
- * Copyright © 2012-2013 Nathan Hjelm <hjelmn@mac.ccom>
+ * Copyright © 2012-2013 Nathan Hjelm <hjelmn@mac.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -24,13 +24,18 @@
 #include "libusb.h"
 
 int done = 0;
-libusb_device_handle *handle;
+libusb_device_handle *handle = NULL;
 
 static int LIBUSB_CALL hotplug_callback(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data)
 {
 	struct libusb_device_descriptor desc;
 	int rc;
 
+	(void)ctx;
+	(void)dev;
+	(void)event;
+	(void)user_data;
+
 	rc = libusb_get_device_descriptor(dev, &desc);
 	if (LIBUSB_SUCCESS != rc) {
 		fprintf (stderr, "Error getting device descriptor\n");
@@ -38,7 +43,15 @@ static int LIBUSB_CALL hotplug_callback(libusb_context *ctx, libusb_device *dev,
 
 	printf ("Device attached: %04x:%04x\n", desc.idVendor, desc.idProduct);
 
-	libusb_open (dev, &handle);
+	if (handle) {
+		libusb_close (handle);
+		handle = NULL;
+	}
+
+	rc = libusb_open (dev, &handle);
+	if (LIBUSB_SUCCESS != rc) {
+		fprintf (stderr, "Error opening device\n");
+	}
 
 	done++;
 
@@ -47,11 +60,20 @@ static int LIBUSB_CALL hotplug_callback(libusb_context *ctx, libusb_device *dev,
 
 static int LIBUSB_CALL hotplug_callback_detach(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data)
 {
+	(void)ctx;
+	(void)dev;
+	(void)event;
+	(void)user_data;
+
 	printf ("Device detached\n");
 
-	libusb_close (handle);
+	if (handle) {
+		libusb_close (handle);
+		handle = NULL;
+	}
 
 	done++;
+
 	return 0;
 }
 
@@ -61,9 +83,9 @@ int main(int argc, char *argv[])
 	int product_id, vendor_id, class_id;
 	int rc;
 
-	vendor_id  = (argc > 1) ? strtol (argv[1], NULL, 0) : 0x045a;
-	product_id = (argc > 2) ? strtol (argv[2], NULL, 0) : 0x5005;
-	class_id   = (argc > 3) ? strtol (argv[3], NULL, 0) : LIBUSB_HOTPLUG_MATCH_ANY;
+	vendor_id  = (argc > 1) ? (int)strtol (argv[1], NULL, 0) : 0x045a;
+	product_id = (argc > 2) ? (int)strtol (argv[2], NULL, 0) : 0x5005;
+	class_id   = (argc > 3) ? (int)strtol (argv[3], NULL, 0) : LIBUSB_HOTPLUG_MATCH_ANY;
 
 	rc = libusb_init (NULL);
 	if (rc < 0)
@@ -100,5 +122,11 @@ int main(int argc, char *argv[])
 			printf("libusb_handle_events() failed: %s\n", libusb_error_name(rc));
 	}
 
+	if (handle) {
+		libusb_close (handle);
+	}
+
 	libusb_exit (NULL);
+
+	return EXIT_SUCCESS;
 }

package/libusb/examples/listdevs.c

@@ -60,8 +60,10 @@ int main(void)
 		return r;
 
 	cnt = libusb_get_device_list(NULL, &devs);
-	if (cnt < 0)
+	if (cnt < 0){
+		libusb_exit(NULL);
 		return (int) cnt;
+	}
 
 	print_devs(devs);
 	libusb_free_device_list(devs, 1);

package/libusb/examples/sam3u_benchmark.c

@@ -42,7 +42,7 @@ static struct timeval tv_start;
 
 static void LIBUSB_CALL cb_xfr(struct libusb_transfer *xfr)
 {
-	unsigned int i;
+	int i;
 
 	if (xfr->status != LIBUSB_TRANSFER_COMPLETED) {
 		fprintf(stderr, "transfer status %d\n", xfr->status);
@@ -55,11 +55,11 @@ static void LIBUSB_CALL cb_xfr(struct libusb_transfer *xfr)
 			struct libusb_iso_packet_descriptor *pack = &xfr->iso_packet_desc[i];
 
 			if (pack->status != LIBUSB_TRANSFER_COMPLETED) {
-				fprintf(stderr, "Error: pack %u status %d\n", i, pack->status);
+				fprintf(stderr, "Error: pack %d status %d\n", i, pack->status);
 				exit(5);
 			}
 
-			printf("pack%u length:%u, actual_length:%u\n", i, pack->length, pack->actual_length);
+			printf("pack%d length:%u, actual_length:%u\n", i, pack->length, pack->actual_length);
 		}
 	}
 

package/libusb/examples/testlibusb.c

@@ -0,0 +1,277 @@
+/*
+* Test suite program based of libusb-0.1-compat testlibusb
+* Copyright (c) 2013 Nathan Hjelm <hjelmn@mac.ccom>
+*
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation; either
+* version 2.1 of the License, or (at your option) any later version.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include "libusb.h"
+
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+#define snprintf _snprintf
+#endif
+
+int verbose = 0;
+
+static void print_endpoint_comp(const struct libusb_ss_endpoint_companion_descriptor *ep_comp)
+{
+	printf("      USB 3.0 Endpoint Companion:\n");
+	printf("        bMaxBurst:        %d\n", ep_comp->bMaxBurst);
+	printf("        bmAttributes:     0x%02x\n", ep_comp->bmAttributes);
+	printf("        wBytesPerInterval: %d\n", ep_comp->wBytesPerInterval);
+}
+
+static void print_endpoint(const struct libusb_endpoint_descriptor *endpoint)
+{
+	int i, ret;
+
+	printf("      Endpoint:\n");
+	printf("        bEndpointAddress: %02xh\n", endpoint->bEndpointAddress);
+	printf("        bmAttributes:     %02xh\n", endpoint->bmAttributes);
+	printf("        wMaxPacketSize:   %d\n", endpoint->wMaxPacketSize);
+	printf("        bInterval:        %d\n", endpoint->bInterval);
+	printf("        bRefresh:         %d\n", endpoint->bRefresh);
+	printf("        bSynchAddress:    %d\n", endpoint->bSynchAddress);
+
+	for (i = 0; i < endpoint->extra_length;) {
+		if (LIBUSB_DT_SS_ENDPOINT_COMPANION == endpoint->extra[i + 1]) {
+			struct libusb_ss_endpoint_companion_descriptor *ep_comp;
+
+			ret = libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp);
+			if (LIBUSB_SUCCESS != ret) {
+				continue;
+			}
+
+			print_endpoint_comp(ep_comp);
+
+			libusb_free_ss_endpoint_companion_descriptor(ep_comp);
+		}
+
+		i += endpoint->extra[i];
+	}
+}
+
+static void print_altsetting(const struct libusb_interface_descriptor *interface)
+{
+	uint8_t i;
+
+	printf("    Interface:\n");
+	printf("      bInterfaceNumber:   %d\n", interface->bInterfaceNumber);
+	printf("      bAlternateSetting:  %d\n", interface->bAlternateSetting);
+	printf("      bNumEndpoints:      %d\n", interface->bNumEndpoints);
+	printf("      bInterfaceClass:    %d\n", interface->bInterfaceClass);
+	printf("      bInterfaceSubClass: %d\n", interface->bInterfaceSubClass);
+	printf("      bInterfaceProtocol: %d\n", interface->bInterfaceProtocol);
+	printf("      iInterface:         %d\n", interface->iInterface);
+
+	for (i = 0; i < interface->bNumEndpoints; i++)
+		print_endpoint(&interface->endpoint[i]);
+}
+
+static void print_2_0_ext_cap(struct libusb_usb_2_0_extension_descriptor *usb_2_0_ext_cap)
+{
+	printf("    USB 2.0 Extension Capabilities:\n");
+	printf("      bDevCapabilityType: %d\n", usb_2_0_ext_cap->bDevCapabilityType);
+	printf("      bmAttributes:       0x%x\n", usb_2_0_ext_cap->bmAttributes);
+}
+
+static void print_ss_usb_cap(struct libusb_ss_usb_device_capability_descriptor *ss_usb_cap)
+{
+	printf("    USB 3.0 Capabilities:\n");
+	printf("      bDevCapabilityType: %d\n", ss_usb_cap->bDevCapabilityType);
+	printf("      bmAttributes:       0x%x\n", ss_usb_cap->bmAttributes);
+	printf("      wSpeedSupported:    0x%x\n", ss_usb_cap->wSpeedSupported);
+	printf("      bFunctionalitySupport: %d\n", ss_usb_cap->bFunctionalitySupport);
+	printf("      bU1devExitLat:      %d\n", ss_usb_cap->bU1DevExitLat);
+	printf("      bU2devExitLat:      %d\n", ss_usb_cap->bU2DevExitLat);
+}
+
+static void print_bos(libusb_device_handle *handle)
+{
+	struct libusb_bos_descriptor *bos;
+	int ret;
+
+	ret = libusb_get_bos_descriptor(handle, &bos);
+	if (0 > ret) {
+		return;
+	}
+
+	printf("  Binary Object Store (BOS):\n");
+	printf("    wTotalLength:       %d\n", bos->wTotalLength);
+	printf("    bNumDeviceCaps:     %d\n", bos->bNumDeviceCaps);
+
+	if(bos->dev_capability[0]->bDevCapabilityType == LIBUSB_BT_USB_2_0_EXTENSION) {
+
+		struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension;
+	        ret =  libusb_get_usb_2_0_extension_descriptor(NULL, bos->dev_capability[0],&usb_2_0_extension);
+	        if (0 > ret) {
+		        return;
+	        }
+
+                print_2_0_ext_cap(usb_2_0_extension);
+                libusb_free_usb_2_0_extension_descriptor(usb_2_0_extension);
+        }
+
+	if(bos->dev_capability[0]->bDevCapabilityType == LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) {
+
+	        struct libusb_ss_usb_device_capability_descriptor *dev_cap;
+		ret = libusb_get_ss_usb_device_capability_descriptor(NULL, bos->dev_capability[0],&dev_cap);
+	        if (0 > ret) {
+		        return;
+	        }
+
+	        print_ss_usb_cap(dev_cap);
+	        libusb_free_ss_usb_device_capability_descriptor(dev_cap);
+        }
+
+	libusb_free_bos_descriptor(bos);
+}
+
+static void print_interface(const struct libusb_interface *interface)
+{
+	int i;
+
+	for (i = 0; i < interface->num_altsetting; i++)
+		print_altsetting(&interface->altsetting[i]);
+}
+
+static void print_configuration(struct libusb_config_descriptor *config)
+{
+	uint8_t i;
+
+	printf("  Configuration:\n");
+	printf("    wTotalLength:         %d\n", config->wTotalLength);
+	printf("    bNumInterfaces:       %d\n", config->bNumInterfaces);
+	printf("    bConfigurationValue:  %d\n", config->bConfigurationValue);
+	printf("    iConfiguration:       %d\n", config->iConfiguration);
+	printf("    bmAttributes:         %02xh\n", config->bmAttributes);
+	printf("    MaxPower:             %d\n", config->MaxPower);
+
+	for (i = 0; i < config->bNumInterfaces; i++)
+		print_interface(&config->interface[i]);
+}
+
+static int print_device(libusb_device *dev, int level)
+{
+	struct libusb_device_descriptor desc;
+	libusb_device_handle *handle = NULL;
+	char description[260];
+	char string[256];
+	int ret;
+	uint8_t i;
+
+	ret = libusb_get_device_descriptor(dev, &desc);
+	if (ret < 0) {
+		fprintf(stderr, "failed to get device descriptor");
+		return -1;
+	}
+
+	ret = libusb_open(dev, &handle);
+	if (LIBUSB_SUCCESS == ret) {
+		if (desc.iManufacturer) {
+			ret = libusb_get_string_descriptor_ascii(handle, desc.iManufacturer, string, sizeof(string));
+			if (ret > 0)
+				snprintf(description, sizeof(description), "%s - ", string);
+			else
+				snprintf(description, sizeof(description), "%04X - ",
+				desc.idVendor);
+		}
+		else
+			snprintf(description, sizeof(description), "%04X - ",
+			desc.idVendor);
+
+		if (desc.iProduct) {
+			ret = libusb_get_string_descriptor_ascii(handle, desc.iProduct, string, sizeof(string));
+			if (ret > 0)
+				snprintf(description + strlen(description), sizeof(description) -
+				strlen(description), "%s", string);
+			else
+				snprintf(description + strlen(description), sizeof(description) -
+				strlen(description), "%04X", desc.idProduct);
+		}
+		else
+			snprintf(description + strlen(description), sizeof(description) -
+			strlen(description), "%04X", desc.idProduct);
+	}
+	else {
+		snprintf(description, sizeof(description), "%04X - %04X",
+			desc.idVendor, desc.idProduct);
+	}
+
+	printf("%.*sDev (bus %d, device %d): %s\n", level * 2, "                    ",
+		libusb_get_bus_number(dev), libusb_get_device_address(dev), description);
+
+	if (handle && verbose) {
+		if (desc.iSerialNumber) {
+			ret = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, string, sizeof(string));
+			if (ret > 0)
+				printf("%.*s  - Serial Number: %s\n", level * 2,
+				"                    ", string);
+		}
+	}
+
+	if (verbose) {
+		for (i = 0; i < desc.bNumConfigurations; i++) {
+			struct libusb_config_descriptor *config;
+			ret = libusb_get_config_descriptor(dev, i, &config);
+			if (LIBUSB_SUCCESS != ret) {
+				printf("  Couldn't retrieve descriptors\n");
+				continue;
+			}
+
+			print_configuration(config);
+
+			libusb_free_config_descriptor(config);
+		}
+
+		if (handle && desc.bcdUSB >= 0x0201) {
+			print_bos(handle);
+		}
+	}
+
+	if (handle)
+		libusb_close(handle);
+
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	libusb_device **devs;
+	ssize_t cnt;
+	int r, i;
+
+	if (argc > 1 && !strcmp(argv[1], "-v"))
+		verbose = 1;
+
+	r = libusb_init(NULL);
+	if (r < 0)
+		return r;
+
+	cnt = libusb_get_device_list(NULL, &devs);
+	if (cnt < 0)
+		return (int)cnt;
+
+	for (i = 0; devs[i]; ++i) {
+		print_device(devs[i], 0);
+	}
+
+	libusb_free_device_list(devs, 1);
+
+	libusb_exit(NULL);
+	return 0;
+}