init

the readme is a ramble and there's no functionality (yet). couldn't ask
for a better start.

deps/libusb/libusb/hotplug.c

@@ -0,0 +1,470 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * Hotplug functions for libusb
+ * Copyright © 2012-2021 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright © 2012-2013 Peter Stuge <peter@stuge.se>
+ *
+ * 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 "libusbi.h"
+
+/**
+ * @defgroup libusb_hotplug Device hotplug event notification
+ * This page details how to use the libusb hotplug interface, where available.
+ *
+ * Be mindful that not all platforms currently implement hotplug notification and
+ * that you should first call on \ref libusb_has_capability() with parameter
+ * \ref LIBUSB_CAP_HAS_HOTPLUG to confirm that hotplug support is available.
+ *
+ * \page libusb_hotplug Device hotplug event notification
+ *
+ * \section hotplug_intro Introduction
+ *
+ * Version 1.0.16, \ref LIBUSBX_API_VERSION >= 0x01000102, has added support
+ * for hotplug events on <b>some</b> platforms (you should test if your platform
+ * supports hotplug notification by calling \ref libusb_has_capability() with
+ * parameter \ref LIBUSB_CAP_HAS_HOTPLUG).
+ *
+ * This interface allows you to request notification for the arrival and departure
+ * of matching USB devices.
+ *
+ * To receive hotplug notification you register a callback by calling
+ * \ref libusb_hotplug_register_callback(). This function will optionally return
+ * a callback handle that can be passed to \ref libusb_hotplug_deregister_callback().
+ *
+ * A callback function must return an int (0 or 1) indicating whether the callback is
+ * expecting additional events. Returning 0 will rearm the callback and 1 will cause
+ * the callback to be deregistered. Note that when callbacks are called from
+ * libusb_hotplug_register_callback() because of the \ref LIBUSB_HOTPLUG_ENUMERATE
+ * flag, the callback return value is ignored. In other words, you cannot cause a
+ * callback to be deregistered by returning 1 when it is called from
+ * libusb_hotplug_register_callback().
+ *
+ * Callbacks for a particular context are automatically deregistered by libusb_exit().
+ *
+ * As of 1.0.16 there are two supported hotplug events:
+ *  - LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED: A device has arrived and is ready to use
+ *  - LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT: A device has left and is no longer available
+ *
+ * A hotplug event can listen for either or both of these events.
+ *
+ * Note: If you receive notification that a device has left and you have any
+ * libusb_device_handles for the device it is up to you to call libusb_close()
+ * on each device handle to free up any remaining resources associated with the device.
+ * Once a device has left any libusb_device_handle associated with the device
+ * are invalid and will remain so even if the device comes back.
+ *
+ * When handling a LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED event it is considered
+ * safe to call any libusb function that takes a libusb_device. It also safe to
+ * open a device and submit asynchronous transfers. However, most other functions
+ * that take a libusb_device_handle are <b>not</b> safe to call. Examples of such
+ * functions are any of the \ref libusb_syncio "synchronous API" functions or the blocking
+ * functions that retrieve various \ref libusb_desc "USB descriptors". These functions must
+ * be used outside of the context of the hotplug callback.
+ *
+ * When handling a LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT event the only safe function
+ * is libusb_get_device_descriptor().
+ *
+ * The following code provides an example of the usage of the hotplug interface:
+\code
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <libusb.h>
+
+static int count = 0;
+
+int hotplug_callback(struct libusb_context *ctx, struct libusb_device *dev,
+                     libusb_hotplug_event event, void *user_data) {
+  static libusb_device_handle *dev_handle = NULL;
+  struct libusb_device_descriptor desc;
+  int rc;
+
+  (void)libusb_get_device_descriptor(dev, &desc);
+
+  if (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED == event) {
+    rc = libusb_open(dev, &dev_handle);
+    if (LIBUSB_SUCCESS != rc) {
+      printf("Could not open USB device\n");
+    }
+  } else if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == event) {
+    if (dev_handle) {
+      libusb_close(dev_handle);
+      dev_handle = NULL;
+    }
+  } else {
+    printf("Unhandled event %d\n", event);
+  }
+  count++;
+
+  return 0;
+}
+
+int main (void) {
+  libusb_hotplug_callback_handle callback_handle;
+  int rc;
+
+  libusb_init_context(NULL, NULL, 0);
+
+  rc = libusb_hotplug_register_callback(NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED |
+                                        LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, 0, 0x045a, 0x5005,
+                                        LIBUSB_HOTPLUG_MATCH_ANY, hotplug_callback, NULL,
+                                        &callback_handle);
+  if (LIBUSB_SUCCESS != rc) {
+    printf("Error creating a hotplug callback\n");
+    libusb_exit(NULL);
+    return EXIT_FAILURE;
+  }
+
+  while (count < 2) {
+    libusb_handle_events_completed(NULL, NULL);
+    nanosleep(&(struct timespec){0, 10000000UL}, NULL);
+  }
+
+  libusb_hotplug_deregister_callback(NULL, callback_handle);
+  libusb_exit(NULL);
+
+  return 0;
+}
+\endcode
+ */
+
+#define VALID_HOTPLUG_EVENTS			\
+	(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED |	\
+	 LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT)
+
+#define VALID_HOTPLUG_FLAGS			\
+	(LIBUSB_HOTPLUG_ENUMERATE)
+
+void usbi_hotplug_init(struct libusb_context *ctx)
+{
+	/* check for hotplug support */
+	if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+		return;
+
+	usbi_mutex_init(&ctx->hotplug_cbs_lock);
+	list_init(&ctx->hotplug_cbs);
+	ctx->next_hotplug_cb_handle = 1;
+	usbi_atomic_store(&ctx->hotplug_ready, 1);
+}
+
+void usbi_hotplug_exit(struct libusb_context *ctx)
+{
+	struct usbi_hotplug_callback *hotplug_cb, *next_cb;
+	struct usbi_hotplug_message *msg;
+	struct libusb_device *dev, *next_dev;
+
+	/* check for hotplug support */
+	if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+		return;
+
+	if (!usbi_atomic_load(&ctx->hotplug_ready))
+		return;
+
+	/* free all registered hotplug callbacks */
+	for_each_hotplug_cb_safe(ctx, hotplug_cb, next_cb) {
+		list_del(&hotplug_cb->list);
+		free(hotplug_cb);
+	}
+
+	/* free all pending hotplug messages */
+	while (!list_empty(&ctx->hotplug_msgs)) {
+		msg = list_first_entry(&ctx->hotplug_msgs, struct usbi_hotplug_message, list);
+
+		/* if the device left, the message holds a reference
+		 * and we must drop it */
+		if (msg->event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT)
+			libusb_unref_device(msg->device);
+
+		list_del(&msg->list);
+		free(msg);
+	}
+
+	/* free all discovered devices. due to parent references loop until no devices are freed. */
+	for_each_device_safe(ctx, dev, next_dev) {
+		/* remove the device from the usb_devs list only if there are no
+		 * references held, otherwise leave it on the list so that a
+		 * warning message will be shown */
+		if (usbi_atomic_load(&dev->refcnt) == 1) {
+			list_del(&dev->list);
+		}
+		if (dev->parent_dev && usbi_atomic_load(&dev->parent_dev->refcnt) == 1) {
+			/* the parent was before this device in the list and will be released.
+			   remove it from the list. this is safe as parent_dev can not be
+			   equal to next_dev. */
+			assert (dev->parent_dev != next_dev);
+			list_del(&dev->parent_dev->list);
+		}
+		libusb_unref_device(dev);
+	}
+
+	usbi_mutex_destroy(&ctx->hotplug_cbs_lock);
+}
+
+static int usbi_hotplug_match_cb(struct libusb_device *dev,
+	libusb_hotplug_event event, struct usbi_hotplug_callback *hotplug_cb)
+{
+	if (!(hotplug_cb->flags & event)) {
+		return 0;
+	}
+
+	if ((hotplug_cb->flags & USBI_HOTPLUG_VENDOR_ID_VALID) &&
+	    hotplug_cb->vendor_id != dev->device_descriptor.idVendor) {
+		return 0;
+	}
+
+	if ((hotplug_cb->flags & USBI_HOTPLUG_PRODUCT_ID_VALID) &&
+	    hotplug_cb->product_id != dev->device_descriptor.idProduct) {
+		return 0;
+	}
+
+	if ((hotplug_cb->flags & USBI_HOTPLUG_DEV_CLASS_VALID) &&
+	    hotplug_cb->dev_class != dev->device_descriptor.bDeviceClass) {
+		return 0;
+	}
+
+	return hotplug_cb->cb(DEVICE_CTX(dev), dev, event, hotplug_cb->user_data);
+}
+
+void usbi_hotplug_notification(struct libusb_context *ctx, struct libusb_device *dev,
+	libusb_hotplug_event event)
+{
+	struct usbi_hotplug_message *msg;
+	unsigned int event_flags;
+
+	/* Only generate a notification if hotplug is ready. This prevents hotplug
+	 * notifications from being generated during initial enumeration or if the
+	 * backend does not support hotplug. */
+	if (!usbi_atomic_load(&ctx->hotplug_ready))
+		return;
+
+	msg = calloc(1, sizeof(*msg));
+	if (!msg) {
+		usbi_err(ctx, "error allocating hotplug message");
+		return;
+	}
+
+	msg->event = event;
+	msg->device = dev;
+
+	/* Take the event data lock and add this message to the list.
+	 * Only signal an event if there are no prior pending events. */
+	usbi_mutex_lock(&ctx->event_data_lock);
+	event_flags = ctx->event_flags;
+	ctx->event_flags |= USBI_EVENT_HOTPLUG_MSG_PENDING;
+	list_add_tail(&msg->list, &ctx->hotplug_msgs);
+	if (!event_flags)
+		usbi_signal_event(&ctx->event);
+	usbi_mutex_unlock(&ctx->event_data_lock);
+}
+
+void usbi_hotplug_process(struct libusb_context *ctx, struct list_head *hotplug_msgs)
+{
+	struct usbi_hotplug_callback *hotplug_cb, *next_cb;
+	struct usbi_hotplug_message *msg;
+	int r;
+
+	usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+
+	/* dispatch all pending hotplug messages */
+	while (!list_empty(hotplug_msgs)) {
+		msg = list_first_entry(hotplug_msgs, struct usbi_hotplug_message, list);
+
+		for_each_hotplug_cb_safe(ctx, hotplug_cb, next_cb) {
+			/* skip callbacks that have unregistered */
+			if (hotplug_cb->flags & USBI_HOTPLUG_NEEDS_FREE)
+				continue;
+
+			usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+			r = usbi_hotplug_match_cb(msg->device, msg->event, hotplug_cb);
+			usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+
+			if (r) {
+				list_del(&hotplug_cb->list);
+				free(hotplug_cb);
+			}
+		}
+
+		/* if the device left, the message holds a reference
+		 * and we must drop it */
+		if (msg->event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT)
+			libusb_unref_device(msg->device);
+
+		list_del(&msg->list);
+		free(msg);
+	}
+
+	/* free any callbacks that have unregistered */
+	for_each_hotplug_cb_safe(ctx, hotplug_cb, next_cb) {
+		if (hotplug_cb->flags & USBI_HOTPLUG_NEEDS_FREE) {
+			usbi_dbg(ctx, "freeing hotplug cb %p with handle %d",
+				 (void *) hotplug_cb, hotplug_cb->handle);
+			list_del(&hotplug_cb->list);
+			free(hotplug_cb);
+		}
+	}
+
+	usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+}
+
+int API_EXPORTED libusb_hotplug_register_callback(libusb_context *ctx,
+	int events, int flags,
+	int vendor_id, int product_id, int dev_class,
+	libusb_hotplug_callback_fn cb_fn, void *user_data,
+	libusb_hotplug_callback_handle *callback_handle)
+{
+	struct usbi_hotplug_callback *hotplug_cb;
+
+	/* check for sane values */
+	if (!events || (~VALID_HOTPLUG_EVENTS & events) ||
+	    (~VALID_HOTPLUG_FLAGS & flags) ||
+	    (LIBUSB_HOTPLUG_MATCH_ANY != vendor_id && (~0xffff & vendor_id)) ||
+	    (LIBUSB_HOTPLUG_MATCH_ANY != product_id && (~0xffff & product_id)) ||
+	    (LIBUSB_HOTPLUG_MATCH_ANY != dev_class && (~0xff & dev_class)) ||
+	    !cb_fn) {
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+
+	/* check for hotplug support */
+	if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+
+	ctx = usbi_get_context(ctx);
+
+	hotplug_cb = calloc(1, sizeof(*hotplug_cb));
+	if (!hotplug_cb)
+		return LIBUSB_ERROR_NO_MEM;
+
+	hotplug_cb->flags = (uint8_t)events;
+	if (LIBUSB_HOTPLUG_MATCH_ANY != vendor_id) {
+		hotplug_cb->flags |= USBI_HOTPLUG_VENDOR_ID_VALID;
+		hotplug_cb->vendor_id = (uint16_t)vendor_id;
+	}
+	if (LIBUSB_HOTPLUG_MATCH_ANY != product_id) {
+		hotplug_cb->flags |= USBI_HOTPLUG_PRODUCT_ID_VALID;
+		hotplug_cb->product_id = (uint16_t)product_id;
+	}
+	if (LIBUSB_HOTPLUG_MATCH_ANY != dev_class) {
+		hotplug_cb->flags |= USBI_HOTPLUG_DEV_CLASS_VALID;
+		hotplug_cb->dev_class = (uint8_t)dev_class;
+	}
+	hotplug_cb->cb = cb_fn;
+	hotplug_cb->user_data = user_data;
+
+	usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+
+	/* protect the handle by the context hotplug lock */
+	hotplug_cb->handle = ctx->next_hotplug_cb_handle++;
+
+	/* handle the unlikely case of overflow */
+	if (ctx->next_hotplug_cb_handle < 0)
+		ctx->next_hotplug_cb_handle = 1;
+
+	list_add(&hotplug_cb->list, &ctx->hotplug_cbs);
+
+	usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+
+	usbi_dbg(ctx, "new hotplug cb %p with handle %d",
+		 (void *) hotplug_cb, hotplug_cb->handle);
+
+	if ((flags & LIBUSB_HOTPLUG_ENUMERATE) && (events & LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED)) {
+		ssize_t i, len;
+		struct libusb_device **devs;
+
+		len = libusb_get_device_list(ctx, &devs);
+		if (len < 0) {
+			libusb_hotplug_deregister_callback(ctx, hotplug_cb->handle);
+			return (int)len;
+		}
+
+		for (i = 0; i < len; i++) {
+			usbi_hotplug_match_cb(devs[i],
+					LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED,
+					hotplug_cb);
+		}
+
+		libusb_free_device_list(devs, 1);
+	}
+
+	if (callback_handle)
+		*callback_handle = hotplug_cb->handle;
+
+	return LIBUSB_SUCCESS;
+}
+
+void API_EXPORTED libusb_hotplug_deregister_callback(libusb_context *ctx,
+	libusb_hotplug_callback_handle callback_handle)
+{
+	struct usbi_hotplug_callback *hotplug_cb;
+	int deregistered = 0;
+
+	/* check for hotplug support */
+	if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+		return;
+
+	usbi_dbg(ctx, "deregister hotplug cb %d", callback_handle);
+
+	ctx = usbi_get_context(ctx);
+
+	usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+	for_each_hotplug_cb(ctx, hotplug_cb) {
+		if (callback_handle == hotplug_cb->handle) {
+			/* mark this callback for deregistration */
+			hotplug_cb->flags |= USBI_HOTPLUG_NEEDS_FREE;
+			deregistered = 1;
+			break;
+		}
+	}
+	usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+
+	if (deregistered) {
+		unsigned int event_flags;
+
+		usbi_mutex_lock(&ctx->event_data_lock);
+		event_flags = ctx->event_flags;
+		ctx->event_flags |= USBI_EVENT_HOTPLUG_CB_DEREGISTERED;
+		if (!event_flags)
+			usbi_signal_event(&ctx->event);
+		usbi_mutex_unlock(&ctx->event_data_lock);
+	}
+}
+
+DEFAULT_VISIBILITY
+void * LIBUSB_CALL libusb_hotplug_get_user_data(libusb_context *ctx,
+	libusb_hotplug_callback_handle callback_handle)
+{
+	struct usbi_hotplug_callback *hotplug_cb;
+	void *user_data = NULL;
+
+	/* check for hotplug support */
+	if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+		return NULL;
+
+	usbi_dbg(ctx, "get hotplug cb %d user data", callback_handle);
+
+	ctx = usbi_get_context(ctx);
+
+	usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+	for_each_hotplug_cb(ctx, hotplug_cb) {
+		if (callback_handle == hotplug_cb->handle) {
+			user_data = hotplug_cb->user_data;
+			break;
+		}
+	}
+	usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+
+	return user_data;
+}

deps/libusb/libusb/os/darwin_usb.h

@@ -0,0 +1,156 @@
+/*
+ * darwin backend for libusb 1.0
+ * Copyright © 2008-2023 Nathan Hjelm <hjelmn@users.sourceforge.net>
+ * Copyright © 2019-2023 Google LLC. All rights reserved.
+ *
+ * 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
+ */
+
+#if !defined(LIBUSB_DARWIN_H)
+#define LIBUSB_DARWIN_H
+
+#include <stdbool.h>
+
+#include "libusbi.h"
+
+#include <IOKit/IOTypes.h>
+#include <IOKit/IOCFBundle.h>
+#include <IOKit/usb/IOUSBLib.h>
+#include <IOKit/IOCFPlugIn.h>
+
+#if defined(HAVE_IOKIT_USB_IOUSBHOSTFAMILYDEFINITIONS_H)
+#include <IOKit/usb/IOUSBHostFamilyDefinitions.h>
+#endif
+
+/* IOUSBInterfaceInferface */
+
+#if defined(kIOUSBInterfaceInterfaceID800)
+#define MAX_INTERFACE_VERSION 800
+#elif defined(kIOUSBInterfaceInterfaceID700)
+#define	MAX_INTERFACE_VERSION 700
+#elif defined(kIOUSBInterfaceInterfaceID650)
+#define MAX_INTERFACE_VERSION 650
+#elif defined(kIOUSBInterfaceInterfaceID550)
+#define MAX_INTERFACE_VERSION 550
+#elif defined(kIOUSBInterfaceInterfaceID245)
+#define MAX_INTERFACE_VERSION 245
+#else
+#define	MAX_INTERFACE_VERSION 220
+#endif
+
+/* set to the minimum version and casted up as needed. */
+typedef IOUSBInterfaceInterface220 **usb_interface_t;
+
+#define IOINTERFACE0(darwin_interface, version) ((IOUSBInterfaceInterface ## version **) (darwin_interface)->interface)
+#define IOINTERFACE_V(darwin_interface, version) IOINTERFACE0(darwin_interface, version)
+#define IOINTERFACE(darwin_interface) ((darwin_interface)->interface)
+
+/* IOUSBDeviceInterface */
+
+#if defined(kIOUSBDeviceInterfaceID650)
+#define MAX_DEVICE_VERSION 650
+#elif defined(kIOUSBDeviceInterfaceID500)
+#define	MAX_DEVICE_VERSION 500
+#elif defined(kIOUSBDeviceInterfaceID320)
+#define MAX_DEVICE_VERSION 320
+#elif defined(kIOUSBDeviceInterfaceID300)
+#define MAX_DEVICE_VERSION 300
+#elif defined(kIOUSBDeviceInterfaceID245)
+#define MAX_DEVICE_VERSION 245
+#else
+#define	MAX_DEVICE_VERSION 197
+#endif
+
+/* set to the minimum version and casted up as needed */
+typedef IOUSBDeviceInterface197 **usb_device_t;
+
+#define IODEVICE0(darwin_device, version) ((IOUSBDeviceInterface ## version **)(darwin_device))
+#define IODEVICE_V(darwin_device, version) IODEVICE0(darwin_device, version)
+
+#if !defined(kIOUSBHostInterfaceClassName)
+#define kIOUSBHostInterfaceClassName "IOUSBHostInterface"
+#endif
+
+#if !defined(kUSBHostMatchingPropertyInterfaceNumber)
+#define kUSBHostMatchingPropertyInterfaceNumber "bInterfaceNumber"
+#endif
+
+#if !defined(IO_OBJECT_NULL)
+#define IO_OBJECT_NULL ((io_object_t) 0)
+#endif
+
+/* returns the current macOS version in a format similar to the
+ * MAC_OS_X_VERSION_MIN_REQUIRED macro.
+ * Examples:
+ *   10.1.5 -> 100105
+ *   13.3.0 -> 130300
+ */
+uint32_t get_running_version(void);
+
+typedef IOCFPlugInInterface *io_cf_plugin_ref_t;
+typedef IONotificationPortRef io_notification_port_t;
+
+/* private structures */
+struct darwin_cached_device {
+  struct list_head      list;
+  IOUSBDeviceDescriptor dev_descriptor;
+  UInt32                location;
+  UInt64                parent_session;
+  UInt64                session;
+  USBDeviceAddress      address;
+  char                  sys_path[21];
+  usb_device_t          device;
+  io_service_t          service;
+  int                   open_count;
+  UInt8                 first_config, active_config, port;
+  int                   can_enumerate;
+  int                   refcount;
+  bool                  in_reenumerate;
+  int                   capture_count;
+};
+
+struct darwin_device_priv {
+  struct darwin_cached_device *dev;
+};
+
+struct darwin_device_handle_priv {
+  bool                 is_open;
+  CFRunLoopSourceRef   cfSource;
+
+  struct darwin_interface {
+    usb_interface_t      interface;
+    uint8_t              num_endpoints;
+    CFRunLoopSourceRef   cfSource;
+    uint64_t             frames[256];
+    uint8_t              endpoint_addrs[USB_MAXENDPOINTS];
+  } interfaces[USB_MAXINTERFACES];
+};
+
+struct darwin_transfer_priv {
+  /* Isoc */
+  IOUSBIsocFrame *isoc_framelist;
+  int num_iso_packets;
+
+  /* Control */
+  IOUSBDevRequestTO req;
+
+  /* Bulk */
+
+  /* Completion status */
+  IOReturn result;
+  UInt32 size;
+};
+
+#endif

deps/libusb/libusb/os/emscripten_webusb.cpp

@@ -0,0 +1,870 @@
+/*
+ * Copyright © 2021 Google LLC
+ * Copyright © 2023 Ingvar Stepanyan <me@rreverser.com>
+ *
+ * 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
+ *
+ * Authors:
+ *		Ingvar Stepanyan <me@rreverser.com>
+ */
+
+#include <emscripten/version.h>
+
+static_assert((__EMSCRIPTEN_major__ * 100 * 100 + __EMSCRIPTEN_minor__ * 100 +
+			   __EMSCRIPTEN_tiny__) >= 30148,
+			  "Emscripten 3.1.48 or newer is required.");
+
+#include <assert.h>
+#include <emscripten.h>
+#include <emscripten/val.h>
+
+#include <type_traits>
+#include <utility>
+
+#include "libusbi.h"
+
+using namespace emscripten;
+
+#ifdef _REENTRANT
+#include <emscripten/proxying.h>
+#include <emscripten/threading.h>
+#include <pthread.h>
+
+static ProxyingQueue queue;
+#endif
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmissing-prototypes"
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wshadow"
+
+namespace {
+
+// clang-format off
+EM_JS(EM_VAL, usbi_em_promise_catch, (EM_VAL handle), {
+	let promise = Emval.toValue(handle);
+	promise = promise.then(
+		value => ({error : 0, value}),
+		error => {
+			console.error(error);
+			let errorCode = -99; // LIBUSB_ERROR_OTHER
+			if (error instanceof DOMException) {
+				const ERROR_CODES = {
+					// LIBUSB_ERROR_IO
+					NetworkError : -1,
+					// LIBUSB_ERROR_INVALID_PARAM
+					DataError : -2,
+					TypeMismatchError : -2,
+					IndexSizeError : -2,
+					// LIBUSB_ERROR_ACCESS
+					SecurityError : -3,
+					// LIBUSB_ERROR_NOT_FOUND
+					NotFoundError : -5,
+					// LIBUSB_ERROR_BUSY
+					InvalidStateError : -6,
+					// LIBUSB_ERROR_TIMEOUT
+					TimeoutError : -7,
+					// LIBUSB_ERROR_INTERRUPTED
+					AbortError : -10,
+					// LIBUSB_ERROR_NOT_SUPPORTED
+					NotSupportedError : -12,
+				};
+				errorCode = ERROR_CODES[error.name] ?? errorCode;
+			} else if (error instanceof RangeError || error instanceof TypeError) {
+				errorCode = -2; // LIBUSB_ERROR_INVALID_PARAM
+			}
+			return {error: errorCode, value: undefined};
+		}
+	);
+	return Emval.toHandle(promise);
+});
+
+EM_JS(void, usbi_em_copy_from_dataview, (void* dst, EM_VAL src), {
+	src = Emval.toValue(src);
+	src = new Uint8Array(src.buffer, src.byteOffset, src.byteLength);
+	HEAPU8.set(src, dst);
+});
+
+// Our implementation proxies operations from multiple threads to the same
+// underlying USBDevice on the main thread. This can lead to issues when
+// multiple threads try to open/close the same device at the same time.
+//
+// First, since open/close operations are asynchronous in WebUSB, we can end up
+// with multiple open/close operations in flight at the same time, which can
+// lead to unpredictable outcome (e.g. device got closed but opening succeeded
+// right before that).
+//
+// Second, since multiple threads are allowed to have their own handles to the
+// same device, we need to keep track of number of open handles and close the
+// device only when the last handle is closed.
+//
+// We fix both of these issues by using a shared promise chain that executes
+// open and close operations sequentially and keeps track of the reference count
+// in each promise's result. This way, we can ensure that only one open/close
+// operation is in flight at any given time. Note that we don't need to worry
+// about all other operations because they're preconditioned on the device being
+// open and having at least 1 reference anyway.
+EM_JS(EM_VAL, usbi_em_device_safe_open_close, (EM_VAL device, bool open), {
+	device = Emval.toValue(device);
+	const symbol = Symbol.for('libusb.open_close_chain');
+	let promiseChain = device[symbol] ?? Promise.resolve(0);
+	device[symbol] = promiseChain = promiseChain.then(async refCount => {
+		if (open) {
+			if (!refCount++) {
+				await device.open();
+			}
+		} else {
+			if (!--refCount) {
+				await device.close();
+			}
+		}
+		return refCount;
+	});
+	return Emval.toHandle(promiseChain);
+});
+// clang-format on
+
+libusb_transfer_status getTransferStatus(const val& transfer_result) {
+	auto status = transfer_result["status"].as<std::string>();
+	if (status == "ok") {
+		return LIBUSB_TRANSFER_COMPLETED;
+	} else if (status == "stall") {
+		return LIBUSB_TRANSFER_STALL;
+	} else if (status == "babble") {
+		return LIBUSB_TRANSFER_OVERFLOW;
+	} else {
+		return LIBUSB_TRANSFER_ERROR;
+	}
+}
+
+// Note: this assumes that `dst` is valid for at least `src.byteLength` bytes.
+// This is true for all results returned from WebUSB as we pass max length to
+// the transfer APIs.
+void copyFromDataView(void* dst, const val& src) {
+	usbi_em_copy_from_dataview(dst, src.as_handle());
+}
+
+auto getUnsharedMemoryView(void* src, size_t len) {
+	auto view = typed_memory_view(len, (uint8_t*)src);
+#ifdef _REENTRANT
+	// Unfortunately, TypedArrays backed by SharedArrayBuffers are not accepted
+	// by most Web APIs, trading off guaranteed thread-safety for performance
+	// loss. The usual workaround is to copy them into a new TypedArray, which
+	// is what we do here via the `.slice()` method.
+	return val(view).call<val>("slice");
+#else
+	// Non-threaded builds can avoid the copy penalty.
+	return view;
+#endif
+}
+
+// A helper that proxies a function call to the main thread if not already
+// there. This is a wrapper around Emscripten's raw proxying API with couple of
+// high-level improvements, namely support for destroying lambda on the target
+// thread as well as custom return types.
+template <typename Func>
+auto runOnMain(Func&& func) {
+#ifdef _REENTRANT
+	if (!emscripten_is_main_runtime_thread()) {
+		if constexpr (std::is_same_v<std::invoke_result_t<Func>, void>) {
+			bool proxied =
+				queue.proxySync(emscripten_main_runtime_thread_id(), [&func] {
+					// Capture func by reference and move into a local variable
+					// to render the captured func inert on the first (and only)
+					// call. This way it can be safely destructed on the main
+					// thread instead of the current one when this call
+					// finishes. TODO: remove this when
+					// https://github.com/emscripten-core/emscripten/issues/20610
+					// is fixed.
+					auto func_ = std::move(func);
+					func_();
+				});
+			assert(proxied);
+			return;
+		} else {
+			// A storage for the result of the function call.
+			// TODO: remove when
+			// https://github.com/emscripten-core/emscripten/issues/20611 is
+			// implemented.
+			std::optional<std::invoke_result_t<Func>> result;
+			runOnMain(
+				[&result, func = std::move(func)] { result.emplace(func()); });
+			return std::move(result.value());
+		}
+	}
+#endif
+	return func();
+}
+
+// C++ struct representation for `{value, error}` object used by `CaughtPromise`
+// below.
+struct PromiseResult {
+	int error;
+	val value;
+
+	PromiseResult() = delete;
+	PromiseResult(PromiseResult&&) = default;
+
+	PromiseResult(val&& result)
+		: error(result["error"].as<int>()), value(result["value"]) {}
+
+	~PromiseResult() {
+		// make sure value is freed on the thread it exists on
+		runOnMain([value = std::move(value)] {});
+	}
+};
+
+struct CaughtPromise : val {
+	CaughtPromise(val&& promise)
+		: val(wrapPromiseWithCatch(std::move(promise))) {}
+
+	using AwaitResult = PromiseResult;
+
+private:
+
+	// Wrap promise with conversion from some value T to `{value: T, error:
+	// number}`.
+	static val wrapPromiseWithCatch(val&& promise) {
+		auto handle = promise.as_handle();
+		handle = usbi_em_promise_catch(handle);
+		return val::take_ownership(handle);
+	}
+};
+
+#define co_await_try(promise)                                   \
+	({                                                          \
+		PromiseResult result = co_await CaughtPromise(promise); \
+		if (result.error) {                                     \
+			co_return result.error;                             \
+		}                                                       \
+		std::move(result.value);                                \
+	})
+
+// A helper that runs an asynchronous callback when the promise is resolved.
+template <typename Promise, typename OnResult>
+val promiseThen(Promise&& promise, OnResult&& onResult) {
+	// Save captures from the callback while we can, or they'll be destructed.
+	// https://devblogs.microsoft.com/oldnewthing/20211103-00/?p=105870
+	auto onResult_ = std::move(onResult);
+	onResult_(co_await promise);
+	co_return val::undefined();
+}
+
+// A helper that runs an asynchronous function on the main thread and blocks the
+// current thread until the promise is resolved (via Asyncify "blocking" if
+// already on the main thread or regular blocking otherwise).
+template <typename Func>
+static std::invoke_result_t<Func>::AwaitResult awaitOnMain(Func&& func) {
+#ifdef _REENTRANT
+	if (!emscripten_is_main_runtime_thread()) {
+		// If we're on a different thread, we can't use main thread's Asyncify
+		// as multiple threads might be fighting for its state; instead, use
+		// proxying to synchronously block the current thread until the promise
+		// is complete.
+		std::optional<typename std::invoke_result_t<Func>::AwaitResult> result;
+		queue.proxySyncWithCtx(
+			emscripten_main_runtime_thread_id(),
+			[&result, &func](ProxyingQueue::ProxyingCtx ctx) {
+				// Same as `func` in `runOnMain`, move to destruct on the first
+				// call.
+				auto func_ = std::move(func);
+				promiseThen(
+					func_(),
+					[&result, ctx = std::move(ctx)](auto&& result_) mutable {
+						result.emplace(std::move(result_));
+						ctx.finish();
+					});
+			});
+		return std::move(result.value());
+	}
+#endif
+	// If we're already on the main thread, use Asyncify to block until the
+	// promise is resolved.
+	return func().await();
+}
+
+// A helper that makes a control transfer given a setup pointer (assumed to be
+// followed by data payload for out-transfers).
+val makeControlTransferPromise(const val& dev, libusb_control_setup* setup) {
+	auto params = val::object();
+
+	const char* request_type = "unknown";
+	// See LIBUSB_REQ_TYPE in windows_winusb.h (or docs for `bmRequestType`).
+	switch (setup->bmRequestType & (0x03 << 5)) {
+		case LIBUSB_REQUEST_TYPE_STANDARD:
+			request_type = "standard";
+			break;
+		case LIBUSB_REQUEST_TYPE_CLASS:
+			request_type = "class";
+			break;
+		case LIBUSB_REQUEST_TYPE_VENDOR:
+			request_type = "vendor";
+			break;
+	}
+	params.set("requestType", request_type);
+
+	const char* recipient = "other";
+	switch (setup->bmRequestType & 0x0f) {
+		case LIBUSB_RECIPIENT_DEVICE:
+			recipient = "device";
+			break;
+		case LIBUSB_RECIPIENT_INTERFACE:
+			recipient = "interface";
+			break;
+		case LIBUSB_RECIPIENT_ENDPOINT:
+			recipient = "endpoint";
+			break;
+	}
+	params.set("recipient", recipient);
+
+	params.set("request", setup->bRequest);
+	params.set("value", setup->wValue);
+	params.set("index", setup->wIndex);
+
+	if (setup->bmRequestType & LIBUSB_ENDPOINT_IN) {
+		return dev.call<val>("controlTransferIn", params, setup->wLength);
+	} else {
+		return dev.call<val>("controlTransferOut", params,
+							 getUnsharedMemoryView(setup + 1, setup->wLength));
+	}
+}
+
+// Smart pointer for managing pointers to places allocated by libusb inside its
+// backend structures.
+template <typename T>
+struct ValPtr {
+	template <typename... Args>
+	void emplace(Args&&... args) {
+		new (ptr) T(std::forward<Args>(args)...);
+	}
+
+	const T& operator*() const { return *ptr; }
+	T& operator*() { return *ptr; }
+
+	const T* operator->() const { return ptr; }
+	T* operator->() { return ptr; }
+
+	void free() { ptr->~T(); }
+
+	T take() {
+		auto value = std::move(*ptr);
+		free();
+		return value;
+	}
+
+protected:
+
+	ValPtr(void* ptr) : ptr(static_cast<T*>(ptr)) {}
+
+private:
+
+	// Note: this is not a heap-allocated pointer, but a pointer to a part
+	// of the backend structure allocated by libusb itself.
+	T* ptr;
+};
+
+struct CachedDevice;
+
+struct WebUsbDevicePtr : ValPtr<CachedDevice> {
+public:
+
+	WebUsbDevicePtr(libusb_device* dev) : ValPtr(usbi_get_device_priv(dev)) {}
+	WebUsbDevicePtr(libusb_device_handle* handle)
+		: WebUsbDevicePtr(handle->dev) {}
+};
+
+struct WebUsbTransferPtr : ValPtr<PromiseResult> {
+public:
+
+	WebUsbTransferPtr(usbi_transfer* itransfer)
+		: ValPtr(usbi_get_transfer_priv(itransfer)) {}
+};
+
+enum class OpenClose : bool {
+	Open = true,
+	Close = false,
+};
+
+struct CachedDevice {
+	CachedDevice() = delete;
+	CachedDevice(CachedDevice&&) = delete;
+
+	// Fill in the device descriptor and configurations by reading them from the
+	// WebUSB device.
+	static val initFromDevice(val&& web_usb_dev, libusb_device* libusb_dev) {
+		auto cachedDevicePtr = WebUsbDevicePtr(libusb_dev);
+		cachedDevicePtr.emplace(std::move(web_usb_dev));
+		bool must_close = false;
+		val result = co_await cachedDevicePtr->initFromDeviceWithoutClosing(
+			libusb_dev, must_close);
+		if (must_close) {
+			co_await_try(cachedDevicePtr->safeOpenCloseAssumingMainThread(
+				OpenClose::Close));
+		}
+		co_return std::move(result);
+	}
+
+	const val& getDeviceAssumingMainThread() const { return device; }
+
+	uint8_t getActiveConfigValue() const {
+		return runOnMain([&] {
+			auto web_usb_config = device["configuration"];
+			return web_usb_config.isNull()
+				? 0
+				: web_usb_config["configurationValue"].as<uint8_t>();
+		});
+	}
+
+	usbi_configuration_descriptor* getConfigDescriptor(uint8_t config_id) {
+		return config_id < configurations.size()
+			? configurations[config_id].get()
+			: nullptr;
+	}
+
+	usbi_configuration_descriptor* findConfigDescriptorByValue(
+		uint8_t config_id) const {
+		for (auto& config : configurations) {
+			if (config->bConfigurationValue == config_id) {
+				return config.get();
+			}
+		}
+		return nullptr;
+	}
+
+	int copyConfigDescriptor(const usbi_configuration_descriptor* config,
+							 void* buf,
+							 size_t buf_len) {
+		auto len = std::min(buf_len, (size_t)config->wTotalLength);
+		memcpy(buf, config, len);
+		return len;
+	}
+
+	template <typename... Args>
+	int awaitOnMain(const char* methodName, Args&&... args) const {
+		return ::awaitOnMain([&] {
+				   return CaughtPromise(device.call<val>(
+					   methodName, std::forward<Args>(args)...));
+			   })
+			.error;
+	}
+
+	~CachedDevice() {
+		runOnMain([device = std::move(device)] {});
+	}
+
+	CaughtPromise safeOpenCloseAssumingMainThread(OpenClose open) {
+		return val::take_ownership(usbi_em_device_safe_open_close(
+			device.as_handle(), static_cast<bool>(open)));
+	}
+
+	int safeOpenCloseOnMain(OpenClose open) {
+		return ::awaitOnMain([this, open] {
+				   return safeOpenCloseAssumingMainThread(open);
+			   })
+			.error;
+	}
+
+private:
+
+	val device;
+	std::vector<std::unique_ptr<usbi_configuration_descriptor>> configurations;
+
+	CaughtPromise requestDescriptor(libusb_descriptor_type desc_type,
+									uint8_t desc_index,
+									uint16_t max_length) const {
+		libusb_control_setup setup = {
+			.bmRequestType = LIBUSB_ENDPOINT_IN,
+			.bRequest = LIBUSB_REQUEST_GET_DESCRIPTOR,
+			.wValue = (uint16_t)((desc_type << 8) | desc_index),
+			.wIndex = 0,
+			.wLength = max_length,
+		};
+		return makeControlTransferPromise(device, &setup);
+	}
+
+	// Implementation of the `CachedDevice::initFromDevice` above. This is a
+	// separate function just because we need to close the device on exit if
+	// we opened it successfully, and we can't use an async operation (`close`)
+	// in RAII destructor.
+	val initFromDeviceWithoutClosing(libusb_device* dev, bool& must_close) {
+		co_await_try(safeOpenCloseAssumingMainThread(OpenClose::Open));
+
+		// Can't use RAII to close on exit as co_await is not permitted in
+		// destructors (yet:
+		// https://github.com/cplusplus/papers/issues/445), so use a good
+		// old boolean + a wrapper instead.
+		must_close = true;
+
+		{
+			auto result = co_await_try(
+				requestDescriptor(LIBUSB_DT_DEVICE, 0, LIBUSB_DT_DEVICE_SIZE));
+			if (auto error = getTransferStatus(result)) {
+				co_return error;
+			}
+			copyFromDataView(&dev->device_descriptor, result["data"]);
+		}
+
+		// Infer the device speed (which is not yet provided by WebUSB) from
+		// the descriptor.
+		if (dev->device_descriptor.bMaxPacketSize0 ==
+			/* actually means 2^9, only valid for superspeeds */ 9) {
+			dev->speed = dev->device_descriptor.bcdUSB >= 0x0310
+				? LIBUSB_SPEED_SUPER_PLUS
+				: LIBUSB_SPEED_SUPER;
+		} else if (dev->device_descriptor.bcdUSB >= 0x0200) {
+			dev->speed = LIBUSB_SPEED_HIGH;
+		} else if (dev->device_descriptor.bMaxPacketSize0 > 8) {
+			dev->speed = LIBUSB_SPEED_FULL;
+		} else {
+			dev->speed = LIBUSB_SPEED_LOW;
+		}
+
+		if (auto error = usbi_sanitize_device(dev)) {
+			co_return error;
+		}
+
+		auto configurations_len = dev->device_descriptor.bNumConfigurations;
+		configurations.reserve(configurations_len);
+		for (uint8_t j = 0; j < configurations_len; j++) {
+			// Note: requesting more than (platform-specific limit) bytes
+			// here will cause the transfer to fail, see
+			// https://crbug.com/1489414. Use the most common limit of 4096
+			// bytes for now.
+			constexpr uint16_t MAX_CTRL_BUFFER_LENGTH = 4096;
+			auto result = co_await_try(
+				requestDescriptor(LIBUSB_DT_CONFIG, j, MAX_CTRL_BUFFER_LENGTH));
+			if (auto error = getTransferStatus(result)) {
+				co_return error;
+			}
+			auto configVal = result["data"];
+			auto configLen = configVal["byteLength"].as<size_t>();
+			auto& config = configurations.emplace_back(
+				(usbi_configuration_descriptor*)::operator new(configLen));
+			copyFromDataView(config.get(), configVal);
+		}
+
+		co_return (int) LIBUSB_SUCCESS;
+	}
+
+	CachedDevice(val device) : device(std::move(device)) {}
+
+	friend struct ValPtr<CachedDevice>;
+};
+
+unsigned long getDeviceSessionId(val& web_usb_device) {
+	thread_local const val SessionIdSymbol =
+		val::global("Symbol")(val("libusb.session_id"));
+
+	val session_id_val = web_usb_device[SessionIdSymbol];
+	if (!session_id_val.isUndefined()) {
+		return session_id_val.as<unsigned long>();
+	}
+
+	// If the device doesn't have a session ID, it means we haven't seen
+	// it before. Generate a new session ID for it. We can associate an
+	// incrementing ID with the `USBDevice` object itself. It's
+	// guaranteed to be alive and, thus, stable as long as the device is
+	// connected, even between different libusb invocations. See
+	// https://github.com/WICG/webusb/issues/241.
+
+	static unsigned long next_session_id = 0;
+
+	web_usb_device.set(SessionIdSymbol, next_session_id);
+	return next_session_id++;
+}
+
+val getDeviceList(libusb_context* ctx, discovered_devs** devs) {
+	// C++ equivalent of `await navigator.usb.getDevices()`. Note: at this point
+	// we must already have some devices exposed - caller must have called
+	// `await navigator.usb.requestDevice(...)` in response to user interaction
+	// before going to LibUSB. Otherwise this list will be empty.
+	auto web_usb_devices =
+		co_await_try(val::global("navigator")["usb"].call<val>("getDevices"));
+	for (auto&& web_usb_device : web_usb_devices) {
+		auto session_id = getDeviceSessionId(web_usb_device);
+
+		auto dev = usbi_get_device_by_session_id(ctx, session_id);
+		if (dev == NULL) {
+			dev = usbi_alloc_device(ctx, session_id);
+			if (dev == NULL) {
+				usbi_err(ctx, "failed to allocate a new device structure");
+				continue;
+			}
+
+			auto statusVal = co_await CachedDevice::initFromDevice(
+				std::move(web_usb_device), dev);
+			if (auto error = statusVal.as<int>()) {
+				usbi_err(ctx, "failed to read device information: %s",
+						 libusb_error_name(error));
+				libusb_unref_device(dev);
+				continue;
+			}
+
+			// We don't have real buses in WebUSB, just pretend everything
+			// is on bus 1.
+			dev->bus_number = 1;
+			// This can wrap around but it's the best approximation of a stable
+			// device address and port number we can provide.
+			dev->device_address = dev->port_number = (uint8_t)session_id;
+		}
+		*devs = discovered_devs_append(*devs, dev);
+		libusb_unref_device(dev);
+	}
+	co_return (int) LIBUSB_SUCCESS;
+}
+
+int em_get_device_list(libusb_context* ctx, discovered_devs** devs) {
+	// No need to wrap into CaughtPromise as we catch all individual ops in the
+	// inner implementation and return just the error code. We do need a custom
+	// promise type to ensure conversion to int happens on the main thread
+	// though.
+	struct IntPromise : val {
+		IntPromise(val&& promise) : val(std::move(promise)) {}
+
+		struct AwaitResult {
+			int error;
+
+			AwaitResult(val&& result) : error(result.as<int>()) {}
+		};
+	};
+
+	return awaitOnMain(
+			   [ctx, devs] { return IntPromise(getDeviceList(ctx, devs)); })
+		.error;
+}
+
+int em_open(libusb_device_handle* handle) {
+	return WebUsbDevicePtr(handle)->safeOpenCloseOnMain(OpenClose::Open);
+}
+
+void em_close(libusb_device_handle* handle) {
+	// LibUSB API doesn't allow us to handle an error here, but we still need to
+	// wait for the promise to make sure that subsequent attempt to reopen the
+	// same device doesn't fail with a "device busy" error.
+	if (auto error =
+			WebUsbDevicePtr(handle)->safeOpenCloseOnMain(OpenClose::Close)) {
+		usbi_err(handle->dev->ctx, "failed to close device: %s",
+				 libusb_error_name(error));
+	}
+}
+
+int em_get_active_config_descriptor(libusb_device* dev, void* buf, size_t len) {
+	auto& cached_device = *WebUsbDevicePtr(dev);
+	auto config_value = cached_device.getActiveConfigValue();
+	if (auto config = cached_device.findConfigDescriptorByValue(config_value)) {
+		return cached_device.copyConfigDescriptor(config, buf, len);
+	} else {
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+}
+
+int em_get_config_descriptor(libusb_device* dev,
+							 uint8_t config_id,
+							 void* buf,
+							 size_t len) {
+	auto& cached_device = *WebUsbDevicePtr(dev);
+	if (auto config = cached_device.getConfigDescriptor(config_id)) {
+		return cached_device.copyConfigDescriptor(config, buf, len);
+	} else {
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+}
+
+int em_get_configuration(libusb_device_handle* dev_handle,
+						 uint8_t* config_value) {
+	*config_value = WebUsbDevicePtr(dev_handle)->getActiveConfigValue();
+	return LIBUSB_SUCCESS;
+}
+
+int em_get_config_descriptor_by_value(libusb_device* dev,
+									  uint8_t config_value,
+									  void** buf) {
+	auto& cached_device = *WebUsbDevicePtr(dev);
+	if (auto config = cached_device.findConfigDescriptorByValue(config_value)) {
+		*buf = config;
+		return config->wTotalLength;
+	} else {
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+}
+
+int em_set_configuration(libusb_device_handle* dev_handle, int config) {
+	return WebUsbDevicePtr(dev_handle)->awaitOnMain("setConfiguration", config);
+}
+
+int em_claim_interface(libusb_device_handle* handle, uint8_t iface) {
+	return WebUsbDevicePtr(handle)->awaitOnMain("claimInterface", iface);
+}
+
+int em_release_interface(libusb_device_handle* handle, uint8_t iface) {
+	return WebUsbDevicePtr(handle)->awaitOnMain("releaseInterface", iface);
+}
+
+int em_set_interface_altsetting(libusb_device_handle* handle,
+								uint8_t iface,
+								uint8_t altsetting) {
+	return WebUsbDevicePtr(handle)->awaitOnMain("selectAlternateInterface",
+												iface, altsetting);
+}
+
+int em_clear_halt(libusb_device_handle* handle, unsigned char endpoint) {
+	std::string direction = endpoint & LIBUSB_ENDPOINT_IN ? "in" : "out";
+	endpoint &= LIBUSB_ENDPOINT_ADDRESS_MASK;
+
+	return WebUsbDevicePtr(handle)->awaitOnMain("clearHalt", direction,
+												endpoint);
+}
+
+int em_reset_device(libusb_device_handle* handle) {
+	return WebUsbDevicePtr(handle)->awaitOnMain("reset");
+}
+
+void em_destroy_device(libusb_device* dev) {
+	WebUsbDevicePtr(dev).free();
+}
+
+int em_submit_transfer(usbi_transfer* itransfer) {
+	return runOnMain([itransfer] {
+		auto transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+		auto& web_usb_device = WebUsbDevicePtr(transfer->dev_handle)
+								   ->getDeviceAssumingMainThread();
+		val transfer_promise;
+		switch (transfer->type) {
+			case LIBUSB_TRANSFER_TYPE_CONTROL: {
+				transfer_promise = makeControlTransferPromise(
+					web_usb_device,
+					libusb_control_transfer_get_setup(transfer));
+				break;
+			}
+			case LIBUSB_TRANSFER_TYPE_BULK:
+			case LIBUSB_TRANSFER_TYPE_INTERRUPT: {
+				auto endpoint =
+					transfer->endpoint & LIBUSB_ENDPOINT_ADDRESS_MASK;
+
+				if (IS_XFERIN(transfer)) {
+					transfer_promise = web_usb_device.call<val>(
+						"transferIn", endpoint, transfer->length);
+				} else {
+					auto data = getUnsharedMemoryView(transfer->buffer,
+													  transfer->length);
+					transfer_promise =
+						web_usb_device.call<val>("transferOut", endpoint, data);
+				}
+
+				break;
+			}
+			// TODO: add implementation for isochronous transfers too.
+			default:
+				return LIBUSB_ERROR_NOT_SUPPORTED;
+		}
+		// Not a coroutine because we don't want to block on this promise, just
+		// schedule an asynchronous callback.
+		promiseThen(CaughtPromise(std::move(transfer_promise)),
+					[itransfer](auto&& result) {
+						WebUsbTransferPtr(itransfer).emplace(std::move(result));
+						usbi_signal_transfer_completion(itransfer);
+					});
+		return LIBUSB_SUCCESS;
+	});
+}
+
+void em_clear_transfer_priv(usbi_transfer* itransfer) {
+	WebUsbTransferPtr(itransfer).free();
+}
+
+int em_cancel_transfer(usbi_transfer* itransfer) {
+	return LIBUSB_SUCCESS;
+}
+
+int em_handle_transfer_completion(usbi_transfer* itransfer) {
+	libusb_transfer_status status = runOnMain([itransfer] {
+		auto transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+		// Take ownership of the transfer result, as `em_clear_transfer_priv` is
+		// not called automatically for completed transfers and we must free it
+		// to avoid leaks.
+
+		auto result = WebUsbTransferPtr(itransfer).take();
+
+		if (itransfer->state_flags & USBI_TRANSFER_CANCELLING) {
+			return LIBUSB_TRANSFER_CANCELLED;
+		}
+
+		if (result.error) {
+			return LIBUSB_TRANSFER_ERROR;
+		}
+
+		auto& value = result.value;
+
+		void* dataDest;
+		unsigned char endpointDir;
+
+		if (transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL) {
+			dataDest = libusb_control_transfer_get_data(transfer);
+			endpointDir =
+				libusb_control_transfer_get_setup(transfer)->bmRequestType;
+		} else {
+			dataDest = transfer->buffer;
+			endpointDir = transfer->endpoint;
+		}
+
+		if (endpointDir & LIBUSB_ENDPOINT_IN) {
+			auto data = value["data"];
+			if (!data.isNull()) {
+				itransfer->transferred = data["byteLength"].as<int>();
+				copyFromDataView(dataDest, data);
+			}
+		} else {
+			itransfer->transferred = value["bytesWritten"].as<int>();
+		}
+
+		return getTransferStatus(value);
+	});
+
+	// Invoke user's handlers outside of the main thread to reduce pressure.
+	return status == LIBUSB_TRANSFER_CANCELLED
+		? usbi_handle_transfer_cancellation(itransfer)
+		: usbi_handle_transfer_completion(itransfer, status);
+}
+
+}  // namespace
+
+#pragma clang diagnostic ignored "-Wmissing-field-initializers"
+extern "C" const usbi_os_backend usbi_backend = {
+	.name = "Emscripten + WebUSB backend",
+	.caps = LIBUSB_CAP_HAS_CAPABILITY,
+	.get_device_list = em_get_device_list,
+	.open = em_open,
+	.close = em_close,
+	.get_active_config_descriptor = em_get_active_config_descriptor,
+	.get_config_descriptor = em_get_config_descriptor,
+	.get_config_descriptor_by_value = em_get_config_descriptor_by_value,
+	.get_configuration = em_get_configuration,
+	.set_configuration = em_set_configuration,
+	.claim_interface = em_claim_interface,
+	.release_interface = em_release_interface,
+	.set_interface_altsetting = em_set_interface_altsetting,
+	.clear_halt = em_clear_halt,
+	.reset_device = em_reset_device,
+	.destroy_device = em_destroy_device,
+	.submit_transfer = em_submit_transfer,
+	.cancel_transfer = em_cancel_transfer,
+	.clear_transfer_priv = em_clear_transfer_priv,
+	.handle_transfer_completion = em_handle_transfer_completion,
+	.device_priv_size = sizeof(CachedDevice),
+	.transfer_priv_size = sizeof(PromiseResult),
+};
+
+#pragma clang diagnostic pop

deps/libusb/libusb/os/events_posix.c

@@ -0,0 +1,340 @@
+/*
+ * libusb event abstraction on POSIX platforms
+ *
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * 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 "libusbi.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#ifdef HAVE_EVENTFD
+#include <sys/eventfd.h>
+#endif
+#ifdef HAVE_TIMERFD
+#include <sys/timerfd.h>
+#endif
+
+#ifdef __EMSCRIPTEN__
+/* On Emscripten `pipe` does not conform to the spec and does not block
+ * until events are available, which makes it unusable for event system
+ * and often results in deadlocks when `pipe` is in a loop like it is
+ * in libusb.
+ *
+ * Therefore use a custom event system based on browser event emitters. */
+#include <emscripten.h>
+#include <emscripten/atomic.h>
+#include <emscripten/threading.h>
+
+EM_ASYNC_JS(void, em_libusb_wait_async, (const _Atomic int* ptr, int expected_value, int timeout), {
+	await Atomics.waitAsync(HEAP32, ptr >> 2, expected_value, timeout).value;
+});
+
+static void em_libusb_wait(const _Atomic int *ptr, int expected_value, int timeout)
+{
+	if (emscripten_is_main_runtime_thread()) {
+		em_libusb_wait_async(ptr, expected_value, timeout);
+	} else {
+		emscripten_atomic_wait_u32((int*)ptr, expected_value, 1000000LL * timeout);
+	}
+}
+#endif
+#include <unistd.h>
+
+#ifdef HAVE_EVENTFD
+#define EVENT_READ_FD(e)	((e)->eventfd)
+#define EVENT_WRITE_FD(e)	((e)->eventfd)
+#else
+#define EVENT_READ_FD(e)	((e)->pipefd[0])
+#define EVENT_WRITE_FD(e)	((e)->pipefd[1])
+#endif
+
+#ifdef HAVE_NFDS_T
+typedef nfds_t usbi_nfds_t;
+#else
+typedef unsigned int usbi_nfds_t;
+#endif
+
+int usbi_create_event(usbi_event_t *event)
+{
+#ifdef HAVE_EVENTFD
+	event->eventfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
+	if (event->eventfd == -1) {
+		usbi_err(NULL, "failed to create eventfd, errno=%d", errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+#else
+#if defined(HAVE_PIPE2)
+	int ret = pipe2(event->pipefd, O_CLOEXEC);
+#else
+	int ret = pipe(event->pipefd);
+#endif
+
+	if (ret != 0) {
+		usbi_err(NULL, "failed to create pipe, errno=%d", errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+#if !defined(HAVE_PIPE2) && defined(FD_CLOEXEC)
+	ret = fcntl(event->pipefd[0], F_GETFD);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to get pipe fd flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+	ret = fcntl(event->pipefd[0], F_SETFD, ret | FD_CLOEXEC);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set pipe fd flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+
+	ret = fcntl(event->pipefd[1], F_GETFD);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to get pipe fd flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+	ret = fcntl(event->pipefd[1], F_SETFD, ret | FD_CLOEXEC);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set pipe fd flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+#endif
+
+	ret = fcntl(event->pipefd[1], F_GETFL);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to get pipe fd status flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+	ret = fcntl(event->pipefd[1], F_SETFL, ret | O_NONBLOCK);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set pipe fd status flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+
+	return 0;
+
+err_close_pipe:
+	close(event->pipefd[1]);
+	close(event->pipefd[0]);
+	return LIBUSB_ERROR_OTHER;
+#endif
+}
+
+void usbi_destroy_event(usbi_event_t *event)
+{
+#ifdef HAVE_EVENTFD
+	if (close(event->eventfd) == -1)
+		usbi_warn(NULL, "failed to close eventfd, errno=%d", errno);
+#else
+	if (close(event->pipefd[1]) == -1)
+		usbi_warn(NULL, "failed to close pipe write end, errno=%d", errno);
+	if (close(event->pipefd[0]) == -1)
+		usbi_warn(NULL, "failed to close pipe read end, errno=%d", errno);
+#endif
+}
+
+void usbi_signal_event(usbi_event_t *event)
+{
+	uint64_t dummy = 1;
+	ssize_t r;
+
+	r = write(EVENT_WRITE_FD(event), &dummy, sizeof(dummy));
+	if (r != sizeof(dummy))
+		usbi_warn(NULL, "event write failed");
+#ifdef __EMSCRIPTEN__
+	event->has_event = 1;
+	emscripten_atomic_notify(&event->has_event, EMSCRIPTEN_NOTIFY_ALL_WAITERS);
+#endif
+}
+
+void usbi_clear_event(usbi_event_t *event)
+{
+	uint64_t dummy;
+	ssize_t r;
+
+	r = read(EVENT_READ_FD(event), &dummy, sizeof(dummy));
+	if (r != sizeof(dummy))
+		usbi_warn(NULL, "event read failed");
+#ifdef __EMSCRIPTEN__
+	event->has_event = 0;
+#endif
+}
+
+#ifdef HAVE_TIMERFD
+int usbi_create_timer(usbi_timer_t *timer)
+{
+	timer->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
+	if (timer->timerfd == -1) {
+		usbi_warn(NULL, "failed to create timerfd, errno=%d", errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+
+void usbi_destroy_timer(usbi_timer_t *timer)
+{
+	if (close(timer->timerfd) == -1)
+		usbi_warn(NULL, "failed to close timerfd, errno=%d", errno);
+}
+
+int usbi_arm_timer(usbi_timer_t *timer, const struct timespec *timeout)
+{
+	const struct itimerspec it = { { 0, 0 }, { timeout->tv_sec, timeout->tv_nsec } };
+
+	if (timerfd_settime(timer->timerfd, TFD_TIMER_ABSTIME, &it, NULL) == -1) {
+		usbi_warn(NULL, "failed to arm timerfd, errno=%d", errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+
+int usbi_disarm_timer(usbi_timer_t *timer)
+{
+	const struct itimerspec it = { { 0, 0 }, { 0, 0 } };
+
+	if (timerfd_settime(timer->timerfd, 0, &it, NULL) == -1) {
+		usbi_warn(NULL, "failed to disarm timerfd, errno=%d", errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+#endif
+
+int usbi_alloc_event_data(struct libusb_context *ctx)
+{
+	struct usbi_event_source *ievent_source;
+	struct pollfd *fds;
+	size_t i = 0;
+
+	if (ctx->event_data) {
+		free(ctx->event_data);
+		ctx->event_data = NULL;
+	}
+
+	ctx->event_data_cnt = 0;
+	for_each_event_source(ctx, ievent_source)
+		ctx->event_data_cnt++;
+
+	fds = calloc(ctx->event_data_cnt, sizeof(*fds));
+	if (!fds)
+		return LIBUSB_ERROR_NO_MEM;
+
+	for_each_event_source(ctx, ievent_source) {
+		fds[i].fd = ievent_source->data.os_handle;
+		fds[i].events = ievent_source->data.poll_events;
+		i++;
+	}
+
+	ctx->event_data = fds;
+	return 0;
+}
+
+int usbi_wait_for_events(struct libusb_context *ctx,
+	struct usbi_reported_events *reported_events, int timeout_ms)
+{
+	struct pollfd *fds = ctx->event_data;
+	usbi_nfds_t nfds = (usbi_nfds_t)ctx->event_data_cnt;
+	int internal_fds, num_ready;
+
+	usbi_dbg(ctx, "poll() %u fds with timeout in %dms", (unsigned int)nfds, timeout_ms);
+#ifdef __EMSCRIPTEN__
+	// Emscripten's poll doesn't actually block, so we need to use an out-of-band
+	// waiting signal.
+	em_libusb_wait(&ctx->event.has_event, 0, timeout_ms);
+	// Emscripten ignores timeout_ms, but set it to 0 for future-proofing in case
+	// they ever implement real poll.
+	timeout_ms = 0;
+#endif
+	num_ready = poll(fds, nfds, timeout_ms);
+	usbi_dbg(ctx, "poll() returned %d", num_ready);
+	if (num_ready == 0) {
+		if (usbi_using_timer(ctx))
+			goto done;
+		return LIBUSB_ERROR_TIMEOUT;
+	} else if (num_ready == -1) {
+		if (errno == EINTR)
+			return LIBUSB_ERROR_INTERRUPTED;
+		usbi_err(ctx, "poll() failed, errno=%d", errno);
+		return LIBUSB_ERROR_IO;
+	}
+
+	/* fds[0] is always the internal signalling event */
+	if (fds[0].revents) {
+		reported_events->event_triggered = 1;
+		num_ready--;
+	} else {
+		reported_events->event_triggered = 0;
+	}
+
+#ifdef HAVE_OS_TIMER
+	/* on timer configurations, fds[1] is the timer */
+	if (usbi_using_timer(ctx) && fds[1].revents) {
+		reported_events->timer_triggered = 1;
+		num_ready--;
+	} else {
+		reported_events->timer_triggered = 0;
+	}
+#endif
+
+	if (!num_ready)
+		goto done;
+
+	/* the backend will never need to attempt to handle events on the
+	 * library's internal file descriptors, so we determine how many are
+	 * in use internally for this context and skip these when passing any
+	 * remaining pollfds to the backend. */
+	internal_fds = usbi_using_timer(ctx) ? 2 : 1;
+	fds += internal_fds;
+	nfds -= internal_fds;
+
+	usbi_mutex_lock(&ctx->event_data_lock);
+	if (ctx->event_flags & USBI_EVENT_EVENT_SOURCES_MODIFIED) {
+		struct usbi_event_source *ievent_source;
+
+		for_each_removed_event_source(ctx, ievent_source) {
+			usbi_nfds_t n;
+
+			for (n = 0; n < nfds; n++) {
+				if (ievent_source->data.os_handle != fds[n].fd)
+					continue;
+				if (!fds[n].revents)
+					continue;
+				/* pollfd was removed between the creation of the fds array and
+				 * here. remove triggered revent as it is no longer relevant. */
+				usbi_dbg(ctx, "fd %d was removed, ignoring raised events", fds[n].fd);
+				fds[n].revents = 0;
+				num_ready--;
+				break;
+			}
+		}
+	}
+	usbi_mutex_unlock(&ctx->event_data_lock);
+
+	if (num_ready) {
+		assert(num_ready > 0);
+		reported_events->event_data = fds;
+		reported_events->event_data_count = (unsigned int)nfds;
+	}
+
+done:
+	reported_events->num_ready = num_ready;
+	return LIBUSB_SUCCESS;
+}

deps/libusb/libusb/os/events_posix.h

@@ -0,0 +1,62 @@
+/*
+ * libusb event abstraction on POSIX platforms
+ *
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * 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
+ */
+
+#ifndef LIBUSB_EVENTS_POSIX_H
+#define LIBUSB_EVENTS_POSIX_H
+
+#include <poll.h>
+
+typedef int usbi_os_handle_t;
+#define USBI_OS_HANDLE_FORMAT_STRING	"fd %d"
+
+#ifdef HAVE_EVENTFD
+typedef struct usbi_event {
+	int eventfd;
+} usbi_event_t;
+#define USBI_EVENT_OS_HANDLE(e)	((e)->eventfd)
+#define USBI_EVENT_POLL_EVENTS	POLLIN
+#define USBI_INVALID_EVENT	{ -1 }
+#else
+typedef struct usbi_event {
+	int pipefd[2];
+#ifdef __EMSCRIPTEN__
+	_Atomic int has_event;
+#endif
+} usbi_event_t;
+#define USBI_EVENT_OS_HANDLE(e)	((e)->pipefd[0])
+#define USBI_EVENT_POLL_EVENTS	POLLIN
+#define USBI_INVALID_EVENT	{ { -1, -1 } }
+#endif
+
+#ifdef HAVE_TIMERFD
+#define HAVE_OS_TIMER 1
+typedef struct usbi_timer {
+	int timerfd;
+} usbi_timer_t;
+#define USBI_TIMER_OS_HANDLE(t)	((t)->timerfd)
+#define USBI_TIMER_POLL_EVENTS	POLLIN
+
+static inline int usbi_timer_valid(usbi_timer_t *timer)
+{
+	return timer->timerfd >= 0;
+}
+#endif
+
+#endif

deps/libusb/libusb/os/events_windows.c

@@ -0,0 +1,214 @@
+/*
+ * libusb event abstraction on Microsoft Windows
+ *
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * 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 <config.h>
+
+#include "libusbi.h"
+#include "windows_common.h"
+
+int usbi_create_event(usbi_event_t *event)
+{
+	event->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	if (event->hEvent == NULL) {
+		usbi_err(NULL, "CreateEvent failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+
+void usbi_destroy_event(usbi_event_t *event)
+{
+	if (!CloseHandle(event->hEvent))
+		usbi_warn(NULL, "CloseHandle failed: %s", windows_error_str(0));
+}
+
+void usbi_signal_event(usbi_event_t *event)
+{
+	if (!SetEvent(event->hEvent))
+		usbi_warn(NULL, "SetEvent failed: %s", windows_error_str(0));
+}
+
+void usbi_clear_event(usbi_event_t *event)
+{
+	if (!ResetEvent(event->hEvent))
+		usbi_warn(NULL, "ResetEvent failed: %s", windows_error_str(0));
+}
+
+#ifdef HAVE_OS_TIMER
+int usbi_create_timer(usbi_timer_t *timer)
+{
+	timer->hTimer = CreateWaitableTimer(NULL, TRUE, NULL);
+	if (timer->hTimer == NULL) {
+		usbi_warn(NULL, "CreateWaitableTimer failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+
+void usbi_destroy_timer(usbi_timer_t *timer)
+{
+	if (!CloseHandle(timer->hTimer))
+		usbi_warn(NULL, "CloseHandle failed: %s", windows_error_str(0));
+}
+
+int usbi_arm_timer(usbi_timer_t *timer, const struct timespec *timeout)
+{
+	struct timespec systime, remaining;
+	FILETIME filetime;
+	LARGE_INTEGER dueTime;
+
+	/* Transfer timeouts are based on the monotonic clock and the waitable
+	 * timers on the system clock. This requires a conversion between the
+	 * two, so we calculate the remaining time relative to the monotonic
+	 * clock and calculate an absolute system time for the timer expiration.
+	 * Note that if the timeout has already passed, the remaining time will
+	 * be negative and thus an absolute system time in the past will be set.
+	 * This works just as intended because the timer becomes signalled
+	 * immediately. */
+	usbi_get_monotonic_time(&systime);
+
+	TIMESPEC_SUB(timeout, &systime, &remaining);
+
+	GetSystemTimeAsFileTime(&filetime);
+	dueTime.LowPart = filetime.dwLowDateTime;
+	dueTime.HighPart = filetime.dwHighDateTime;
+	dueTime.QuadPart += (remaining.tv_sec * 10000000LL) + (remaining.tv_nsec / 100LL);
+
+	if (!SetWaitableTimer(timer->hTimer, &dueTime, 0, NULL, NULL, FALSE)) {
+		usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+
+int usbi_disarm_timer(usbi_timer_t *timer)
+{
+	LARGE_INTEGER dueTime;
+
+	/* A manual-reset waitable timer will stay in the signalled state until
+	 * another call to SetWaitableTimer() is made. It is possible that the
+	 * timer has already expired by the time we come in to disarm it, so to
+	 * be entirely sure the timer is disarmed and not in the signalled state,
+	 * we will set it with an impossibly large expiration and immediately
+	 * cancel. */
+	dueTime.QuadPart = LLONG_MAX;
+	if (!SetWaitableTimer(timer->hTimer, &dueTime, 0, NULL, NULL, FALSE)) {
+		usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	if (!CancelWaitableTimer(timer->hTimer)) {
+		usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+#endif
+
+int usbi_alloc_event_data(struct libusb_context *ctx)
+{
+	struct usbi_event_source *ievent_source;
+	HANDLE *handles;
+	size_t i = 0;
+
+	/* Event sources are only added during usbi_io_init(). We should not
+	 * be running this function again if the event data has already been
+	 * allocated. */
+	if (ctx->event_data) {
+		usbi_warn(ctx, "program assertion failed - event data already allocated");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	ctx->event_data_cnt = 0;
+	for_each_event_source(ctx, ievent_source)
+		ctx->event_data_cnt++;
+
+	/* We only expect up to two HANDLEs to wait on, one for the internal
+	 * signalling event and the other for the timer. */
+	if (ctx->event_data_cnt != 1 && ctx->event_data_cnt != 2) {
+		usbi_err(ctx, "program assertion failed - expected exactly 1 or 2 HANDLEs");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	handles = calloc(ctx->event_data_cnt, sizeof(HANDLE));
+	if (!handles)
+		return LIBUSB_ERROR_NO_MEM;
+
+	for_each_event_source(ctx, ievent_source) {
+		handles[i] = ievent_source->data.os_handle;
+		i++;
+	}
+
+	ctx->event_data = handles;
+	return 0;
+}
+
+int usbi_wait_for_events(struct libusb_context *ctx,
+	struct usbi_reported_events *reported_events, int timeout_ms)
+{
+	HANDLE *handles = ctx->event_data;
+	DWORD num_handles = (DWORD)ctx->event_data_cnt;
+	DWORD result;
+
+	usbi_dbg(ctx, "WaitForMultipleObjects() for %lu HANDLEs with timeout in %dms", ULONG_CAST(num_handles), timeout_ms);
+	result = WaitForMultipleObjects(num_handles, handles, FALSE, (DWORD)timeout_ms);
+	usbi_dbg(ctx, "WaitForMultipleObjects() returned %lu", ULONG_CAST(result));
+	if (result == WAIT_TIMEOUT) {
+		if (usbi_using_timer(ctx))
+			goto done;
+		return LIBUSB_ERROR_TIMEOUT;
+	} else if (result == WAIT_FAILED) {
+		usbi_err(ctx, "WaitForMultipleObjects() failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_IO;
+	}
+
+	result -= WAIT_OBJECT_0;
+
+	/* handles[0] is always the internal signalling event */
+	if (result == 0)
+		reported_events->event_triggered = 1;
+	else
+		reported_events->event_triggered = 0;
+
+#ifdef HAVE_OS_TIMER
+	/* on timer configurations, handles[1] is the timer */
+	if (usbi_using_timer(ctx)) {
+		/* The WaitForMultipleObjects() function reports the index of
+		 * the first object that became signalled. If the internal
+		 * signalling event was reported, we need to also check and
+		 * report whether the timer is in the signalled state. */
+		if (result == 1 || WaitForSingleObject(handles[1], 0) == WAIT_OBJECT_0)
+			reported_events->timer_triggered = 1;
+		else
+			reported_events->timer_triggered = 0;
+	} else {
+		reported_events->timer_triggered = 0;
+	}
+#endif
+
+done:
+	/* no events are ever reported to the backend */
+	reported_events->num_ready = 0;
+	return LIBUSB_SUCCESS;
+}

deps/libusb/libusb/os/events_windows.h

@@ -0,0 +1,46 @@
+/*
+ * libusb event abstraction on Microsoft Windows
+ *
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * 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
+ */
+
+#ifndef LIBUSB_EVENTS_WINDOWS_H
+#define LIBUSB_EVENTS_WINDOWS_H
+
+typedef HANDLE usbi_os_handle_t;
+#define USBI_OS_HANDLE_FORMAT_STRING	"HANDLE %p"
+
+typedef struct usbi_event {
+	HANDLE hEvent;
+} usbi_event_t;
+#define USBI_EVENT_OS_HANDLE(e)	((e)->hEvent)
+#define USBI_EVENT_POLL_EVENTS	0
+#define USBI_INVALID_EVENT	{ INVALID_HANDLE_VALUE }
+
+#define HAVE_OS_TIMER 1
+typedef struct usbi_timer {
+	HANDLE hTimer;
+} usbi_timer_t;
+#define USBI_TIMER_OS_HANDLE(t)	((t)->hTimer)
+#define USBI_TIMER_POLL_EVENTS	0
+
+static inline int usbi_timer_valid(usbi_timer_t *timer)
+{
+	return timer->hTimer != NULL;
+}
+
+#endif

deps/libusb/libusb/os/haiku_pollfs.cpp

@@ -0,0 +1,372 @@
+/*
+ * Copyright 2007-2008, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *		Michael Lotz <mmlr@mlotz.ch>
+ */
+
+#include "haiku_usb.h"
+#include <cstdio>
+#include <Directory.h>
+#include <Entry.h>
+#include <Looper.h>
+#include <Messenger.h>
+#include <Node.h>
+#include <NodeMonitor.h>
+#include <Path.h>
+#include <cstring>
+
+class WatchedEntry {
+public:
+			WatchedEntry(BMessenger *, entry_ref *);
+			~WatchedEntry();
+	bool		EntryCreated(entry_ref *ref);
+	bool		EntryRemoved(ino_t node);
+	bool		InitCheck();
+
+private:
+	BMessenger*	fMessenger;
+	node_ref	fNode;
+	bool		fIsDirectory;
+	USBDevice*	fDevice;
+	WatchedEntry*	fEntries;
+	WatchedEntry*	fLink;
+	bool		fInitCheck;
+};
+
+
+class RosterLooper : public BLooper {
+public:
+			RosterLooper(USBRoster *);
+	void		Stop();
+	virtual void	MessageReceived(BMessage *);
+	bool		InitCheck();
+
+private:
+	USBRoster*	fRoster;
+	WatchedEntry*	fRoot;
+	BMessenger*	fMessenger;
+	bool		fInitCheck;
+};
+
+
+WatchedEntry::WatchedEntry(BMessenger *messenger, entry_ref *ref)
+	:	fMessenger(messenger),
+		fIsDirectory(false),
+		fDevice(NULL),
+		fEntries(NULL),
+		fLink(NULL),
+		fInitCheck(false)
+{
+	BEntry entry(ref);
+	entry.GetNodeRef(&fNode);
+
+	BDirectory directory;
+	if (entry.IsDirectory() && directory.SetTo(ref) >= B_OK) {
+		fIsDirectory = true;
+
+		while (directory.GetNextEntry(&entry) >= B_OK) {
+			if (entry.GetRef(ref) < B_OK)
+				continue;
+
+			WatchedEntry *child = new(std::nothrow) WatchedEntry(fMessenger, ref);
+			if (child == NULL)
+				continue;
+			if (child->InitCheck() == false) {
+				delete child;
+				continue;
+			}
+
+			child->fLink = fEntries;
+			fEntries = child;
+		}
+
+		watch_node(&fNode, B_WATCH_DIRECTORY, *fMessenger);
+	}
+	else {
+		if (strncmp(ref->name, "raw", 3) == 0)
+			return;
+
+		BPath path, parent_path;
+		entry.GetPath(&path);
+		fDevice = new(std::nothrow) USBDevice(path.Path());
+		if (fDevice != NULL && fDevice->InitCheck() == true) {
+			// Add this new device to each active context's device list
+			struct libusb_context *ctx;
+			unsigned long session_id = (unsigned long)&fDevice;
+
+			usbi_mutex_lock(&active_contexts_lock);
+			for_each_context(ctx) {
+				struct libusb_device *dev = usbi_get_device_by_session_id(ctx, session_id);
+				if (dev) {
+					usbi_dbg(NULL, "using previously allocated device with location %lu", session_id);
+					libusb_unref_device(dev);
+					continue;
+				}
+				usbi_dbg(NULL, "allocating new device with location %lu", session_id);
+				dev = usbi_alloc_device(ctx, session_id);
+				if (!dev) {
+					usbi_dbg(NULL, "device allocation failed");
+					continue;
+				}
+				*((USBDevice **)usbi_get_device_priv(dev)) = fDevice;
+
+				// Calculate pseudo-device-address
+				int addr, tmp;
+				if (strcmp(path.Leaf(), "hub") == 0)
+					tmp = 100;	//Random Number
+				else
+					sscanf(path.Leaf(), "%d", &tmp);
+				addr = tmp + 1;
+				path.GetParent(&parent_path);
+				while (strcmp(parent_path.Leaf(), "usb") != 0) {
+					sscanf(parent_path.Leaf(), "%d", &tmp);
+					addr += tmp + 1;
+					parent_path.GetParent(&parent_path);
+				}
+				sscanf(path.Path(), "/dev/bus/usb/%hhu", &dev->bus_number);
+				dev->device_address = addr - (dev->bus_number + 1);
+
+				static_assert(sizeof(dev->device_descriptor) == sizeof(usb_device_descriptor),
+					      "mismatch between libusb and OS device descriptor sizes");
+				memcpy(&dev->device_descriptor, fDevice->Descriptor(), LIBUSB_DT_DEVICE_SIZE);
+				usbi_localize_device_descriptor(&dev->device_descriptor);
+
+				if (usbi_sanitize_device(dev) < 0) {
+					usbi_dbg(NULL, "device sanitization failed");
+					libusb_unref_device(dev);
+					continue;
+				}
+				usbi_connect_device(dev);
+			}
+			usbi_mutex_unlock(&active_contexts_lock);
+		}
+		else if (fDevice) {
+			delete fDevice;
+			fDevice = NULL;
+			return;
+		}
+	}
+	fInitCheck = true;
+}
+
+
+WatchedEntry::~WatchedEntry()
+{
+	if (fIsDirectory) {
+		watch_node(&fNode, B_STOP_WATCHING, *fMessenger);
+
+		WatchedEntry *child = fEntries;
+		while (child) {
+			WatchedEntry *next = child->fLink;
+			delete child;
+			child = next;
+		}
+	}
+
+	if (fDevice) {
+		// Remove this device from each active context's device list
+		struct libusb_context *ctx;
+		struct libusb_device *dev;
+		unsigned long session_id = (unsigned long)&fDevice;
+
+		usbi_mutex_lock(&active_contexts_lock);
+		for_each_context(ctx) {
+			dev = usbi_get_device_by_session_id(ctx, session_id);
+			if (dev != NULL) {
+				usbi_disconnect_device(dev);
+				libusb_unref_device(dev);
+			} else {
+				usbi_dbg(ctx, "device with location %lu not found", session_id);
+			}
+		}
+		usbi_mutex_static_unlock(&active_contexts_lock);
+		delete fDevice;
+	}
+}
+
+
+bool
+WatchedEntry::EntryCreated(entry_ref *ref)
+{
+	if (!fIsDirectory)
+		return false;
+
+	if (ref->directory != fNode.node) {
+		WatchedEntry *child = fEntries;
+		while (child) {
+			if (child->EntryCreated(ref))
+				return true;
+			child = child->fLink;
+		}
+		return false;
+	}
+
+	WatchedEntry *child = new(std::nothrow) WatchedEntry(fMessenger, ref);
+	if (child == NULL)
+		return false;
+	child->fLink = fEntries;
+	fEntries = child;
+	return true;
+}
+
+
+bool
+WatchedEntry::EntryRemoved(ino_t node)
+{
+	if (!fIsDirectory)
+		return false;
+
+	WatchedEntry *child = fEntries;
+	WatchedEntry *lastChild = NULL;
+	while (child) {
+		if (child->fNode.node == node) {
+			if (lastChild)
+				lastChild->fLink = child->fLink;
+			else
+				fEntries = child->fLink;
+			delete child;
+			return true;
+		}
+
+		if (child->EntryRemoved(node))
+			return true;
+
+		lastChild = child;
+		child = child->fLink;
+	}
+	return false;
+}
+
+
+bool
+WatchedEntry::InitCheck()
+{
+	return fInitCheck;
+}
+
+
+RosterLooper::RosterLooper(USBRoster *roster)
+	:	BLooper("LibusbRoster Looper"),
+		fRoster(roster),
+		fRoot(NULL),
+		fMessenger(NULL),
+		fInitCheck(false)
+{
+	BEntry entry("/dev/bus/usb");
+	if (!entry.Exists()) {
+		usbi_err(NULL, "usb_raw not published");
+		return;
+	}
+
+	Run();
+	fMessenger = new(std::nothrow) BMessenger(this);
+	if (fMessenger == NULL) {
+		usbi_err(NULL, "error creating BMessenger object");
+		return;
+	}
+
+	if (Lock()) {
+		entry_ref ref;
+		entry.GetRef(&ref);
+		fRoot = new(std::nothrow) WatchedEntry(fMessenger, &ref);
+		Unlock();
+		if (fRoot == NULL)
+			return;
+		if (fRoot->InitCheck() == false) {
+			delete fRoot;
+			fRoot = NULL;
+			return;
+		}
+	}
+	fInitCheck = true;
+}
+
+
+void
+RosterLooper::Stop()
+{
+	Lock();
+	delete fRoot;
+	delete fMessenger;
+	Quit();
+}
+
+
+void
+RosterLooper::MessageReceived(BMessage *message)
+{
+	int32 opcode;
+	if (message->FindInt32("opcode", &opcode) < B_OK)
+		return;
+
+	switch (opcode) {
+		case B_ENTRY_CREATED:
+		{
+			dev_t device;
+			ino_t directory;
+			const char *name;
+			if (message->FindInt32("device", &device) < B_OK ||
+				message->FindInt64("directory", &directory) < B_OK ||
+				message->FindString("name", &name) < B_OK)
+				break;
+
+			entry_ref ref(device, directory, name);
+			fRoot->EntryCreated(&ref);
+			break;
+		}
+		case B_ENTRY_REMOVED:
+		{
+			ino_t node;
+			if (message->FindInt64("node", &node) < B_OK)
+				break;
+			fRoot->EntryRemoved(node);
+			break;
+		}
+	}
+}
+
+
+bool
+RosterLooper::InitCheck()
+{
+	return fInitCheck;
+}
+
+
+USBRoster::USBRoster()
+	:	fLooper(NULL)
+{
+}
+
+
+USBRoster::~USBRoster()
+{
+	Stop();
+}
+
+
+int
+USBRoster::Start()
+{
+	if (fLooper == NULL) {
+		fLooper = new(std::nothrow) RosterLooper(this);
+		if (fLooper == NULL || ((RosterLooper *)fLooper)->InitCheck() == false) {
+			if (fLooper)
+				fLooper = NULL;
+			return LIBUSB_ERROR_OTHER;
+		}
+	}
+	return LIBUSB_SUCCESS;
+}
+
+
+void
+USBRoster::Stop()
+{
+	if (fLooper) {
+		((RosterLooper *)fLooper)->Stop();
+		fLooper = NULL;
+	}
+}

deps/libusb/libusb/os/haiku_usb.h

@@ -0,0 +1,113 @@
+/*
+ * Haiku Backend for libusb
+ * Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
+ *
+ * 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 <List.h>
+#include <Locker.h>
+#include <Autolock.h>
+#include <USBKit.h>
+#include <map>
+#include "libusbi.h"
+#include "haiku_usb_raw.h"
+
+using namespace std;
+
+class USBDevice;
+class USBDeviceHandle;
+class USBTransfer;
+
+class USBDevice {
+public:
+						USBDevice(const char *);
+	virtual					~USBDevice();
+	const char*				Location() const;
+	uint8					CountConfigurations() const;
+	const usb_device_descriptor*		Descriptor() const;
+	const usb_configuration_descriptor*	ConfigurationDescriptor(uint8) const;
+	const usb_configuration_descriptor*	ActiveConfiguration() const;
+	uint8					EndpointToIndex(uint8) const;
+	uint8					EndpointToInterface(uint8) const;
+	int					ClaimInterface(uint8);
+	int					ReleaseInterface(uint8);
+	int					CheckInterfacesFree(uint8);
+	void					SetActiveConfiguration(uint8);
+	uint8					ActiveConfigurationIndex() const;
+	bool					InitCheck();
+private:
+	int					Initialise();
+	unsigned int				fClaimedInterfaces;	// Max Interfaces can be 32. Using a bitmask
+	usb_device_descriptor			fDeviceDescriptor;
+	unsigned char**				fConfigurationDescriptors;
+	uint8					fActiveConfiguration;
+	char*					fPath;
+	map<uint8,uint8>			fConfigToIndex;
+	map<uint8,uint8>*			fEndpointToIndex;
+	map<uint8,uint8>*			fEndpointToInterface;
+	bool					fInitCheck;
+};
+
+class USBDeviceHandle {
+public:
+				USBDeviceHandle(USBDevice *dev);
+	virtual			~USBDeviceHandle();
+	int			ClaimInterface(uint8);
+	int			ReleaseInterface(uint8);
+	int			SetConfiguration(uint8);
+	int			SetAltSetting(uint8, uint8);
+	int			ClearHalt(uint8);
+	status_t		SubmitTransfer(struct usbi_transfer *);
+	status_t		CancelTransfer(USBTransfer *);
+	bool			InitCheck();
+private:
+	int			fRawFD;
+	static status_t		TransfersThread(void *);
+	void			TransfersWorker();
+	USBDevice*		fUSBDevice;
+	unsigned int		fClaimedInterfaces;
+	BList			fTransfers;
+	BLocker			fTransfersLock;
+	sem_id			fTransfersSem;
+	thread_id		fTransfersThread;
+	bool			fInitCheck;
+};
+
+class USBTransfer {
+public:
+					USBTransfer(struct usbi_transfer *, USBDevice *);
+	virtual				~USBTransfer();
+	void				Do(int);
+	struct usbi_transfer*		UsbiTransfer();
+	void				SetCancelled();
+	bool				IsCancelled();
+private:
+	struct usbi_transfer*		fUsbiTransfer;
+	struct libusb_transfer*		fLibusbTransfer;
+	USBDevice*			fUSBDevice;
+	BLocker				fStatusLock;
+	bool				fCancelled;
+};
+
+class USBRoster {
+public:
+			USBRoster();
+	virtual		~USBRoster();
+	int		Start();
+	void		Stop();
+private:
+	void*		fLooper;
+};

deps/libusb/libusb/os/haiku_usb_backend.cpp

@@ -0,0 +1,532 @@
+/*
+ * Haiku Backend for libusb
+ * Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
+ *
+ * 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 <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <new>
+#include <vector>
+
+#include "haiku_usb.h"
+
+static int _errno_to_libusb(int status)
+{
+	return status;
+}
+
+USBTransfer::USBTransfer(struct usbi_transfer *itransfer, USBDevice *device)
+{
+	fUsbiTransfer = itransfer;
+	fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	fUSBDevice = device;
+	fCancelled = false;
+}
+
+USBTransfer::~USBTransfer()
+{
+}
+
+struct usbi_transfer *
+USBTransfer::UsbiTransfer()
+{
+	return fUsbiTransfer;
+}
+
+void
+USBTransfer::SetCancelled()
+{
+	fCancelled = true;
+}
+
+bool
+USBTransfer::IsCancelled()
+{
+	return fCancelled;
+}
+
+void
+USBTransfer::Do(int fRawFD)
+{
+	switch (fLibusbTransfer->type) {
+		case LIBUSB_TRANSFER_TYPE_CONTROL:
+		{
+			struct libusb_control_setup *setup = (struct libusb_control_setup *)fLibusbTransfer->buffer;
+			usb_raw_command command;
+			command.control.request_type = setup->bmRequestType;
+			command.control.request = setup->bRequest;
+			command.control.value = setup->wValue;
+			command.control.index = setup->wIndex;
+			command.control.length = setup->wLength;
+			command.control.data = fLibusbTransfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+			if (fCancelled)
+				break;
+			if (ioctl(fRawFD, B_USB_RAW_COMMAND_CONTROL_TRANSFER, &command, sizeof(command)) ||
+					command.control.status != B_USB_RAW_STATUS_SUCCESS) {
+				fUsbiTransfer->transferred = -1;
+				usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed control transfer");
+				break;
+			}
+			fUsbiTransfer->transferred = command.control.length;
+		}
+		break;
+		case LIBUSB_TRANSFER_TYPE_BULK:
+		case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		{
+			usb_raw_command command;
+			command.transfer.interface = fUSBDevice->EndpointToInterface(fLibusbTransfer->endpoint);
+			command.transfer.endpoint = fUSBDevice->EndpointToIndex(fLibusbTransfer->endpoint);
+			command.transfer.data = fLibusbTransfer->buffer;
+			command.transfer.length = fLibusbTransfer->length;
+			if (fCancelled)
+				break;
+			if (fLibusbTransfer->type == LIBUSB_TRANSFER_TYPE_BULK) {
+				if (ioctl(fRawFD, B_USB_RAW_COMMAND_BULK_TRANSFER, &command, sizeof(command)) ||
+						command.transfer.status != B_USB_RAW_STATUS_SUCCESS) {
+					fUsbiTransfer->transferred = -1;
+					usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed bulk transfer");
+					break;
+				}
+			}
+			else {
+				if (ioctl(fRawFD, B_USB_RAW_COMMAND_INTERRUPT_TRANSFER, &command, sizeof(command)) ||
+						command.transfer.status != B_USB_RAW_STATUS_SUCCESS) {
+					fUsbiTransfer->transferred = -1;
+					usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed interrupt transfer");
+					break;
+				}
+			}
+			fUsbiTransfer->transferred = command.transfer.length;
+		}
+		break;
+		// IsochronousTransfers not tested
+		case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		{
+			usb_raw_command command;
+			command.isochronous.interface = fUSBDevice->EndpointToInterface(fLibusbTransfer->endpoint);
+			command.isochronous.endpoint = fUSBDevice->EndpointToIndex(fLibusbTransfer->endpoint);
+			command.isochronous.data = fLibusbTransfer->buffer;
+			command.isochronous.length = fLibusbTransfer->length;
+			command.isochronous.packet_count = fLibusbTransfer->num_iso_packets;
+			int i;
+			usb_iso_packet_descriptor *packetDescriptors = new usb_iso_packet_descriptor[fLibusbTransfer->num_iso_packets];
+			for (i = 0; i < fLibusbTransfer->num_iso_packets; i++) {
+				if ((fLibusbTransfer->iso_packet_desc[i]).length > (unsigned int)INT16_MAX) {
+					fUsbiTransfer->transferred = -1;
+					usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed isochronous transfer");
+					break;
+				}
+				packetDescriptors[i].request_length = (int16)(fLibusbTransfer->iso_packet_desc[i]).length;
+			}
+			if (i < fLibusbTransfer->num_iso_packets)
+				break;	// TODO Handle this error
+			command.isochronous.packet_descriptors = packetDescriptors;
+			if (fCancelled)
+				break;
+			if (ioctl(fRawFD, B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER, &command, sizeof(command)) ||
+					command.isochronous.status != B_USB_RAW_STATUS_SUCCESS) {
+				fUsbiTransfer->transferred = -1;
+				usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed isochronous transfer");
+				break;
+			}
+			for (i = 0; i < fLibusbTransfer->num_iso_packets; i++) {
+				(fLibusbTransfer->iso_packet_desc[i]).actual_length = packetDescriptors[i].actual_length;
+				switch (packetDescriptors[i].status) {
+					case B_OK:
+						(fLibusbTransfer->iso_packet_desc[i]).status = LIBUSB_TRANSFER_COMPLETED;
+						break;
+					default:
+						(fLibusbTransfer->iso_packet_desc[i]).status = LIBUSB_TRANSFER_ERROR;
+						break;
+				}
+			}
+			delete[] packetDescriptors;
+			// Do we put the length of transfer here, for isochronous transfers?
+			fUsbiTransfer->transferred = command.transfer.length;
+		}
+		break;
+		default:
+			usbi_err(TRANSFER_CTX(fLibusbTransfer), "Unknown type of transfer");
+	}
+}
+
+bool
+USBDeviceHandle::InitCheck()
+{
+	return fInitCheck;
+}
+
+status_t
+USBDeviceHandle::TransfersThread(void *self)
+{
+	USBDeviceHandle *handle = (USBDeviceHandle *)self;
+	handle->TransfersWorker();
+	return B_OK;
+}
+
+void
+USBDeviceHandle::TransfersWorker()
+{
+	while (true) {
+		status_t status = acquire_sem(fTransfersSem);
+		if (status == B_BAD_SEM_ID)
+			break;
+		if (status == B_INTERRUPTED)
+			continue;
+		fTransfersLock.Lock();
+		USBTransfer *fPendingTransfer = (USBTransfer *) fTransfers.RemoveItem((int32)0);
+		fTransfersLock.Unlock();
+		fPendingTransfer->Do(fRawFD);
+		usbi_signal_transfer_completion(fPendingTransfer->UsbiTransfer());
+	}
+}
+
+status_t
+USBDeviceHandle::SubmitTransfer(struct usbi_transfer *itransfer)
+{
+	USBTransfer *transfer = new USBTransfer(itransfer, fUSBDevice);
+	*((USBTransfer **)usbi_get_transfer_priv(itransfer)) = transfer;
+	BAutolock locker(fTransfersLock);
+	fTransfers.AddItem(transfer);
+	release_sem(fTransfersSem);
+	return LIBUSB_SUCCESS;
+}
+
+status_t
+USBDeviceHandle::CancelTransfer(USBTransfer *transfer)
+{
+	transfer->SetCancelled();
+	fTransfersLock.Lock();
+	bool removed = fTransfers.RemoveItem(transfer);
+	fTransfersLock.Unlock();
+	if (removed)
+		usbi_signal_transfer_completion(transfer->UsbiTransfer());
+	return LIBUSB_SUCCESS;
+}
+
+USBDeviceHandle::USBDeviceHandle(USBDevice *dev)
+	:
+	fUSBDevice(dev),
+	fClaimedInterfaces(0),
+	fTransfersThread(-1),
+	fInitCheck(false)
+{
+	fRawFD = open(dev->Location(), O_RDWR | O_CLOEXEC);
+	if (fRawFD < 0) {
+		usbi_err(NULL,"failed to open device");
+		return;
+	}
+	fTransfersSem = create_sem(0, "Transfers Queue Sem");
+	fTransfersThread = spawn_thread(TransfersThread, "Transfer Worker", B_NORMAL_PRIORITY, this);
+	resume_thread(fTransfersThread);
+	fInitCheck = true;
+}
+
+USBDeviceHandle::~USBDeviceHandle()
+{
+	if (fRawFD > 0)
+		close(fRawFD);
+	for (int i = 0; i < 32; i++) {
+		if (fClaimedInterfaces & (1U << i))
+			ReleaseInterface(i);
+	}
+	delete_sem(fTransfersSem);
+	if (fTransfersThread > 0)
+		wait_for_thread(fTransfersThread, NULL);
+}
+
+int
+USBDeviceHandle::ClaimInterface(uint8 inumber)
+{
+	int status = fUSBDevice->ClaimInterface(inumber);
+	if (status == LIBUSB_SUCCESS)
+		fClaimedInterfaces |= (1U << inumber);
+	return status;
+}
+
+int
+USBDeviceHandle::ReleaseInterface(uint8 inumber)
+{
+	fUSBDevice->ReleaseInterface(inumber);
+	fClaimedInterfaces &= ~(1U << inumber);
+	return LIBUSB_SUCCESS;
+}
+
+int
+USBDeviceHandle::SetConfiguration(uint8 config)
+{
+	int config_index = fUSBDevice->CheckInterfacesFree(config);
+	if (config_index == LIBUSB_ERROR_BUSY || config_index == LIBUSB_ERROR_NOT_FOUND)
+		return config_index;
+	usb_raw_command command;
+	command.config.config_index = config_index;
+	if (ioctl(fRawFD, B_USB_RAW_COMMAND_SET_CONFIGURATION, &command, sizeof(command)) ||
+			command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+		return _errno_to_libusb(command.config.status);
+	}
+	fUSBDevice->SetActiveConfiguration((uint8)config_index);
+	return LIBUSB_SUCCESS;
+}
+
+int
+USBDeviceHandle::SetAltSetting(uint8 inumber, uint8 alt)
+{
+	usb_raw_command command;
+	command.alternate.config_index = fUSBDevice->ActiveConfigurationIndex();
+	command.alternate.interface_index = inumber;
+	if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ACTIVE_ALT_INTERFACE_INDEX, &command, sizeof(command)) ||
+			command.alternate.status != B_USB_RAW_STATUS_SUCCESS) {
+		usbi_err(NULL, "Error retrieving active alternate interface");
+		return _errno_to_libusb(command.alternate.status);
+	}
+	if (command.alternate.alternate_info == (uint32)alt) {
+		usbi_dbg(NULL, "Setting alternate interface successful");
+		return LIBUSB_SUCCESS;
+	}
+	command.alternate.alternate_info = alt;
+	if (ioctl(fRawFD, B_USB_RAW_COMMAND_SET_ALT_INTERFACE, &command, sizeof(command)) ||
+			command.alternate.status != B_USB_RAW_STATUS_SUCCESS) { //IF IOCTL FAILS DEVICE DISCONNECTED PROBABLY
+		usbi_err(NULL, "Error setting alternate interface");
+		return _errno_to_libusb(command.alternate.status);
+	}
+	usbi_dbg(NULL, "Setting alternate interface successful");
+	return LIBUSB_SUCCESS;
+}
+
+int
+USBDeviceHandle::ClearHalt(uint8 endpoint)
+{
+	usb_raw_command command;
+	command.control.request_type = USB_REQTYPE_ENDPOINT_OUT;
+	command.control.request = USB_REQUEST_CLEAR_FEATURE;
+	command.control.value = USB_FEATURE_ENDPOINT_HALT;
+	command.control.index = endpoint;
+	command.control.length = 0;
+
+	if (ioctl(fRawFD, B_USB_RAW_COMMAND_CONTROL_TRANSFER, &command, sizeof(command)) ||
+			command.control.status != B_USB_RAW_STATUS_SUCCESS) {
+		return _errno_to_libusb(command.control.status);
+	}
+	return LIBUSB_SUCCESS;
+}
+
+
+USBDevice::USBDevice(const char *path)
+	:
+	fClaimedInterfaces(0),
+	fConfigurationDescriptors(NULL),
+	fActiveConfiguration(0),	//0?
+	fPath(NULL),
+	fEndpointToIndex(NULL),
+	fEndpointToInterface(NULL),
+	fInitCheck(false)
+{
+	fPath=strdup(path);
+	Initialise();
+}
+
+USBDevice::~USBDevice()
+{
+	free(fPath);
+	if (fConfigurationDescriptors) {
+		for (uint8 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
+			if (fConfigurationDescriptors[i])
+				delete fConfigurationDescriptors[i];
+		}
+		delete[] fConfigurationDescriptors;
+	}
+	if (fEndpointToIndex)
+		delete[] fEndpointToIndex;
+	if (fEndpointToInterface)
+		delete[] fEndpointToInterface;
+}
+
+bool
+USBDevice::InitCheck()
+{
+	return fInitCheck;
+}
+
+const char *
+USBDevice::Location() const
+{
+	return fPath;
+}
+
+uint8
+USBDevice::CountConfigurations() const
+{
+	return fDeviceDescriptor.num_configurations;
+}
+
+const usb_device_descriptor *
+USBDevice::Descriptor() const
+{
+	return &fDeviceDescriptor;
+}
+
+const usb_configuration_descriptor *
+USBDevice::ConfigurationDescriptor(uint8 index) const
+{
+	if (index > CountConfigurations())
+		return NULL;
+	return (usb_configuration_descriptor *) fConfigurationDescriptors[index];
+}
+
+const usb_configuration_descriptor *
+USBDevice::ActiveConfiguration() const
+{
+	return (usb_configuration_descriptor *) fConfigurationDescriptors[fActiveConfiguration];
+}
+
+uint8
+USBDevice::ActiveConfigurationIndex() const
+{
+	return fActiveConfiguration;
+}
+
+int USBDevice::ClaimInterface(uint8 interface)
+{
+	if (interface > ActiveConfiguration()->number_interfaces)
+		return LIBUSB_ERROR_NOT_FOUND;
+	if (fClaimedInterfaces & (1U << interface))
+		return LIBUSB_ERROR_BUSY;
+	fClaimedInterfaces |= (1U << interface);
+	return LIBUSB_SUCCESS;
+}
+
+int USBDevice::ReleaseInterface(uint8 interface)
+{
+	fClaimedInterfaces &= ~(1U << interface);
+	return LIBUSB_SUCCESS;
+}
+
+int
+USBDevice::CheckInterfacesFree(uint8 config)
+{
+	if (fConfigToIndex.count(config) == 0)
+		return LIBUSB_ERROR_NOT_FOUND;
+	if (fClaimedInterfaces == 0)
+		return fConfigToIndex[config];
+	return LIBUSB_ERROR_BUSY;
+}
+
+void
+USBDevice::SetActiveConfiguration(uint8 config_index)
+{
+	fActiveConfiguration = config_index;
+}
+
+uint8
+USBDevice::EndpointToIndex(uint8 address) const
+{
+	return fEndpointToIndex[fActiveConfiguration][address];
+}
+
+uint8
+USBDevice::EndpointToInterface(uint8 address) const
+{
+	return fEndpointToInterface[fActiveConfiguration][address];
+}
+
+int
+USBDevice::Initialise()		//Do we need more error checking, etc? How to report?
+{
+	int fRawFD = open(fPath, O_RDWR | O_CLOEXEC);
+	if (fRawFD < 0)
+		return B_ERROR;
+	usb_raw_command command;
+	command.device.descriptor = &fDeviceDescriptor;
+	if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR, &command, sizeof(command)) ||
+			command.device.status != B_USB_RAW_STATUS_SUCCESS) {
+		close(fRawFD);
+		return B_ERROR;
+	}
+
+	fConfigurationDescriptors = new(std::nothrow) unsigned char *[fDeviceDescriptor.num_configurations];
+	fEndpointToIndex = new(std::nothrow) map<uint8,uint8> [fDeviceDescriptor.num_configurations];
+	fEndpointToInterface = new(std::nothrow) map<uint8,uint8> [fDeviceDescriptor.num_configurations];
+	for (uint8 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
+		usb_configuration_descriptor tmp_config;
+		command.config.descriptor = &tmp_config;
+		command.config.config_index = i;
+		if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR, &command, sizeof(command)) ||
+				command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+			usbi_err(NULL, "failed retrieving configuration descriptor");
+			close(fRawFD);
+			return B_ERROR;
+		}
+		fConfigToIndex[tmp_config.configuration_value] = i;
+		fConfigurationDescriptors[i] = new(std::nothrow) unsigned char[tmp_config.total_length];
+
+		command.config_etc.descriptor = (usb_configuration_descriptor*)fConfigurationDescriptors[i];
+		command.config_etc.length = tmp_config.total_length;
+		command.config_etc.config_index = i;
+		if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR_ETC, &command, sizeof(command)) ||
+				command.config_etc.status != B_USB_RAW_STATUS_SUCCESS) {
+			usbi_err(NULL, "failed retrieving full configuration descriptor");
+			close(fRawFD);
+			return B_ERROR;
+		}
+
+		for (uint8 j = 0; j < tmp_config.number_interfaces; j++) {
+			command.alternate.config_index = i;
+			command.alternate.interface_index = j;
+			if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT, &command, sizeof(command)) ||
+					command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+				usbi_err(NULL, "failed retrieving number of alternate interfaces");
+				close(fRawFD);
+				return B_ERROR;
+			}
+			uint8 num_alternate = (uint8)command.alternate.alternate_info;
+			for (uint8 k = 0; k < num_alternate; k++) {
+				usb_interface_descriptor tmp_interface;
+				command.interface_etc.config_index = i;
+				command.interface_etc.interface_index = j;
+				command.interface_etc.alternate_index = k;
+				command.interface_etc.descriptor = &tmp_interface;
+				if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR_ETC, &command, sizeof(command)) ||
+						command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+					usbi_err(NULL, "failed retrieving interface descriptor");
+					close(fRawFD);
+					return B_ERROR;
+				}
+				for (uint8 l = 0; l < tmp_interface.num_endpoints; l++) {
+					usb_endpoint_descriptor tmp_endpoint;
+					command.endpoint_etc.config_index = i;
+					command.endpoint_etc.interface_index = j;
+					command.endpoint_etc.alternate_index = k;
+					command.endpoint_etc.endpoint_index = l;
+					command.endpoint_etc.descriptor = &tmp_endpoint;
+					if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR_ETC, &command, sizeof(command)) ||
+							command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+						usbi_err(NULL, "failed retrieving endpoint descriptor");
+						close(fRawFD);
+						return B_ERROR;
+					}
+					fEndpointToIndex[i][tmp_endpoint.endpoint_address] = l;
+					fEndpointToInterface[i][tmp_endpoint.endpoint_address] = j;
+				}
+			}
+		}
+	}
+	close(fRawFD);
+	fInitCheck = true;
+	return B_OK;
+}

deps/libusb/libusb/os/haiku_usb_raw.cpp

@@ -0,0 +1,231 @@
+/*
+ * Haiku Backend for libusb
+ * Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
+ *
+ * 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 <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <new>
+#include <vector>
+
+#include "haiku_usb.h"
+
+USBRoster gUsbRoster;
+int32 gInitCount = 0;
+
+static int haiku_get_config_descriptor(struct libusb_device *, uint8_t,
+    void *, size_t);
+
+static int
+haiku_init(struct libusb_context *ctx)
+{
+	UNUSED(ctx);
+	if (atomic_add(&gInitCount, 1) == 0)
+		return gUsbRoster.Start();
+	return LIBUSB_SUCCESS;
+}
+
+static void
+haiku_exit(struct libusb_context *ctx)
+{
+	UNUSED(ctx);
+	if (atomic_add(&gInitCount, -1) == 1)
+		gUsbRoster.Stop();
+}
+
+static int
+haiku_open(struct libusb_device_handle *dev_handle)
+{
+	USBDevice *dev = *((USBDevice **)usbi_get_device_priv(dev_handle->dev));
+	USBDeviceHandle *handle = new(std::nothrow) USBDeviceHandle(dev);
+	if (handle == NULL)
+		return LIBUSB_ERROR_NO_MEM;
+	if (handle->InitCheck() == false) {
+		delete handle;
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+	*((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle)) = handle;
+	return LIBUSB_SUCCESS;
+}
+
+static void
+haiku_close(struct libusb_device_handle *dev_handle)
+{
+	USBDeviceHandle **pHandle = (USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle);
+	USBDeviceHandle *handle = *pHandle;
+	if (handle == NULL)
+		return;
+	delete handle;
+	*pHandle = NULL;
+}
+
+static int
+haiku_get_active_config_descriptor(struct libusb_device *device, void *buffer, size_t len)
+{
+	USBDevice *dev = *((USBDevice **)usbi_get_device_priv(device));
+	return haiku_get_config_descriptor(device, dev->ActiveConfigurationIndex(), buffer, len);
+}
+
+static int
+haiku_get_config_descriptor(struct libusb_device *device, uint8_t config_index, void *buffer, size_t len)
+{
+	USBDevice *dev = *((USBDevice **)usbi_get_device_priv(device));
+	const usb_configuration_descriptor *config = dev->ConfigurationDescriptor(config_index);
+	if (config == NULL) {
+		usbi_err(DEVICE_CTX(device), "failed getting configuration descriptor");
+		return LIBUSB_ERROR_IO;
+	}
+	if (len > config->total_length) {
+		len = config->total_length;
+	}
+	memcpy(buffer, config, len);
+	return len;
+}
+
+static int
+haiku_set_configuration(struct libusb_device_handle *dev_handle, int config)
+{
+	USBDeviceHandle *handle= *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	if (config <= 0)
+		return LIBUSB_ERROR_NOT_SUPPORTED;	// cannot unconfigure
+	return handle->SetConfiguration((uint8)config);
+}
+
+static int
+haiku_claim_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	return handle->ClaimInterface(interface_number);
+}
+
+static int
+haiku_set_altsetting(struct libusb_device_handle *dev_handle, uint8_t interface_number, uint8_t altsetting)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	return handle->SetAltSetting(interface_number, altsetting);
+}
+
+static int
+haiku_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	return handle->ClearHalt(endpoint);
+}
+
+static int
+haiku_release_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	haiku_set_altsetting(dev_handle, interface_number, 0);
+	return handle->ReleaseInterface(interface_number);
+}
+
+static int
+haiku_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)usbi_get_device_handle_priv(fLibusbTransfer->dev_handle));
+	return fDeviceHandle->SubmitTransfer(itransfer);
+}
+
+static int
+haiku_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)usbi_get_device_handle_priv(fLibusbTransfer->dev_handle));
+	return fDeviceHandle->CancelTransfer(*((USBTransfer **)usbi_get_transfer_priv(itransfer)));
+}
+
+static int
+haiku_handle_transfer_completion(struct usbi_transfer *itransfer)
+{
+	USBTransfer **pTransfer = (USBTransfer **)usbi_get_transfer_priv(itransfer);
+	USBTransfer *transfer = *pTransfer;
+
+	usbi_mutex_lock(&itransfer->lock);
+	if (transfer->IsCancelled()) {
+		delete transfer;
+		*pTransfer = NULL;
+		usbi_mutex_unlock(&itransfer->lock);
+		if (itransfer->transferred < 0)
+			itransfer->transferred = 0;
+		return usbi_handle_transfer_cancellation(itransfer);
+	}
+	libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
+	if (itransfer->transferred < 0) {
+		usbi_err(ITRANSFER_CTX(itransfer), "error in transfer");
+		status = LIBUSB_TRANSFER_ERROR;
+		itransfer->transferred = 0;
+	}
+	delete transfer;
+	*pTransfer = NULL;
+	usbi_mutex_unlock(&itransfer->lock);
+	return usbi_handle_transfer_completion(itransfer, status);
+}
+
+const struct usbi_os_backend usbi_backend = {
+	/*.name =*/ "Haiku usbfs",
+	/*.caps =*/ 0,
+	/*.init =*/ haiku_init,
+	/*.exit =*/ haiku_exit,
+	/*.set_option =*/ NULL,
+	/*.get_device_list =*/ NULL,
+	/*.hotplug_poll =*/ NULL,
+	/*.wrap_sys_device =*/ NULL,
+	/*.open =*/ haiku_open,
+	/*.close =*/ haiku_close,
+
+	/*.get_active_config_descriptor =*/ haiku_get_active_config_descriptor,
+	/*.get_config_descriptor =*/ haiku_get_config_descriptor,
+	/*.get_config_descriptor_by_value =*/ NULL,
+
+	/*.get_configuration =*/ NULL,
+	/*.set_configuration =*/ haiku_set_configuration,
+
+	/*.claim_interface =*/ haiku_claim_interface,
+	/*.release_interface =*/ haiku_release_interface,
+	/*.set_interface_altsetting =*/ haiku_set_altsetting,
+
+	/*.clear_halt =*/ haiku_clear_halt,
+	/*.reset_device =*/ NULL,
+
+	/*.alloc_streams =*/ NULL,
+	/*.free_streams =*/ NULL,
+
+	/*.dev_mem_alloc =*/ NULL,
+	/*.dev_mem_free =*/ NULL,
+
+	/*.kernel_driver_active =*/ NULL,
+	/*.detach_kernel_driver =*/ NULL,
+	/*.attach_kernel_driver =*/ NULL,
+
+	/*.destroy_device =*/ NULL,
+
+	/*.submit_transfer =*/ haiku_submit_transfer,
+	/*.cancel_transfer =*/ haiku_cancel_transfer,
+	/*.clear_transfer_priv =*/ NULL,
+
+	/*.handle_events =*/ NULL,
+	/*.handle_transfer_completion =*/ haiku_handle_transfer_completion,
+
+	/*.context_priv_size =*/ 0,
+	/*.device_priv_size =*/ sizeof(USBDevice *),
+	/*.device_handle_priv_size =*/ sizeof(USBDeviceHandle *),
+	/*.transfer_priv_size =*/ sizeof(USBTransfer *),
+};

deps/libusb/libusb/os/haiku_usb_raw.h

@@ -0,0 +1,188 @@
+/*
+ * Copyright 2006-2008, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#ifndef _USB_RAW_H_
+#define _USB_RAW_H_
+
+#include <USB3.h>
+
+#define B_USB_RAW_PROTOCOL_VERSION	0x0015
+#define B_USB_RAW_ACTIVE_ALTERNATE	0xffffffff
+
+typedef enum {
+	B_USB_RAW_COMMAND_GET_VERSION = 0x1000,
+
+	B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR = 0x2000,
+	B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_STRING_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT,
+	B_USB_RAW_COMMAND_GET_ACTIVE_ALT_INTERFACE_INDEX,
+	B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR_ETC,
+	B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR_ETC,
+	B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR_ETC,
+	B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR_ETC,
+
+	B_USB_RAW_COMMAND_SET_CONFIGURATION = 0x3000,
+	B_USB_RAW_COMMAND_SET_FEATURE,
+	B_USB_RAW_COMMAND_CLEAR_FEATURE,
+	B_USB_RAW_COMMAND_GET_STATUS,
+	B_USB_RAW_COMMAND_GET_DESCRIPTOR,
+	B_USB_RAW_COMMAND_SET_ALT_INTERFACE,
+
+	B_USB_RAW_COMMAND_CONTROL_TRANSFER = 0x4000,
+	B_USB_RAW_COMMAND_INTERRUPT_TRANSFER,
+	B_USB_RAW_COMMAND_BULK_TRANSFER,
+	B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER
+} usb_raw_command_id;
+
+
+typedef enum {
+	B_USB_RAW_STATUS_SUCCESS = 0,
+
+	B_USB_RAW_STATUS_FAILED,
+	B_USB_RAW_STATUS_ABORTED,
+	B_USB_RAW_STATUS_STALLED,
+	B_USB_RAW_STATUS_CRC_ERROR,
+	B_USB_RAW_STATUS_TIMEOUT,
+
+	B_USB_RAW_STATUS_INVALID_CONFIGURATION,
+	B_USB_RAW_STATUS_INVALID_INTERFACE,
+	B_USB_RAW_STATUS_INVALID_ENDPOINT,
+	B_USB_RAW_STATUS_INVALID_STRING,
+
+	B_USB_RAW_STATUS_NO_MEMORY
+} usb_raw_command_status;
+
+
+typedef union {
+	struct {
+		status_t status;
+	} version;
+
+	struct {
+		status_t status;
+		usb_device_descriptor *descriptor;
+	} device;
+
+	struct {
+		status_t status;
+		usb_configuration_descriptor *descriptor;
+		uint32 config_index;
+	} config;
+
+	struct {
+		status_t status;
+		usb_configuration_descriptor *descriptor;
+		uint32 config_index;
+		size_t length;
+	} config_etc;
+
+	struct {
+		status_t status;
+		uint32 alternate_info;
+		uint32 config_index;
+		uint32 interface_index;
+	} alternate;
+
+	struct {
+		status_t status;
+		usb_interface_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+	} interface;
+
+	struct {
+		status_t status;
+		usb_interface_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 alternate_index;
+	} interface_etc;
+
+	struct {
+		status_t status;
+		usb_endpoint_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 endpoint_index;
+	} endpoint;
+
+	struct {
+		status_t status;
+		usb_endpoint_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 alternate_index;
+		uint32 endpoint_index;
+	} endpoint_etc;
+
+	struct {
+		status_t status;
+		usb_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 generic_index;
+		size_t length;
+	} generic;
+
+	struct {
+		status_t status;
+		usb_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 alternate_index;
+		uint32 generic_index;
+		size_t length;
+	} generic_etc;
+
+	struct {
+		status_t status;
+		usb_string_descriptor *descriptor;
+		uint32 string_index;
+		size_t length;
+	} string;
+
+	struct {
+		status_t status;
+		uint8 type;
+		uint8 index;
+		uint16 language_id;
+		void *data;
+		size_t length;
+	} descriptor;
+
+	struct {
+		status_t status;
+		uint8 request_type;
+		uint8 request;
+		uint16 value;
+		uint16 index;
+		uint16 length;
+		void *data;
+	} control;
+
+	struct {
+		status_t status;
+		uint32 interface;
+		uint32 endpoint;
+		void *data;
+		size_t length;
+	} transfer;
+
+	struct {
+		status_t status;
+		uint32 interface;
+		uint32 endpoint;
+		void *data;
+		size_t length;
+		usb_iso_packet_descriptor *packet_descriptors;
+		uint32 packet_count;
+	} isochronous;
+} usb_raw_command;
+
+#endif // _USB_RAW_H_

deps/libusb/libusb/os/linux_netlink.c

@@ -0,0 +1,401 @@
+/* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
+/*
+ * Linux usbfs backend for libusb
+ * Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright (c) 2013 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright (c) 2016 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * 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 "libusbi.h"
+#include "linux_usbfs.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <pthread.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifdef HAVE_ASM_TYPES_H
+#include <asm/types.h>
+#endif
+#include <sys/socket.h>
+#include <linux/netlink.h>
+
+#define NL_GROUP_KERNEL 1
+
+#ifndef SOCK_CLOEXEC
+#define SOCK_CLOEXEC	0
+#endif
+
+#ifndef SOCK_NONBLOCK
+#define SOCK_NONBLOCK	0
+#endif
+
+static int linux_netlink_socket = -1;
+static usbi_event_t netlink_control_event = USBI_INVALID_EVENT;
+static pthread_t libusb_linux_event_thread;
+
+static void *linux_netlink_event_thread_main(void *arg);
+
+static int set_fd_cloexec_nb(int fd, int socktype)
+{
+	int flags;
+
+#if defined(FD_CLOEXEC)
+	/* Make sure the netlink socket file descriptor is marked as CLOEXEC */
+	if (!(socktype & SOCK_CLOEXEC)) {
+		flags = fcntl(fd, F_GETFD);
+		if (flags == -1) {
+			usbi_err(NULL, "failed to get netlink fd flags, errno=%d", errno);
+			return -1;
+		}
+
+		if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {
+			usbi_err(NULL, "failed to set netlink fd flags, errno=%d", errno);
+			return -1;
+		}
+	}
+#endif
+
+	/* Make sure the netlink socket is non-blocking */
+	if (!(socktype & SOCK_NONBLOCK)) {
+		flags = fcntl(fd, F_GETFL);
+		if (flags == -1) {
+			usbi_err(NULL, "failed to get netlink fd status flags, errno=%d", errno);
+			return -1;
+		}
+
+		if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+			usbi_err(NULL, "failed to set netlink fd status flags, errno=%d", errno);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int linux_netlink_start_event_monitor(void)
+{
+	struct sockaddr_nl sa_nl = { .nl_family = AF_NETLINK, .nl_groups = NL_GROUP_KERNEL };
+	int socktype = SOCK_RAW | SOCK_NONBLOCK | SOCK_CLOEXEC;
+	int opt = 1;
+	int ret;
+
+	linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
+	if (linux_netlink_socket == -1 && errno == EINVAL) {
+		usbi_dbg(NULL, "failed to create netlink socket of type %d, attempting SOCK_RAW", socktype);
+		socktype = SOCK_RAW;
+		linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
+	}
+
+	if (linux_netlink_socket == -1) {
+		usbi_err(NULL, "failed to create netlink socket, errno=%d", errno);
+		goto err;
+	}
+
+	ret = set_fd_cloexec_nb(linux_netlink_socket, socktype);
+	if (ret == -1)
+		goto err_close_socket;
+
+	ret = bind(linux_netlink_socket, (struct sockaddr *)&sa_nl, sizeof(sa_nl));
+	if (ret == -1) {
+		usbi_err(NULL, "failed to bind netlink socket, errno=%d", errno);
+		goto err_close_socket;
+	}
+
+	ret = setsockopt(linux_netlink_socket, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(opt));
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set netlink socket SO_PASSCRED option, errno=%d", errno);
+		goto err_close_socket;
+	}
+
+	ret = usbi_create_event(&netlink_control_event);
+	if (ret) {
+		usbi_err(NULL, "failed to create netlink control event");
+		goto err_close_socket;
+	}
+
+	ret = pthread_create(&libusb_linux_event_thread, NULL, linux_netlink_event_thread_main, NULL);
+	if (ret != 0) {
+		usbi_err(NULL, "failed to create netlink event thread (%d)", ret);
+		goto err_destroy_event;
+	}
+
+	return LIBUSB_SUCCESS;
+
+err_destroy_event:
+	usbi_destroy_event(&netlink_control_event);
+	netlink_control_event = (usbi_event_t)USBI_INVALID_EVENT;
+err_close_socket:
+	close(linux_netlink_socket);
+	linux_netlink_socket = -1;
+err:
+	return LIBUSB_ERROR_OTHER;
+}
+
+int linux_netlink_stop_event_monitor(void)
+{
+	int ret;
+
+	assert(linux_netlink_socket != -1);
+
+	/* Signal the control event and wait for the thread to exit */
+	usbi_signal_event(&netlink_control_event);
+
+	ret = pthread_join(libusb_linux_event_thread, NULL);
+	if (ret)
+		usbi_warn(NULL, "failed to join netlink event thread (%d)", ret);
+
+	usbi_destroy_event(&netlink_control_event);
+	netlink_control_event = (usbi_event_t)USBI_INVALID_EVENT;
+
+	close(linux_netlink_socket);
+	linux_netlink_socket = -1;
+
+	return LIBUSB_SUCCESS;
+}
+
+static const char *netlink_message_parse(const char *buffer, size_t len, const char *key)
+{
+	const char *end = buffer + len;
+	size_t keylen = strlen(key);
+
+	while (buffer < end && *buffer) {
+		if (strncmp(buffer, key, keylen) == 0 && buffer[keylen] == '=')
+			return buffer + keylen + 1;
+		buffer += strlen(buffer) + 1;
+	}
+
+	return NULL;
+}
+
+/* parse parts of netlink message common to both libudev and the kernel */
+static int linux_netlink_parse(const char *buffer, size_t len, int *detached,
+	const char **sys_name, uint8_t *busnum, uint8_t *devaddr)
+{
+	const char *tmp, *slash;
+
+	errno = 0;
+
+	*sys_name = NULL;
+	*detached = 0;
+	*busnum   = 0;
+	*devaddr  = 0;
+
+	tmp = netlink_message_parse(buffer, len, "ACTION");
+	if (!tmp) {
+		return -1;
+	} else if (strcmp(tmp, "remove") == 0) {
+		*detached = 1;
+	} else if (strcmp(tmp, "add") != 0) {
+		usbi_dbg(NULL, "unknown device action %s", tmp);
+		return -1;
+	}
+
+	/* check that this is a usb message */
+	tmp = netlink_message_parse(buffer, len, "SUBSYSTEM");
+	if (!tmp || strcmp(tmp, "usb") != 0) {
+		/* not usb. ignore */
+		return -1;
+	}
+
+	/* check that this is an actual usb device */
+	tmp = netlink_message_parse(buffer, len, "DEVTYPE");
+	if (!tmp || strcmp(tmp, "usb_device") != 0) {
+		/* not usb. ignore */
+		return -1;
+	}
+
+	tmp = netlink_message_parse(buffer, len, "BUSNUM");
+	if (tmp) {
+		*busnum = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
+		if (errno) {
+			errno = 0;
+			return -1;
+		}
+
+		tmp = netlink_message_parse(buffer, len, "DEVNUM");
+		if (NULL == tmp)
+			return -1;
+
+		*devaddr = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
+		if (errno) {
+			errno = 0;
+			return -1;
+		}
+	} else {
+		/* no bus number. try "DEVICE" */
+		tmp = netlink_message_parse(buffer, len, "DEVICE");
+		if (!tmp) {
+			/* not usb. ignore */
+			return -1;
+		}
+
+		/* Parse a device path such as /dev/bus/usb/003/004 */
+		slash = strrchr(tmp, '/');
+		if (!slash)
+			return -1;
+
+		*busnum = (uint8_t)(strtoul(slash - 3, NULL, 10) & 0xff);
+		if (errno) {
+			errno = 0;
+			return -1;
+		}
+
+		*devaddr = (uint8_t)(strtoul(slash + 1, NULL, 10) & 0xff);
+		if (errno) {
+			errno = 0;
+			return -1;
+		}
+
+		return 0;
+	}
+
+	tmp = netlink_message_parse(buffer, len, "DEVPATH");
+	if (!tmp)
+		return -1;
+
+	slash = strrchr(tmp, '/');
+	if (slash)
+		*sys_name = slash + 1;
+
+	/* found a usb device */
+	return 0;
+}
+
+static int linux_netlink_read_message(void)
+{
+	char cred_buffer[CMSG_SPACE(sizeof(struct ucred))];
+	char msg_buffer[2048];
+	const char *sys_name = NULL;
+	uint8_t busnum, devaddr;
+	int detached, r;
+	ssize_t len;
+	struct cmsghdr *cmsg;
+	struct ucred *cred;
+	struct sockaddr_nl sa_nl;
+	struct iovec iov = { .iov_base = msg_buffer, .iov_len = sizeof(msg_buffer) };
+	struct msghdr msg = {
+		.msg_iov = &iov, .msg_iovlen = 1,
+		.msg_control = cred_buffer, .msg_controllen = sizeof(cred_buffer),
+		.msg_name = &sa_nl, .msg_namelen = sizeof(sa_nl)
+	};
+
+	/* read netlink message */
+	len = recvmsg(linux_netlink_socket, &msg, 0);
+	if (len == -1) {
+		if (errno != EAGAIN && errno != EINTR)
+			usbi_err(NULL, "error receiving message from netlink, errno=%d", errno);
+		return -1;
+	}
+
+	if (len < 32 || (msg.msg_flags & MSG_TRUNC)) {
+		usbi_err(NULL, "invalid netlink message length");
+		return -1;
+	}
+
+	if (sa_nl.nl_groups != NL_GROUP_KERNEL || sa_nl.nl_pid != 0) {
+		usbi_dbg(NULL, "ignoring netlink message from unknown group/PID (%u/%u)",
+			 (unsigned int)sa_nl.nl_groups, (unsigned int)sa_nl.nl_pid);
+		return -1;
+	}
+
+	cmsg = CMSG_FIRSTHDR(&msg);
+	if (!cmsg || cmsg->cmsg_type != SCM_CREDENTIALS) {
+		usbi_dbg(NULL, "ignoring netlink message with no sender credentials");
+		return -1;
+	}
+
+	cred = (struct ucred *)CMSG_DATA(cmsg);
+	if (cred->uid != 0) {
+		usbi_dbg(NULL, "ignoring netlink message with non-zero sender UID %u", (unsigned int)cred->uid);
+		return -1;
+	}
+
+	r = linux_netlink_parse(msg_buffer, (size_t)len, &detached, &sys_name, &busnum, &devaddr);
+	if (r)
+		return r;
+
+	usbi_dbg(NULL, "netlink hotplug found device busnum: %hhu, devaddr: %hhu, sys_name: %s, removed: %s",
+		 busnum, devaddr, sys_name, detached ? "yes" : "no");
+
+	/* signal device is available (or not) to all contexts */
+	if (detached)
+		linux_device_disconnected(busnum, devaddr);
+	else
+		linux_hotplug_enumerate(busnum, devaddr, sys_name);
+
+	return 0;
+}
+
+static void *linux_netlink_event_thread_main(void *arg)
+{
+	struct pollfd fds[] = {
+		{ .fd = USBI_EVENT_OS_HANDLE(&netlink_control_event),
+		  .events = USBI_EVENT_POLL_EVENTS },
+		{ .fd = linux_netlink_socket,
+		  .events = POLLIN },
+	};
+	int r;
+
+	UNUSED(arg);
+
+#if defined(HAVE_PTHREAD_SETNAME_NP)
+	r = pthread_setname_np(pthread_self(), "libusb_event");
+	if (r)
+		usbi_warn(NULL, "failed to set hotplug event thread name, error=%d", r);
+#endif
+
+	usbi_dbg(NULL, "netlink event thread entering");
+
+	while (1) {
+		r = poll(fds, 2, -1);
+		if (r == -1) {
+			/* check for temporary failure */
+			if (errno == EINTR)
+				continue;
+			usbi_err(NULL, "poll() failed, errno=%d", errno);
+			break;
+		}
+		if (fds[0].revents) {
+			/* activity on control event, exit */
+			break;
+		}
+		if (fds[1].revents) {
+			usbi_mutex_static_lock(&linux_hotplug_lock);
+			linux_netlink_read_message();
+			usbi_mutex_static_unlock(&linux_hotplug_lock);
+		}
+	}
+
+	usbi_dbg(NULL, "netlink event thread exiting");
+
+	return NULL;
+}
+
+void linux_netlink_hotplug_poll(void)
+{
+	int r;
+
+	usbi_mutex_static_lock(&linux_hotplug_lock);
+	do {
+		r = linux_netlink_read_message();
+	} while (r == 0);
+	usbi_mutex_static_unlock(&linux_hotplug_lock);
+}

deps/libusb/libusb/os/linux_udev.c

@@ -0,0 +1,321 @@
+/* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
+/*
+ * Linux usbfs backend for libusb
+ * Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright (c) 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
+ * 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 "libusbi.h"
+#include "linux_usbfs.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <libudev.h>
+#include <poll.h>
+#include <pthread.h>
+#include <string.h>
+#include <unistd.h>
+
+/* udev context */
+static struct udev *udev_ctx = NULL;
+static int udev_monitor_fd = -1;
+static usbi_event_t udev_control_event = USBI_INVALID_EVENT;
+static struct udev_monitor *udev_monitor = NULL;
+static pthread_t linux_event_thread;
+
+static void udev_hotplug_event(struct udev_device *udev_dev);
+static void *linux_udev_event_thread_main(void *arg);
+
+int linux_udev_start_event_monitor(void)
+{
+	int r;
+
+	assert(udev_ctx == NULL);
+	udev_ctx = udev_new();
+	if (!udev_ctx) {
+		usbi_err(NULL, "could not create udev context");
+		goto err;
+	}
+
+	udev_monitor = udev_monitor_new_from_netlink(udev_ctx, "udev");
+	if (!udev_monitor) {
+		usbi_err(NULL, "could not initialize udev monitor");
+		goto err_free_ctx;
+	}
+
+	r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", "usb_device");
+	if (r) {
+		usbi_err(NULL, "could not initialize udev monitor filter for \"usb\" subsystem");
+		goto err_free_monitor;
+	}
+
+	if (udev_monitor_enable_receiving(udev_monitor)) {
+		usbi_err(NULL, "failed to enable the udev monitor");
+		goto err_free_monitor;
+	}
+
+	udev_monitor_fd = udev_monitor_get_fd(udev_monitor);
+
+#if defined(FD_CLOEXEC)
+	/* Make sure the udev file descriptor is marked as CLOEXEC */
+	r = fcntl(udev_monitor_fd, F_GETFD);
+	if (r == -1) {
+		usbi_err(NULL, "failed to get udev monitor fd flags, errno=%d", errno);
+		goto err_free_monitor;
+	}
+	if (!(r & FD_CLOEXEC)) {
+		if (fcntl(udev_monitor_fd, F_SETFD, r | FD_CLOEXEC) == -1) {
+			usbi_err(NULL, "failed to set udev monitor fd flags, errno=%d", errno);
+			goto err_free_monitor;
+		}
+	}
+#endif
+
+	/* Some older versions of udev are not non-blocking by default,
+	 * so make sure this is set */
+	r = fcntl(udev_monitor_fd, F_GETFL);
+	if (r == -1) {
+		usbi_err(NULL, "failed to get udev monitor fd status flags, errno=%d", errno);
+		goto err_free_monitor;
+	}
+	if (!(r & O_NONBLOCK)) {
+		if (fcntl(udev_monitor_fd, F_SETFL, r | O_NONBLOCK) == -1) {
+			usbi_err(NULL, "failed to set udev monitor fd status flags, errno=%d", errno);
+			goto err_free_monitor;
+		}
+	}
+
+	r = usbi_create_event(&udev_control_event);
+	if (r) {
+		usbi_err(NULL, "failed to create udev control event");
+		goto err_free_monitor;
+	}
+
+	r = pthread_create(&linux_event_thread, NULL, linux_udev_event_thread_main, NULL);
+	if (r) {
+		usbi_err(NULL, "failed to create hotplug event thread (%d)", r);
+		goto err_destroy_event;
+	}
+
+	return LIBUSB_SUCCESS;
+
+err_destroy_event:
+	usbi_destroy_event(&udev_control_event);
+	udev_control_event = (usbi_event_t)USBI_INVALID_EVENT;
+err_free_monitor:
+	udev_monitor_unref(udev_monitor);
+	udev_monitor = NULL;
+	udev_monitor_fd = -1;
+err_free_ctx:
+	udev_unref(udev_ctx);
+err:
+	udev_ctx = NULL;
+	return LIBUSB_ERROR_OTHER;
+}
+
+int linux_udev_stop_event_monitor(void)
+{
+	int r;
+
+	assert(udev_ctx != NULL);
+	assert(udev_monitor != NULL);
+	assert(udev_monitor_fd != -1);
+
+	/* Signal the control event and wait for the thread to exit */
+	usbi_signal_event(&udev_control_event);
+
+	r = pthread_join(linux_event_thread, NULL);
+	if (r)
+		usbi_warn(NULL, "failed to join hotplug event thread (%d)", r);
+
+	usbi_destroy_event(&udev_control_event);
+	udev_control_event = (usbi_event_t)USBI_INVALID_EVENT;
+
+	/* Release the udev monitor */
+	udev_monitor_unref(udev_monitor);
+	udev_monitor = NULL;
+	udev_monitor_fd = -1;
+
+	/* Clean up the udev context */
+	udev_unref(udev_ctx);
+	udev_ctx = NULL;
+
+	return LIBUSB_SUCCESS;
+}
+
+static void *linux_udev_event_thread_main(void *arg)
+{
+	struct pollfd fds[] = {
+		{ .fd = USBI_EVENT_OS_HANDLE(&udev_control_event),
+		  .events = USBI_EVENT_POLL_EVENTS },
+		{ .fd = udev_monitor_fd,
+		  .events = POLLIN },
+	};
+	struct udev_device *udev_dev;
+	int r;
+
+	UNUSED(arg);
+
+#if defined(HAVE_PTHREAD_SETNAME_NP)
+	r = pthread_setname_np(pthread_self(), "libusb_event");
+	if (r)
+		usbi_warn(NULL, "failed to set hotplug event thread name, error=%d", r);
+#endif
+
+	usbi_dbg(NULL, "udev event thread entering");
+
+	while (1) {
+		r = poll(fds, 2, -1);
+		if (r == -1) {
+			/* check for temporary failure */
+			if (errno == EINTR)
+				continue;
+			usbi_err(NULL, "poll() failed, errno=%d", errno);
+			break;
+		}
+		if (fds[0].revents) {
+			/* activity on control event, exit */
+			break;
+		}
+		if (fds[1].revents) {
+			usbi_mutex_static_lock(&linux_hotplug_lock);
+			udev_dev = udev_monitor_receive_device(udev_monitor);
+			if (udev_dev)
+				udev_hotplug_event(udev_dev);
+			usbi_mutex_static_unlock(&linux_hotplug_lock);
+		}
+	}
+
+	usbi_dbg(NULL, "udev event thread exiting");
+
+	return NULL;
+}
+
+static int udev_device_info(struct libusb_context *ctx, int detached,
+			    struct udev_device *udev_dev, uint8_t *busnum,
+			    uint8_t *devaddr, const char **sys_name) {
+	const char *dev_node;
+
+	dev_node = udev_device_get_devnode(udev_dev);
+	if (!dev_node) {
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	*sys_name = udev_device_get_sysname(udev_dev);
+	if (!*sys_name) {
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return linux_get_device_address(ctx, detached, busnum, devaddr,
+					dev_node, *sys_name, -1);
+}
+
+static void udev_hotplug_event(struct udev_device *udev_dev)
+{
+	const char *udev_action;
+	const char *sys_name = NULL;
+	uint8_t busnum = 0, devaddr = 0;
+	int detached;
+	int r;
+
+	do {
+		udev_action = udev_device_get_action(udev_dev);
+		if (!udev_action) {
+			break;
+		}
+
+		detached = !strncmp(udev_action, "remove", 6);
+
+		r = udev_device_info(NULL, detached, udev_dev, &busnum, &devaddr, &sys_name);
+		if (LIBUSB_SUCCESS != r) {
+			break;
+		}
+
+		usbi_dbg(NULL, "udev hotplug event. action: %s.", udev_action);
+
+		if (strncmp(udev_action, "add", 3) == 0) {
+			linux_hotplug_enumerate(busnum, devaddr, sys_name);
+		} else if (detached) {
+			linux_device_disconnected(busnum, devaddr);
+		} else if (strncmp(udev_action, "bind", 4) == 0) {
+			/* silently ignore "known unhandled" action */
+		} else {
+			usbi_err(NULL, "ignoring udev action %s", udev_action);
+		}
+	} while (0);
+
+	udev_device_unref(udev_dev);
+}
+
+int linux_udev_scan_devices(struct libusb_context *ctx)
+{
+	struct udev_enumerate *enumerator;
+	struct udev_list_entry *devices, *entry;
+	struct udev_device *udev_dev;
+	const char *sys_name;
+	int r;
+
+	assert(udev_ctx != NULL);
+
+	enumerator = udev_enumerate_new(udev_ctx);
+	if (NULL == enumerator) {
+		usbi_err(ctx, "error creating udev enumerator");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	udev_enumerate_add_match_subsystem(enumerator, "usb");
+	udev_enumerate_add_match_property(enumerator, "DEVTYPE", "usb_device");
+	udev_enumerate_scan_devices(enumerator);
+	devices = udev_enumerate_get_list_entry(enumerator);
+
+	entry = NULL;
+	udev_list_entry_foreach(entry, devices) {
+		const char *path = udev_list_entry_get_name(entry);
+		uint8_t busnum = 0, devaddr = 0;
+
+		udev_dev = udev_device_new_from_syspath(udev_ctx, path);
+
+		r = udev_device_info(ctx, 0, udev_dev, &busnum, &devaddr, &sys_name);
+		if (r) {
+			udev_device_unref(udev_dev);
+			continue;
+		}
+
+		linux_enumerate_device(ctx, busnum, devaddr, sys_name);
+		udev_device_unref(udev_dev);
+	}
+
+	udev_enumerate_unref(enumerator);
+
+	return LIBUSB_SUCCESS;
+}
+
+void linux_udev_hotplug_poll(void)
+{
+	struct udev_device *udev_dev;
+
+	usbi_mutex_static_lock(&linux_hotplug_lock);
+	do {
+		udev_dev = udev_monitor_receive_device(udev_monitor);
+		if (udev_dev) {
+			usbi_dbg(NULL, "Handling hotplug event from hotplug_poll");
+			udev_hotplug_event(udev_dev);
+		}
+	} while (udev_dev);
+	usbi_mutex_static_unlock(&linux_hotplug_lock);
+}

deps/libusb/libusb/os/linux_usbfs.h

@@ -0,0 +1,211 @@
+/*
+ * usbfs header structures
+ * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * 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
+ */
+
+#ifndef LIBUSB_USBFS_H
+#define LIBUSB_USBFS_H
+
+#include <linux/magic.h>
+#include <linux/types.h>
+
+#define SYSFS_MOUNT_PATH	"/sys"
+#define SYSFS_DEVICE_PATH	SYSFS_MOUNT_PATH "/bus/usb/devices"
+
+struct usbfs_ctrltransfer {
+	/* keep in sync with usbdevice_fs.h:usbdevfs_ctrltransfer */
+	__u8 bmRequestType;
+	__u8 bRequest;
+	__u16 wValue;
+	__u16 wIndex;
+	__u16 wLength;
+	__u32 timeout;	/* in milliseconds */
+
+	/* pointer to data */
+	void *data;
+};
+
+struct usbfs_setinterface {
+	/* keep in sync with usbdevice_fs.h:usbdevfs_setinterface */
+	unsigned int interface;
+	unsigned int altsetting;
+};
+
+#define USBFS_MAXDRIVERNAME		255
+
+struct usbfs_getdriver {
+	unsigned int interface;
+	char driver[USBFS_MAXDRIVERNAME + 1];
+};
+
+#define USBFS_URB_SHORT_NOT_OK		0x01
+#define USBFS_URB_ISO_ASAP		0x02
+#define USBFS_URB_BULK_CONTINUATION	0x04
+#define USBFS_URB_QUEUE_BULK		0x10
+#define USBFS_URB_ZERO_PACKET		0x40
+
+#define USBFS_URB_TYPE_ISO		0
+#define USBFS_URB_TYPE_INTERRUPT	1
+#define USBFS_URB_TYPE_CONTROL		2
+#define USBFS_URB_TYPE_BULK		3
+
+struct usbfs_iso_packet_desc {
+	unsigned int length;
+	unsigned int actual_length;
+	unsigned int status;
+};
+
+#define MAX_BULK_BUFFER_LENGTH		16384
+#define MAX_CTRL_BUFFER_LENGTH		4096
+
+#define MAX_ISO_PACKETS_PER_URB		128
+
+struct usbfs_urb {
+	unsigned char type;
+	unsigned char endpoint;
+	int status;
+	unsigned int flags;
+	void *buffer;
+	int buffer_length;
+	int actual_length;
+	int start_frame;
+	union {
+		int number_of_packets;	/* Only used for isoc urbs */
+		unsigned int stream_id;	/* Only used with bulk streams */
+	};
+	int error_count;
+	unsigned int signr;
+	void *usercontext;
+	struct usbfs_iso_packet_desc iso_frame_desc[0];
+};
+
+struct usbfs_connectinfo {
+	unsigned int devnum;
+	unsigned char slow;
+};
+
+struct usbfs_ioctl {
+	int ifno;	/* interface 0..N ; negative numbers reserved */
+	int ioctl_code;	/* MUST encode size + direction of data so the
+			 * macros in <asm/ioctl.h> give correct values */
+	void *data;	/* param buffer (in, or out) */
+};
+
+#define USBFS_CAP_ZERO_PACKET			0x01
+#define USBFS_CAP_BULK_CONTINUATION		0x02
+#define USBFS_CAP_NO_PACKET_SIZE_LIM		0x04
+#define USBFS_CAP_BULK_SCATTER_GATHER		0x08
+#define USBFS_CAP_REAP_AFTER_DISCONNECT		0x10
+
+#define USBFS_DISCONNECT_CLAIM_IF_DRIVER	0x01
+#define USBFS_DISCONNECT_CLAIM_EXCEPT_DRIVER	0x02
+
+struct usbfs_disconnect_claim {
+	unsigned int interface;
+	unsigned int flags;
+	char driver[USBFS_MAXDRIVERNAME + 1];
+};
+
+struct usbfs_streams {
+	unsigned int num_streams; /* Not used by USBDEVFS_FREE_STREAMS */
+	unsigned int num_eps;
+	unsigned char eps[0];
+};
+
+#define USBFS_SPEED_UNKNOWN			0
+#define USBFS_SPEED_LOW				1
+#define USBFS_SPEED_FULL			2
+#define USBFS_SPEED_HIGH			3
+#define USBFS_SPEED_WIRELESS			4
+#define USBFS_SPEED_SUPER			5
+#define USBFS_SPEED_SUPER_PLUS			6
+
+#define IOCTL_USBFS_CONTROL		_IOWR('U', 0, struct usbfs_ctrltransfer)
+#define IOCTL_USBFS_SETINTERFACE	_IOR('U', 4, struct usbfs_setinterface)
+#define IOCTL_USBFS_SETCONFIGURATION	_IOR('U', 5, unsigned int)
+#define IOCTL_USBFS_GETDRIVER		_IOW('U', 8, struct usbfs_getdriver)
+#define IOCTL_USBFS_SUBMITURB		_IOR('U', 10, struct usbfs_urb)
+#define IOCTL_USBFS_DISCARDURB		_IO('U', 11)
+#define IOCTL_USBFS_REAPURBNDELAY	_IOW('U', 13, void *)
+#define IOCTL_USBFS_CLAIMINTERFACE	_IOR('U', 15, unsigned int)
+#define IOCTL_USBFS_RELEASEINTERFACE	_IOR('U', 16, unsigned int)
+#define IOCTL_USBFS_CONNECTINFO		_IOW('U', 17, struct usbfs_connectinfo)
+#define IOCTL_USBFS_IOCTL		_IOWR('U', 18, struct usbfs_ioctl)
+#define IOCTL_USBFS_RESET		_IO('U', 20)
+#define IOCTL_USBFS_CLEAR_HALT		_IOR('U', 21, unsigned int)
+#define IOCTL_USBFS_DISCONNECT		_IO('U', 22)
+#define IOCTL_USBFS_CONNECT		_IO('U', 23)
+#define IOCTL_USBFS_GET_CAPABILITIES	_IOR('U', 26, __u32)
+#define IOCTL_USBFS_DISCONNECT_CLAIM	_IOR('U', 27, struct usbfs_disconnect_claim)
+#define IOCTL_USBFS_ALLOC_STREAMS	_IOR('U', 28, struct usbfs_streams)
+#define IOCTL_USBFS_FREE_STREAMS	_IOR('U', 29, struct usbfs_streams)
+#define IOCTL_USBFS_DROP_PRIVILEGES	_IOW('U', 30, __u32)
+#define IOCTL_USBFS_GET_SPEED		_IO('U', 31)
+
+extern usbi_mutex_static_t linux_hotplug_lock;
+
+#ifdef HAVE_LIBUDEV
+int linux_udev_start_event_monitor(void);
+int linux_udev_stop_event_monitor(void);
+int linux_udev_scan_devices(struct libusb_context *ctx);
+void linux_udev_hotplug_poll(void);
+#else
+int linux_netlink_start_event_monitor(void);
+int linux_netlink_stop_event_monitor(void);
+void linux_netlink_hotplug_poll(void);
+#endif
+
+static inline int linux_start_event_monitor(void)
+{
+#if defined(HAVE_LIBUDEV)
+	return linux_udev_start_event_monitor();
+#elif !defined(__ANDROID__)
+	return linux_netlink_start_event_monitor();
+#else
+	return LIBUSB_SUCCESS;
+#endif
+}
+
+static inline void linux_stop_event_monitor(void)
+{
+#if defined(HAVE_LIBUDEV)
+	linux_udev_stop_event_monitor();
+#elif !defined(__ANDROID__)
+	linux_netlink_stop_event_monitor();
+#endif
+}
+
+static inline void linux_hotplug_poll(void)
+{
+#if defined(HAVE_LIBUDEV)
+	linux_udev_hotplug_poll();
+#elif !defined(__ANDROID__)
+	linux_netlink_hotplug_poll();
+#endif
+}
+
+void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name);
+void linux_device_disconnected(uint8_t busnum, uint8_t devaddr);
+
+int linux_get_device_address(struct libusb_context *ctx, int detached,
+	uint8_t *busnum, uint8_t *devaddr, const char *dev_node,
+	const char *sys_name, int fd);
+int linux_enumerate_device(struct libusb_context *ctx,
+	uint8_t busnum, uint8_t devaddr, const char *sysfs_dir);
+
+#endif

deps/libusb/libusb/os/netbsd_usb.c

@@ -0,0 +1,617 @@
+/*
+ * Copyright © 2011 Martin Pieuchot <mpi@openbsd.org>
+ *
+ * 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 <config.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <dev/usb/usb.h>
+
+#include "libusbi.h"
+
+struct device_priv {
+	char devnode[16];
+	int fd;
+
+	usb_config_descriptor_t *cdesc;		/* active config descriptor */
+};
+
+struct handle_priv {
+	int endpoints[USB_MAX_ENDPOINTS];
+};
+
+/*
+ * Backend functions
+ */
+static int netbsd_get_device_list(struct libusb_context *,
+    struct discovered_devs **);
+static int netbsd_open(struct libusb_device_handle *);
+static void netbsd_close(struct libusb_device_handle *);
+
+static int netbsd_get_active_config_descriptor(struct libusb_device *,
+    void *, size_t);
+static int netbsd_get_config_descriptor(struct libusb_device *, uint8_t,
+    void *, size_t);
+
+static int netbsd_get_configuration(struct libusb_device_handle *, uint8_t *);
+static int netbsd_set_configuration(struct libusb_device_handle *, int);
+
+static int netbsd_claim_interface(struct libusb_device_handle *, uint8_t);
+static int netbsd_release_interface(struct libusb_device_handle *, uint8_t);
+
+static int netbsd_set_interface_altsetting(struct libusb_device_handle *,
+    uint8_t, uint8_t);
+static int netbsd_clear_halt(struct libusb_device_handle *, unsigned char);
+static void netbsd_destroy_device(struct libusb_device *);
+
+static int netbsd_submit_transfer(struct usbi_transfer *);
+static int netbsd_cancel_transfer(struct usbi_transfer *);
+static int netbsd_handle_transfer_completion(struct usbi_transfer *);
+
+/*
+ * Private functions
+ */
+static int _errno_to_libusb(int);
+static int _cache_active_config_descriptor(struct libusb_device *, int);
+static int _sync_control_transfer(struct usbi_transfer *);
+static int _sync_gen_transfer(struct usbi_transfer *);
+static int _access_endpoint(struct libusb_transfer *);
+
+const struct usbi_os_backend usbi_backend = {
+	.name = "Synchronous NetBSD backend",
+	.caps = 0,
+	.get_device_list = netbsd_get_device_list,
+	.open = netbsd_open,
+	.close = netbsd_close,
+
+	.get_active_config_descriptor = netbsd_get_active_config_descriptor,
+	.get_config_descriptor = netbsd_get_config_descriptor,
+
+	.get_configuration = netbsd_get_configuration,
+	.set_configuration = netbsd_set_configuration,
+
+	.claim_interface = netbsd_claim_interface,
+	.release_interface = netbsd_release_interface,
+
+	.set_interface_altsetting = netbsd_set_interface_altsetting,
+	.clear_halt = netbsd_clear_halt,
+
+	.destroy_device = netbsd_destroy_device,
+
+	.submit_transfer = netbsd_submit_transfer,
+	.cancel_transfer = netbsd_cancel_transfer,
+
+	.handle_transfer_completion = netbsd_handle_transfer_completion,
+
+	.device_priv_size = sizeof(struct device_priv),
+	.device_handle_priv_size = sizeof(struct handle_priv),
+};
+
+int
+netbsd_get_device_list(struct libusb_context * ctx,
+	struct discovered_devs **discdevs)
+{
+	struct libusb_device *dev;
+	struct device_priv *dpriv;
+	struct usb_device_info di;
+	usb_device_descriptor_t ddesc;
+	unsigned long session_id;
+	char devnode[16];
+	int fd, err, i;
+
+	usbi_dbg(ctx, " ");
+
+	/* Only ugen(4) is supported */
+	for (i = 0; i < USB_MAX_DEVICES; i++) {
+		/* Control endpoint is always .00 */
+		snprintf(devnode, sizeof(devnode), "/dev/ugen%d.00", i);
+
+		if ((fd = open(devnode, O_RDONLY)) < 0) {
+			if (errno != ENOENT && errno != ENXIO)
+				usbi_err(ctx, "could not open %s", devnode);
+			continue;
+		}
+
+		if (ioctl(fd, USB_GET_DEVICEINFO, &di) < 0)
+			continue;
+
+		session_id = (di.udi_bus << 8 | di.udi_addr);
+		dev = usbi_get_device_by_session_id(ctx, session_id);
+
+		if (dev == NULL) {
+			dev = usbi_alloc_device(ctx, session_id);
+			if (dev == NULL)
+				return LIBUSB_ERROR_NO_MEM;
+
+			dev->bus_number = 1 + di.udi_bus;
+			dev->device_address = 1 + di.udi_addr;
+			dev->speed = di.udi_speed; /* NetBSD #define's happen to match libusb enum */
+
+			dpriv = usbi_get_device_priv(dev);
+			strlcpy(dpriv->devnode, devnode, sizeof(devnode));
+			dpriv->fd = -1;
+
+			if (ioctl(fd, USB_GET_DEVICE_DESC, &ddesc) < 0) {
+				err = errno;
+				goto error;
+			}
+
+			static_assert(sizeof(dev->device_descriptor) == sizeof(ddesc),
+				      "mismatch between libusb and OS device descriptor sizes");
+			memcpy(&dev->device_descriptor, &ddesc, LIBUSB_DT_DEVICE_SIZE);
+			usbi_localize_device_descriptor(&dev->device_descriptor);
+
+			if (_cache_active_config_descriptor(dev, fd)) {
+				err = errno;
+				goto error;
+			}
+
+			if ((err = usbi_sanitize_device(dev)))
+				goto error;
+		}
+		close(fd);
+
+		if (discovered_devs_append(*discdevs, dev) == NULL)
+			return LIBUSB_ERROR_NO_MEM;
+
+		libusb_unref_device(dev);
+	}
+
+	return LIBUSB_SUCCESS;
+
+error:
+	close(fd);
+	libusb_unref_device(dev);
+	return _errno_to_libusb(err);
+}
+
+int
+netbsd_open(struct libusb_device_handle *handle)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+	struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+	int i;
+
+	dpriv->fd = open(dpriv->devnode, O_RDWR);
+	if (dpriv->fd < 0) {
+		dpriv->fd = open(dpriv->devnode, O_RDONLY);
+		if (dpriv->fd < 0)
+			return _errno_to_libusb(errno);
+	}
+
+	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+		hpriv->endpoints[i] = -1;
+
+	usbi_dbg(HANDLE_CTX(handle), "open %s: fd %d", dpriv->devnode, dpriv->fd);
+
+	return LIBUSB_SUCCESS;
+}
+
+void
+netbsd_close(struct libusb_device_handle *handle)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+
+	usbi_dbg(HANDLE_CTX(handle), "close: fd %d", dpriv->fd);
+
+	close(dpriv->fd);
+	dpriv->fd = -1;
+}
+
+int
+netbsd_get_active_config_descriptor(struct libusb_device *dev,
+    void *buf, size_t len)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
+
+	len = MIN(len, (size_t)UGETW(dpriv->cdesc->wTotalLength));
+
+	usbi_dbg(DEVICE_CTX(dev), "len %zu", len);
+
+	memcpy(buf, dpriv->cdesc, len);
+
+	return (int)len;
+}
+
+int
+netbsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
+    void *buf, size_t len)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
+	struct usb_full_desc ufd;
+	int fd, err;
+
+	usbi_dbg(DEVICE_CTX(dev), "index %u, len %zu", idx, len);
+
+	/* A config descriptor may be requested before opening the device */
+	if (dpriv->fd >= 0) {
+		fd = dpriv->fd;
+	} else {
+		fd = open(dpriv->devnode, O_RDONLY);
+		if (fd < 0)
+			return _errno_to_libusb(errno);
+	}
+
+	ufd.ufd_config_index = idx;
+	ufd.ufd_size = len;
+	ufd.ufd_data = buf;
+
+	if (ioctl(fd, USB_GET_FULL_DESC, &ufd) < 0) {
+		err = errno;
+		if (dpriv->fd < 0)
+			close(fd);
+		return _errno_to_libusb(err);
+	}
+
+	if (dpriv->fd < 0)
+		close(fd);
+
+	return (int)len;
+}
+
+int
+netbsd_get_configuration(struct libusb_device_handle *handle, uint8_t *config)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+	int tmp;
+
+	usbi_dbg(HANDLE_CTX(handle), " ");
+
+	if (ioctl(dpriv->fd, USB_GET_CONFIG, &tmp) < 0)
+		return _errno_to_libusb(errno);
+
+	usbi_dbg(HANDLE_CTX(handle), "configuration %d", tmp);
+	*config = (uint8_t)tmp;
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+netbsd_set_configuration(struct libusb_device_handle *handle, int config)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+
+	usbi_dbg(HANDLE_CTX(handle), "configuration %d", config);
+
+	if (ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
+		return _errno_to_libusb(errno);
+
+	return _cache_active_config_descriptor(handle->dev, dpriv->fd);
+}
+
+int
+netbsd_claim_interface(struct libusb_device_handle *handle, uint8_t iface)
+{
+	struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+	int i;
+
+	UNUSED(iface);
+
+	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+		hpriv->endpoints[i] = -1;
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+netbsd_release_interface(struct libusb_device_handle *handle, uint8_t iface)
+{
+	struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+	int i;
+
+	UNUSED(iface);
+
+	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+		if (hpriv->endpoints[i] >= 0)
+			close(hpriv->endpoints[i]);
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+netbsd_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface,
+    uint8_t altsetting)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+	struct usb_alt_interface intf;
+
+	usbi_dbg(HANDLE_CTX(handle), "iface %u, setting %u", iface, altsetting);
+
+	memset(&intf, 0, sizeof(intf));
+
+	intf.uai_interface_index = iface;
+	intf.uai_alt_no = altsetting;
+
+	if (ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
+		return _errno_to_libusb(errno);
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+netbsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+	struct usb_ctl_request req;
+
+	usbi_dbg(HANDLE_CTX(handle), " ");
+
+	req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
+	req.ucr_request.bRequest = UR_CLEAR_FEATURE;
+	USETW(req.ucr_request.wValue, UF_ENDPOINT_HALT);
+	USETW(req.ucr_request.wIndex, endpoint);
+	USETW(req.ucr_request.wLength, 0);
+
+	if (ioctl(dpriv->fd, USB_DO_REQUEST, &req) < 0)
+		return _errno_to_libusb(errno);
+
+	return LIBUSB_SUCCESS;
+}
+
+void
+netbsd_destroy_device(struct libusb_device *dev)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
+
+	usbi_dbg(DEVICE_CTX(dev), " ");
+
+	free(dpriv->cdesc);
+}
+
+int
+netbsd_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	int err = 0;
+
+	usbi_dbg(ITRANSFER_CTX(itransfer), " ");
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		err = _sync_control_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		if (IS_XFEROUT(transfer)) {
+			/* Isochronous write is not supported */
+			err = LIBUSB_ERROR_NOT_SUPPORTED;
+			break;
+		}
+		err = _sync_gen_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		if (IS_XFEROUT(transfer) &&
+		    transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
+			err = LIBUSB_ERROR_NOT_SUPPORTED;
+			break;
+		}
+		err = _sync_gen_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		err = LIBUSB_ERROR_NOT_SUPPORTED;
+		break;
+	}
+
+	if (err)
+		return err;
+
+	usbi_signal_transfer_completion(itransfer);
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+netbsd_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	UNUSED(itransfer);
+
+	usbi_dbg(ITRANSFER_CTX(itransfer), " ");
+
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+int
+netbsd_handle_transfer_completion(struct usbi_transfer *itransfer)
+{
+	return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
+}
+
+int
+_errno_to_libusb(int err)
+{
+	switch (err) {
+	case EIO:
+		return LIBUSB_ERROR_IO;
+	case EACCES:
+		return LIBUSB_ERROR_ACCESS;
+	case ENOENT:
+		return LIBUSB_ERROR_NO_DEVICE;
+	case ENOMEM:
+		return LIBUSB_ERROR_NO_MEM;
+	case EWOULDBLOCK:
+	case ETIMEDOUT:
+		return LIBUSB_ERROR_TIMEOUT;
+	}
+
+	usbi_dbg(NULL, "error: %s (%d)", strerror(err), err);
+
+	return LIBUSB_ERROR_OTHER;
+}
+
+int
+_cache_active_config_descriptor(struct libusb_device *dev, int fd)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
+	struct usb_config_desc ucd;
+	struct usb_full_desc ufd;
+	void *buf;
+	int len;
+
+	usbi_dbg(DEVICE_CTX(dev), "fd %d", fd);
+
+	ucd.ucd_config_index = USB_CURRENT_CONFIG_INDEX;
+
+	if (ioctl(fd, USB_GET_CONFIG_DESC, &ucd) < 0)
+		return _errno_to_libusb(errno);
+
+	usbi_dbg(DEVICE_CTX(dev), "active bLength %d", ucd.ucd_desc.bLength);
+
+	len = UGETW(ucd.ucd_desc.wTotalLength);
+	buf = malloc((size_t)len);
+	if (buf == NULL)
+		return LIBUSB_ERROR_NO_MEM;
+
+	ufd.ufd_config_index = ucd.ucd_config_index;
+	ufd.ufd_size = len;
+	ufd.ufd_data = buf;
+
+	usbi_dbg(DEVICE_CTX(dev), "index %d, len %d", ufd.ufd_config_index, len);
+
+	if (ioctl(fd, USB_GET_FULL_DESC, &ufd) < 0) {
+		free(buf);
+		return _errno_to_libusb(errno);
+	}
+
+	if (dpriv->cdesc)
+		free(dpriv->cdesc);
+	dpriv->cdesc = buf;
+
+	return 0;
+}
+
+int
+_sync_control_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	struct libusb_control_setup *setup;
+	struct device_priv *dpriv;
+	struct usb_ctl_request req;
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
+	setup = (struct libusb_control_setup *)transfer->buffer;
+
+	usbi_dbg(ITRANSFER_CTX(itransfer), "type 0x%x request 0x%x value 0x%x index %d length %d timeout %d",
+	    setup->bmRequestType, setup->bRequest,
+	    libusb_le16_to_cpu(setup->wValue),
+	    libusb_le16_to_cpu(setup->wIndex),
+	    libusb_le16_to_cpu(setup->wLength), transfer->timeout);
+
+	req.ucr_request.bmRequestType = setup->bmRequestType;
+	req.ucr_request.bRequest = setup->bRequest;
+	/* Don't use USETW, libusb already deals with the endianness */
+	(*(uint16_t *)req.ucr_request.wValue) = setup->wValue;
+	(*(uint16_t *)req.ucr_request.wIndex) = setup->wIndex;
+	(*(uint16_t *)req.ucr_request.wLength) = setup->wLength;
+	req.ucr_data = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+
+	if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+		req.ucr_flags = USBD_SHORT_XFER_OK;
+
+	if (ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout) < 0)
+		return _errno_to_libusb(errno);
+
+	if (ioctl(dpriv->fd, USB_DO_REQUEST, &req) < 0)
+		return _errno_to_libusb(errno);
+
+	itransfer->transferred = req.ucr_actlen;
+
+	usbi_dbg(ITRANSFER_CTX(itransfer), "transferred %d", itransfer->transferred);
+
+	return 0;
+}
+
+int
+_access_endpoint(struct libusb_transfer *transfer)
+{
+	struct handle_priv *hpriv;
+	struct device_priv *dpriv;
+	char *s, devnode[16];
+	int fd, endpt;
+	mode_t mode;
+
+	hpriv = usbi_get_device_handle_priv(transfer->dev_handle);
+	dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
+
+	endpt = UE_GET_ADDR(transfer->endpoint);
+	mode = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
+
+	usbi_dbg(TRANSFER_CTX(transfer), "endpoint %d mode %d", endpt, mode);
+
+	if (hpriv->endpoints[endpt] < 0) {
+		/* Pick the right node given the control one */
+		strlcpy(devnode, dpriv->devnode, sizeof(devnode));
+		s = strchr(devnode, '.');
+		snprintf(s, 4, ".%02d", endpt);
+
+		/* We may need to read/write to the same endpoint later. */
+		if (((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
+			if ((fd = open(devnode, mode)) < 0)
+				return -1;
+
+		hpriv->endpoints[endpt] = fd;
+	}
+
+	return hpriv->endpoints[endpt];
+}
+
+int
+_sync_gen_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	int fd, nr = 1;
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	/*
+	 * Bulk, Interrupt or Isochronous transfer depends on the
+	 * endpoint and thus the node to open.
+	 */
+	if ((fd = _access_endpoint(transfer)) < 0)
+		return _errno_to_libusb(errno);
+
+	if (ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout) < 0)
+		return _errno_to_libusb(errno);
+
+	if (IS_XFERIN(transfer)) {
+		if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+			if (ioctl(fd, USB_SET_SHORT_XFER, &nr) < 0)
+				return _errno_to_libusb(errno);
+
+		nr = read(fd, transfer->buffer, transfer->length);
+	} else {
+		nr = write(fd, transfer->buffer, transfer->length);
+	}
+
+	if (nr < 0)
+		return _errno_to_libusb(errno);
+
+	itransfer->transferred = nr;
+
+	return 0;
+}

deps/libusb/libusb/os/null_usb.c

@@ -0,0 +1,111 @@
+/*
+ * Copyright © 2019 Pino Toscano <toscano.pino@tiscali.it>
+ *
+ * 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 "libusbi.h"
+
+static int
+null_get_device_list(struct libusb_context * ctx,
+	struct discovered_devs **discdevs)
+{
+	return LIBUSB_SUCCESS;
+}
+
+static int
+null_open(struct libusb_device_handle *handle)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static void
+null_close(struct libusb_device_handle *handle)
+{
+}
+
+static int
+null_get_active_config_descriptor(struct libusb_device *dev,
+    void *buf, size_t len)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
+    void *buf, size_t len)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_set_configuration(struct libusb_device_handle *handle, int config)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_claim_interface(struct libusb_device_handle *handle, uint8_t iface)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_release_interface(struct libusb_device_handle *handle, uint8_t iface)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface,
+    uint8_t altsetting)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_submit_transfer(struct usbi_transfer *itransfer)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+const struct usbi_os_backend usbi_backend = {
+	.name = "Null backend",
+	.caps = 0,
+	.get_device_list = null_get_device_list,
+	.open = null_open,
+	.close = null_close,
+	.get_active_config_descriptor = null_get_active_config_descriptor,
+	.get_config_descriptor = null_get_config_descriptor,
+	.set_configuration = null_set_configuration,
+	.claim_interface = null_claim_interface,
+	.release_interface = null_release_interface,
+	.set_interface_altsetting = null_set_interface_altsetting,
+	.clear_halt = null_clear_halt,
+	.submit_transfer = null_submit_transfer,
+	.cancel_transfer = null_cancel_transfer,
+};

deps/libusb/libusb/os/openbsd_usb.c

@@ -0,0 +1,700 @@
+/*
+ * Copyright © 2011-2013 Martin Pieuchot <mpi@openbsd.org>
+ *
+ * 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 <config.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <dev/usb/usb.h>
+
+#include "libusbi.h"
+
+struct device_priv {
+	char *devname;				/* name of the ugen(4) node */
+	int fd;					/* device file descriptor */
+
+	usb_config_descriptor_t *cdesc;		/* active config descriptor */
+};
+
+struct handle_priv {
+	int endpoints[USB_MAX_ENDPOINTS];
+};
+
+/*
+ * Backend functions
+ */
+static int obsd_get_device_list(struct libusb_context *,
+    struct discovered_devs **);
+static int obsd_open(struct libusb_device_handle *);
+static void obsd_close(struct libusb_device_handle *);
+
+static int obsd_get_active_config_descriptor(struct libusb_device *,
+    void *, size_t);
+static int obsd_get_config_descriptor(struct libusb_device *, uint8_t,
+    void *, size_t);
+
+static int obsd_get_configuration(struct libusb_device_handle *, uint8_t *);
+static int obsd_set_configuration(struct libusb_device_handle *, int);
+
+static int obsd_claim_interface(struct libusb_device_handle *, uint8_t);
+static int obsd_release_interface(struct libusb_device_handle *, uint8_t);
+
+static int obsd_set_interface_altsetting(struct libusb_device_handle *, uint8_t,
+    uint8_t);
+static int obsd_clear_halt(struct libusb_device_handle *, unsigned char);
+static void obsd_destroy_device(struct libusb_device *);
+
+static int obsd_submit_transfer(struct usbi_transfer *);
+static int obsd_cancel_transfer(struct usbi_transfer *);
+static int obsd_handle_transfer_completion(struct usbi_transfer *);
+
+/*
+ * Private functions
+ */
+static int _errno_to_libusb(int);
+static int _cache_active_config_descriptor(struct libusb_device *);
+static int _sync_control_transfer(struct usbi_transfer *);
+static int _sync_gen_transfer(struct usbi_transfer *);
+static int _access_endpoint(struct libusb_transfer *);
+
+static int _bus_open(int);
+
+
+const struct usbi_os_backend usbi_backend = {
+	.name = "Synchronous OpenBSD backend",
+	.get_device_list = obsd_get_device_list,
+	.open = obsd_open,
+	.close = obsd_close,
+
+	.get_active_config_descriptor = obsd_get_active_config_descriptor,
+	.get_config_descriptor = obsd_get_config_descriptor,
+
+	.get_configuration = obsd_get_configuration,
+	.set_configuration = obsd_set_configuration,
+
+	.claim_interface = obsd_claim_interface,
+	.release_interface = obsd_release_interface,
+
+	.set_interface_altsetting = obsd_set_interface_altsetting,
+	.clear_halt = obsd_clear_halt,
+	.destroy_device = obsd_destroy_device,
+
+	.submit_transfer = obsd_submit_transfer,
+	.cancel_transfer = obsd_cancel_transfer,
+
+	.handle_transfer_completion = obsd_handle_transfer_completion,
+
+	.device_priv_size = sizeof(struct device_priv),
+	.device_handle_priv_size = sizeof(struct handle_priv),
+};
+
+#define DEVPATH	"/dev/"
+#define USBDEV	DEVPATH "usb"
+
+int
+obsd_get_device_list(struct libusb_context * ctx,
+	struct discovered_devs **discdevs)
+{
+	struct discovered_devs *ddd;
+	struct libusb_device *dev;
+	struct device_priv *dpriv;
+	struct usb_device_info di;
+	struct usb_device_ddesc dd;
+	unsigned long session_id;
+	char devices[USB_MAX_DEVICES];
+	char busnode[16];
+	char *udevname;
+	int fd, addr, i, j;
+
+	usbi_dbg(ctx, " ");
+
+	for (i = 0; i < 8; i++) {
+		snprintf(busnode, sizeof(busnode), USBDEV "%d", i);
+
+		if ((fd = open(busnode, O_RDWR)) < 0) {
+			if (errno != ENOENT && errno != ENXIO)
+				usbi_err(ctx, "could not open %s", busnode);
+			continue;
+		}
+
+		bzero(devices, sizeof(devices));
+		for (addr = 1; addr < USB_MAX_DEVICES; addr++) {
+			if (devices[addr])
+				continue;
+
+			di.udi_addr = addr;
+			if (ioctl(fd, USB_DEVICEINFO, &di) < 0)
+				continue;
+
+			/*
+			 * XXX If ugen(4) is attached to the USB device
+			 * it will be used.
+			 */
+			udevname = NULL;
+			for (j = 0; j < USB_MAX_DEVNAMES; j++)
+				if (!strncmp("ugen", di.udi_devnames[j], 4)) {
+					udevname = strdup(di.udi_devnames[j]);
+					break;
+				}
+
+			session_id = (di.udi_bus << 8 | di.udi_addr);
+			dev = usbi_get_device_by_session_id(ctx, session_id);
+
+			if (dev == NULL) {
+				dev = usbi_alloc_device(ctx, session_id);
+				if (dev == NULL) {
+					close(fd);
+					return LIBUSB_ERROR_NO_MEM;
+				}
+
+				dev->bus_number = di.udi_bus;
+				dev->device_address = di.udi_addr;
+				dev->speed = di.udi_speed;
+				dev->port_number = di.udi_port;
+
+				dpriv = usbi_get_device_priv(dev);
+				dpriv->fd = -1;
+				dpriv->devname = udevname;
+
+				dd.udd_bus = di.udi_bus;
+				dd.udd_addr = di.udi_addr;
+				if (ioctl(fd, USB_DEVICE_GET_DDESC, &dd) < 0) {
+					libusb_unref_device(dev);
+					continue;
+				}
+
+				static_assert(sizeof(dev->device_descriptor) == sizeof(dd.udd_desc),
+					      "mismatch between libusb and OS device descriptor sizes");
+				memcpy(&dev->device_descriptor, &dd.udd_desc, LIBUSB_DT_DEVICE_SIZE);
+				usbi_localize_device_descriptor(&dev->device_descriptor);
+
+				if (_cache_active_config_descriptor(dev)) {
+					libusb_unref_device(dev);
+					continue;
+				}
+
+				if (usbi_sanitize_device(dev)) {
+					libusb_unref_device(dev);
+					continue;
+				}
+			}
+
+			ddd = discovered_devs_append(*discdevs, dev);
+			if (ddd == NULL) {
+				close(fd);
+				return LIBUSB_ERROR_NO_MEM;
+			}
+			libusb_unref_device(dev);
+
+			*discdevs = ddd;
+			devices[addr] = 1;
+		}
+
+		close(fd);
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+obsd_open(struct libusb_device_handle *handle)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+	char devnode[16];
+
+	if (dpriv->devname) {
+		int fd;
+		/*
+		 * Only open ugen(4) attached devices read-write, all
+		 * read-only operations are done through the bus node.
+		 */
+		snprintf(devnode, sizeof(devnode), DEVPATH "%s.00",
+		    dpriv->devname);
+		fd = open(devnode, O_RDWR);
+		if (fd < 0)
+			return _errno_to_libusb(errno);
+		dpriv->fd = fd;
+
+		usbi_dbg(HANDLE_CTX(handle), "open %s: fd %d", devnode, dpriv->fd);
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+void
+obsd_close(struct libusb_device_handle *handle)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+
+	if (dpriv->devname) {
+		usbi_dbg(HANDLE_CTX(handle), "close: fd %d", dpriv->fd);
+
+		close(dpriv->fd);
+		dpriv->fd = -1;
+	}
+}
+
+int
+obsd_get_active_config_descriptor(struct libusb_device *dev,
+    void *buf, size_t len)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
+
+	len = MIN(len, (size_t)UGETW(dpriv->cdesc->wTotalLength));
+
+	usbi_dbg(DEVICE_CTX(dev), "len %zu", len);
+
+	memcpy(buf, dpriv->cdesc, len);
+
+	return (int)len;
+}
+
+int
+obsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
+    void *buf, size_t len)
+{
+	struct usb_device_fdesc udf;
+	int fd, err;
+
+	if ((fd = _bus_open(dev->bus_number)) < 0)
+		return _errno_to_libusb(errno);
+
+	udf.udf_bus = dev->bus_number;
+	udf.udf_addr = dev->device_address;
+	udf.udf_config_index = idx;
+	udf.udf_size = len;
+	udf.udf_data = buf;
+
+	usbi_dbg(DEVICE_CTX(dev), "index %d, len %zu", udf.udf_config_index, len);
+
+	if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
+		err = errno;
+		close(fd);
+		return _errno_to_libusb(err);
+	}
+	close(fd);
+
+	return (int)len;
+}
+
+int
+obsd_get_configuration(struct libusb_device_handle *handle, uint8_t *config)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+
+	*config = dpriv->cdesc->bConfigurationValue;
+
+	usbi_dbg(HANDLE_CTX(handle), "bConfigurationValue %u", *config);
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+obsd_set_configuration(struct libusb_device_handle *handle, int config)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+
+	if (dpriv->devname == NULL)
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+
+	usbi_dbg(HANDLE_CTX(handle), "bConfigurationValue %d", config);
+
+	if (ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
+		return _errno_to_libusb(errno);
+
+	return _cache_active_config_descriptor(handle->dev);
+}
+
+int
+obsd_claim_interface(struct libusb_device_handle *handle, uint8_t iface)
+{
+	struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+	int i;
+
+	UNUSED(iface);
+
+	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+		hpriv->endpoints[i] = -1;
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+obsd_release_interface(struct libusb_device_handle *handle, uint8_t iface)
+{
+	struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+	int i;
+
+	UNUSED(iface);
+
+	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+		if (hpriv->endpoints[i] >= 0)
+			close(hpriv->endpoints[i]);
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+obsd_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface,
+    uint8_t altsetting)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+	struct usb_alt_interface intf;
+
+	if (dpriv->devname == NULL)
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+
+	usbi_dbg(HANDLE_CTX(handle), "iface %u, setting %u", iface, altsetting);
+
+	memset(&intf, 0, sizeof(intf));
+
+	intf.uai_interface_index = iface;
+	intf.uai_alt_no = altsetting;
+
+	if (ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
+		return _errno_to_libusb(errno);
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+obsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
+{
+	struct usb_ctl_request req;
+	int fd, err;
+
+	if ((fd = _bus_open(handle->dev->bus_number)) < 0)
+		return _errno_to_libusb(errno);
+
+	usbi_dbg(HANDLE_CTX(handle), " ");
+
+	req.ucr_addr = handle->dev->device_address;
+	req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
+	req.ucr_request.bRequest = UR_CLEAR_FEATURE;
+	USETW(req.ucr_request.wValue, UF_ENDPOINT_HALT);
+	USETW(req.ucr_request.wIndex, endpoint);
+	USETW(req.ucr_request.wLength, 0);
+
+	if (ioctl(fd, USB_REQUEST, &req) < 0) {
+		err = errno;
+		close(fd);
+		return _errno_to_libusb(err);
+	}
+	close(fd);
+
+	return LIBUSB_SUCCESS;
+}
+
+void
+obsd_destroy_device(struct libusb_device *dev)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
+
+	usbi_dbg(DEVICE_CTX(dev), " ");
+
+	free(dpriv->cdesc);
+	free(dpriv->devname);
+}
+
+int
+obsd_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	int err = 0;
+
+	usbi_dbg(ITRANSFER_CTX(itransfer), " ");
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		err = _sync_control_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		if (IS_XFEROUT(transfer)) {
+			/* Isochronous write is not supported */
+			err = LIBUSB_ERROR_NOT_SUPPORTED;
+			break;
+		}
+		err = _sync_gen_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		if (IS_XFEROUT(transfer) &&
+		    transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
+			err = LIBUSB_ERROR_NOT_SUPPORTED;
+			break;
+		}
+		err = _sync_gen_transfer(itransfer);
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		err = LIBUSB_ERROR_NOT_SUPPORTED;
+		break;
+	}
+
+	if (err)
+		return err;
+
+	usbi_signal_transfer_completion(itransfer);
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+obsd_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	UNUSED(itransfer);
+
+	usbi_dbg(ITRANSFER_CTX(itransfer), " ");
+
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+int
+obsd_handle_transfer_completion(struct usbi_transfer *itransfer)
+{
+	return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
+}
+
+int
+_errno_to_libusb(int err)
+{
+	usbi_dbg(NULL, "error: %s (%d)", strerror(err), err);
+
+	switch (err) {
+	case EIO:
+		return LIBUSB_ERROR_IO;
+	case EACCES:
+		return LIBUSB_ERROR_ACCESS;
+	case ENOENT:
+		return LIBUSB_ERROR_NO_DEVICE;
+	case ENOMEM:
+		return LIBUSB_ERROR_NO_MEM;
+	case ETIMEDOUT:
+		return LIBUSB_ERROR_TIMEOUT;
+	}
+
+	return LIBUSB_ERROR_OTHER;
+}
+
+int
+_cache_active_config_descriptor(struct libusb_device *dev)
+{
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
+	struct usb_device_cdesc udc;
+	struct usb_device_fdesc udf;
+	void *buf;
+	int fd, len, err;
+
+	if ((fd = _bus_open(dev->bus_number)) < 0)
+		return _errno_to_libusb(errno);
+
+	usbi_dbg(DEVICE_CTX(dev), "fd %d, addr %d", fd, dev->device_address);
+
+	udc.udc_bus = dev->bus_number;
+	udc.udc_addr = dev->device_address;
+	udc.udc_config_index = USB_CURRENT_CONFIG_INDEX;
+	if (ioctl(fd, USB_DEVICE_GET_CDESC, &udc) < 0) {
+		err = errno;
+		close(fd);
+		return _errno_to_libusb(errno);
+	}
+
+	usbi_dbg(DEVICE_CTX(dev), "active bLength %d", udc.udc_desc.bLength);
+
+	len = UGETW(udc.udc_desc.wTotalLength);
+	buf = malloc((size_t)len);
+	if (buf == NULL)
+		return LIBUSB_ERROR_NO_MEM;
+
+	udf.udf_bus = dev->bus_number;
+	udf.udf_addr = dev->device_address;
+	udf.udf_config_index = udc.udc_config_index;
+	udf.udf_size = len;
+	udf.udf_data = buf;
+
+	usbi_dbg(DEVICE_CTX(dev), "index %d, len %d", udf.udf_config_index, len);
+
+	if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
+		err = errno;
+		close(fd);
+		free(buf);
+		return _errno_to_libusb(err);
+	}
+	close(fd);
+
+	if (dpriv->cdesc)
+		free(dpriv->cdesc);
+	dpriv->cdesc = buf;
+
+	return LIBUSB_SUCCESS;
+}
+
+int
+_sync_control_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	struct libusb_control_setup *setup;
+	struct device_priv *dpriv;
+	struct usb_ctl_request req;
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
+	setup = (struct libusb_control_setup *)transfer->buffer;
+
+	usbi_dbg(ITRANSFER_CTX(itransfer), "type 0x%x request 0x%x value 0x%x index %d length %d timeout %d",
+	    setup->bmRequestType, setup->bRequest,
+	    libusb_le16_to_cpu(setup->wValue),
+	    libusb_le16_to_cpu(setup->wIndex),
+	    libusb_le16_to_cpu(setup->wLength), transfer->timeout);
+
+	req.ucr_addr = transfer->dev_handle->dev->device_address;
+	req.ucr_request.bmRequestType = setup->bmRequestType;
+	req.ucr_request.bRequest = setup->bRequest;
+	/* Don't use USETW, libusb already deals with the endianness */
+	(*(uint16_t *)req.ucr_request.wValue) = setup->wValue;
+	(*(uint16_t *)req.ucr_request.wIndex) = setup->wIndex;
+	(*(uint16_t *)req.ucr_request.wLength) = setup->wLength;
+	req.ucr_data = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+
+	if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+		req.ucr_flags = USBD_SHORT_XFER_OK;
+
+	if (dpriv->devname == NULL) {
+		/*
+		 * XXX If the device is not attached to ugen(4) it is
+		 * XXX still possible to submit a control transfer but
+		 * XXX with the default timeout only.
+		 */
+		int fd, err;
+
+		if ((fd = _bus_open(transfer->dev_handle->dev->bus_number)) < 0)
+			return _errno_to_libusb(errno);
+
+		if (ioctl(fd, USB_REQUEST, &req) < 0) {
+			err = errno;
+			close(fd);
+			return _errno_to_libusb(err);
+		}
+		close(fd);
+	} else {
+		if (ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout) < 0)
+			return _errno_to_libusb(errno);
+
+		if (ioctl(dpriv->fd, USB_DO_REQUEST, &req) < 0)
+			return _errno_to_libusb(errno);
+	}
+
+	itransfer->transferred = req.ucr_actlen;
+
+	usbi_dbg(ITRANSFER_CTX(itransfer), "transferred %d", itransfer->transferred);
+
+	return 0;
+}
+
+int
+_access_endpoint(struct libusb_transfer *transfer)
+{
+	struct handle_priv *hpriv;
+	struct device_priv *dpriv;
+	char devnode[16];
+	int fd, endpt;
+	mode_t mode;
+
+	hpriv = usbi_get_device_handle_priv(transfer->dev_handle);
+	dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
+
+	endpt = UE_GET_ADDR(transfer->endpoint);
+	mode = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
+
+	usbi_dbg(TRANSFER_CTX(transfer), "endpoint %d mode %d", endpt, mode);
+
+	if (hpriv->endpoints[endpt] < 0) {
+		/* Pick the right endpoint node */
+		snprintf(devnode, sizeof(devnode), DEVPATH "%s.%02d",
+		    dpriv->devname, endpt);
+
+		/* We may need to read/write to the same endpoint later. */
+		if (((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
+			if ((fd = open(devnode, mode)) < 0)
+				return -1;
+
+		hpriv->endpoints[endpt] = fd;
+	}
+
+	return hpriv->endpoints[endpt];
+}
+
+int
+_sync_gen_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer;
+	struct device_priv *dpriv;
+	int fd, nr = 1;
+
+	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
+
+	if (dpriv->devname == NULL)
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+
+	/*
+	 * Bulk, Interrupt or Isochronous transfer depends on the
+	 * endpoint and thus the node to open.
+	 */
+	if ((fd = _access_endpoint(transfer)) < 0)
+		return _errno_to_libusb(errno);
+
+	if (ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout) < 0)
+		return _errno_to_libusb(errno);
+
+	if (IS_XFERIN(transfer)) {
+		if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+			if (ioctl(fd, USB_SET_SHORT_XFER, &nr) < 0)
+				return _errno_to_libusb(errno);
+
+		nr = read(fd, transfer->buffer, transfer->length);
+	} else {
+		nr = write(fd, transfer->buffer, transfer->length);
+	}
+
+	if (nr < 0)
+		return _errno_to_libusb(errno);
+
+	itransfer->transferred = nr;
+
+	return 0;
+}
+
+int
+_bus_open(int number)
+{
+	char busnode[16];
+
+	snprintf(busnode, sizeof(busnode), USBDEV "%d", number);
+
+	return open(busnode, O_RDWR);
+}

deps/libusb/libusb/os/sunos_usb.h

@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright (c) 2016, Oracle and/or its affiliates.
+ *
+ * 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
+ */
+
+#ifndef	LIBUSB_SUNOS_H
+#define	LIBUSB_SUNOS_H
+
+#include <libdevinfo.h>
+#include <pthread.h>
+#include "libusbi.h"
+
+#define	READ	0
+#define	WRITE	1
+
+typedef struct sunos_device_priv {
+	uint8_t	cfgvalue;		/* active config value */
+	uint8_t	*raw_cfgdescr;		/* active config descriptor */
+	char	*ugenpath;		/* name of the ugen(4) node */
+	char	*phypath;		/* physical path */
+} sunos_dev_priv_t;
+
+typedef	struct endpoint {
+	int datafd;	/* data file */
+	int statfd;	/* state file */
+} sunos_ep_priv_t;
+
+typedef struct sunos_device_handle_priv {
+	uint8_t			altsetting[USB_MAXINTERFACES];	/* a interface's alt */
+	uint8_t			config_index;
+	sunos_ep_priv_t		eps[USB_MAXENDPOINTS];
+	sunos_dev_priv_t	*dpriv; /* device private */
+} sunos_dev_handle_priv_t;
+
+typedef	struct sunos_transfer_priv {
+	struct aiocb		aiocb;
+	struct libusb_transfer	*transfer;
+} sunos_xfer_priv_t;
+
+struct node_args {
+	struct libusb_context	*ctx;
+	struct discovered_devs	**discdevs;
+	const char		*last_ugenpath;
+	di_devlink_handle_t	dlink_hdl;
+};
+
+struct devlink_cbarg {
+	struct node_args	*nargs;	/* di node walk arguments */
+	di_node_t		myself;	/* the di node */
+	di_minor_t		minor;
+};
+
+typedef struct walk_link {
+	char *path;
+	int len;
+	char **linkpp;
+} walk_link_t;
+
+/* AIO callback args */
+struct aio_callback_args{
+	struct libusb_transfer *transfer;
+	struct aiocb aiocb;
+};
+
+#endif /* LIBUSB_SUNOS_H */

deps/libusb/libusb/os/threads_posix.c

@@ -0,0 +1,125 @@
+/*
+ * libusb synchronization using POSIX Threads
+ *
+ * Copyright © 2011 Vitali Lovich <vlovich@aliph.com>
+ * Copyright © 2011 Peter Stuge <peter@stuge.se>
+ *
+ * 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 "libusbi.h"
+
+#include <errno.h>
+#if defined(__ANDROID__)
+# include <unistd.h>
+#elif defined(__HAIKU__)
+# include <os/kernel/OS.h>
+#elif defined(__linux__)
+# include <sys/syscall.h>
+# include <unistd.h>
+#elif defined(__NetBSD__)
+# include <lwp.h>
+#elif defined(__OpenBSD__)
+# include <unistd.h>
+#elif defined(__sun__)
+# include <sys/lwp.h>
+#endif
+
+void usbi_cond_init(pthread_cond_t *cond)
+{
+#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK
+	pthread_condattr_t condattr;
+
+	PTHREAD_CHECK(pthread_condattr_init(&condattr));
+	PTHREAD_CHECK(pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC));
+	PTHREAD_CHECK(pthread_cond_init(cond, &condattr));
+	PTHREAD_CHECK(pthread_condattr_destroy(&condattr));
+#else
+	PTHREAD_CHECK(pthread_cond_init(cond, NULL));
+#endif
+}
+
+int usbi_cond_timedwait(pthread_cond_t *cond,
+	pthread_mutex_t *mutex, const struct timeval *tv)
+{
+	struct timespec timeout;
+	int r;
+
+#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK
+	usbi_get_monotonic_time(&timeout);
+#else
+	usbi_get_real_time(&timeout);
+#endif
+
+	timeout.tv_sec += tv->tv_sec;
+	timeout.tv_nsec += tv->tv_usec * 1000L;
+	if (timeout.tv_nsec >= NSEC_PER_SEC) {
+		timeout.tv_nsec -= NSEC_PER_SEC;
+		timeout.tv_sec++;
+	}
+
+	r = pthread_cond_timedwait(cond, mutex, &timeout);
+	if (r == 0)
+		return 0;
+	else if (r == ETIMEDOUT)
+		return LIBUSB_ERROR_TIMEOUT;
+	else
+		return LIBUSB_ERROR_OTHER;
+}
+
+unsigned int usbi_get_tid(void)
+{
+	static _Thread_local unsigned int tl_tid;
+	int tid;
+
+	if (tl_tid)
+		return tl_tid;
+
+#if defined(__ANDROID__)
+	tid = gettid();
+#elif defined(__APPLE__)
+#ifdef HAVE_PTHREAD_THREADID_NP
+	uint64_t thread_id;
+
+	if (pthread_threadid_np(NULL, &thread_id) == 0)
+		tid = (int)thread_id;
+	else
+		tid = -1;
+#else
+	tid = (int)pthread_mach_thread_np(pthread_self());
+#endif
+#elif defined(__HAIKU__)
+	tid = get_pthread_thread_id(pthread_self());
+#elif defined(__linux__)
+	tid = (int)syscall(SYS_gettid);
+#elif defined(__NetBSD__)
+	tid = _lwp_self();
+#elif defined(__OpenBSD__)
+	tid = getthrid();
+#elif defined(__sun__)
+	tid = _lwp_self();
+#else
+	tid = -1;
+#endif
+
+	if (tid == -1) {
+		/* If we don't have a thread ID, at least return a unique
+		 * value that can be used to distinguish individual
+		 * threads. */
+		tid = (int)(intptr_t)pthread_self();
+	}
+
+	return tl_tid = (unsigned int)tid;
+}

deps/libusb/libusb/os/threads_posix.h

@@ -0,0 +1,98 @@
+/*
+ * libusb synchronization using POSIX Threads
+ *
+ * Copyright © 2010 Peter Stuge <peter@stuge.se>
+ *
+ * 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
+ */
+
+#ifndef LIBUSB_THREADS_POSIX_H
+#define LIBUSB_THREADS_POSIX_H
+
+#include <pthread.h>
+
+#define PTHREAD_CHECK(expression)	ASSERT_EQ(expression, 0)
+
+#define USBI_MUTEX_INITIALIZER	PTHREAD_MUTEX_INITIALIZER
+typedef pthread_mutex_t usbi_mutex_static_t;
+static inline void usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
+{
+	PTHREAD_CHECK(pthread_mutex_lock(mutex));
+}
+static inline void usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
+{
+	PTHREAD_CHECK(pthread_mutex_unlock(mutex));
+}
+
+typedef pthread_mutex_t usbi_mutex_t;
+static inline void usbi_mutex_init(usbi_mutex_t *mutex)
+{
+	PTHREAD_CHECK(pthread_mutex_init(mutex, NULL));
+}
+static inline void usbi_mutex_lock(usbi_mutex_t *mutex)
+{
+	PTHREAD_CHECK(pthread_mutex_lock(mutex));
+}
+static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
+{
+	PTHREAD_CHECK(pthread_mutex_unlock(mutex));
+}
+static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
+{
+	return pthread_mutex_trylock(mutex) == 0;
+}
+static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
+{
+	PTHREAD_CHECK(pthread_mutex_destroy(mutex));
+}
+
+typedef pthread_cond_t usbi_cond_t;
+void usbi_cond_init(pthread_cond_t *cond);
+static inline void usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
+{
+	PTHREAD_CHECK(pthread_cond_wait(cond, mutex));
+}
+int usbi_cond_timedwait(usbi_cond_t *cond,
+	usbi_mutex_t *mutex, const struct timeval *tv);
+static inline void usbi_cond_broadcast(usbi_cond_t *cond)
+{
+	PTHREAD_CHECK(pthread_cond_broadcast(cond));
+}
+static inline void usbi_cond_destroy(usbi_cond_t *cond)
+{
+	PTHREAD_CHECK(pthread_cond_destroy(cond));
+}
+
+typedef pthread_key_t usbi_tls_key_t;
+static inline void usbi_tls_key_create(usbi_tls_key_t *key)
+{
+	PTHREAD_CHECK(pthread_key_create(key, NULL));
+}
+static inline void *usbi_tls_key_get(usbi_tls_key_t key)
+{
+	return pthread_getspecific(key);
+}
+static inline void usbi_tls_key_set(usbi_tls_key_t key, void *ptr)
+{
+	PTHREAD_CHECK(pthread_setspecific(key, ptr));
+}
+static inline void usbi_tls_key_delete(usbi_tls_key_t key)
+{
+	PTHREAD_CHECK(pthread_key_delete(key));
+}
+
+unsigned int usbi_get_tid(void);
+
+#endif /* LIBUSB_THREADS_POSIX_H */

deps/libusb/libusb/os/threads_windows.c

@@ -0,0 +1,40 @@
+/*
+ * libusb synchronization on Microsoft Windows
+ *
+ * Copyright © 2010 Michael Plante <michael.plante@gmail.com>
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * 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 "libusbi.h"
+
+int usbi_cond_timedwait(usbi_cond_t *cond,
+	usbi_mutex_t *mutex, const struct timeval *tv)
+{
+	DWORD millis;
+
+	millis = (DWORD)(tv->tv_sec * 1000L) + (tv->tv_usec / 1000L);
+	/* round up to next millisecond */
+	if (tv->tv_usec % 1000L)
+		millis++;
+
+	if (SleepConditionVariableCS(cond, mutex, millis))
+		return 0;
+	else if (GetLastError() == ERROR_TIMEOUT)
+		return LIBUSB_ERROR_TIMEOUT;
+	else
+		return LIBUSB_ERROR_OTHER;
+}

deps/libusb/libusb/os/threads_windows.h

@@ -0,0 +1,113 @@
+/*
+ * libusb synchronization on Microsoft Windows
+ *
+ * Copyright © 2010 Michael Plante <michael.plante@gmail.com>
+ *
+ * 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
+ */
+
+#ifndef LIBUSB_THREADS_WINDOWS_H
+#define LIBUSB_THREADS_WINDOWS_H
+
+#define WINAPI_CHECK(expression)	ASSERT_NE(expression, 0)
+
+#define USBI_MUTEX_INITIALIZER	0L
+typedef LONG usbi_mutex_static_t;
+static inline void usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
+{
+	while (InterlockedExchange(mutex, 1L) == 1L)
+		SleepEx(0, TRUE);
+}
+static inline void usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
+{
+	InterlockedExchange(mutex, 0L);
+}
+
+typedef CRITICAL_SECTION usbi_mutex_t;
+static inline void usbi_mutex_init(usbi_mutex_t *mutex)
+{
+	InitializeCriticalSection(mutex);
+}
+static inline void usbi_mutex_lock(usbi_mutex_t *mutex)
+{
+	EnterCriticalSection(mutex);
+}
+static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
+{
+	LeaveCriticalSection(mutex);
+}
+static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
+{
+	return TryEnterCriticalSection(mutex) != 0;
+}
+static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
+{
+	DeleteCriticalSection(mutex);
+}
+
+#if !defined(HAVE_STRUCT_TIMESPEC) && !defined(_TIMESPEC_DEFINED)
+#define HAVE_STRUCT_TIMESPEC 1
+#define _TIMESPEC_DEFINED 1
+struct timespec {
+	long tv_sec;
+	long tv_nsec;
+};
+#endif /* HAVE_STRUCT_TIMESPEC || _TIMESPEC_DEFINED */
+
+typedef CONDITION_VARIABLE usbi_cond_t;
+static inline void usbi_cond_init(usbi_cond_t *cond)
+{
+	InitializeConditionVariable(cond);
+}
+static inline void usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
+{
+	WINAPI_CHECK(SleepConditionVariableCS(cond, mutex, INFINITE));
+}
+int usbi_cond_timedwait(usbi_cond_t *cond,
+	usbi_mutex_t *mutex, const struct timeval *tv);
+static inline void usbi_cond_broadcast(usbi_cond_t *cond)
+{
+	WakeAllConditionVariable(cond);
+}
+static inline void usbi_cond_destroy(usbi_cond_t *cond)
+{
+	UNUSED(cond);
+}
+
+typedef DWORD usbi_tls_key_t;
+static inline void usbi_tls_key_create(usbi_tls_key_t *key)
+{
+	*key = TlsAlloc();
+	assert(*key != TLS_OUT_OF_INDEXES);
+}
+static inline void *usbi_tls_key_get(usbi_tls_key_t key)
+{
+	return TlsGetValue(key);
+}
+static inline void usbi_tls_key_set(usbi_tls_key_t key, void *ptr)
+{
+	WINAPI_CHECK(TlsSetValue(key, ptr));
+}
+static inline void usbi_tls_key_delete(usbi_tls_key_t key)
+{
+	WINAPI_CHECK(TlsFree(key));
+}
+
+static inline unsigned int usbi_get_tid(void)
+{
+	return (unsigned int)GetCurrentThreadId();
+}
+
+#endif /* LIBUSB_THREADS_WINDOWS_H */

deps/libusb/libusb/os/windows_common.c

@@ -0,0 +1,923 @@
+/*
+ * windows backend for libusb 1.0
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * HID Reports IOCTLs inspired from HIDAPI by Alan Ott, Signal 11 Software
+ * Hash table functions adapted from glibc, by Ulrich Drepper et al.
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * 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 <config.h>
+
+#include <stdio.h>
+
+#include "libusbi.h"
+#include "windows_common.h"
+
+#define EPOCH_TIME	UINT64_C(116444736000000000)	// 1970.01.01 00:00:000 in MS Filetime
+
+#define STATUS_SUCCESS	((ULONG_PTR)0UL)
+
+// Public
+enum windows_version windows_version = WINDOWS_UNDEFINED;
+
+// Global variables for init/exit
+static unsigned int init_count;
+static bool usbdk_available;
+
+/*
+* Converts a windows error to human readable string
+* uses retval as errorcode, or, if 0, use GetLastError()
+*/
+#if defined(ENABLE_LOGGING)
+const char *windows_error_str(DWORD error_code)
+{
+	static char err_string[256];
+
+	DWORD size;
+	int len;
+
+	if (error_code == 0)
+		error_code = GetLastError();
+
+	len = sprintf(err_string, "[%lu] ", ULONG_CAST(error_code));
+
+	// Translate codes returned by SetupAPI. The ones we are dealing with are either
+	// in 0x0000xxxx or 0xE000xxxx and can be distinguished from standard error codes.
+	// See http://msdn.microsoft.com/en-us/library/windows/hardware/ff545011.aspx
+	switch (error_code & 0xE0000000) {
+	case 0:
+		error_code = HRESULT_FROM_WIN32(error_code); // Still leaves ERROR_SUCCESS unmodified
+		break;
+	case 0xE0000000:
+		error_code = 0x80000000 | (FACILITY_SETUPAPI << 16) | (error_code & 0x0000FFFF);
+		break;
+	default:
+		break;
+	}
+
+	size = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
+			NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+			&err_string[len], sizeof(err_string) - len, NULL);
+	if (size == 0) {
+		DWORD format_error = GetLastError();
+		if (format_error)
+			snprintf(err_string, sizeof(err_string),
+				"Windows error code %lu (FormatMessage error code %lu)",
+				ULONG_CAST(error_code), ULONG_CAST(format_error));
+		else
+			snprintf(err_string, sizeof(err_string), "Unknown error code %lu",
+				ULONG_CAST(error_code));
+	} else {
+		// Remove CRLF from end of message, if present
+		size_t pos = len + size - 2;
+		if (err_string[pos] == '\r')
+			err_string[pos] = '\0';
+	}
+
+	return err_string;
+}
+#endif
+
+/*
+ * Dynamically loads a DLL from the Windows system directory.  Unlike the
+ * LoadLibraryA() function, this function will not search through any
+ * directories to try and find the library.
+ */
+HMODULE load_system_library(struct libusb_context *ctx, const char *name)
+{
+	char library_path[MAX_PATH];
+	char *filename_start;
+	UINT length;
+
+	length = GetSystemDirectoryA(library_path, sizeof(library_path));
+	if ((length == 0) || (length >= (UINT)sizeof(library_path))) {
+		usbi_err(ctx, "program assertion failed - could not get system directory");
+		return NULL;
+	}
+
+	filename_start = library_path + length;
+	// Append '\' + name + ".dll" + NUL
+	length += 1 + (UINT)strlen(name) + 4 + 1;
+	if (length >= (UINT)sizeof(library_path)) {
+		usbi_err(ctx, "program assertion failed - library path buffer overflow");
+		return NULL;
+	}
+
+	sprintf(filename_start, "\\%s.dll", name);
+	return LoadLibraryA(library_path);
+}
+
+/* Hash table functions - modified From glibc 2.3.2:
+   [Aho,Sethi,Ullman] Compilers: Principles, Techniques and Tools, 1986
+   [Knuth]            The Art of Computer Programming, part 3 (6.4)  */
+
+#define HTAB_SIZE 1021UL	// *MUST* be a prime number!!
+
+typedef struct htab_entry {
+	unsigned long used;
+	char *str;
+} htab_entry;
+
+static htab_entry *htab_table;
+static usbi_mutex_t htab_mutex;
+static unsigned long htab_filled;
+
+/* Before using the hash table we must allocate memory for it.
+   We allocate one element more as the found prime number says.
+   This is done for more effective indexing as explained in the
+   comment for the hash function.  */
+static bool htab_create(struct libusb_context *ctx)
+{
+	if (htab_table != NULL) {
+		usbi_err(ctx, "program assertion failed - hash table already allocated");
+		return true;
+	}
+
+	// Create a mutex
+	usbi_mutex_init(&htab_mutex);
+
+	usbi_dbg(ctx, "using %lu entries hash table", HTAB_SIZE);
+	htab_filled = 0;
+
+	// allocate memory and zero out.
+	htab_table = calloc(HTAB_SIZE + 1, sizeof(htab_entry));
+	if (htab_table == NULL) {
+		usbi_err(ctx, "could not allocate space for hash table");
+		return false;
+	}
+
+	return true;
+}
+
+/* After using the hash table it has to be destroyed.  */
+static void htab_destroy(void)
+{
+	unsigned long i;
+
+	if (htab_table == NULL)
+		return;
+
+	for (i = 0; i < HTAB_SIZE; i++)
+		free(htab_table[i].str);
+
+	safe_free(htab_table);
+
+	usbi_mutex_destroy(&htab_mutex);
+}
+
+/* This is the search function. It uses double hashing with open addressing.
+   We use a trick to speed up the lookup. The table is created with one
+   more element available. This enables us to use the index zero special.
+   This index will never be used because we store the first hash index in
+   the field used where zero means not used. Every other value means used.
+   The used field can be used as a first fast comparison for equality of
+   the stored and the parameter value. This helps to prevent unnecessary
+   expensive calls of strcmp.  */
+unsigned long htab_hash(const char *str)
+{
+	unsigned long hval, hval2;
+	unsigned long idx;
+	unsigned long r = 5381UL;
+	int c;
+	const char *sz = str;
+
+	if (str == NULL)
+		return 0;
+
+	// Compute main hash value (algorithm suggested by Nokia)
+	while ((c = *sz++) != 0)
+		r = ((r << 5) + r) + c;
+	if (r == 0)
+		++r;
+
+	// compute table hash: simply take the modulus
+	hval = r % HTAB_SIZE;
+	if (hval == 0)
+		++hval;
+
+	// Try the first index
+	idx = hval;
+
+	// Mutually exclusive access (R/W lock would be better)
+	usbi_mutex_lock(&htab_mutex);
+
+	if (htab_table[idx].used) {
+		if ((htab_table[idx].used == hval) && (strcmp(str, htab_table[idx].str) == 0))
+			goto out_unlock; // existing hash
+
+		usbi_dbg(NULL, "hash collision ('%s' vs '%s')", str, htab_table[idx].str);
+
+		// Second hash function, as suggested in [Knuth]
+		hval2 = 1UL + hval % (HTAB_SIZE - 2);
+
+		do {
+			// Because size is prime this guarantees to step through all available indexes
+			if (idx <= hval2)
+				idx = HTAB_SIZE + idx - hval2;
+			else
+				idx -= hval2;
+
+			// If we visited all entries leave the loop unsuccessfully
+			if (idx == hval)
+				break;
+
+			// If entry is found use it.
+			if ((htab_table[idx].used == hval) && (strcmp(str, htab_table[idx].str) == 0))
+				goto out_unlock;
+		} while (htab_table[idx].used);
+	}
+
+	// Not found => New entry
+
+	// If the table is full return an error
+	if (htab_filled >= HTAB_SIZE) {
+		usbi_err(NULL, "hash table is full (%lu entries)", HTAB_SIZE);
+		idx = 0UL;
+		goto out_unlock;
+	}
+
+	htab_table[idx].str = _strdup(str);
+	if (htab_table[idx].str == NULL) {
+		usbi_err(NULL, "could not duplicate string for hash table");
+		idx = 0UL;
+		goto out_unlock;
+	}
+
+	htab_table[idx].used = hval;
+	++htab_filled;
+
+out_unlock:
+	usbi_mutex_unlock(&htab_mutex);
+
+	return idx;
+}
+
+enum libusb_transfer_status usbd_status_to_libusb_transfer_status(USBD_STATUS status)
+{
+	if (USBD_SUCCESS(status))
+		return LIBUSB_TRANSFER_COMPLETED;
+
+	switch (status) {
+	case USBD_STATUS_TIMEOUT:
+		return LIBUSB_TRANSFER_TIMED_OUT;
+	case USBD_STATUS_CANCELED:
+		return LIBUSB_TRANSFER_CANCELLED;
+	case USBD_STATUS_ENDPOINT_HALTED:
+	case USBD_STATUS_STALL_PID:
+		return LIBUSB_TRANSFER_STALL;
+	case USBD_STATUS_DEVICE_GONE:
+		return LIBUSB_TRANSFER_NO_DEVICE;
+	default:
+		usbi_dbg(NULL, "USBD_STATUS 0x%08lx translated to LIBUSB_TRANSFER_ERROR", ULONG_CAST(status));
+		return LIBUSB_TRANSFER_ERROR;
+	}
+}
+
+/*
+ * Make a transfer complete synchronously
+ */
+void windows_force_sync_completion(struct usbi_transfer *itransfer, ULONG size)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct windows_context_priv *priv = usbi_get_context_priv(TRANSFER_CTX(transfer));
+	struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+	OVERLAPPED *overlapped = &transfer_priv->overlapped;
+
+	usbi_dbg(TRANSFER_CTX(transfer), "transfer %p, length %lu", transfer, ULONG_CAST(size));
+
+	overlapped->Internal = (ULONG_PTR)STATUS_SUCCESS;
+	overlapped->InternalHigh = (ULONG_PTR)size;
+
+	if (!PostQueuedCompletionStatus(priv->completion_port, (DWORD)size, (ULONG_PTR)transfer->dev_handle, overlapped))
+		usbi_err(TRANSFER_CTX(transfer), "failed to post I/O completion: %s", windows_error_str(0));
+}
+
+/* Windows version detection */
+static BOOL is_x64(void)
+{
+	BOOL ret = FALSE;
+
+	// Detect if we're running a 32 or 64 bit system
+	if (sizeof(uintptr_t) < 8) {
+		IsWow64Process(GetCurrentProcess(), &ret);
+	} else {
+		ret = TRUE;
+	}
+
+	return ret;
+}
+
+static enum windows_version get_windows_version(void)
+{
+	enum windows_version winver;
+	OSVERSIONINFOEXA vi, vi2;
+	unsigned major, minor, version;
+	ULONGLONG major_equal, minor_equal;
+	const char *w, *arch;
+	bool ws;
+
+#ifndef ENABLE_LOGGING
+	UNUSED(w); UNUSED(arch);
+#endif
+	memset(&vi, 0, sizeof(vi));
+	vi.dwOSVersionInfoSize = sizeof(vi);
+	if (!GetVersionExA((OSVERSIONINFOA *)&vi)) {
+		memset(&vi, 0, sizeof(vi));
+		vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
+		if (!GetVersionExA((OSVERSIONINFOA *)&vi))
+			return WINDOWS_UNDEFINED;
+	}
+
+	if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
+		return WINDOWS_UNDEFINED;
+
+	if ((vi.dwMajorVersion > 6) || ((vi.dwMajorVersion == 6) && (vi.dwMinorVersion >= 2))) {
+		// Starting with Windows 8.1 Preview, GetVersionEx() does no longer report the actual OS version
+		// See: http://msdn.microsoft.com/en-us/library/windows/desktop/dn302074.aspx
+		// And starting with Windows 10 Preview 2, Windows enforces the use of the application/supportedOS
+		// manifest in order for VerSetConditionMask() to report the ACTUAL OS major and minor...
+
+		major_equal = VerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL);
+		for (major = vi.dwMajorVersion; major <= 9; major++) {
+			memset(&vi2, 0, sizeof(vi2));
+			vi2.dwOSVersionInfoSize = sizeof(vi2);
+			vi2.dwMajorVersion = major;
+			if (!VerifyVersionInfoA(&vi2, VER_MAJORVERSION, major_equal))
+				continue;
+
+			if (vi.dwMajorVersion < major) {
+				vi.dwMajorVersion = major;
+				vi.dwMinorVersion = 0;
+			}
+
+			minor_equal = VerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL);
+			for (minor = vi.dwMinorVersion; minor <= 9; minor++) {
+				memset(&vi2, 0, sizeof(vi2));
+				vi2.dwOSVersionInfoSize = sizeof(vi2);
+				vi2.dwMinorVersion = minor;
+				if (!VerifyVersionInfoA(&vi2, VER_MINORVERSION, minor_equal))
+					continue;
+
+				vi.dwMinorVersion = minor;
+				break;
+			}
+
+			break;
+		}
+	}
+
+	if ((vi.dwMajorVersion > 0xf) || (vi.dwMinorVersion > 0xf))
+		return WINDOWS_UNDEFINED;
+
+	ws = (vi.wProductType <= VER_NT_WORKSTATION);
+	version = vi.dwMajorVersion << 4 | vi.dwMinorVersion;
+
+	switch (version) {
+	case 0x50: winver = WINDOWS_2000;  w = "2000"; break;
+	case 0x51: winver = WINDOWS_XP;	   w = "XP";   break;
+	case 0x52: winver = WINDOWS_2003;  w = "2003"; break;
+	case 0x60: winver = WINDOWS_VISTA; w = (ws ? "Vista" : "2008");	 break;
+	case 0x61: winver = WINDOWS_7;	   w = (ws ? "7" : "2008_R2");	 break;
+	case 0x62: winver = WINDOWS_8;	   w = (ws ? "8" : "2012");	 break;
+	case 0x63: winver = WINDOWS_8_1;   w = (ws ? "8.1" : "2012_R2"); break;
+	case 0x64: // Early Windows 10 Insider Previews and Windows Server 2017 Technical Preview 1 used version 6.4
+	case 0xA0: winver = WINDOWS_10;	   w = (ws ? "10" : "2016");
+		   if (vi.dwBuildNumber < 20000)
+			   break;
+		   // fallthrough
+	case 0xB0: winver = WINDOWS_11;	   w = (ws ? "11" : "2022");	 break;
+	default:
+		if (version < 0x50)
+			return WINDOWS_UNDEFINED;
+		winver = WINDOWS_12_OR_LATER;
+		w = "12 or later";
+	}
+
+	// We cannot tell if we are on 8, 10, or 11 without "app manifest"
+	if (version == 0x62 && vi.dwBuildNumber == 9200)
+		w = "8 (or later)";
+
+	arch = is_x64() ? "64-bit" : "32-bit";
+
+	if (vi.wServicePackMinor)
+		usbi_dbg(NULL, "Windows %s SP%u.%u %s", w, vi.wServicePackMajor, vi.wServicePackMinor, arch);
+	else if (vi.wServicePackMajor)
+		usbi_dbg(NULL, "Windows %s SP%u %s", w, vi.wServicePackMajor, arch);
+	else
+		usbi_dbg(NULL, "Windows %s %s", w, arch);
+
+	return winver;
+}
+
+static unsigned __stdcall windows_iocp_thread(void *arg)
+{
+	struct libusb_context *ctx = arg;
+	struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+	HANDLE iocp = priv->completion_port;
+	DWORD num_bytes;
+	ULONG_PTR completion_key;
+	OVERLAPPED *overlapped;
+	struct libusb_device_handle *dev_handle;
+	struct libusb_device_handle *opened_device_handle;
+	struct windows_device_handle_priv *handle_priv;
+	struct windows_transfer_priv *transfer_priv;
+	struct usbi_transfer *itransfer;
+	bool found;
+
+	usbi_dbg(ctx, "I/O completion thread started");
+
+	while (true) {
+		overlapped = NULL;
+		if (!GetQueuedCompletionStatus(iocp, &num_bytes, &completion_key, &overlapped, INFINITE) && (overlapped == NULL)) {
+			usbi_err(ctx, "GetQueuedCompletionStatus failed: %s", windows_error_str(0));
+			break;
+		}
+
+		if (overlapped == NULL) {
+			// Signal to quit
+			if (completion_key != (ULONG_PTR)ctx)
+				usbi_err(ctx, "program assertion failed - overlapped is NULL");
+			break;
+		}
+
+		// Find the transfer associated with the OVERLAPPED that just completed.
+		// If we cannot find a match, the I/O operation originated from outside of libusb
+		// (e.g. within libusbK) and we need to ignore it.
+		dev_handle = (struct libusb_device_handle *)completion_key;
+
+		found = false;
+		transfer_priv = NULL;
+
+		// Issue 912: lock opened device handles in context to search the current device handle
+		// to avoid accessing unallocated memory after device has been closed
+		usbi_mutex_lock(&ctx->open_devs_lock);
+		for_each_open_device(ctx, opened_device_handle) {
+			if (dev_handle == opened_device_handle) {
+				handle_priv = usbi_get_device_handle_priv(dev_handle);
+
+				usbi_mutex_lock(&dev_handle->lock);
+				list_for_each_entry(transfer_priv, &handle_priv->active_transfers, list, struct windows_transfer_priv) {
+					if (overlapped == &transfer_priv->overlapped) {
+						// This OVERLAPPED belongs to us, remove the transfer from the device handle's list
+						list_del(&transfer_priv->list);
+						found = true;
+						break;
+					}
+				}
+				usbi_mutex_unlock(&dev_handle->lock);
+			}
+		}
+		usbi_mutex_unlock(&ctx->open_devs_lock);
+
+		if (!found) {
+			usbi_dbg(ctx, "ignoring overlapped %p for handle %p",
+				 overlapped, dev_handle);
+			continue;
+		}
+
+		itransfer = TRANSFER_PRIV_TO_USBI_TRANSFER(transfer_priv);
+		struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+		usbi_dbg(ctx, "transfer %p completed, length %lu",
+			 transfer, ULONG_CAST(num_bytes));
+		usbi_signal_transfer_completion(itransfer);
+	}
+
+	usbi_dbg(ctx, "I/O completion thread exiting");
+
+	return 0;
+}
+
+static int windows_init(struct libusb_context *ctx)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+	bool winusb_backend_init = false;
+	int r;
+
+	// NB: concurrent usage supposes that init calls are equally balanced with
+	// exit calls. If init is called more than exit, we will not exit properly
+	if (++init_count == 1) { // First init?
+		windows_version = get_windows_version();
+		if (windows_version == WINDOWS_UNDEFINED) {
+			usbi_err(ctx, "failed to detect Windows version");
+			r = LIBUSB_ERROR_NOT_SUPPORTED;
+			goto init_exit;
+		} else if (windows_version < WINDOWS_VISTA) {
+			usbi_err(ctx, "Windows version is too old");
+			r = LIBUSB_ERROR_NOT_SUPPORTED;
+			goto init_exit;
+		}
+
+		if (!htab_create(ctx)) {
+			r = LIBUSB_ERROR_NO_MEM;
+			goto init_exit;
+		}
+
+		r = winusb_backend.init(ctx);
+		if (r != LIBUSB_SUCCESS)
+			goto init_exit;
+		winusb_backend_init = true;
+
+		r = usbdk_backend.init(ctx);
+		if (r == LIBUSB_SUCCESS) {
+			usbi_dbg(ctx, "UsbDk backend is available");
+			usbdk_available = true;
+		} else {
+			usbi_info(ctx, "UsbDk backend is not available");
+			// Do not report this as an error
+		}
+	}
+
+	// By default, new contexts will use the WinUSB backend
+	priv->backend = &winusb_backend;
+
+	r = LIBUSB_ERROR_NO_MEM;
+
+	// Use an I/O completion port to manage all transfers for this context
+	priv->completion_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);
+	if (priv->completion_port == NULL) {
+		usbi_err(ctx, "failed to create I/O completion port: %s", windows_error_str(0));
+		goto init_exit;
+	}
+
+	// And a dedicated thread to wait for I/O completions
+	priv->completion_port_thread = (HANDLE)_beginthreadex(NULL, 0, windows_iocp_thread, ctx, 0, NULL);
+	if (priv->completion_port_thread == NULL) {
+		usbi_err(ctx, "failed to create I/O completion port thread");
+		CloseHandle(priv->completion_port);
+		goto init_exit;
+	}
+
+	r = LIBUSB_SUCCESS;
+
+init_exit: // Holds semaphore here
+	if ((init_count == 1) && (r != LIBUSB_SUCCESS)) { // First init failed?
+		if (usbdk_available) {
+			usbdk_backend.exit(ctx);
+			usbdk_available = false;
+		}
+		if (winusb_backend_init)
+			winusb_backend.exit(ctx);
+		htab_destroy();
+		--init_count;
+	}
+
+	return r;
+}
+
+static void windows_exit(struct libusb_context *ctx)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+
+	// A NULL completion status will indicate to the thread that it is time to exit
+	if (!PostQueuedCompletionStatus(priv->completion_port, 0, (ULONG_PTR)ctx, NULL))
+		usbi_err(ctx, "failed to post I/O completion: %s", windows_error_str(0));
+
+	if (WaitForSingleObject(priv->completion_port_thread, INFINITE) == WAIT_FAILED)
+		usbi_err(ctx, "failed to wait for I/O completion port thread: %s", windows_error_str(0));
+
+	CloseHandle(priv->completion_port_thread);
+	CloseHandle(priv->completion_port);
+
+	// Only works if exits and inits are balanced exactly
+	if (--init_count == 0) { // Last exit
+		if (usbdk_available) {
+			usbdk_backend.exit(ctx);
+			usbdk_available = false;
+		}
+		winusb_backend.exit(ctx);
+		htab_destroy();
+	}
+}
+
+static int windows_set_option(struct libusb_context *ctx, enum libusb_option option, va_list ap)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+
+	UNUSED(ap);
+
+	if (option == LIBUSB_OPTION_USE_USBDK) {
+		if (!usbdk_available) {
+			usbi_err(ctx, "UsbDk backend not available");
+			return LIBUSB_ERROR_NOT_FOUND;
+		}
+		usbi_dbg(ctx, "switching context %p to use UsbDk backend", ctx);
+		priv->backend = &usbdk_backend;
+		return LIBUSB_SUCCESS;
+	}
+
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int windows_get_device_list(struct libusb_context *ctx, struct discovered_devs **discdevs)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+	return priv->backend->get_device_list(ctx, discdevs);
+}
+
+static int windows_open(struct libusb_device_handle *dev_handle)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	struct windows_device_handle_priv *handle_priv = usbi_get_device_handle_priv(dev_handle);
+
+	list_init(&handle_priv->active_transfers);
+	return priv->backend->open(dev_handle);
+}
+
+static void windows_close(struct libusb_device_handle *dev_handle)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	priv->backend->close(dev_handle);
+}
+
+static int windows_get_active_config_descriptor(struct libusb_device *dev,
+	void *buffer, size_t len)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
+	return priv->backend->get_active_config_descriptor(dev, buffer, len);
+}
+
+static int windows_get_config_descriptor(struct libusb_device *dev,
+	uint8_t config_index, void *buffer, size_t len)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
+	return priv->backend->get_config_descriptor(dev, config_index, buffer, len);
+}
+
+static int windows_get_config_descriptor_by_value(struct libusb_device *dev,
+	uint8_t bConfigurationValue, void **buffer)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
+	return priv->backend->get_config_descriptor_by_value(dev, bConfigurationValue, buffer);
+}
+
+static int windows_get_configuration(struct libusb_device_handle *dev_handle, uint8_t *config)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->get_configuration(dev_handle, config);
+}
+
+static int windows_set_configuration(struct libusb_device_handle *dev_handle, int config)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	if (config == -1)
+		config = 0;
+	return priv->backend->set_configuration(dev_handle, (uint8_t)config);
+}
+
+static int windows_claim_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->claim_interface(dev_handle, interface_number);
+}
+
+static int windows_release_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->release_interface(dev_handle, interface_number);
+}
+
+static int windows_set_interface_altsetting(struct libusb_device_handle *dev_handle,
+	uint8_t interface_number, uint8_t altsetting)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->set_interface_altsetting(dev_handle, interface_number, altsetting);
+}
+
+static int windows_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->clear_halt(dev_handle, endpoint);
+}
+
+static int windows_reset_device(struct libusb_device_handle *dev_handle)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	return priv->backend->reset_device(dev_handle);
+}
+
+static void windows_destroy_device(struct libusb_device *dev)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
+	priv->backend->destroy_device(dev);
+}
+
+static int windows_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct libusb_device_handle *dev_handle = transfer->dev_handle;
+	struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+	struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+	struct windows_device_handle_priv *handle_priv = usbi_get_device_handle_priv(dev_handle);
+	struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+	int r;
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		break;
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+		usbi_warn(ctx, "bulk stream transfers are not yet supported on this platform");
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	default:
+		usbi_err(ctx, "unknown endpoint type %d", transfer->type);
+		return LIBUSB_ERROR_INVALID_PARAM;
+	}
+
+	if (transfer_priv->handle != NULL) {
+		usbi_err(ctx, "program assertion failed - transfer HANDLE is not NULL");
+		transfer_priv->handle = NULL;
+	}
+
+	// Add transfer to the device handle's list
+	usbi_mutex_lock(&dev_handle->lock);
+	list_add_tail(&transfer_priv->list, &handle_priv->active_transfers);
+	usbi_mutex_unlock(&dev_handle->lock);
+
+	r = priv->backend->submit_transfer(itransfer);
+	if (r != LIBUSB_SUCCESS) {
+		// Remove the unsuccessful transfer from the device handle's list
+		usbi_mutex_lock(&dev_handle->lock);
+		list_del(&transfer_priv->list);
+		usbi_mutex_unlock(&dev_handle->lock);
+
+		// Always call the backend's clear_transfer_priv() function on failure
+		priv->backend->clear_transfer_priv(itransfer);
+		transfer_priv->handle = NULL;
+		return r;
+	}
+
+	// The backend should set the HANDLE used for each submitted transfer
+	// by calling set_transfer_priv_handle()
+	if (transfer_priv->handle == NULL)
+		usbi_err(ctx, "program assertion failed - transfer HANDLE is NULL after transfer was submitted");
+
+	return r;
+}
+
+static int windows_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(ITRANSFER_CTX(itransfer));
+	struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+
+	// Try CancelIoEx() on the transfer
+	// If that fails, fall back to the backend's cancel_transfer()
+	// function if it is available
+	if (CancelIoEx(transfer_priv->handle, &transfer_priv->overlapped))
+		return LIBUSB_SUCCESS;
+	else if (GetLastError() == ERROR_NOT_FOUND)
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	if (priv->backend->cancel_transfer)
+		return priv->backend->cancel_transfer(itransfer);
+
+	usbi_warn(ITRANSFER_CTX(itransfer), "cancellation not supported for this transfer's driver");
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int windows_handle_transfer_completion(struct usbi_transfer *itransfer)
+{
+	struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
+	struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+	const struct windows_backend *backend = priv->backend;
+	struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+	enum libusb_transfer_status status, istatus;
+	DWORD result, bytes_transferred;
+
+	if (GetOverlappedResult(transfer_priv->handle, &transfer_priv->overlapped, &bytes_transferred, FALSE))
+		result = NO_ERROR;
+	else
+		result = GetLastError();
+
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	usbi_dbg(ctx, "handling transfer %p completion with errcode %lu, length %lu",
+		 transfer, ULONG_CAST(result), ULONG_CAST(bytes_transferred));
+
+	switch (result) {
+	case NO_ERROR:
+		status = backend->copy_transfer_data(itransfer, bytes_transferred);
+		break;
+	case ERROR_GEN_FAILURE:
+		usbi_dbg(ctx, "detected endpoint stall");
+		status = LIBUSB_TRANSFER_STALL;
+		break;
+	case ERROR_SEM_TIMEOUT:
+		usbi_dbg(ctx, "detected semaphore timeout");
+		status = LIBUSB_TRANSFER_TIMED_OUT;
+		break;
+	case ERROR_OPERATION_ABORTED:
+		istatus = backend->copy_transfer_data(itransfer, bytes_transferred);
+		if (istatus != LIBUSB_TRANSFER_COMPLETED)
+			usbi_dbg(ctx, "failed to copy partial data in aborted operation: %d", (int)istatus);
+
+		usbi_dbg(ctx, "detected operation aborted");
+		status = LIBUSB_TRANSFER_CANCELLED;
+		break;
+	case ERROR_FILE_NOT_FOUND:
+	case ERROR_DEVICE_NOT_CONNECTED:
+	case ERROR_NO_SUCH_DEVICE:
+		usbi_dbg(ctx, "detected device removed");
+		status = LIBUSB_TRANSFER_NO_DEVICE;
+		break;
+	default:
+		usbi_err(ctx, "detected I/O error %lu: %s",
+			ULONG_CAST(result), windows_error_str(result));
+		status = LIBUSB_TRANSFER_ERROR;
+		break;
+	}
+
+	transfer_priv->handle = NULL;
+
+	// Backend-specific cleanup
+	backend->clear_transfer_priv(itransfer);
+
+	if (status == LIBUSB_TRANSFER_CANCELLED)
+		return usbi_handle_transfer_cancellation(itransfer);
+	else
+		return usbi_handle_transfer_completion(itransfer, status);
+}
+
+#ifndef HAVE_CLOCK_GETTIME
+void usbi_get_monotonic_time(struct timespec *tp)
+{
+	static LONG hires_counter_init;
+	static uint64_t hires_ticks_to_ps;
+	static uint64_t hires_frequency;
+	LARGE_INTEGER hires_counter;
+
+	if (InterlockedExchange(&hires_counter_init, 1L) == 0L) {
+		LARGE_INTEGER li_frequency;
+
+		// Microsoft says that the QueryPerformanceFrequency() and
+		// QueryPerformanceCounter() functions always succeed on XP and later
+		QueryPerformanceFrequency(&li_frequency);
+
+		// The hires frequency can go as high as 4 GHz, so we'll use a conversion
+		// to picoseconds to compute the tv_nsecs part
+		hires_frequency = li_frequency.QuadPart;
+		hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency;
+	}
+
+	QueryPerformanceCounter(&hires_counter);
+	tp->tv_sec = (long)(hires_counter.QuadPart / hires_frequency);
+	tp->tv_nsec = (long)(((hires_counter.QuadPart % hires_frequency) * hires_ticks_to_ps) / UINT64_C(1000));
+}
+#endif
+
+// NB: MSVC6 does not support named initializers.
+const struct usbi_os_backend usbi_backend = {
+	"Windows",
+	USBI_CAP_HAS_HID_ACCESS,
+	windows_init,
+	windows_exit,
+	windows_set_option,
+	windows_get_device_list,
+	NULL,	/* hotplug_poll */
+	NULL,	/* wrap_sys_device */
+	windows_open,
+	windows_close,
+	windows_get_active_config_descriptor,
+	windows_get_config_descriptor,
+	windows_get_config_descriptor_by_value,
+	windows_get_configuration,
+	windows_set_configuration,
+	windows_claim_interface,
+	windows_release_interface,
+	windows_set_interface_altsetting,
+	windows_clear_halt,
+	windows_reset_device,
+	NULL,	/* alloc_streams */
+	NULL,	/* free_streams */
+	NULL,	/* dev_mem_alloc */
+	NULL,	/* dev_mem_free */
+	NULL,	/* kernel_driver_active */
+	NULL,	/* detach_kernel_driver */
+	NULL,	/* attach_kernel_driver */
+	windows_destroy_device,
+	windows_submit_transfer,
+	windows_cancel_transfer,
+	NULL,	/* clear_transfer_priv */
+	NULL,	/* handle_events */
+	windows_handle_transfer_completion,
+	sizeof(struct windows_context_priv),
+	sizeof(union windows_device_priv),
+	sizeof(struct windows_device_handle_priv),
+	sizeof(struct windows_transfer_priv),
+};

deps/libusb/libusb/os/windows_common.h

@@ -0,0 +1,424 @@
+/*
+ * Windows backend common header for libusb 1.0
+ *
+ * This file brings together header code common between
+ * the desktop Windows backends.
+ * Copyright © 2012-2013 RealVNC Ltd.
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * Copyright © 2014-2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * 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
+ */
+
+#ifndef LIBUSB_WINDOWS_COMMON_H
+#define LIBUSB_WINDOWS_COMMON_H
+
+#include <stdbool.h>
+
+/*
+ * Workaround for the mess that exists with the DWORD and ULONG types.
+ * Visual Studio unconditionally defines these types as 'unsigned long'
+ * and a long is always 32-bits, even on 64-bit builds. GCC on the other
+ * hand varies the width of a long, matching it to the build. To make
+ * matters worse, the platform headers for these GCC builds define a
+ * DWORD/ULONG to be 'unsigned long' on 32-bit builds and 'unsigned int'
+ * on 64-bit builds. This creates a great deal of warnings for compilers
+ * that support printf format checking since it will never actually be
+ * an unsigned long.
+ */
+#if defined(_MSC_VER)
+#define ULONG_CAST(x)	(x)
+#else
+#define ULONG_CAST(x)	((unsigned long)(x))
+#endif
+
+#if defined(__CYGWIN__)
+#define _stricmp strcasecmp
+#define _strdup strdup
+// _beginthreadex is MSVCRT => unavailable for cygwin. Fallback to using CreateThread
+#define _beginthreadex(a, b, c, d, e, f) CreateThread(a, b, (LPTHREAD_START_ROUTINE)c, d, e, (LPDWORD)f)
+#else
+#include <process.h>
+#endif
+
+#define safe_free(p) do {if (p != NULL) {free((void *)p); p = NULL;}} while (0)
+
+/*
+ * API macros - leveraged from libusb-win32 1.x
+ */
+#define DLL_STRINGIFY(s) #s
+
+/*
+ * Macros for handling DLL themselves
+ */
+#define DLL_HANDLE_NAME(name) __dll_##name##_handle
+
+#define DLL_DECLARE_HANDLE(name)					\
+	static HMODULE DLL_HANDLE_NAME(name)
+
+#define DLL_GET_HANDLE(ctx, name)					\
+	do {								\
+		DLL_HANDLE_NAME(name) = load_system_library(ctx,	\
+				DLL_STRINGIFY(name));			\
+		if (!DLL_HANDLE_NAME(name))				\
+			return false;					\
+	} while (0)
+
+#define DLL_FREE_HANDLE(name)						\
+	do {								\
+		if (DLL_HANDLE_NAME(name)) {				\
+			FreeLibrary(DLL_HANDLE_NAME(name));		\
+			DLL_HANDLE_NAME(name) = NULL;			\
+		}							\
+	} while (0)
+
+/*
+ * Macros for handling functions within a DLL
+ */
+#define DLL_FUNC_NAME(name) __dll_##name##_func_t
+
+#define DLL_DECLARE_FUNC_PREFIXNAME(api, ret, prefixname, name, args)	\
+	typedef ret (api * DLL_FUNC_NAME(name))args;			\
+	static DLL_FUNC_NAME(name) prefixname
+
+#define DLL_DECLARE_FUNC(api, ret, name, args)				\
+	DLL_DECLARE_FUNC_PREFIXNAME(api, ret, name, name, args)
+#define DLL_DECLARE_FUNC_PREFIXED(api, ret, prefix, name, args)		\
+	DLL_DECLARE_FUNC_PREFIXNAME(api, ret, prefix##name, name, args)
+
+#define DLL_LOAD_FUNC_PREFIXNAME(dll, prefixname, name, ret_on_failure)	\
+	do {								\
+		HMODULE h = DLL_HANDLE_NAME(dll);			\
+		prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h,	\
+				DLL_STRINGIFY(name));			\
+		if (prefixname)						\
+			break;						\
+		prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h,	\
+				DLL_STRINGIFY(name) DLL_STRINGIFY(A));	\
+		if (prefixname)						\
+			break;						\
+		prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h,	\
+				DLL_STRINGIFY(name) DLL_STRINGIFY(W));	\
+		if (prefixname)						\
+			break;						\
+		if (ret_on_failure)					\
+			return false;					\
+	} while (0)
+
+#define DLL_LOAD_FUNC(dll, name, ret_on_failure)			\
+	DLL_LOAD_FUNC_PREFIXNAME(dll, name, name, ret_on_failure)
+#define DLL_LOAD_FUNC_PREFIXED(dll, prefix, name, ret_on_failure)	\
+	DLL_LOAD_FUNC_PREFIXNAME(dll, prefix##name, name, ret_on_failure)
+
+// https://msdn.microsoft.com/en-us/library/windows/hardware/ff539136(v=vs.85).aspx
+#if !defined(USBD_SUCCESS)
+typedef LONG USBD_STATUS;
+
+#define USBD_SUCCESS(Status)		((USBD_STATUS)(Status) >= 0)
+
+#define USBD_STATUS_STALL_PID		((USBD_STATUS)0xC0000004L)
+#define USBD_STATUS_ENDPOINT_HALTED	((USBD_STATUS)0xC0000030L)
+#define USBD_STATUS_TIMEOUT		((USBD_STATUS)0xC0006000L)
+#define USBD_STATUS_DEVICE_GONE		((USBD_STATUS)0xC0007000L)
+#define USBD_STATUS_CANCELED		((USBD_STATUS)0xC0010000L)
+#endif
+
+// error code added with Windows SDK 10.0.18362
+#ifndef ERROR_NO_SUCH_DEVICE
+#define ERROR_NO_SUCH_DEVICE	433L
+#endif
+
+/* Windows versions */
+enum windows_version {
+	WINDOWS_UNDEFINED,
+	WINDOWS_2000,
+	WINDOWS_XP,
+	WINDOWS_2003,	// Also XP x64
+	WINDOWS_VISTA,
+	WINDOWS_7,
+	WINDOWS_8,
+	WINDOWS_8_1,
+	WINDOWS_10,
+	WINDOWS_11,
+	WINDOWS_12_OR_LATER
+};
+
+extern enum windows_version windows_version;
+
+#include <pshpack1.h>
+
+typedef struct USB_DEVICE_DESCRIPTOR {
+	UCHAR  bLength;
+	UCHAR  bDescriptorType;
+	USHORT bcdUSB;
+	UCHAR  bDeviceClass;
+	UCHAR  bDeviceSubClass;
+	UCHAR  bDeviceProtocol;
+	UCHAR  bMaxPacketSize0;
+	USHORT idVendor;
+	USHORT idProduct;
+	USHORT bcdDevice;
+	UCHAR  iManufacturer;
+	UCHAR  iProduct;
+	UCHAR  iSerialNumber;
+	UCHAR  bNumConfigurations;
+} USB_DEVICE_DESCRIPTOR, *PUSB_DEVICE_DESCRIPTOR;
+
+typedef struct USB_CONFIGURATION_DESCRIPTOR {
+	UCHAR  bLength;
+	UCHAR  bDescriptorType;
+	USHORT wTotalLength;
+	UCHAR  bNumInterfaces;
+	UCHAR  bConfigurationValue;
+	UCHAR  iConfiguration;
+	UCHAR  bmAttributes;
+	UCHAR  MaxPower;
+} USB_CONFIGURATION_DESCRIPTOR, *PUSB_CONFIGURATION_DESCRIPTOR;
+
+#include <poppack.h>
+
+#define MAX_DEVICE_ID_LEN	200
+
+typedef struct USB_DK_DEVICE_ID {
+	WCHAR DeviceID[MAX_DEVICE_ID_LEN];
+	WCHAR InstanceID[MAX_DEVICE_ID_LEN];
+} USB_DK_DEVICE_ID, *PUSB_DK_DEVICE_ID;
+
+typedef struct USB_DK_DEVICE_INFO {
+	USB_DK_DEVICE_ID ID;
+	ULONG64 FilterID;
+	ULONG64 Port;
+	ULONG64 Speed;
+	USB_DEVICE_DESCRIPTOR DeviceDescriptor;
+} USB_DK_DEVICE_INFO, *PUSB_DK_DEVICE_INFO;
+
+typedef struct USB_DK_ISO_TRANSFER_RESULT {
+	ULONG64 ActualLength;
+	ULONG64 TransferResult;
+} USB_DK_ISO_TRANSFER_RESULT, *PUSB_DK_ISO_TRANSFER_RESULT;
+
+typedef struct USB_DK_GEN_TRANSFER_RESULT {
+	ULONG64 BytesTransferred;
+	ULONG64 UsbdStatus; // USBD_STATUS code
+} USB_DK_GEN_TRANSFER_RESULT, *PUSB_DK_GEN_TRANSFER_RESULT;
+
+typedef struct USB_DK_TRANSFER_RESULT {
+	USB_DK_GEN_TRANSFER_RESULT GenResult;
+	PVOID64 IsochronousResultsArray; // array of USB_DK_ISO_TRANSFER_RESULT
+} USB_DK_TRANSFER_RESULT, *PUSB_DK_TRANSFER_RESULT;
+
+typedef struct USB_DK_TRANSFER_REQUEST {
+	ULONG64 EndpointAddress;
+	PVOID64 Buffer;
+	ULONG64 BufferLength;
+	ULONG64 TransferType;
+	ULONG64 IsochronousPacketsArraySize;
+	PVOID64 IsochronousPacketsArray;
+	USB_DK_TRANSFER_RESULT Result;
+} USB_DK_TRANSFER_REQUEST, *PUSB_DK_TRANSFER_REQUEST;
+
+struct usbdk_device_priv {
+	USB_DK_DEVICE_ID ID;
+	PUSB_CONFIGURATION_DESCRIPTOR *config_descriptors;
+	HANDLE redirector_handle;
+	HANDLE system_handle;
+	uint8_t active_configuration;
+};
+
+struct winusb_device_priv {
+	bool initialized;
+	bool root_hub;
+	uint8_t active_config;
+	uint8_t depth; // distance to HCD
+	const struct windows_usb_api_backend *apib;
+	char *dev_id;
+	char *path;  // device interface path
+	int sub_api; // for WinUSB-like APIs
+	struct {
+		char *path; // each interface needs a device interface path,
+		const struct windows_usb_api_backend *apib; // an API backend (multiple drivers support),
+		int sub_api;
+		int8_t nb_endpoints; // and a set of endpoint addresses (USB_MAXENDPOINTS)
+		uint8_t *endpoint;
+		int current_altsetting;
+		bool restricted_functionality;  // indicates if the interface functionality is restricted
+						// by Windows (eg. HID keyboards or mice cannot do R/W)
+		uint8_t num_associated_interfaces; // If non-zero, the interface is part of a grouped
+		                                   // set of associated interfaces (defined by an IAD)
+						   // and this is the number of interfaces within the
+						   // associated group (bInterfaceCount in IAD).
+		uint8_t first_associated_interface; // For associated interfaces, this is the index of
+						    // the first interface (bFirstInterface in IAD) for
+		                                    // the grouped set of associated interfaces.
+	} usb_interface[USB_MAXINTERFACES];
+	struct hid_device_priv *hid;
+	PUSB_CONFIGURATION_DESCRIPTOR *config_descriptor; // list of pointers to the cached config descriptors
+	GUID class_guid; // checked for change during re-enumeration
+};
+
+struct usbdk_device_handle_priv {
+	// Not currently used
+	char dummy;
+};
+ 
+enum WINUSB_ZLP {
+	WINUSB_ZLP_UNSET = 0,
+	WINUSB_ZLP_OFF = 1,
+	WINUSB_ZLP_ON = 2
+};
+
+struct winusb_device_handle_priv {
+	int active_interface;
+	struct {
+		HANDLE dev_handle; // WinUSB needs an extra handle for the file
+		HANDLE api_handle; // used by the API to communicate with the device
+		uint8_t zlp[USB_MAXENDPOINTS]; // Current per-endpoint SHORT_PACKET_TERMINATE status (enum WINUSB_ZLP)
+	} interface_handle[USB_MAXINTERFACES];
+	int autoclaim_count[USB_MAXINTERFACES]; // For auto-release
+};
+
+struct usbdk_transfer_priv {
+	USB_DK_TRANSFER_REQUEST request;
+	PULONG64 IsochronousPacketsArray;
+	PUSB_DK_ISO_TRANSFER_RESULT IsochronousResultsArray;
+};
+
+struct winusb_transfer_priv {
+	uint8_t interface_number;
+
+	uint8_t *hid_buffer; // 1 byte extended data buffer, required for HID
+	uint8_t *hid_dest;   // transfer buffer destination, required for HID
+	size_t hid_expected_size;
+
+	// For isochronous transfers with LibUSBk driver:
+	void *iso_context;
+
+	// For isochronous transfers with Microsoft WinUSB driver:
+	void *isoch_buffer_handle; // The isoch_buffer_handle to free at the end of the transfer
+	BOOL iso_break_stream;	// Whether the isoch. stream was to be continued in the last call of libusb_submit_transfer.
+							// As we this structure is zeroed out upon initialization, we need to use inverse logic here.
+	libusb_transfer_cb_fn iso_user_callback; // Original transfer callback of the user. Might be used for isochronous transfers.
+};
+
+struct windows_backend {
+	int (*init)(struct libusb_context *ctx);
+	void (*exit)(struct libusb_context *ctx);
+	int (*get_device_list)(struct libusb_context *ctx,
+		struct discovered_devs **discdevs);
+	int (*open)(struct libusb_device_handle *dev_handle);
+	void (*close)(struct libusb_device_handle *dev_handle);
+	int (*get_active_config_descriptor)(struct libusb_device *device,
+		void *buffer, size_t len);
+	int (*get_config_descriptor)(struct libusb_device *device,
+		uint8_t config_index, void *buffer, size_t len);
+	int (*get_config_descriptor_by_value)(struct libusb_device *device,
+		uint8_t bConfigurationValue, void **buffer);
+	int (*get_configuration)(struct libusb_device_handle *dev_handle, uint8_t *config);
+	int (*set_configuration)(struct libusb_device_handle *dev_handle, uint8_t config);
+	int (*claim_interface)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
+	int (*release_interface)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
+	int (*set_interface_altsetting)(struct libusb_device_handle *dev_handle,
+		uint8_t interface_number, uint8_t altsetting);
+	int (*clear_halt)(struct libusb_device_handle *dev_handle,
+		unsigned char endpoint);
+	int (*reset_device)(struct libusb_device_handle *dev_handle);
+	void (*destroy_device)(struct libusb_device *dev);
+	int (*submit_transfer)(struct usbi_transfer *itransfer);
+	int (*cancel_transfer)(struct usbi_transfer *itransfer);
+	void (*clear_transfer_priv)(struct usbi_transfer *itransfer);
+	enum libusb_transfer_status (*copy_transfer_data)(struct usbi_transfer *itransfer, DWORD length);
+};
+
+struct windows_context_priv {
+	const struct windows_backend *backend;
+	HANDLE completion_port;
+	HANDLE completion_port_thread;
+};
+
+union windows_device_priv {
+	struct usbdk_device_priv usbdk_priv;
+	struct winusb_device_priv winusb_priv;
+};
+
+struct windows_device_handle_priv {
+	struct list_head active_transfers;
+	union {
+		struct usbdk_device_handle_priv usbdk_priv;
+		struct winusb_device_handle_priv winusb_priv;
+	};
+};
+
+struct windows_transfer_priv {
+	OVERLAPPED overlapped;
+	HANDLE handle;
+	struct list_head list;
+	union {
+		struct usbdk_transfer_priv usbdk_priv;
+		struct winusb_transfer_priv winusb_priv;
+	};
+};
+
+static inline struct usbdk_device_handle_priv *get_usbdk_device_handle_priv(struct libusb_device_handle *dev_handle)
+{
+	struct windows_device_handle_priv *handle_priv = usbi_get_device_handle_priv(dev_handle);
+	return &handle_priv->usbdk_priv;
+}
+
+static inline struct winusb_device_handle_priv *get_winusb_device_handle_priv(struct libusb_device_handle *dev_handle)
+{
+	struct windows_device_handle_priv *handle_priv = usbi_get_device_handle_priv(dev_handle);
+	return &handle_priv->winusb_priv;
+}
+
+static inline OVERLAPPED *get_transfer_priv_overlapped(struct usbi_transfer *itransfer)
+{
+	struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+	return &transfer_priv->overlapped;
+}
+
+static inline void set_transfer_priv_handle(struct usbi_transfer *itransfer, HANDLE handle)
+{
+	struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+	transfer_priv->handle = handle;
+}
+
+static inline struct usbdk_transfer_priv *get_usbdk_transfer_priv(struct usbi_transfer *itransfer)
+{
+	struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+	return &transfer_priv->usbdk_priv;
+}
+
+static inline struct winusb_transfer_priv *get_winusb_transfer_priv(struct usbi_transfer *itransfer)
+{
+	struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+	return &transfer_priv->winusb_priv;
+}
+
+extern const struct windows_backend usbdk_backend;
+extern const struct windows_backend winusb_backend;
+
+HMODULE load_system_library(struct libusb_context *ctx, const char *name);
+unsigned long htab_hash(const char *str);
+enum libusb_transfer_status usbd_status_to_libusb_transfer_status(USBD_STATUS status);
+void windows_force_sync_completion(struct usbi_transfer *itransfer, ULONG size);
+
+#if defined(ENABLE_LOGGING)
+const char *windows_error_str(DWORD error_code);
+#endif
+
+#endif

deps/libusb/libusb/os/windows_usbdk.c

@@ -0,0 +1,724 @@
+/*
+ * windows UsbDk backend for libusb 1.0
+ * Copyright © 2014 Red Hat, Inc.
+
+ * Authors:
+ * Dmitry Fleytman <dmitry@daynix.com>
+ * Pavel Gurvich <pavel@daynix.com>
+ *
+ * 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 <config.h>
+
+#include <windows.h>
+#include <stdio.h>
+
+#include "libusbi.h"
+#include "windows_usbdk.h"
+
+#if !defined(STATUS_SUCCESS)
+typedef LONG NTSTATUS;
+#define STATUS_SUCCESS			((NTSTATUS)0x00000000L)
+#endif
+
+#if !defined(STATUS_CANCELLED)
+#define STATUS_CANCELLED		((NTSTATUS)0xC0000120L)
+#endif
+
+#if !defined(STATUS_REQUEST_CANCELED)
+#define STATUS_REQUEST_CANCELED		((NTSTATUS)0xC0000703L)
+#endif
+
+static struct {
+	HMODULE module;
+
+	USBDK_GET_DEVICES_LIST			GetDevicesList;
+	USBDK_RELEASE_DEVICES_LIST		ReleaseDevicesList;
+	USBDK_START_REDIRECT			StartRedirect;
+	USBDK_STOP_REDIRECT			StopRedirect;
+	USBDK_GET_CONFIGURATION_DESCRIPTOR	GetConfigurationDescriptor;
+	USBDK_RELEASE_CONFIGURATION_DESCRIPTOR	ReleaseConfigurationDescriptor;
+	USBDK_READ_PIPE				ReadPipe;
+	USBDK_WRITE_PIPE			WritePipe;
+	USBDK_ABORT_PIPE			AbortPipe;
+	USBDK_RESET_PIPE			ResetPipe;
+	USBDK_SET_ALTSETTING			SetAltsetting;
+	USBDK_RESET_DEVICE			ResetDevice;
+	USBDK_GET_REDIRECTOR_SYSTEM_HANDLE	GetRedirectorSystemHandle;
+} usbdk_helper;
+
+static FARPROC get_usbdk_proc_addr(struct libusb_context *ctx, LPCSTR api_name)
+{
+	FARPROC api_ptr = GetProcAddress(usbdk_helper.module, api_name);
+
+	if (api_ptr == NULL)
+		usbi_err(ctx, "UsbDkHelper API %s not found: %s", api_name, windows_error_str(0));
+
+	return api_ptr;
+}
+
+static void unload_usbdk_helper_dll(void)
+{
+	if (usbdk_helper.module != NULL) {
+		FreeLibrary(usbdk_helper.module);
+		usbdk_helper.module = NULL;
+	}
+}
+
+static int load_usbdk_helper_dll(struct libusb_context *ctx)
+{
+	usbdk_helper.module = load_system_library(ctx, "UsbDkHelper");
+	if (usbdk_helper.module == NULL) {
+		usbi_err(ctx, "Failed to load UsbDkHelper.dll: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	usbdk_helper.GetDevicesList = (USBDK_GET_DEVICES_LIST)get_usbdk_proc_addr(ctx, "UsbDk_GetDevicesList");
+	if (usbdk_helper.GetDevicesList == NULL)
+		goto error_unload;
+
+	usbdk_helper.ReleaseDevicesList = (USBDK_RELEASE_DEVICES_LIST)get_usbdk_proc_addr(ctx, "UsbDk_ReleaseDevicesList");
+	if (usbdk_helper.ReleaseDevicesList == NULL)
+		goto error_unload;
+
+	usbdk_helper.StartRedirect = (USBDK_START_REDIRECT)get_usbdk_proc_addr(ctx, "UsbDk_StartRedirect");
+	if (usbdk_helper.StartRedirect == NULL)
+		goto error_unload;
+
+	usbdk_helper.StopRedirect = (USBDK_STOP_REDIRECT)get_usbdk_proc_addr(ctx, "UsbDk_StopRedirect");
+	if (usbdk_helper.StopRedirect == NULL)
+		goto error_unload;
+
+	usbdk_helper.GetConfigurationDescriptor = (USBDK_GET_CONFIGURATION_DESCRIPTOR)get_usbdk_proc_addr(ctx, "UsbDk_GetConfigurationDescriptor");
+	if (usbdk_helper.GetConfigurationDescriptor == NULL)
+		goto error_unload;
+
+	usbdk_helper.ReleaseConfigurationDescriptor = (USBDK_RELEASE_CONFIGURATION_DESCRIPTOR)get_usbdk_proc_addr(ctx, "UsbDk_ReleaseConfigurationDescriptor");
+	if (usbdk_helper.ReleaseConfigurationDescriptor == NULL)
+		goto error_unload;
+
+	usbdk_helper.ReadPipe = (USBDK_READ_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_ReadPipe");
+	if (usbdk_helper.ReadPipe == NULL)
+		goto error_unload;
+
+	usbdk_helper.WritePipe = (USBDK_WRITE_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_WritePipe");
+	if (usbdk_helper.WritePipe == NULL)
+		goto error_unload;
+
+	usbdk_helper.AbortPipe = (USBDK_ABORT_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_AbortPipe");
+	if (usbdk_helper.AbortPipe == NULL)
+		goto error_unload;
+
+	usbdk_helper.ResetPipe = (USBDK_RESET_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_ResetPipe");
+	if (usbdk_helper.ResetPipe == NULL)
+		goto error_unload;
+
+	usbdk_helper.SetAltsetting = (USBDK_SET_ALTSETTING)get_usbdk_proc_addr(ctx, "UsbDk_SetAltsetting");
+	if (usbdk_helper.SetAltsetting == NULL)
+		goto error_unload;
+
+	usbdk_helper.ResetDevice = (USBDK_RESET_DEVICE)get_usbdk_proc_addr(ctx, "UsbDk_ResetDevice");
+	if (usbdk_helper.ResetDevice == NULL)
+		goto error_unload;
+
+	usbdk_helper.GetRedirectorSystemHandle = (USBDK_GET_REDIRECTOR_SYSTEM_HANDLE)get_usbdk_proc_addr(ctx, "UsbDk_GetRedirectorSystemHandle");
+	if (usbdk_helper.GetRedirectorSystemHandle == NULL)
+		goto error_unload;
+
+	return LIBUSB_SUCCESS;
+
+error_unload:
+	FreeLibrary(usbdk_helper.module);
+	usbdk_helper.module = NULL;
+	return LIBUSB_ERROR_NOT_FOUND;
+}
+
+typedef SC_HANDLE (WINAPI *POPENSCMANAGERA)(LPCSTR, LPCSTR, DWORD);
+typedef SC_HANDLE (WINAPI *POPENSERVICEA)(SC_HANDLE, LPCSTR, DWORD);
+typedef BOOL (WINAPI *PCLOSESERVICEHANDLE)(SC_HANDLE);
+
+static int usbdk_init(struct libusb_context *ctx)
+{
+	POPENSCMANAGERA pOpenSCManagerA;
+	POPENSERVICEA pOpenServiceA;
+	PCLOSESERVICEHANDLE pCloseServiceHandle;
+	SC_HANDLE managerHandle;
+	SC_HANDLE serviceHandle;
+	HMODULE h;
+
+	h = load_system_library(ctx, "Advapi32");
+	if (h == NULL) {
+		usbi_warn(ctx, "failed to open Advapi32\n");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	pOpenSCManagerA = (POPENSCMANAGERA)GetProcAddress(h, "OpenSCManagerA");
+	if (pOpenSCManagerA == NULL) {
+		usbi_warn(ctx, "failed to find %s in Advapi32\n", "OpenSCManagerA");
+		goto error_free_library;
+	}
+	pOpenServiceA = (POPENSERVICEA)GetProcAddress(h, "OpenServiceA");
+	if (pOpenServiceA == NULL) {
+		usbi_warn(ctx, "failed to find %s in Advapi32\n", "OpenServiceA");
+		goto error_free_library;
+	}
+	pCloseServiceHandle = (PCLOSESERVICEHANDLE)GetProcAddress(h, "CloseServiceHandle");
+	if (pCloseServiceHandle == NULL) {
+		usbi_warn(ctx, "failed to find %s in Advapi32\n", "CloseServiceHandle");
+		goto error_free_library;
+	}
+
+	managerHandle = pOpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
+	if (managerHandle == NULL) {
+		usbi_warn(ctx, "failed to open service control manager: %s", windows_error_str(0));
+		goto error_free_library;
+	}
+
+	serviceHandle = pOpenServiceA(managerHandle, "UsbDk", GENERIC_READ);
+	pCloseServiceHandle(managerHandle);
+
+	if (serviceHandle == NULL) {
+		if (GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
+			usbi_warn(ctx, "failed to open UsbDk service: %s", windows_error_str(0));
+		FreeLibrary(h);
+		return LIBUSB_ERROR_NOT_FOUND;
+	}
+
+	pCloseServiceHandle(serviceHandle);
+	FreeLibrary(h);
+
+	return load_usbdk_helper_dll(ctx);
+
+error_free_library:
+	FreeLibrary(h);
+	return LIBUSB_ERROR_OTHER;
+}
+
+static void usbdk_exit(struct libusb_context *ctx)
+{
+	UNUSED(ctx);
+	unload_usbdk_helper_dll();
+}
+
+static int usbdk_get_session_id_for_device(struct libusb_context *ctx,
+	PUSB_DK_DEVICE_ID id, unsigned long *session_id)
+{
+	char dev_identity[ARRAYSIZE(id->DeviceID) + ARRAYSIZE(id->InstanceID) + 1];
+
+	if (snprintf(dev_identity, sizeof(dev_identity), "%S%S", id->DeviceID, id->InstanceID) == -1) {
+		usbi_warn(ctx, "cannot form device identity");
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	}
+
+	*session_id = htab_hash(dev_identity);
+
+	return LIBUSB_SUCCESS;
+}
+
+static void usbdk_release_config_descriptors(struct usbdk_device_priv *priv, uint8_t count)
+{
+	uint8_t i;
+
+	for (i = 0; i < count; i++)
+		usbdk_helper.ReleaseConfigurationDescriptor(priv->config_descriptors[i]);
+
+	free(priv->config_descriptors);
+	priv->config_descriptors = NULL;
+}
+
+static int usbdk_cache_config_descriptors(struct libusb_context *ctx,
+	struct usbdk_device_priv *priv, PUSB_DK_DEVICE_INFO info)
+{
+	uint8_t i;
+	USB_DK_CONFIG_DESCRIPTOR_REQUEST Request;
+	Request.ID = info->ID;
+
+	priv->config_descriptors = calloc(info->DeviceDescriptor.bNumConfigurations, sizeof(PUSB_CONFIGURATION_DESCRIPTOR));
+	if (priv->config_descriptors == NULL) {
+		usbi_err(ctx, "failed to allocate configuration descriptors holder");
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	for (i = 0; i < info->DeviceDescriptor.bNumConfigurations; i++) {
+		ULONG Length;
+
+		Request.Index = i;
+		if (!usbdk_helper.GetConfigurationDescriptor(&Request, &priv->config_descriptors[i], &Length)) {
+			usbi_err(ctx, "failed to retrieve configuration descriptors");
+			usbdk_release_config_descriptors(priv, i);
+			return LIBUSB_ERROR_OTHER;
+		}
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static inline int usbdk_device_priv_init(struct libusb_context *ctx, struct libusb_device *dev, PUSB_DK_DEVICE_INFO info)
+{
+	struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
+
+	priv->ID = info->ID;
+	priv->active_configuration = 0;
+
+	return usbdk_cache_config_descriptors(ctx, priv, info);
+}
+
+static void usbdk_device_init(struct libusb_device *dev, PUSB_DK_DEVICE_INFO info)
+{
+	dev->bus_number = (uint8_t)info->FilterID;
+	dev->port_number = (uint8_t)info->Port;
+	dev->parent_dev = NULL;
+
+	// Addresses in libusb are 1-based
+	dev->device_address = (uint8_t)(info->Port + 1);
+
+	static_assert(sizeof(dev->device_descriptor) == sizeof(info->DeviceDescriptor),
+		      "mismatch between libusb and OS device descriptor sizes");
+	memcpy(&dev->device_descriptor, &info->DeviceDescriptor, LIBUSB_DT_DEVICE_SIZE);
+	usbi_localize_device_descriptor(&dev->device_descriptor);
+
+	switch (info->Speed) {
+	case LowSpeed:
+		dev->speed = LIBUSB_SPEED_LOW;
+		break;
+	case FullSpeed:
+		dev->speed = LIBUSB_SPEED_FULL;
+		break;
+	case HighSpeed:
+		dev->speed = LIBUSB_SPEED_HIGH;
+		break;
+	case SuperSpeed:
+		dev->speed = LIBUSB_SPEED_SUPER;
+		break;
+	case NoSpeed:
+	default:
+		dev->speed = LIBUSB_SPEED_UNKNOWN;
+		break;
+	}
+}
+
+static int usbdk_get_device_list(struct libusb_context *ctx, struct discovered_devs **_discdevs)
+{
+	int r = LIBUSB_SUCCESS;
+	ULONG i;
+	struct discovered_devs *discdevs = NULL;
+	ULONG dev_number;
+	PUSB_DK_DEVICE_INFO devices;
+
+	if (!usbdk_helper.GetDevicesList(&devices, &dev_number))
+		return LIBUSB_ERROR_OTHER;
+
+	for (i = 0; i < dev_number; i++) {
+		unsigned long session_id;
+		struct libusb_device *dev = NULL;
+
+		if (usbdk_get_session_id_for_device(ctx, &devices[i].ID, &session_id))
+			continue;
+
+		dev = usbi_get_device_by_session_id(ctx, session_id);
+		if (dev == NULL) {
+			dev = usbi_alloc_device(ctx, session_id);
+			if (dev == NULL) {
+				usbi_err(ctx, "failed to allocate a new device structure");
+				continue;
+			}
+
+			usbdk_device_init(dev, &devices[i]);
+			if (usbdk_device_priv_init(ctx, dev, &devices[i]) != LIBUSB_SUCCESS) {
+				libusb_unref_device(dev);
+				continue;
+			}
+		}
+
+		discdevs = discovered_devs_append(*_discdevs, dev);
+		libusb_unref_device(dev);
+		if (!discdevs) {
+			usbi_err(ctx, "cannot append new device to list");
+			r = LIBUSB_ERROR_NO_MEM;
+			goto func_exit;
+		}
+
+		*_discdevs = discdevs;
+	}
+
+func_exit:
+	usbdk_helper.ReleaseDevicesList(devices);
+	return r;
+}
+
+static int usbdk_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, void *buffer, size_t len)
+{
+	struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
+	PUSB_CONFIGURATION_DESCRIPTOR config_header;
+	size_t size;
+
+	config_header = (PUSB_CONFIGURATION_DESCRIPTOR)priv->config_descriptors[config_index];
+
+	size = min(config_header->wTotalLength, len);
+	memcpy(buffer, config_header, size);
+	return (int)size;
+}
+
+static int usbdk_get_config_descriptor_by_value(struct libusb_device *dev, uint8_t bConfigurationValue,
+	void **buffer)
+{
+	struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
+	PUSB_CONFIGURATION_DESCRIPTOR config_header;
+	uint8_t index;
+
+	for (index = 0; index < dev->device_descriptor.bNumConfigurations; index++) {
+		config_header = priv->config_descriptors[index];
+		if (config_header->bConfigurationValue == bConfigurationValue) {
+			*buffer = priv->config_descriptors[index];
+			return (int)config_header->wTotalLength;
+		}
+	}
+
+	return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int usbdk_get_active_config_descriptor(struct libusb_device *dev, void *buffer, size_t len)
+{
+	struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
+
+	return usbdk_get_config_descriptor(dev, priv->active_configuration, buffer, len);
+}
+
+static int usbdk_open(struct libusb_device_handle *dev_handle)
+{
+	struct libusb_device *dev = dev_handle->dev;
+	struct libusb_context *ctx = DEVICE_CTX(dev);
+	struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+	struct usbdk_device_priv *device_priv = usbi_get_device_priv(dev);
+
+	device_priv->redirector_handle = usbdk_helper.StartRedirect(&device_priv->ID);
+	if (device_priv->redirector_handle == INVALID_HANDLE_VALUE) {
+		usbi_err(ctx, "Redirector startup failed");
+		device_priv->redirector_handle = NULL;
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	device_priv->system_handle = usbdk_helper.GetRedirectorSystemHandle(device_priv->redirector_handle);
+
+	if (CreateIoCompletionPort(device_priv->system_handle, priv->completion_port, (ULONG_PTR)dev_handle, 0) == NULL) {
+		usbi_err(ctx, "failed to associate handle to I/O completion port: %s", windows_error_str(0));
+		usbdk_helper.StopRedirect(device_priv->redirector_handle);
+		device_priv->system_handle = NULL;
+		device_priv->redirector_handle = NULL;
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static void usbdk_close(struct libusb_device_handle *dev_handle)
+{
+	struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+	if (!usbdk_helper.StopRedirect(priv->redirector_handle))
+		usbi_err(HANDLE_CTX(dev_handle), "Redirector shutdown failed");
+
+	priv->system_handle = NULL;
+	priv->redirector_handle = NULL;
+}
+
+static int usbdk_get_configuration(struct libusb_device_handle *dev_handle, uint8_t *config)
+{
+	struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+	*config = priv->active_configuration;
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_set_configuration(struct libusb_device_handle *dev_handle, uint8_t config)
+{
+	UNUSED(dev_handle);
+	UNUSED(config);
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_claim_interface(struct libusb_device_handle *dev_handle, uint8_t iface)
+{
+	UNUSED(dev_handle);
+	UNUSED(iface);
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_set_interface_altsetting(struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting)
+{
+	struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+	if (!usbdk_helper.SetAltsetting(priv->redirector_handle, iface, altsetting)) {
+		usbi_err(HANDLE_CTX(dev_handle), "SetAltsetting failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_release_interface(struct libusb_device_handle *dev_handle, uint8_t iface)
+{
+	UNUSED(dev_handle);
+	UNUSED(iface);
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
+{
+	struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+	if (!usbdk_helper.ResetPipe(priv->redirector_handle, endpoint)) {
+		usbi_err(HANDLE_CTX(dev_handle), "ResetPipe failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_reset_device(struct libusb_device_handle *dev_handle)
+{
+	struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+	if (!usbdk_helper.ResetDevice(priv->redirector_handle)) {
+		usbi_err(HANDLE_CTX(dev_handle), "ResetDevice failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static void usbdk_destroy_device(struct libusb_device *dev)
+{
+	struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
+
+	if (priv->config_descriptors != NULL)
+		usbdk_release_config_descriptors(priv, dev->device_descriptor.bNumConfigurations);
+}
+
+static void usbdk_clear_transfer_priv(struct usbi_transfer *itransfer)
+{
+	struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+		safe_free(transfer_priv->IsochronousPacketsArray);
+		safe_free(transfer_priv->IsochronousResultsArray);
+	}
+}
+
+static int usbdk_do_control_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct usbdk_device_priv *priv = usbi_get_device_priv(transfer->dev_handle->dev);
+	struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
+	OVERLAPPED *overlapped = get_transfer_priv_overlapped(itransfer);
+	TransferResult transResult;
+
+	transfer_priv->request.Buffer = (PVOID64)transfer->buffer;
+	transfer_priv->request.BufferLength = transfer->length;
+	transfer_priv->request.TransferType = ControlTransferType;
+
+	set_transfer_priv_handle(itransfer, priv->system_handle);
+
+	if (transfer->buffer[0] & LIBUSB_ENDPOINT_IN)
+		transResult = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+	else
+		transResult = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+
+	switch (transResult) {
+	case TransferSuccess:
+		windows_force_sync_completion(itransfer, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
+		break;
+	case TransferSuccessAsync:
+		break;
+	case TransferFailure:
+		usbi_err(TRANSFER_CTX(transfer), "ControlTransfer failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_IO;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_do_bulk_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct usbdk_device_priv *priv = usbi_get_device_priv(transfer->dev_handle->dev);
+	struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
+	OVERLAPPED *overlapped = get_transfer_priv_overlapped(itransfer);
+	TransferResult transferRes;
+
+	transfer_priv->request.Buffer = (PVOID64)transfer->buffer;
+	transfer_priv->request.BufferLength = transfer->length;
+	transfer_priv->request.EndpointAddress = transfer->endpoint;
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_BULK:
+		transfer_priv->request.TransferType = BulkTransferType;
+		break;
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		transfer_priv->request.TransferType = InterruptTransferType;
+		break;
+	}
+
+	set_transfer_priv_handle(itransfer, priv->system_handle);
+
+	if (IS_XFERIN(transfer))
+		transferRes = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+	else
+		transferRes = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+
+	switch (transferRes) {
+	case TransferSuccess:
+		windows_force_sync_completion(itransfer, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
+		break;
+	case TransferSuccessAsync:
+		break;
+	case TransferFailure:
+		usbi_err(TRANSFER_CTX(transfer), "ReadPipe/WritePipe failed: %s", windows_error_str(0));
+		return LIBUSB_ERROR_IO;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_do_iso_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct usbdk_device_priv *priv = usbi_get_device_priv(transfer->dev_handle->dev);
+	struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
+	OVERLAPPED *overlapped = get_transfer_priv_overlapped(itransfer);
+	TransferResult transferRes;
+	int i;
+
+	transfer_priv->request.Buffer = (PVOID64)transfer->buffer;
+	transfer_priv->request.BufferLength = transfer->length;
+	transfer_priv->request.EndpointAddress = transfer->endpoint;
+	transfer_priv->request.TransferType = IsochronousTransferType;
+	transfer_priv->request.IsochronousPacketsArraySize = transfer->num_iso_packets;
+	transfer_priv->IsochronousPacketsArray = malloc(transfer->num_iso_packets * sizeof(ULONG64));
+	transfer_priv->request.IsochronousPacketsArray = (PVOID64)transfer_priv->IsochronousPacketsArray;
+	if (!transfer_priv->IsochronousPacketsArray) {
+		usbi_err(TRANSFER_CTX(transfer), "Allocation of IsochronousPacketsArray failed");
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	transfer_priv->IsochronousResultsArray = malloc(transfer->num_iso_packets * sizeof(USB_DK_ISO_TRANSFER_RESULT));
+	transfer_priv->request.Result.IsochronousResultsArray = (PVOID64)transfer_priv->IsochronousResultsArray;
+	if (!transfer_priv->IsochronousResultsArray) {
+		usbi_err(TRANSFER_CTX(transfer), "Allocation of isochronousResultsArray failed");
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	for (i = 0; i < transfer->num_iso_packets; i++)
+		transfer_priv->IsochronousPacketsArray[i] = transfer->iso_packet_desc[i].length;
+
+	set_transfer_priv_handle(itransfer, priv->system_handle);
+
+	if (IS_XFERIN(transfer))
+		transferRes = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+	else
+		transferRes = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+
+	switch (transferRes) {
+	case TransferSuccess:
+		windows_force_sync_completion(itransfer, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
+		break;
+	case TransferSuccessAsync:
+		break;
+	case TransferFailure:
+		return LIBUSB_ERROR_IO;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int usbdk_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+	switch (transfer->type) {
+	case LIBUSB_TRANSFER_TYPE_CONTROL:
+		return usbdk_do_control_transfer(itransfer);
+	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+		if (IS_XFEROUT(transfer) && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET))
+			return LIBUSB_ERROR_NOT_SUPPORTED; //TODO: Check whether we can support this in UsbDk
+		return usbdk_do_bulk_transfer(itransfer);
+	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+		return usbdk_do_iso_transfer(itransfer);
+	default:
+		// Should not get here since windows_submit_transfer() validates
+		// the transfer->type field
+		usbi_err(TRANSFER_CTX(transfer), "unsupported endpoint type %d", transfer->type);
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+	}
+}
+
+static enum libusb_transfer_status usbdk_copy_transfer_data(struct usbi_transfer *itransfer, DWORD length)
+{
+	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
+
+	UNUSED(length);
+
+	if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+		ULONG64 i;
+
+		for (i = 0; i < transfer_priv->request.IsochronousPacketsArraySize; i++) {
+			struct libusb_iso_packet_descriptor *lib_desc = &transfer->iso_packet_desc[i];
+
+			switch (transfer_priv->IsochronousResultsArray[i].TransferResult) {
+			case STATUS_SUCCESS:
+			case STATUS_CANCELLED:
+			case STATUS_REQUEST_CANCELED:
+				lib_desc->status = LIBUSB_TRANSFER_COMPLETED; // == ERROR_SUCCESS
+				break;
+			default:
+				lib_desc->status = LIBUSB_TRANSFER_ERROR; // ERROR_UNKNOWN_EXCEPTION;
+				break;
+			}
+
+			lib_desc->actual_length = (unsigned int)transfer_priv->IsochronousResultsArray[i].ActualLength;
+		}
+	}
+
+	itransfer->transferred += (int)transfer_priv->request.Result.GenResult.BytesTransferred;
+	return usbd_status_to_libusb_transfer_status((USBD_STATUS)transfer_priv->request.Result.GenResult.UsbdStatus);
+}
+
+const struct windows_backend usbdk_backend = {
+	usbdk_init,
+	usbdk_exit,
+	usbdk_get_device_list,
+	usbdk_open,
+	usbdk_close,
+	usbdk_get_active_config_descriptor,
+	usbdk_get_config_descriptor,
+	usbdk_get_config_descriptor_by_value,
+	usbdk_get_configuration,
+	usbdk_set_configuration,
+	usbdk_claim_interface,
+	usbdk_release_interface,
+	usbdk_set_interface_altsetting,
+	usbdk_clear_halt,
+	usbdk_reset_device,
+	usbdk_destroy_device,
+	usbdk_submit_transfer,
+	NULL,	/* cancel_transfer */
+	usbdk_clear_transfer_priv,
+	usbdk_copy_transfer_data,
+};

deps/libusb/libusb/os/windows_usbdk.h

@@ -0,0 +1,106 @@
+/*
+* windows UsbDk backend for libusb 1.0
+* Copyright © 2014 Red Hat, Inc.
+
+* Authors:
+* Dmitry Fleytman <dmitry@daynix.com>
+* Pavel Gurvich <pavel@daynix.com>
+*
+* 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
+*/
+
+#ifndef LIBUSB_WINDOWS_USBDK_H
+#define LIBUSB_WINDOWS_USBDK_H
+
+#include "windows_common.h"
+
+typedef struct USB_DK_CONFIG_DESCRIPTOR_REQUEST {
+	USB_DK_DEVICE_ID ID;
+	ULONG64 Index;
+} USB_DK_CONFIG_DESCRIPTOR_REQUEST, *PUSB_DK_CONFIG_DESCRIPTOR_REQUEST;
+
+typedef enum {
+	TransferFailure = 0,
+	TransferSuccess,
+	TransferSuccessAsync
+} TransferResult;
+
+typedef enum {
+	NoSpeed = 0,
+	LowSpeed,
+	FullSpeed,
+	HighSpeed,
+	SuperSpeed
+} USB_DK_DEVICE_SPEED;
+
+typedef enum {
+	ControlTransferType,
+	BulkTransferType,
+	InterruptTransferType,
+	IsochronousTransferType
+} USB_DK_TRANSFER_TYPE;
+
+typedef BOOL (__cdecl *USBDK_GET_DEVICES_LIST)(
+	PUSB_DK_DEVICE_INFO *DeviceInfo,
+	PULONG DeviceNumber
+);
+typedef void (__cdecl *USBDK_RELEASE_DEVICES_LIST)(
+	PUSB_DK_DEVICE_INFO DeviceInfo
+);
+typedef HANDLE (__cdecl *USBDK_START_REDIRECT)(
+	PUSB_DK_DEVICE_ID DeviceId
+);
+typedef BOOL (__cdecl *USBDK_STOP_REDIRECT)(
+	HANDLE DeviceHandle
+);
+typedef BOOL (__cdecl *USBDK_GET_CONFIGURATION_DESCRIPTOR)(
+	PUSB_DK_CONFIG_DESCRIPTOR_REQUEST Request,
+	PUSB_CONFIGURATION_DESCRIPTOR *Descriptor,
+	PULONG Length
+);
+typedef void (__cdecl *USBDK_RELEASE_CONFIGURATION_DESCRIPTOR)(
+	PUSB_CONFIGURATION_DESCRIPTOR Descriptor
+);
+typedef TransferResult (__cdecl *USBDK_WRITE_PIPE)(
+	HANDLE DeviceHandle,
+	PUSB_DK_TRANSFER_REQUEST Request,
+	LPOVERLAPPED lpOverlapped
+);
+typedef TransferResult (__cdecl *USBDK_READ_PIPE)(
+	HANDLE DeviceHandle,
+	PUSB_DK_TRANSFER_REQUEST Request,
+	LPOVERLAPPED lpOverlapped
+);
+typedef BOOL (__cdecl *USBDK_ABORT_PIPE)(
+	HANDLE DeviceHandle,
+	ULONG64 PipeAddress
+);
+typedef BOOL (__cdecl *USBDK_RESET_PIPE)(
+	HANDLE DeviceHandle,
+	ULONG64 PipeAddress
+);
+typedef BOOL (__cdecl *USBDK_SET_ALTSETTING)(
+	HANDLE DeviceHandle,
+	ULONG64 InterfaceIdx,
+	ULONG64 AltSettingIdx
+);
+typedef BOOL (__cdecl *USBDK_RESET_DEVICE)(
+	HANDLE DeviceHandle
+);
+typedef HANDLE (__cdecl *USBDK_GET_REDIRECTOR_SYSTEM_HANDLE)(
+	HANDLE DeviceHandle
+);
+
+#endif

deps/libusb/libusb/os/windows_winusb.h

@@ -0,0 +1,787 @@
+/*
+ * Windows backend for libusb 1.0
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * 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
+ */
+
+#ifndef LIBUSB_WINDOWS_WINUSB_H
+#define LIBUSB_WINDOWS_WINUSB_H
+
+#include <devioctl.h>
+#include <initguid.h>
+#include <usbiodef.h>
+
+#include "windows_common.h"
+
+#define MAX_CTRL_BUFFER_LENGTH	4096
+#define MAX_USB_STRING_LENGTH	128
+#define MAX_HID_REPORT_SIZE	1024
+#define MAX_HID_DESCRIPTOR_SIZE	256
+#define MAX_GUID_STRING_LENGTH	39
+#define MAX_PATH_LENGTH		256
+#define MAX_KEY_LENGTH		256
+#define LIST_SEPARATOR		';'
+
+// Handle code for HID interface that have been claimed ("dibs")
+#define INTERFACE_CLAIMED	((HANDLE)(intptr_t)0xD1B5)
+// Additional return code for HID operations that completed synchronously
+#define LIBUSB_COMPLETED	(LIBUSB_SUCCESS + 1)
+
+// libusb0 Filter Device Interface GUID
+DEFINE_GUID(GUID_DEVINTERFACE_LIBUSB0_FILTER, 0xF9F3FF14, 0xAE21, 0x48A0, 0x8A, 0x25, 0x80, 0x11, 0xA7, 0xA9, 0x31, 0xD9);
+
+// The following define MUST be == sizeof(USB_DESCRIPTOR_REQUEST)
+#define USB_DESCRIPTOR_REQUEST_SIZE	12U
+
+/*
+ * Multiple USB API backend support
+ */
+#define USB_API_UNSUPPORTED	0
+#define USB_API_HUB		1
+#define USB_API_COMPOSITE	2
+#define USB_API_WINUSBX		3
+#define USB_API_HID		4
+#define USB_API_MAX		5
+
+// Sub-APIs for WinUSB-like driver APIs (WinUSB, libusbK, libusb-win32 through the libusbK DLL)
+// Must have the same values as the KUSB_DRVID enum from libusbk.h
+#define SUB_API_NOTSET		-1
+#define SUB_API_LIBUSBK		0
+#define SUB_API_LIBUSB0		1
+#define SUB_API_WINUSB		2
+#define SUB_API_MAX		3
+
+struct windows_usb_api_backend {
+	const uint8_t id;
+	const char * const designation;
+	const char * const * const driver_name_list; // Driver name, without .sys, e.g. "usbccgp"
+	const uint8_t nb_driver_names;
+	bool (*init)(struct libusb_context *ctx);
+	void (*exit)(void);
+	int (*open)(int sub_api, struct libusb_device_handle *dev_handle);
+	void (*close)(int sub_api, struct libusb_device_handle *dev_handle);
+	int (*configure_endpoints)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+	int (*claim_interface)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+	int (*set_interface_altsetting)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting);
+	int (*release_interface)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+	int (*clear_halt)(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
+	int (*reset_device)(int sub_api, struct libusb_device_handle *dev_handle);
+	int (*submit_bulk_transfer)(int sub_api, struct usbi_transfer *itransfer);
+	int (*submit_iso_transfer)(int sub_api, struct usbi_transfer *itransfer);
+	int (*submit_control_transfer)(int sub_api, struct usbi_transfer *itransfer);
+	int (*cancel_transfer)(int sub_api, struct usbi_transfer *itransfer);
+	enum libusb_transfer_status (*copy_transfer_data)(int sub_api, struct usbi_transfer *itransfer, DWORD length);
+};
+
+extern const struct windows_usb_api_backend usb_api_backend[USB_API_MAX];
+
+#define PRINT_UNSUPPORTED_API(fname)				\
+	usbi_dbg(NULL, "unsupported API call for '%s' "		\
+		"(unrecognized device driver)", #fname)
+
+#define CHECK_SUPPORTED_API(apip, fname)			\
+	do {							\
+		if ((apip)->fname == NULL) {			\
+			PRINT_UNSUPPORTED_API(fname);		\
+			return LIBUSB_ERROR_NOT_SUPPORTED;	\
+		}						\
+	} while (0)
+
+/*
+ * private structures definition
+ * with inline pseudo constructors/destructors
+ */
+
+// TODO (v2+): move hid desc to libusb.h?
+struct libusb_hid_descriptor {
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+	uint16_t bcdHID;
+	uint8_t bCountryCode;
+	uint8_t bNumDescriptors;
+	uint8_t bClassDescriptorType;
+	uint16_t wClassDescriptorLength;
+};
+
+#define LIBUSB_DT_HID_SIZE		9
+#define HID_MAX_CONFIG_DESC_SIZE (LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE \
+	+ LIBUSB_DT_HID_SIZE + 2 * LIBUSB_DT_ENDPOINT_SIZE)
+#define HID_MAX_REPORT_SIZE		1024
+#define HID_IN_EP			0x81
+#define HID_OUT_EP			0x02
+#define LIBUSB_REQ_RECIPIENT(request_type)	((request_type) & 0x1F)
+#define LIBUSB_REQ_TYPE(request_type)		((request_type) & (0x03 << 5))
+#define LIBUSB_REQ_IN(request_type)		((request_type) & LIBUSB_ENDPOINT_IN)
+#define LIBUSB_REQ_OUT(request_type)		(!LIBUSB_REQ_IN(request_type))
+
+// The following are used for HID reports IOCTLs
+#define HID_IN_CTL_CODE(id) \
+	CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_IN_DIRECT, FILE_ANY_ACCESS)
+#define HID_OUT_CTL_CODE(id) \
+	CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
+
+#define IOCTL_HID_GET_FEATURE		HID_OUT_CTL_CODE(100)
+#define IOCTL_HID_GET_INPUT_REPORT	HID_OUT_CTL_CODE(104)
+#define IOCTL_HID_SET_FEATURE		HID_IN_CTL_CODE(100)
+#define IOCTL_HID_SET_OUTPUT_REPORT	HID_IN_CTL_CODE(101)
+
+enum libusb_hid_request_type {
+	HID_REQ_GET_REPORT = 0x01,
+	HID_REQ_GET_IDLE = 0x02,
+	HID_REQ_GET_PROTOCOL = 0x03,
+	HID_REQ_SET_REPORT = 0x09,
+	HID_REQ_SET_IDLE = 0x0A,
+	HID_REQ_SET_PROTOCOL = 0x0B
+};
+
+enum libusb_hid_report_type {
+	HID_REPORT_TYPE_INPUT = 0x01,
+	HID_REPORT_TYPE_OUTPUT = 0x02,
+	HID_REPORT_TYPE_FEATURE = 0x03
+};
+
+struct hid_device_priv {
+	uint16_t vid;
+	uint16_t pid;
+	uint8_t config;
+	uint8_t nb_interfaces;
+	bool uses_report_ids[3]; // input, ouptput, feature
+	uint16_t input_report_size;
+	uint16_t output_report_size;
+	uint16_t feature_report_size;
+	uint16_t usage;
+	uint16_t usagePage;
+	WCHAR string[3][MAX_USB_STRING_LENGTH];
+	uint8_t string_index[3]; // man, prod, ser
+};
+
+static inline struct winusb_device_priv *winusb_device_priv_init(struct libusb_device *dev)
+{
+	struct winusb_device_priv *priv = usbi_get_device_priv(dev);
+	int i;
+
+	priv->apib = &usb_api_backend[USB_API_UNSUPPORTED];
+	priv->sub_api = SUB_API_NOTSET;
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		priv->usb_interface[i].apib = &usb_api_backend[USB_API_UNSUPPORTED];
+		priv->usb_interface[i].sub_api = SUB_API_NOTSET;
+	}
+
+	return priv;
+}
+
+static inline void winusb_device_priv_release(struct libusb_device *dev)
+{
+	struct winusb_device_priv *priv = usbi_get_device_priv(dev);
+	int i;
+
+	free(priv->dev_id);
+	free(priv->path);
+	if ((dev->device_descriptor.bNumConfigurations > 0) && (priv->config_descriptor != NULL)) {
+		for (i = 0; i < dev->device_descriptor.bNumConfigurations; i++) {
+			if (priv->config_descriptor[i] == NULL)
+				continue;
+			free((UCHAR *)priv->config_descriptor[i] - USB_DESCRIPTOR_REQUEST_SIZE);
+		}
+	}
+	free(priv->config_descriptor);
+	free(priv->hid);
+	for (i = 0; i < USB_MAXINTERFACES; i++) {
+		free(priv->usb_interface[i].path);
+		free(priv->usb_interface[i].endpoint);
+	}
+}
+
+// used to match a device driver (including filter drivers) against a supported API
+struct driver_lookup {
+	char list[MAX_KEY_LENGTH + 1]; // REG_MULTI_SZ list of services (driver) names
+	const DWORD reg_prop;          // SPDRP registry key to use to retrieve list
+	const char *designation;       // internal designation (for debug output)
+};
+
+/*
+ * Windows DDK API definitions. Most of it copied from MinGW's includes
+ */
+typedef DWORD DEVNODE, DEVINST;
+typedef DEVNODE *PDEVNODE, *PDEVINST;
+typedef DWORD RETURN_TYPE;
+typedef RETURN_TYPE CONFIGRET;
+
+#define CR_SUCCESS	0x00000000
+
+/* Cfgmgr32 dependencies */
+DLL_DECLARE_HANDLE(Cfgmgr32);
+DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Parent, (PDEVINST, DEVINST, ULONG));
+DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Child, (PDEVINST, DEVINST, ULONG));
+
+/* AdvAPI32 dependencies */
+DLL_DECLARE_HANDLE(AdvAPI32);
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegQueryValueExA, (HKEY, LPCSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegCloseKey, (HKEY));
+
+/* SetupAPI dependencies */
+DLL_DECLARE_HANDLE(SetupAPI);
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, HDEVINFO, p, SetupDiGetClassDevsA, (LPCGUID, PCSTR, HWND, DWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInfo, (HDEVINFO, DWORD, PSP_DEVINFO_DATA));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInterfaces, (HDEVINFO, PSP_DEVINFO_DATA,
+			LPCGUID, DWORD, PSP_DEVICE_INTERFACE_DATA));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInstanceIdA, (HDEVINFO, PSP_DEVINFO_DATA,
+			PCSTR, DWORD, PDWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInterfaceDetailA, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA,
+			PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceRegistryPropertyA, (HDEVINFO,
+			PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiDestroyDeviceInfoList, (HDEVINFO));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDevRegKey, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDeviceInterfaceRegKey, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA, DWORD, DWORD));
+
+#define FILE_DEVICE_USB	FILE_DEVICE_UNKNOWN
+
+#define USB_GET_NODE_INFORMATION			258
+#define USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION		260
+#define USB_GET_NODE_CONNECTION_INFORMATION_EX		274
+#define USB_GET_NODE_CONNECTION_INFORMATION_EX_V2	279
+
+#define USB_CTL_CODE(id) \
+	CTL_CODE(FILE_DEVICE_USB, (id), METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define IOCTL_USB_GET_NODE_INFORMATION \
+	USB_CTL_CODE(USB_GET_NODE_INFORMATION)
+
+#define IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION \
+	USB_CTL_CODE(USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION)
+
+#define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX \
+	USB_CTL_CODE(USB_GET_NODE_CONNECTION_INFORMATION_EX)
+
+#define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 \
+	USB_CTL_CODE(USB_GET_NODE_CONNECTION_INFORMATION_EX_V2)
+
+typedef enum _USB_CONNECTION_STATUS {
+	NoDeviceConnected,
+	DeviceConnected,
+	DeviceFailedEnumeration,
+	DeviceGeneralFailure,
+	DeviceCausedOvercurrent,
+	DeviceNotEnoughPower,
+	DeviceNotEnoughBandwidth,
+	DeviceHubNestedTooDeeply,
+	DeviceInLegacyHub,
+	DeviceEnumerating,
+	DeviceReset
+} USB_CONNECTION_STATUS;
+
+typedef enum _USB_DEVICE_SPEED {
+	UsbLowSpeed = 0,
+	UsbFullSpeed,
+	UsbHighSpeed,
+	UsbSuperSpeed,
+	UsbSuperSpeedPlus	// Not in Microsoft headers
+} USB_DEVICE_SPEED;
+
+typedef enum _USB_HUB_NODE {
+	UsbHub,
+	UsbMIParent
+} USB_HUB_NODE;
+
+#if defined(_MSC_VER)
+// disable /W4 MSVC warnings that are benign
+#pragma warning(push)
+#pragma warning(disable:4214)  // bit field types other than int
+#endif
+
+// Most of the structures below need to be packed
+#include <pshpack1.h>
+
+typedef struct _USB_HUB_DESCRIPTOR {
+	UCHAR bDescriptorLength;
+	UCHAR bDescriptorType;
+	UCHAR bNumberOfPorts;
+	USHORT wHubCharacteristics;
+	UCHAR bPowerOnToPowerGood;
+	UCHAR bHubControlCurrent;
+	UCHAR bRemoveAndPowerMask[64];
+} USB_HUB_DESCRIPTOR, *PUSB_HUB_DESCRIPTOR;
+
+typedef struct _USB_HUB_INFORMATION {
+	USB_HUB_DESCRIPTOR HubDescriptor;
+	BOOLEAN HubIsBusPowered;
+} USB_HUB_INFORMATION, *PUSB_HUB_INFORMATION;
+
+typedef struct _USB_NODE_INFORMATION {
+	USB_HUB_NODE NodeType;
+	union {
+		USB_HUB_INFORMATION HubInformation;
+//		USB_MI_PARENT_INFORMATION MiParentInformation;
+	} u;
+} USB_NODE_INFORMATION, *PUSB_NODE_INFORMATION;
+
+typedef struct _USB_DESCRIPTOR_REQUEST {
+	ULONG ConnectionIndex;
+	struct {
+		UCHAR bmRequest;
+		UCHAR bRequest;
+		USHORT wValue;
+		USHORT wIndex;
+		USHORT wLength;
+	} SetupPacket;
+//	UCHAR Data[0];
+} USB_DESCRIPTOR_REQUEST, *PUSB_DESCRIPTOR_REQUEST;
+
+typedef struct _USB_CONFIGURATION_DESCRIPTOR_SHORT {
+	USB_DESCRIPTOR_REQUEST req;
+	USB_CONFIGURATION_DESCRIPTOR desc;
+} USB_CONFIGURATION_DESCRIPTOR_SHORT;
+
+typedef struct USB_INTERFACE_DESCRIPTOR {
+	UCHAR bLength;
+	UCHAR bDescriptorType;
+	UCHAR bInterfaceNumber;
+	UCHAR bAlternateSetting;
+	UCHAR bNumEndpoints;
+	UCHAR bInterfaceClass;
+	UCHAR bInterfaceSubClass;
+	UCHAR bInterfaceProtocol;
+	UCHAR iInterface;
+} USB_INTERFACE_DESCRIPTOR, *PUSB_INTERFACE_DESCRIPTOR;
+
+typedef struct _USB_NODE_CONNECTION_INFORMATION_EX {
+	ULONG ConnectionIndex;
+	USB_DEVICE_DESCRIPTOR DeviceDescriptor;
+	UCHAR CurrentConfigurationValue;
+	UCHAR Speed;
+	BOOLEAN DeviceIsHub;
+	USHORT DeviceAddress;
+	ULONG NumberOfOpenPipes;
+	USB_CONNECTION_STATUS ConnectionStatus;
+//	USB_PIPE_INFO PipeList[0];
+} USB_NODE_CONNECTION_INFORMATION_EX, *PUSB_NODE_CONNECTION_INFORMATION_EX;
+
+typedef union _USB_PROTOCOLS {
+	ULONG ul;
+	struct {
+		ULONG Usb110:1;
+		ULONG Usb200:1;
+		ULONG Usb300:1;
+		ULONG ReservedMBZ:29;
+	};
+} USB_PROTOCOLS, *PUSB_PROTOCOLS;
+
+typedef union _USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS {
+	ULONG ul;
+	struct {
+		ULONG DeviceIsOperatingAtSuperSpeedOrHigher:1;
+		ULONG DeviceIsSuperSpeedCapableOrHigher:1;
+		ULONG DeviceIsOperatingAtSuperSpeedPlusOrHigher:1;
+		ULONG DeviceIsSuperSpeedPlusCapableOrHigher:1;
+		ULONG ReservedMBZ:28;
+	};
+} USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS;
+
+typedef struct _USB_NODE_CONNECTION_INFORMATION_EX_V2 {
+	ULONG ConnectionIndex;
+	ULONG Length;
+	USB_PROTOCOLS SupportedUsbProtocols;
+	USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS Flags;
+} USB_NODE_CONNECTION_INFORMATION_EX_V2, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2;
+
+#include <poppack.h>
+
+#if defined(_MSC_VER)
+// Restore original warnings
+#pragma warning(pop)
+#endif
+
+/* winusb.dll interface */
+
+/* pipe policies */
+#define SHORT_PACKET_TERMINATE	0x01
+#define AUTO_CLEAR_STALL	0x02
+#define PIPE_TRANSFER_TIMEOUT	0x03
+#define IGNORE_SHORT_PACKETS	0x04
+#define ALLOW_PARTIAL_READS	0x05
+#define AUTO_FLUSH		0x06
+#define RAW_IO			0x07
+#define MAXIMUM_TRANSFER_SIZE	0x08
+/* libusbK */
+#define ISO_ALWAYS_START_ASAP	0x21
+
+typedef struct _USBD_ISO_PACKET_DESCRIPTOR {
+	ULONG Offset;
+	ULONG Length;
+	USBD_STATUS Status;
+} USBD_ISO_PACKET_DESCRIPTOR, *PUSBD_ISO_PACKET_DESCRIPTOR;
+
+typedef enum _USBD_PIPE_TYPE {
+	UsbdPipeTypeControl,
+	UsbdPipeTypeIsochronous,
+	UsbdPipeTypeBulk,
+	UsbdPipeTypeInterrupt
+} USBD_PIPE_TYPE;
+
+typedef struct {
+	USBD_PIPE_TYPE PipeType;
+	UCHAR PipeId;
+	USHORT MaximumPacketSize;
+	UCHAR Interval;
+	ULONG MaximumBytesPerInterval;
+} WINUSB_PIPE_INFORMATION_EX, *PWINUSB_PIPE_INFORMATION_EX;
+
+#include <pshpack1.h>
+
+typedef struct _WINUSB_SETUP_PACKET {
+	UCHAR RequestType;
+	UCHAR Request;
+	USHORT Value;
+	USHORT Index;
+	USHORT Length;
+} WINUSB_SETUP_PACKET, *PWINUSB_SETUP_PACKET;
+
+#include <poppack.h>
+
+typedef PVOID WINUSB_INTERFACE_HANDLE, *PWINUSB_INTERFACE_HANDLE;
+typedef PVOID WINUSB_ISOCH_BUFFER_HANDLE, *PWINUSB_ISOCH_BUFFER_HANDLE;
+
+typedef BOOL (WINAPI *WinUsb_AbortPipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID
+);
+typedef BOOL (WINAPI *WinUsb_ControlTransfer_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	WINUSB_SETUP_PACKET SetupPacket,
+	PUCHAR Buffer,
+	ULONG BufferLength,
+	PULONG LengthTransferred,
+	LPOVERLAPPED Overlapped
+);
+typedef BOOL (WINAPI *WinUsb_FlushPipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID
+);
+typedef BOOL (WINAPI *WinUsb_Free_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle
+);
+typedef BOOL (WINAPI *WinUsb_GetAssociatedInterface_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR AssociatedInterfaceIndex,
+	PWINUSB_INTERFACE_HANDLE AssociatedInterfaceHandle
+);
+typedef BOOL (WINAPI *WinUsb_Initialize_t)(
+	HANDLE DeviceHandle,
+	PWINUSB_INTERFACE_HANDLE InterfaceHandle
+);
+typedef BOOL (WINAPI *WinUsb_QueryPipeEx_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR AlternateInterfaceHandle,
+	UCHAR PipeIndex,
+	PWINUSB_PIPE_INFORMATION_EX PipeInformationEx
+);
+typedef BOOL (WINAPI *WinUsb_ReadIsochPipeAsap_t)(
+	PWINUSB_ISOCH_BUFFER_HANDLE BufferHandle,
+	ULONG Offset,
+	ULONG Length,
+	BOOL ContinueStream,
+	ULONG NumberOfPackets,
+	PUSBD_ISO_PACKET_DESCRIPTOR IsoPacketDescriptors,
+	LPOVERLAPPED Overlapped
+);
+typedef BOOL (WINAPI *WinUsb_ReadPipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	PUCHAR Buffer,
+	ULONG BufferLength,
+	PULONG LengthTransferred,
+	LPOVERLAPPED Overlapped
+);
+typedef BOOL (WINAPI *WinUsb_RegisterIsochBuffer_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	PVOID Buffer,
+	ULONG BufferLength,
+	PWINUSB_ISOCH_BUFFER_HANDLE BufferHandle
+);
+typedef BOOL (WINAPI *WinUsb_ResetPipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID
+);
+typedef BOOL (WINAPI *WinUsb_SetCurrentAlternateSetting_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR AlternateSetting
+);
+typedef BOOL (WINAPI *WinUsb_SetPipePolicy_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	ULONG PolicyType,
+	ULONG ValueLength,
+	PVOID Value
+);
+typedef BOOL (WINAPI *WinUsb_GetPipePolicy_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	ULONG PolicyType,
+	PULONG ValueLength,
+	PVOID Value
+);
+typedef BOOL (WINAPI *WinUsb_UnregisterIsochBuffer_t)(
+	WINUSB_ISOCH_BUFFER_HANDLE BufferHandle
+);
+typedef BOOL (WINAPI *WinUsb_WriteIsochPipeAsap_t)(
+	WINUSB_ISOCH_BUFFER_HANDLE BufferHandle,
+	ULONG Offset,
+	ULONG Length,
+	BOOL ContinueStream,
+	LPOVERLAPPED Overlapped
+);
+typedef BOOL (WINAPI *WinUsb_WritePipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	PUCHAR Buffer,
+	ULONG BufferLength,
+	PULONG LengthTransferred,
+	LPOVERLAPPED Overlapped
+);
+
+/* /!\ These must match the ones from the official libusbk.h */
+typedef enum _KUSB_FNID {
+	KUSB_FNID_Init,
+	KUSB_FNID_Free,
+	KUSB_FNID_ClaimInterface,
+	KUSB_FNID_ReleaseInterface,
+	KUSB_FNID_SetAltInterface,
+	KUSB_FNID_GetAltInterface,
+	KUSB_FNID_GetDescriptor,
+	KUSB_FNID_ControlTransfer,
+	KUSB_FNID_SetPowerPolicy,
+	KUSB_FNID_GetPowerPolicy,
+	KUSB_FNID_SetConfiguration,
+	KUSB_FNID_GetConfiguration,
+	KUSB_FNID_ResetDevice,
+	KUSB_FNID_Initialize,
+	KUSB_FNID_SelectInterface,
+	KUSB_FNID_GetAssociatedInterface,
+	KUSB_FNID_Clone,
+	KUSB_FNID_QueryInterfaceSettings,
+	KUSB_FNID_QueryDeviceInformation,
+	KUSB_FNID_SetCurrentAlternateSetting,
+	KUSB_FNID_GetCurrentAlternateSetting,
+	KUSB_FNID_QueryPipe,
+	KUSB_FNID_SetPipePolicy,
+	KUSB_FNID_GetPipePolicy,
+	KUSB_FNID_ReadPipe,
+	KUSB_FNID_WritePipe,
+	KUSB_FNID_ResetPipe,
+	KUSB_FNID_AbortPipe,
+	KUSB_FNID_FlushPipe,
+	KUSB_FNID_IsoReadPipe,
+	KUSB_FNID_IsoWritePipe,
+	KUSB_FNID_GetCurrentFrameNumber,
+	KUSB_FNID_GetOverlappedResult,
+	KUSB_FNID_GetProperty,
+	KUSB_FNID_COUNT,
+} KUSB_FNID;
+
+typedef struct _KLIB_VERSION {
+	INT Major;
+	INT Minor;
+	INT Micro;
+	INT Nano;
+} KLIB_VERSION, *PKLIB_VERSION;
+
+typedef BOOL (WINAPI *LibK_GetProcAddress_t)(
+	PVOID ProcAddress,
+	INT DriverID,
+	INT FunctionID
+);
+
+typedef VOID (WINAPI *LibK_GetVersion_t)(
+	PKLIB_VERSION Version
+);
+
+typedef BOOL (WINAPI *LibK_ResetDevice_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle
+);
+
+//KISO_PACKET is equivalent of libusb_iso_packet_descriptor except uses absolute "offset" field instead of sequential Lengths
+typedef struct _KISO_PACKET {
+	UINT offset;
+	USHORT actual_length; //changed from libusbk_shared.h "Length" for clarity
+	USHORT status;
+} KISO_PACKET, *PKISO_PACKET;
+
+typedef enum _KISO_FLAG {
+	KISO_FLAG_NONE = 0,
+	KISO_FLAG_SET_START_FRAME = 0x00000001,
+} KISO_FLAG;
+
+//KISO_CONTEXT is the conceptual equivalent of libusb_transfer except is isochronous-specific and must match libusbk's version
+typedef struct _KISO_CONTEXT {
+	KISO_FLAG Flags;
+	UINT StartFrame;
+	SHORT ErrorCount;
+	SHORT NumberOfPackets;
+	UINT UrbHdrStatus;
+	KISO_PACKET IsoPackets[0];
+} KISO_CONTEXT, *PKISO_CONTEXT;
+
+typedef BOOL(WINAPI *LibK_IsoReadPipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	PUCHAR Buffer,
+	ULONG BufferLength,
+	LPOVERLAPPED Overlapped,
+	PKISO_CONTEXT IsoContext
+);
+
+typedef BOOL(WINAPI *LibK_IsoWritePipe_t)(
+	WINUSB_INTERFACE_HANDLE InterfaceHandle,
+	UCHAR PipeID,
+	PUCHAR Buffer,
+	ULONG BufferLength,
+	LPOVERLAPPED Overlapped,
+	PKISO_CONTEXT IsoContext
+);
+
+struct winusb_interface {
+	HMODULE hDll;
+	WinUsb_AbortPipe_t AbortPipe;
+	WinUsb_ControlTransfer_t ControlTransfer;
+	WinUsb_FlushPipe_t FlushPipe;
+	WinUsb_Free_t Free;
+	WinUsb_GetAssociatedInterface_t GetAssociatedInterface;
+	WinUsb_Initialize_t Initialize;
+	WinUsb_ReadPipe_t ReadPipe;
+	WinUsb_ResetPipe_t ResetPipe;
+	WinUsb_SetCurrentAlternateSetting_t SetCurrentAlternateSetting;
+	WinUsb_SetPipePolicy_t SetPipePolicy;
+	WinUsb_GetPipePolicy_t GetPipePolicy;
+	WinUsb_WritePipe_t WritePipe;
+	union {
+		struct {
+			// Isochoronous functions for libusbK sub api:
+			LibK_IsoReadPipe_t IsoReadPipe;
+			LibK_IsoWritePipe_t IsoWritePipe;
+			// Reset device function for libusbK sub api:
+			LibK_ResetDevice_t ResetDevice;
+		};
+		struct {
+			// Isochronous functions for WinUSB sub api:
+			WinUsb_QueryPipeEx_t QueryPipeEx;
+			WinUsb_ReadIsochPipeAsap_t ReadIsochPipeAsap;
+			WinUsb_RegisterIsochBuffer_t RegisterIsochBuffer;
+			WinUsb_UnregisterIsochBuffer_t UnregisterIsochBuffer;
+			WinUsb_WriteIsochPipeAsap_t WriteIsochPipeAsap;
+		};
+	};
+};
+
+/* hid.dll interface */
+
+#define HIDP_STATUS_SUCCESS	0x110000
+typedef void * PHIDP_PREPARSED_DATA;
+
+#include <pshpack1.h>
+
+typedef struct _HIDD_ATTIRBUTES {
+	ULONG Size;
+	USHORT VendorID;
+	USHORT ProductID;
+	USHORT VersionNumber;
+} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
+
+#include <poppack.h>
+
+typedef USHORT USAGE;
+typedef struct _HIDP_CAPS {
+	USAGE Usage;
+	USAGE UsagePage;
+	USHORT InputReportByteLength;
+	USHORT OutputReportByteLength;
+	USHORT FeatureReportByteLength;
+	USHORT Reserved[17];
+	USHORT NumberLinkCollectionNodes;
+	USHORT NumberInputButtonCaps;
+	USHORT NumberInputValueCaps;
+	USHORT NumberInputDataIndices;
+	USHORT NumberOutputButtonCaps;
+	USHORT NumberOutputValueCaps;
+	USHORT NumberOutputDataIndices;
+	USHORT NumberFeatureButtonCaps;
+	USHORT NumberFeatureValueCaps;
+	USHORT NumberFeatureDataIndices;
+} HIDP_CAPS, *PHIDP_CAPS;
+
+typedef enum _HIDP_REPORT_TYPE {
+	HidP_Input,
+	HidP_Output,
+	HidP_Feature
+} HIDP_REPORT_TYPE;
+
+typedef struct _HIDP_VALUE_CAPS {
+	USAGE UsagePage;
+	UCHAR ReportID;
+	BOOLEAN IsAlias;
+	USHORT BitField;
+	USHORT LinkCollection;
+	USAGE LinkUsage;
+	USAGE LinkUsagePage;
+	BOOLEAN IsRange;
+	BOOLEAN IsStringRange;
+	BOOLEAN IsDesignatorRange;
+	BOOLEAN IsAbsolute;
+	BOOLEAN HasNull;
+	UCHAR Reserved;
+	USHORT BitSize;
+	USHORT ReportCount;
+	USHORT Reserved2[5];
+	ULONG UnitsExp;
+	ULONG Units;
+	LONG LogicalMin, LogicalMax;
+	LONG PhysicalMin, PhysicalMax;
+	union {
+		struct {
+			USAGE UsageMin, UsageMax;
+			USHORT StringMin, StringMax;
+			USHORT DesignatorMin, DesignatorMax;
+			USHORT DataIndexMin, DataIndexMax;
+		} Range;
+		struct {
+			USAGE Usage, Reserved1;
+			USHORT StringIndex, Reserved2;
+			USHORT DesignatorIndex, Reserved3;
+			USHORT DataIndex, Reserved4;
+		} NotRange;
+	} u;
+} HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS;
+
+DLL_DECLARE_HANDLE(hid);
+DLL_DECLARE_FUNC(WINAPI, VOID, HidD_GetHidGuid, (LPGUID));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetAttributes, (HANDLE, PHIDD_ATTRIBUTES));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPreparsedData, (HANDLE, PHIDP_PREPARSED_DATA *));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FreePreparsedData, (PHIDP_PREPARSED_DATA));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetManufacturerString, (HANDLE, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetProductString, (HANDLE, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetSerialNumberString, (HANDLE, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetIndexedString, (HANDLE, ULONG, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, LONG, HidP_GetCaps, (PHIDP_PREPARSED_DATA, PHIDP_CAPS));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_SetNumInputBuffers, (HANDLE, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPhysicalDescriptor, (HANDLE, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FlushQueue, (HANDLE));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidP_GetValueCaps, (HIDP_REPORT_TYPE, PHIDP_VALUE_CAPS, PULONG, PHIDP_PREPARSED_DATA));
+
+#endif

deps/libusb/libusb/strerror.c

@@ -0,0 +1,223 @@
+/*
+ * libusb strerror code
+ * Copyright © 2013 Hans de Goede <hdegoede@redhat.com>
+ *
+ * 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 "libusbi.h"
+
+#include <ctype.h>
+#include <string.h>
+
+/** \ingroup libusb_misc
+ * How to add a new \ref libusb_strerror() translation:
+ * <ol>
+ * <li> Download the latest \c strerror.c from:<br>
+ *      https://raw.github.com/libusb/libusb/master/libusb/strerror.c </li>
+ * <li> Open the file in an UTF-8 capable editor </li>
+ * <li> Add the 2 letter <a href="https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes">ISO 639-1</a>
+ *      code for your locale at the end of \c usbi_locale_supported[]<br>
+ *    Eg. for Chinese, you would add "zh" so that:
+ *    \code... usbi_locale_supported[] = { "en", "nl", "fr" };\endcode
+ *    becomes:
+ *    \code... usbi_locale_supported[] = { "en", "nl", "fr", "zh" };\endcode </li>
+ * <li> Copy the <tt>{ / * English (en) * / ... }</tt> section and add it at the end of \c usbi_localized_errors<br>
+ *    Eg. for Chinese, the last section of \c usbi_localized_errors could look like:
+ *    \code
+ *     }, { / * Chinese (zh) * /
+ *         "Success",
+ *         ...
+ *         "Other error",
+ *     },
+ * };\endcode </li>
+ * <li> Translate each of the English messages from the section you copied into your language </li>
+ * <li> Save the file (in UTF-8 format) and send it to \c libusb-devel\@lists.sourceforge.net </li>
+ * </ol>
+ */
+
+static const char * const usbi_locale_supported[] = { "en", "nl", "fr", "ru", "de", "hu" };
+static const char * const usbi_localized_errors[ARRAYSIZE(usbi_locale_supported)][LIBUSB_ERROR_COUNT] = {
+	{ /* English (en) */
+		"Success",
+		"Input/Output Error",
+		"Invalid parameter",
+		"Access denied (insufficient permissions)",
+		"No such device (it may have been disconnected)",
+		"Entity not found",
+		"Resource busy",
+		"Operation timed out",
+		"Overflow",
+		"Pipe error",
+		"System call interrupted (perhaps due to signal)",
+		"Insufficient memory",
+		"Operation not supported or unimplemented on this platform",
+		"Other error",
+	}, { /* Dutch (nl) */
+		"Gelukt",
+		"Invoer-/uitvoerfout",
+		"Ongeldig argument",
+		"Toegang geweigerd (onvoldoende toegangsrechten)",
+		"Apparaat bestaat niet (verbinding met apparaat verbroken?)",
+		"Niet gevonden",
+		"Apparaat of hulpbron is bezig",
+		"Bewerking verlopen",
+		"Waarde is te groot",
+		"Gebroken pijp",
+		"Onderbroken systeemaanroep",
+		"Onvoldoende geheugen beschikbaar",
+		"Bewerking wordt niet ondersteund",
+		"Andere fout",
+	}, { /* French (fr) */
+		"Succès",
+		"Erreur d'entrée/sortie",
+		"Paramètre invalide",
+		"Accès refusé (permissions insuffisantes)",
+		"Périphérique introuvable (peut-être déconnecté)",
+		"Elément introuvable",
+		"Resource déjà occupée",
+		"Operation expirée",
+		"Débordement",
+		"Erreur de pipe",
+		"Appel système abandonné (peut-être à cause d’un signal)",
+		"Mémoire insuffisante",
+		"Opération non supportée or non implémentée sur cette plateforme",
+		"Autre erreur",
+	}, { /* Russian (ru) */
+		"Успех",
+		"Ошибка ввода/вывода",
+		"Неверный параметр",
+		"Доступ запрещён (не хватает прав)",
+		"Устройство отсутствует (возможно, оно было отсоединено)",
+		"Элемент не найден",
+		"Ресурс занят",
+		"Истекло время ожидания операции",
+		"Переполнение",
+		"Ошибка канала",
+		"Системный вызов прерван (возможно, сигналом)",
+		"Память исчерпана",
+		"Операция не поддерживается данной платформой",
+		"Неизвестная ошибка"
+	}, { /* German (de) */
+		"Erfolgreich",
+		"Eingabe-/Ausgabefehler",
+		"Ungültiger Parameter",
+		"Keine Berechtigung (Zugriffsrechte fehlen)",
+		"Kein passendes Gerät gefunden (es könnte entfernt worden sein)",
+		"Entität nicht gefunden",
+		"Die Ressource ist belegt",
+		"Die Wartezeit für die Operation ist abgelaufen",
+		"Mehr Daten empfangen als erwartet",
+		"Datenübergabe unterbrochen (broken pipe)",
+		"Unterbrechung während des Betriebssystemaufrufs",
+		"Nicht genügend Hauptspeicher verfügbar",
+		"Die Operation wird nicht unterstützt oder ist auf dieser Platform nicht implementiert",
+		"Allgemeiner Fehler",
+	}, { /* Hungarian (hu) */
+		"Sikeres",
+		"Be-/kimeneti hiba",
+		"Érvénytelen paraméter",
+		"Hozzáférés megtagadva",
+		"Az eszköz nem található (eltávolították?)",
+		"Nem található",
+		"Az erőforrás foglalt",
+		"Időtúllépés",
+		"Túlcsordulás",
+		"Törött adatcsatorna",
+		"Rendszerhívás megszakítva",
+		"Nincs elég memória",
+		"A művelet nem támogatott ezen a rendszeren",
+		"Általános hiba",
+	},
+};
+
+static const char * const (*usbi_error_strings)[LIBUSB_ERROR_COUNT] = &usbi_localized_errors[0];
+
+/** \ingroup libusb_misc
+ * Set the language, and only the language, not the encoding! used for
+ * translatable libusb messages.
+ *
+ * This takes a locale string in the default setlocale format: lang[-region]
+ * or lang[_country_region][.codeset]. Only the lang part of the string is
+ * used, and only 2 letter ISO 639-1 codes are accepted for it, such as "de".
+ * The optional region, country_region or codeset parts are ignored. This
+ * means that functions which return translatable strings will NOT honor the
+ * specified encoding.
+ * All strings returned are encoded as UTF-8 strings.
+ *
+ * If libusb_setlocale() is not called, all messages will be in English.
+ *
+ * The following functions return translatable strings: libusb_strerror().
+ * Note that the libusb log messages controlled through LIBUSB_OPTION_LOG_LEVEL
+ * are not translated, they are always in English.
+ *
+ * For POSIX UTF-8 environments if you want libusb to follow the standard
+ * locale settings, call libusb_setlocale(setlocale(LC_MESSAGES, NULL)),
+ * after your app has done its locale setup.
+ *
+ * \param locale locale-string in the form of lang[_country_region][.codeset]
+ * or lang[-region], where lang is a 2 letter ISO 639-1 code
+ * \returns \ref LIBUSB_SUCCESS on success
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the locale doesn't meet the requirements
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the requested language is not supported
+ * \returns a LIBUSB_ERROR code on other errors
+ */
+
+int API_EXPORTED libusb_setlocale(const char *locale)
+{
+	size_t i;
+
+	if (!locale || strlen(locale) < 2
+	    || (locale[2] != '\0' && locale[2] != '-' && locale[2] != '_' && locale[2] != '.'))
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	for (i = 0; i < ARRAYSIZE(usbi_locale_supported); i++) {
+		if (usbi_locale_supported[i][0] == tolower((unsigned char)locale[0])
+		    && usbi_locale_supported[i][1] == tolower((unsigned char)locale[1]))
+			break;
+	}
+
+	if (i == ARRAYSIZE(usbi_locale_supported))
+		return LIBUSB_ERROR_NOT_FOUND;
+
+	usbi_error_strings = &usbi_localized_errors[i];
+
+	return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_misc
+ * Returns a constant string with a short description of the given error code,
+ * this description is intended for displaying to the end user and will be in
+ * the language set by libusb_setlocale().
+ *
+ * The returned string is encoded in UTF-8.
+ *
+ * The messages always start with a capital letter and end without any dot.
+ * The caller must not free() the returned string.
+ *
+ * \param errcode the error code whose description is desired
+ * \returns a short description of the error code in UTF-8 encoding
+ */
+DEFAULT_VISIBILITY const char * LIBUSB_CALL libusb_strerror(int errcode)
+{
+	int errcode_index = -errcode;
+
+	if (errcode_index < 0 || errcode_index >= LIBUSB_ERROR_COUNT) {
+		/* "Other Error", which should always be our last message, is returned */
+		errcode_index = LIBUSB_ERROR_COUNT - 1;
+	}
+
+	return (*usbi_error_strings)[errcode_index];
+}

deps/libusb/libusb/sync.c

@@ -0,0 +1,339 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * Synchronous I/O functions for libusb
+ * Copyright © 2007-2008 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2019 Nathan Hjelm <hjelmn@cs.unm.edu>
+ * Copyright © 2019 Google LLC. All rights reserved.
+ *
+ * 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 "libusbi.h"
+
+#include <string.h>
+
+/**
+ * @defgroup libusb_syncio Synchronous device I/O
+ *
+ * This page documents libusb's synchronous (blocking) API for USB device I/O.
+ * This interface is easy to use but has some limitations. More advanced users
+ * may wish to consider using the \ref libusb_asyncio "asynchronous I/O API" instead.
+ */
+
+static void LIBUSB_CALL sync_transfer_cb(struct libusb_transfer *transfer)
+{
+	usbi_dbg(TRANSFER_CTX(transfer), "actual_length=%d", transfer->actual_length);
+
+	int *completed = transfer->user_data;
+	*completed = 1;
+	/*
+	 * Right after setting 'completed', another thread might free the transfer, so don't
+	 * access it beyond this point. The instantiating thread (not necessarily the
+	 * current one) interprets the result and frees the transfer.
+	 */
+}
+
+static void sync_transfer_wait_for_completion(struct libusb_transfer *transfer)
+{
+	int r, *completed = transfer->user_data;
+	struct libusb_context *ctx = HANDLE_CTX(transfer->dev_handle);
+
+	while (!*completed) {
+		r = libusb_handle_events_completed(ctx, completed);
+		if (r < 0) {
+			if (r == LIBUSB_ERROR_INTERRUPTED)
+				continue;
+			usbi_err(ctx, "libusb_handle_events failed: %s, cancelling transfer and retrying",
+				 libusb_error_name(r));
+			libusb_cancel_transfer(transfer);
+			continue;
+		}
+		if (NULL == transfer->dev_handle) {
+			/* transfer completion after libusb_close() */
+			transfer->status = LIBUSB_TRANSFER_NO_DEVICE;
+			*completed = 1;
+		}
+	}
+}
+
+/** \ingroup libusb_syncio
+ * Perform a USB control transfer.
+ *
+ * The direction of the transfer is inferred from the bmRequestType field of
+ * the setup packet.
+ *
+ * The wValue, wIndex and wLength fields values should be given in host-endian
+ * byte order.
+ *
+ * \param dev_handle a handle for the device to communicate with
+ * \param bmRequestType the request type field for the setup packet
+ * \param bRequest the request field for the setup packet
+ * \param wValue the value field for the setup packet
+ * \param wIndex the index field for the setup packet
+ * \param data a suitably-sized data buffer for either input or output
+ * (depending on direction bits within bmRequestType)
+ * \param wLength the length field for the setup packet. The data buffer should
+ * be at least this size.
+ * \param timeout timeout (in milliseconds) that this function should wait
+ * before giving up due to no response being received. For an unlimited
+ * timeout, use value 0.
+ * \returns on success, the number of bytes actually transferred
+ * \returns \ref LIBUSB_ERROR_TIMEOUT if the transfer timed out
+ * \returns \ref LIBUSB_ERROR_PIPE if the control request was not supported by the
+ * device
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns \ref LIBUSB_ERROR_BUSY if called from event handling context
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the transfer size is larger than
+ * the operating system and/or hardware can support (see \ref asynclimits)
+ * \returns another LIBUSB_ERROR code on other failures
+ */
+int API_EXPORTED libusb_control_transfer(libusb_device_handle *dev_handle,
+	uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
+	unsigned char *data, uint16_t wLength, unsigned int timeout)
+{
+	struct libusb_transfer *transfer;
+	unsigned char *buffer;
+	int completed = 0;
+	int r;
+
+	if (usbi_handling_events(HANDLE_CTX(dev_handle)))
+		return LIBUSB_ERROR_BUSY;
+
+	transfer = libusb_alloc_transfer(0);
+	if (!transfer)
+		return LIBUSB_ERROR_NO_MEM;
+
+	buffer = malloc(LIBUSB_CONTROL_SETUP_SIZE + wLength);
+	if (!buffer) {
+		libusb_free_transfer(transfer);
+		return LIBUSB_ERROR_NO_MEM;
+	}
+
+	libusb_fill_control_setup(buffer, bmRequestType, bRequest, wValue, wIndex,
+		wLength);
+	if ((bmRequestType & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_OUT)
+		memcpy(buffer + LIBUSB_CONTROL_SETUP_SIZE, data, wLength);
+
+	libusb_fill_control_transfer(transfer, dev_handle, buffer,
+		sync_transfer_cb, &completed, timeout);
+	transfer->flags = LIBUSB_TRANSFER_FREE_BUFFER;
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		libusb_free_transfer(transfer);
+		return r;
+	}
+
+	sync_transfer_wait_for_completion(transfer);
+
+	if ((bmRequestType & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN)
+		memcpy(data, libusb_control_transfer_get_data(transfer),
+			transfer->actual_length);
+
+	switch (transfer->status) {
+	case LIBUSB_TRANSFER_COMPLETED:
+		r = transfer->actual_length;
+		break;
+	case LIBUSB_TRANSFER_TIMED_OUT:
+		r = LIBUSB_ERROR_TIMEOUT;
+		break;
+	case LIBUSB_TRANSFER_STALL:
+		r = LIBUSB_ERROR_PIPE;
+		break;
+	case LIBUSB_TRANSFER_NO_DEVICE:
+		r = LIBUSB_ERROR_NO_DEVICE;
+		break;
+	case LIBUSB_TRANSFER_OVERFLOW:
+		r = LIBUSB_ERROR_OVERFLOW;
+		break;
+	case LIBUSB_TRANSFER_ERROR:
+	case LIBUSB_TRANSFER_CANCELLED:
+		r = LIBUSB_ERROR_IO;
+		break;
+	default:
+		usbi_warn(HANDLE_CTX(dev_handle),
+			"unrecognised status code %d", transfer->status);
+		r = LIBUSB_ERROR_OTHER;
+	}
+
+	libusb_free_transfer(transfer);
+	return r;
+}
+
+static int do_sync_bulk_transfer(struct libusb_device_handle *dev_handle,
+	unsigned char endpoint, unsigned char *buffer, int length,
+	int *transferred, unsigned int timeout, unsigned char type)
+{
+	struct libusb_transfer *transfer;
+	int completed = 0;
+	int r;
+
+	if (usbi_handling_events(HANDLE_CTX(dev_handle)))
+		return LIBUSB_ERROR_BUSY;
+
+	transfer = libusb_alloc_transfer(0);
+	if (!transfer)
+		return LIBUSB_ERROR_NO_MEM;
+
+	libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer, length,
+		sync_transfer_cb, &completed, timeout);
+	transfer->type = type;
+
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		libusb_free_transfer(transfer);
+		return r;
+	}
+
+	sync_transfer_wait_for_completion(transfer);
+
+	if (transferred)
+		*transferred = transfer->actual_length;
+
+	switch (transfer->status) {
+	case LIBUSB_TRANSFER_COMPLETED:
+		r = 0;
+		break;
+	case LIBUSB_TRANSFER_TIMED_OUT:
+		r = LIBUSB_ERROR_TIMEOUT;
+		break;
+	case LIBUSB_TRANSFER_STALL:
+		r = LIBUSB_ERROR_PIPE;
+		break;
+	case LIBUSB_TRANSFER_OVERFLOW:
+		r = LIBUSB_ERROR_OVERFLOW;
+		break;
+	case LIBUSB_TRANSFER_NO_DEVICE:
+		r = LIBUSB_ERROR_NO_DEVICE;
+		break;
+	case LIBUSB_TRANSFER_ERROR:
+	case LIBUSB_TRANSFER_CANCELLED:
+		r = LIBUSB_ERROR_IO;
+		break;
+	default:
+		usbi_warn(HANDLE_CTX(dev_handle),
+			"unrecognised status code %d", transfer->status);
+		r = LIBUSB_ERROR_OTHER;
+	}
+
+	libusb_free_transfer(transfer);
+	return r;
+}
+
+/** \ingroup libusb_syncio
+ * Perform a USB bulk transfer. The direction of the transfer is inferred from
+ * the direction bits of the endpoint address.
+ *
+ * For bulk reads, the <tt>length</tt> field indicates the maximum length of
+ * data you are expecting to receive. If less data arrives than expected,
+ * this function will return that data, so be sure to check the
+ * <tt>transferred</tt> output parameter.
+ *
+ * You should also check the <tt>transferred</tt> parameter for bulk writes.
+ * Not all of the data may have been written.
+ *
+ * Also check <tt>transferred</tt> when dealing with a timeout error code.
+ * libusb may have to split your transfer into a number of chunks to satisfy
+ * underlying O/S requirements, meaning that the timeout may expire after
+ * the first few chunks have completed. libusb is careful not to lose any data
+ * that may have been transferred; do not assume that timeout conditions
+ * indicate a complete lack of I/O. See \ref asynctimeout for more details.
+ *
+ * \param dev_handle a handle for the device to communicate with
+ * \param endpoint the address of a valid endpoint to communicate with
+ * \param data a suitably-sized data buffer for either input or output
+ * (depending on endpoint)
+ * \param length for bulk writes, the number of bytes from data to be sent. for
+ * bulk reads, the maximum number of bytes to receive into the data buffer.
+ * \param transferred output location for the number of bytes actually
+ * transferred. Since version 1.0.21 (\ref LIBUSB_API_VERSION >= 0x01000105),
+ * it is legal to pass a NULL pointer if you do not wish to receive this
+ * information.
+ * \param timeout timeout (in milliseconds) that this function should wait
+ * before giving up due to no response being received. For an unlimited
+ * timeout, use value 0.
+ *
+ * \returns 0 on success (and populates <tt>transferred</tt>)
+ * \returns \ref LIBUSB_ERROR_TIMEOUT if the transfer timed out (and populates
+ * <tt>transferred</tt>)
+ * \returns \ref LIBUSB_ERROR_PIPE if the endpoint halted
+ * \returns \ref LIBUSB_ERROR_OVERFLOW if the device offered more data, see
+ * \ref libusb_packetoverflow
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns \ref LIBUSB_ERROR_BUSY if called from event handling context
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the transfer size is larger than
+ * the operating system and/or hardware can support (see \ref asynclimits)
+ * \returns another LIBUSB_ERROR code on other failures
+ */
+int API_EXPORTED libusb_bulk_transfer(libusb_device_handle *dev_handle,
+	unsigned char endpoint, unsigned char *data, int length,
+	int *transferred, unsigned int timeout)
+{
+	return do_sync_bulk_transfer(dev_handle, endpoint, data, length,
+		transferred, timeout, LIBUSB_TRANSFER_TYPE_BULK);
+}
+
+/** \ingroup libusb_syncio
+ * Perform a USB interrupt transfer. The direction of the transfer is inferred
+ * from the direction bits of the endpoint address.
+ *
+ * For interrupt reads, the <tt>length</tt> field indicates the maximum length
+ * of data you are expecting to receive. If less data arrives than expected,
+ * this function will return that data, so be sure to check the
+ * <tt>transferred</tt> output parameter.
+ *
+ * You should also check the <tt>transferred</tt> parameter for interrupt
+ * writes. Not all of the data may have been written.
+ *
+ * Also check <tt>transferred</tt> when dealing with a timeout error code.
+ * libusb may have to split your transfer into a number of chunks to satisfy
+ * underlying O/S requirements, meaning that the timeout may expire after
+ * the first few chunks have completed. libusb is careful not to lose any data
+ * that may have been transferred; do not assume that timeout conditions
+ * indicate a complete lack of I/O. See \ref asynctimeout for more details.
+ *
+ * The default endpoint bInterval value is used as the polling interval.
+ *
+ * \param dev_handle a handle for the device to communicate with
+ * \param endpoint the address of a valid endpoint to communicate with
+ * \param data a suitably-sized data buffer for either input or output
+ * (depending on endpoint)
+ * \param length for bulk writes, the number of bytes from data to be sent. for
+ * bulk reads, the maximum number of bytes to receive into the data buffer.
+ * \param transferred output location for the number of bytes actually
+ * transferred. Since version 1.0.21 (\ref LIBUSB_API_VERSION >= 0x01000105),
+ * it is legal to pass a NULL pointer if you do not wish to receive this
+ * information.
+ * \param timeout timeout (in milliseconds) that this function should wait
+ * before giving up due to no response being received. For an unlimited
+ * timeout, use value 0.
+ *
+ * \returns 0 on success (and populates <tt>transferred</tt>)
+ * \returns \ref LIBUSB_ERROR_TIMEOUT if the transfer timed out
+ * \returns \ref LIBUSB_ERROR_PIPE if the endpoint halted
+ * \returns \ref LIBUSB_ERROR_OVERFLOW if the device offered more data, see
+ * \ref libusb_packetoverflow
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns \ref LIBUSB_ERROR_BUSY if called from event handling context
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the transfer size is larger than
+ * the operating system and/or hardware can support (see \ref asynclimits)
+ * \returns another LIBUSB_ERROR code on other error
+ */
+int API_EXPORTED libusb_interrupt_transfer(libusb_device_handle *dev_handle,
+	unsigned char endpoint, unsigned char *data, int length,
+	int *transferred, unsigned int timeout)
+{
+	return do_sync_bulk_transfer(dev_handle, endpoint, data, length,
+		transferred, timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT);
+}

deps/libusb/libusb/version.h

@@ -0,0 +1,18 @@
+/* This file is parsed by m4 and windres and RC.EXE so please keep it simple. */
+#include "version_nano.h"
+#ifndef LIBUSB_MAJOR
+#define LIBUSB_MAJOR 1
+#endif
+#ifndef LIBUSB_MINOR
+#define LIBUSB_MINOR 0
+#endif
+#ifndef LIBUSB_MICRO
+#define LIBUSB_MICRO 27
+#endif
+#ifndef LIBUSB_NANO
+#define LIBUSB_NANO 0
+#endif
+/* LIBUSB_RC is the release candidate suffix. Should normally be empty. */
+#ifndef LIBUSB_RC
+#define LIBUSB_RC ""
+#endif

deps/libusb/libusb/version_nano.h

@@ -0,0 +1 @@
+#define LIBUSB_NANO 11882