libusb 0.3.4 → 0.4.0

data/ext/libusbx-1.0.17/libusb/os/wince_usb.h

@@ -0,0 +1,131 @@
+/*
+ * Windows CE backend for libusbx 1.0
+ * Copyright © 2011-2013 RealVNC Ltd.
+ * Portions taken from Windows backend, which is
+ * Copyright © 2009-2010 Pete Batard <pbatard@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
+ */
+#pragma once
+
+#include "windows_common.h"
+
+#include <windows.h>
+#include "poll_windows.h"
+
+#define MAX_DEVICE_COUNT            256
+
+// This is a modified dump of the types in the ceusbkwrapper.h library header
+// with functions transformed into extern pointers.
+//
+// This backend dynamically loads ceusbkwrapper.dll and doesn't include
+// ceusbkwrapper.h directly to simplify the build process. The kernel
+// side wrapper driver is built using the platform image build tools,
+// which makes it difficult to reference directly from the libusbx build
+// system.
+struct UKW_DEVICE_PRIV;
+typedef struct UKW_DEVICE_PRIV *UKW_DEVICE;
+typedef UKW_DEVICE *PUKW_DEVICE, *LPUKW_DEVICE;
+
+typedef struct {
+	UINT8 bLength;
+	UINT8 bDescriptorType;
+	UINT16 bcdUSB;
+	UINT8 bDeviceClass;
+	UINT8 bDeviceSubClass;
+	UINT8 bDeviceProtocol;
+	UINT8 bMaxPacketSize0;
+	UINT16 idVendor;
+	UINT16 idProduct;
+	UINT16 bcdDevice;
+	UINT8 iManufacturer;
+	UINT8 iProduct;
+	UINT8 iSerialNumber;
+	UINT8 bNumConfigurations;
+} UKW_DEVICE_DESCRIPTOR, *PUKW_DEVICE_DESCRIPTOR, *LPUKW_DEVICE_DESCRIPTOR;
+
+typedef struct {
+	UINT8 bmRequestType;
+	UINT8 bRequest;
+	UINT16 wValue;
+	UINT16 wIndex;
+	UINT16 wLength;
+} UKW_CONTROL_HEADER, *PUKW_CONTROL_HEADER, *LPUKW_CONTROL_HEADER;
+
+// Collection of flags which can be used when issuing transfer requests
+/* Indicates that the transfer direction is 'in' */
+#define UKW_TF_IN_TRANSFER        0x00000001
+/* Indicates that the transfer direction is 'out' */
+#define UKW_TF_OUT_TRANSFER       0x00000000
+/* Specifies that the transfer should complete as soon as possible,
+ * even if no OVERLAPPED structure has been provided. */
+#define UKW_TF_NO_WAIT            0x00000100
+/* Indicates that transfers shorter than the buffer are ok */
+#define UKW_TF_SHORT_TRANSFER_OK  0x00000200
+#define UKW_TF_SEND_TO_DEVICE     0x00010000
+#define UKW_TF_SEND_TO_INTERFACE  0x00020000
+#define UKW_TF_SEND_TO_ENDPOINT   0x00040000
+/* Don't block when waiting for memory allocations */
+#define UKW_TF_DONT_BLOCK_FOR_MEM 0x00080000
+
+/* Value to use when dealing with configuration values, such as UkwGetConfigDescriptor, 
+ * to specify the currently active configuration for the device. */
+#define UKW_ACTIVE_CONFIGURATION -1
+
+DLL_DECLARE(WINAPI, HANDLE, UkwOpenDriver, ());
+DLL_DECLARE(WINAPI, BOOL, UkwGetDeviceList, (HANDLE, LPUKW_DEVICE, DWORD, LPDWORD));
+DLL_DECLARE(WINAPI, void, UkwReleaseDeviceList, (HANDLE, LPUKW_DEVICE, DWORD));
+DLL_DECLARE(WINAPI, BOOL, UkwGetDeviceAddress, (UKW_DEVICE, unsigned char*, unsigned char*, unsigned long*));
+DLL_DECLARE(WINAPI, BOOL, UkwGetDeviceDescriptor, (UKW_DEVICE, LPUKW_DEVICE_DESCRIPTOR));
+DLL_DECLARE(WINAPI, BOOL, UkwGetConfigDescriptor, (UKW_DEVICE, DWORD, LPVOID, DWORD, LPDWORD));
+DLL_DECLARE(WINAPI, void, UkwCloseDriver, (HANDLE));
+DLL_DECLARE(WINAPI, BOOL, UkwCancelTransfer, (UKW_DEVICE, LPOVERLAPPED, DWORD));
+DLL_DECLARE(WINAPI, BOOL, UkwIssueControlTransfer, (UKW_DEVICE, DWORD, LPUKW_CONTROL_HEADER, LPVOID, DWORD, LPDWORD, LPOVERLAPPED));
+DLL_DECLARE(WINAPI, BOOL, UkwClaimInterface, (UKW_DEVICE, DWORD));
+DLL_DECLARE(WINAPI, BOOL, UkwReleaseInterface, (UKW_DEVICE, DWORD));
+DLL_DECLARE(WINAPI, BOOL, UkwSetInterfaceAlternateSetting, (UKW_DEVICE, DWORD, DWORD));
+DLL_DECLARE(WINAPI, BOOL, UkwClearHaltHost, (UKW_DEVICE, UCHAR));
+DLL_DECLARE(WINAPI, BOOL, UkwClearHaltDevice, (UKW_DEVICE, UCHAR));
+DLL_DECLARE(WINAPI, BOOL, UkwGetConfig, (UKW_DEVICE, PUCHAR));
+DLL_DECLARE(WINAPI, BOOL, UkwSetConfig, (UKW_DEVICE, UCHAR));
+DLL_DECLARE(WINAPI, BOOL, UkwResetDevice, (UKW_DEVICE));
+DLL_DECLARE(WINAPI, BOOL, UkwKernelDriverActive, (UKW_DEVICE, DWORD, PBOOL));
+DLL_DECLARE(WINAPI, BOOL, UkwAttachKernelDriver, (UKW_DEVICE, DWORD));
+DLL_DECLARE(WINAPI, BOOL, UkwDetachKernelDriver, (UKW_DEVICE, DWORD));
+DLL_DECLARE(WINAPI, BOOL, UkwIssueBulkTransfer, (UKW_DEVICE, DWORD, UCHAR, LPVOID, DWORD, LPDWORD, LPOVERLAPPED));
+DLL_DECLARE(WINAPI, BOOL, UkwIsPipeHalted, (UKW_DEVICE, UCHAR, LPBOOL));
+
+// Used to determine if an endpoint status really is halted on a failed transfer.
+#define STATUS_HALT_FLAG 0x1
+
+struct wince_device_priv {
+	UKW_DEVICE dev;
+	UKW_DEVICE_DESCRIPTOR desc;
+};
+
+struct wince_device_handle_priv {
+	// This member isn't used, but only exists to avoid an empty structure
+	// for private data for the device handle.
+	int reserved;
+};
+
+struct wince_transfer_priv {
+	struct winfd pollable_fd;
+	uint8_t interface_number;
+};
+

data/ext/libusbx-1.0.17/libusb/os/windows_common.h

@@ -0,0 +1,108 @@
+/*
+ * Windows backend common header for libusbx 1.0
+ *
+ * This file brings together header code common between
+ * the desktop Windows and Windows CE backends.
+ * Copyright © 2012-2013 RealVNC Ltd.
+ * 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
+ */
+
+#pragma once
+
+// Windows API default is uppercase - ugh!
+#if !defined(bool)
+#define bool BOOL
+#endif
+#if !defined(true)
+#define true TRUE
+#endif
+#if !defined(false)
+#define false FALSE
+#endif
+
+#define safe_free(p) do {if (p != NULL) {free((void*)p); p = NULL;}} while(0)
+#define safe_closehandle(h) do {if (h != INVALID_HANDLE_VALUE) {CloseHandle(h); h = INVALID_HANDLE_VALUE;}} while(0)
+#define safe_min(a, b) min((size_t)(a), (size_t)(b))
+#define safe_strcp(dst, dst_max, src, count) do {memcpy(dst, src, safe_min(count, dst_max)); \
+	((char*)dst)[safe_min(count, dst_max)-1] = 0;} while(0)
+#define safe_strcpy(dst, dst_max, src) safe_strcp(dst, dst_max, src, safe_strlen(src)+1)
+#define safe_strncat(dst, dst_max, src, count) strncat(dst, src, safe_min(count, dst_max - safe_strlen(dst) - 1))
+#define safe_strcat(dst, dst_max, src) safe_strncat(dst, dst_max, src, safe_strlen(src)+1)
+#define safe_strcmp(str1, str2) strcmp(((str1==NULL)?"<NULL>":str1), ((str2==NULL)?"<NULL>":str2))
+#define safe_stricmp(str1, str2) _stricmp(((str1==NULL)?"<NULL>":str1), ((str2==NULL)?"<NULL>":str2))
+#define safe_strncmp(str1, str2, count) strncmp(((str1==NULL)?"<NULL>":str1), ((str2==NULL)?"<NULL>":str2), count)
+#define safe_strlen(str) ((str==NULL)?0:strlen(str))
+#define safe_sprintf(dst, count, ...) do {_snprintf(dst, count, __VA_ARGS__); (dst)[(count)-1] = 0; } while(0)
+#define safe_stprintf _sntprintf
+#define safe_tcslen(str) ((str==NULL)?0:_tcslen(str))
+#define safe_unref_device(dev) do {if (dev != NULL) {libusb_unref_device(dev); dev = NULL;}} while(0)
+#define wchar_to_utf8_ms(wstr, str, strlen) WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, strlen, NULL, NULL)
+#ifndef ARRAYSIZE
+#define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))
+#endif
+
+#define ERR_BUFFER_SIZE             256
+#define TIMER_REQUEST_RETRY_MS      100
+#define MAX_TIMER_SEMAPHORES        128
+
+
+/*
+ * API macros - from libusb-win32 1.x
+ */
+#define DLL_DECLARE_PREFIXNAME(api, ret, prefixname, name, args)    \
+	typedef ret (api * __dll_##name##_t)args;                       \
+	static __dll_##name##_t prefixname = NULL
+
+#ifndef _WIN32_WCE
+#define DLL_STRINGIFY(dll) #dll
+#define DLL_GET_MODULE_HANDLE(dll) GetModuleHandleA(DLL_STRINGIFY(dll))
+#define DLL_LOAD_LIBRARY(dll) LoadLibraryA(DLL_STRINGIFY(dll))
+#else
+#define DLL_STRINGIFY(dll) L#dll
+#define DLL_GET_MODULE_HANDLE(dll) GetModuleHandle(DLL_STRINGIFY(dll))
+#define DLL_LOAD_LIBRARY(dll) LoadLibrary(DLL_STRINGIFY(dll))
+#endif
+
+#define DLL_LOAD_PREFIXNAME(dll, prefixname, name, ret_on_failure) \
+	do {                                                           \
+		HMODULE h = DLL_GET_MODULE_HANDLE(dll);                    \
+	if (!h)                                                        \
+		h = DLL_LOAD_LIBRARY(dll);                                 \
+	if (!h) {                                                      \
+		if (ret_on_failure) { return LIBUSB_ERROR_NOT_FOUND; }     \
+		else { break; }                                            \
+	}                                                              \
+	prefixname = (__dll_##name##_t)GetProcAddress(h,               \
+	                        DLL_STRINGIFY(name));                  \
+	if (prefixname) break;                                         \
+	prefixname = (__dll_##name##_t)GetProcAddress(h,               \
+	                        DLL_STRINGIFY(name) DLL_STRINGIFY(A)); \
+	if (prefixname) break;                                         \
+	prefixname = (__dll_##name##_t)GetProcAddress(h,               \
+	                        DLL_STRINGIFY(name) DLL_STRINGIFY(W)); \
+	if (prefixname) break;                                         \
+	if(ret_on_failure)                                             \
+		return LIBUSB_ERROR_NOT_FOUND;                             \
+	} while(0)
+
+#define DLL_DECLARE(api, ret, name, args)   DLL_DECLARE_PREFIXNAME(api, ret, name, name, args)
+#define DLL_LOAD(dll, name, ret_on_failure) DLL_LOAD_PREFIXNAME(dll, name, name, ret_on_failure)
+#define DLL_DECLARE_PREFIXED(api, ret, prefix, name, args)   DLL_DECLARE_PREFIXNAME(api, ret, prefix##name, name, args)
+#define DLL_LOAD_PREFIXED(dll, prefix, name, ret_on_failure) DLL_LOAD_PREFIXNAME(dll, prefix##name, name, ret_on_failure)

data/ext/{libusbx-1.0.14 → libusbx-1.0.17}/libusb/os/windows_usb.c

@@ -34,7 +34,7 @@
 #include <objbase.h>
 #include <winioctl.h>
 
-#include <libusbi.h>
+#include "libusbi.h"
 #include "poll_windows.h"
 #include "windows_usb.h"
 
@@ -42,8 +42,6 @@
 #define LOOP_CHECK(fcall) { r=fcall; if (r != LIBUSB_SUCCESS) continue; }
 #define LOOP_BREAK(err) { r=err; continue; }
 
-extern void usbi_fd_notification(struct libusb_context *ctx);
-
 // Helper prototypes
 static int windows_get_active_config_descriptor(struct libusb_device *dev, unsigned char *buffer, size_t len, int *host_endian);
 static int windows_clock_gettime(int clk_id, struct timespec *tp);
@@ -153,7 +151,7 @@ static char *windows_error_str(uint32_t retval)
 static char err_string[ERR_BUFFER_SIZE];
 
 	DWORD size;
-	size_t i;
+	ssize_t i;
 	uint32_t error_code, format_error;
 
 	error_code = retval?retval:GetLastError();
@@ -172,7 +170,7 @@ static char err_string[ERR_BUFFER_SIZE];
 			safe_sprintf(err_string, ERR_BUFFER_SIZE, "Unknown error code %u", error_code);
 	} else {
 		// Remove CR/LF terminators
-		for (i=safe_strlen(err_string)-1; ((err_string[i]==0x0A) || (err_string[i]==0x0D)); i--) {
+		for (i=safe_strlen(err_string)-1; (i>=0) && ((err_string[i]==0x0A) || (err_string[i]==0x0D)); i--) {
 			err_string[i] = 0;
 		}
 	}
@@ -261,7 +259,7 @@ static int init_dlls(void)
  * incremented index starting at zero) until all interfaces have been returned.
  */
 static bool get_devinfo_data(struct libusb_context *ctx,
-	HDEVINFO *dev_info, SP_DEVINFO_DATA *dev_info_data, char* usb_class, unsigned _index)
+	HDEVINFO *dev_info, SP_DEVINFO_DATA *dev_info_data, const char* usb_class, unsigned _index)
 {
 	if (_index <= 0) {
 		*dev_info = pSetupDiGetClassDevsA(NULL, usb_class, NULL, DIGCF_PRESENT|DIGCF_ALLCLASSES);
@@ -365,7 +363,7 @@ err_exit:
 }
 
 /* For libusb0 filter */
-SP_DEVICE_INTERFACE_DETAIL_DATA_A *get_interface_details_filter(struct libusb_context *ctx,
+static SP_DEVICE_INTERFACE_DETAIL_DATA_A *get_interface_details_filter(struct libusb_context *ctx,
 	HDEVINFO *dev_info, SP_DEVINFO_DATA *dev_info_data, const GUID* guid, unsigned _index, char* filter_path){
 	SP_DEVICE_INTERFACE_DATA dev_interface_data;
 	SP_DEVICE_INTERFACE_DETAIL_DATA_A *dev_interface_details = NULL;
@@ -537,6 +535,9 @@ static unsigned long htab_hash(char* str)
 	int c;
 	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;
@@ -635,7 +636,7 @@ static unsigned long get_ancestor_session_id(DWORD devinst, unsigned level)
 	if (CM_Get_Device_IDA(devinst, path, MAX_PATH_LENGTH, 0) != CR_SUCCESS) {
 		return 0;
 	}
-	// TODO (post hotplug): try without sanitizing
+	// TODO: (post hotplug): try without sanitizing
 	sanitized_path = sanitize_path(path);
 	if (sanitized_path == NULL) {
 		return 0;
@@ -688,7 +689,7 @@ static int windows_assign_endpoints(struct libusb_device_handle *dev_handle, int
 
 // Lookup for a match in the list of API driver names
 // return -1 if not found, driver match number otherwise
-int get_sub_api(char* driver, int api){
+static int get_sub_api(char* driver, int api){
 	int i;
 	const char sep_str[2] = {LIST_SEPARATOR, 0};
 	char *tok, *tmp_str;
@@ -885,6 +886,12 @@ static int windows_init(struct libusb_context *ctx)
 		}
 		SetThreadAffinityMask(timer_thread, 0);
 
+		// Wait for timer thread to init before continuing.
+		if (WaitForSingleObject(timer_response, INFINITE) != WAIT_OBJECT_0) {
+			usbi_err(ctx, "Failed to wait for timer thread to become ready - aborting");
+			goto init_exit;
+		}
+
 		// Create a hash table to store session ids. Second parameter is better if prime
 		htab_create(ctx, HTAB_SIZE);
 	}
@@ -1109,7 +1116,7 @@ static int init_device(struct libusb_device* dev, struct libusb_device* parent_d
 	dev->port_number = port_number;
 	priv->depth = parent_priv->depth + 1;
 	priv->parent_dev = parent_dev;
-	dev->parent_dev = parent_dev;
+	dev->parent_dev = libusb_ref_device(parent_dev);
 
 	// If the device address is already set, we can stop here
 	if (dev->device_address != 0) {
@@ -1169,6 +1176,8 @@ static int init_device(struct libusb_device* dev, struct libusb_device* parent_d
 		force_hcd_device_descriptor(dev);
 	}
 
+	usbi_sanitize_device(dev);
+
 	usbi_dbg("(bus: %d, addr: %d, depth: %d, port: %d): '%s'",
 		dev->bus_number, dev->device_address, priv->depth, priv->port, device_id);
 
@@ -1176,7 +1185,7 @@ static int init_device(struct libusb_device* dev, struct libusb_device* parent_d
 }
 
 // Returns the api type, or 0 if not found/unsupported
-void get_api_type(struct libusb_context *ctx, HDEVINFO *dev_info,
+static void get_api_type(struct libusb_context *ctx, HDEVINFO *dev_info,
 	SP_DEVINFO_DATA *dev_info_data, int *api, int *sub_api)
 {
 	// Precedence for filter drivers vs driver is in the order of this array
@@ -1277,7 +1286,7 @@ static int set_composite_interface(struct libusb_context* ctx, struct libusb_dev
 	priv->usb_interface[interface_number].apib = &usb_api_backend[api];
 	priv->usb_interface[interface_number].sub_api = sub_api;
 	if ((api == USB_API_HID) && (priv->hid == NULL)) {
-		priv->hid = calloc(1, sizeof(struct hid_device_priv));
+		priv->hid = (struct hid_device_priv*) calloc(1, sizeof(struct hid_device_priv));
 		if (priv->hid == NULL)
 			return LIBUSB_ERROR_NO_MEM;
 	}
@@ -1288,6 +1297,7 @@ static int set_composite_interface(struct libusb_context* ctx, struct libusb_dev
 static int set_hid_interface(struct libusb_context* ctx, struct libusb_device* dev,
 							char* dev_interface_path)
 {
+	int i;
 	struct windows_device_priv *priv = _device_priv(dev);
 
 	if (priv->hid == NULL) {
@@ -1298,8 +1308,11 @@ static int set_hid_interface(struct libusb_context* ctx, struct libusb_device* d
 		usbi_err(ctx, "program assertion failed: max USB interfaces reached for HID device");
 		return LIBUSB_ERROR_NO_DEVICE;
 	}
-	if (priv->usb_interface[priv->hid->nb_interfaces].path != NULL) {
-		safe_free(priv->usb_interface[priv->hid->nb_interfaces].path);
+	for (i=0; i<priv->hid->nb_interfaces; i++) {
+		if (safe_strcmp(priv->usb_interface[i].path, dev_interface_path) == 0) {
+			usbi_dbg("interface[%d] already set to %s", i, dev_interface_path);
+			return LIBUSB_SUCCESS;
+		}
 	}
 
 	priv->usb_interface[priv->hid->nb_interfaces].path = dev_interface_path;
@@ -1316,7 +1329,7 @@ static int windows_get_device_list(struct libusb_context *ctx, struct discovered
 {
 	struct discovered_devs *discdevs;
 	HDEVINFO dev_info = { 0 };
-	char* usb_class[] = {"USB", "NUSB3", "IUSB3"};
+	const char* usb_class[] = {"USB", "NUSB3", "IUSB3"};
 	SP_DEVINFO_DATA dev_info_data = { 0 };
 	SP_DEVICE_INTERFACE_DETAIL_DATA_A *dev_interface_details = NULL;
 	GUID hid_guid;
@@ -1329,7 +1342,7 @@ static int windows_get_device_list(struct libusb_context *ctx, struct discovered
 #define HID_PASS 4
 	int r = LIBUSB_SUCCESS;
 	int api, sub_api;
-	int class_index = 0;
+	size_t class_index = 0;
 	unsigned int nb_guids, pass, i, j, ancestor;
 	char path[MAX_PATH_LENGTH];
 	char strbuf[MAX_PATH_LENGTH];
@@ -1750,8 +1763,9 @@ static int windows_get_config_descriptor(struct libusb_device *dev, uint8_t conf
 
 	size = min(config_header->wTotalLength, len);
 	memcpy(buffer, priv->config_descriptor[config_index], size);
+	*host_endian = 0;
 
-	return LIBUSB_SUCCESS;
+	return (int)size;
 }
 
 /*
@@ -1906,7 +1920,7 @@ static void windows_clear_transfer_priv(struct usbi_transfer *itransfer)
 {
 	struct windows_transfer_priv *transfer_priv = (struct windows_transfer_priv*)usbi_transfer_get_os_priv(itransfer);
 
-	usbi_free_fd(transfer_priv->pollable_fd.fd);
+	usbi_free_fd(&transfer_priv->pollable_fd);
 	safe_free(transfer_priv->hid_buffer);
 	// When auto claim is in use, attempt to release the auto-claimed interface
 	auto_release(itransfer);
@@ -2030,9 +2044,9 @@ static void windows_transfer_callback(struct usbi_transfer *itransfer, uint32_t
 {
 	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 	struct windows_device_priv *priv = _device_priv(transfer->dev_handle->dev);
-	int status;
+	int status, istatus;
 
-	usbi_dbg("handling I/O completion with errcode %d", io_result);
+	usbi_dbg("handling I/O completion with errcode %d, size %d", io_result, io_size);
 
 	switch(io_result) {
 	case NO_ERROR:
@@ -2047,6 +2061,10 @@ static void windows_transfer_callback(struct usbi_transfer *itransfer, uint32_t
 		status = LIBUSB_TRANSFER_TIMED_OUT;
 		break;
 	case ERROR_OPERATION_ABORTED:
+		istatus = priv->apib->copy_transfer_data(SUB_API_NOTSET, itransfer, io_size);
+		if (istatus != LIBUSB_TRANSFER_COMPLETED) {
+			usbi_dbg("Failed to copy partial data in aborted operation: %d", istatus);
+		}
 		if (itransfer->flags & USBI_TRANSFER_TIMED_OUT) {
 			usbi_dbg("detected timeout");
 			status = LIBUSB_TRANSFER_TIMED_OUT;
@@ -2056,7 +2074,7 @@ static void windows_transfer_callback(struct usbi_transfer *itransfer, uint32_t
 		}
 		break;
 	default:
-		usbi_err(ITRANSFER_CTX(itransfer), "detected I/O error: %s", windows_error_str(0));
+		usbi_err(ITRANSFER_CTX(itransfer), "detected I/O error %d: %s", io_result, windows_error_str(0));
 		status = LIBUSB_TRANSFER_ERROR;
 		break;
 	}
@@ -2160,6 +2178,11 @@ unsigned __stdcall windows_clock_gettime_threaded(void* param)
 		usbi_dbg("hires timer available (Frequency: %"PRIu64" Hz)", hires_frequency);
 	}
 
+	// Signal windows_init() that we're ready to service requests
+	if (ReleaseSemaphore(timer_response, 1, NULL) == 0) {
+		usbi_dbg("unable to release timer semaphore: %s", windows_error_str(0));
+	}
+
 	// Main loop - wait for requests
 	while (1) {
 		timer_index = WaitForMultipleObjects(2, timer_request, FALSE, INFINITE) - WAIT_OBJECT_0;
@@ -2194,7 +2217,7 @@ unsigned __stdcall windows_clock_gettime_threaded(void* param)
 			nb_responses = InterlockedExchange((LONG*)&request_count[0], 0);
 			if ( (nb_responses)
 			  && (ReleaseSemaphore(timer_response, nb_responses, NULL) == 0) ) {
-				usbi_dbg("unable to release timer semaphore %d: %s", windows_error_str(0));
+				usbi_dbg("unable to release timer semaphore: %s", windows_error_str(0));
 			}
 			continue;
 		case 1: // time to quit
@@ -2253,16 +2276,19 @@ static int windows_clock_gettime(int clk_id, struct timespec *tp)
 // NB: MSVC6 does not support named initializers.
 const struct usbi_os_backend windows_backend = {
 	"Windows",
+	USBI_CAP_HAS_HID_ACCESS,
 	windows_init,
 	windows_exit,
 
 	windows_get_device_list,
+	NULL,				/* hotplug_poll */
 	windows_open,
 	windows_close,
 
 	windows_get_device_descriptor,
 	windows_get_active_config_descriptor,
 	windows_get_config_descriptor,
+	NULL,				/* get_config_descriptor_by_value() */
 
 	windows_get_configuration,
 	windows_set_configuration,
@@ -2594,6 +2620,8 @@ static void winusbx_close(int sub_api, struct libusb_device_handle *dev_handle)
 	HANDLE file_handle;
 	int i;
 
+	if (sub_api == SUB_API_NOTSET)
+		sub_api = priv->sub_api;
 	if (!WinUSBX[sub_api].initialized)
 		return;
 
@@ -2662,9 +2690,10 @@ static int winusbx_claim_interface(int sub_api, struct libusb_device_handle *dev
 	struct windows_device_priv *priv = _device_priv(dev_handle->dev);
 	bool is_using_usbccgp = (priv->apib->id == USB_API_COMPOSITE);
 	HANDLE file_handle, winusb_handle;
+	DWORD err;
 	int i;
 	SP_DEVICE_INTERFACE_DETAIL_DATA_A *dev_interface_details = NULL;
-	HDEVINFO dev_info;
+	HDEVINFO dev_info = INVALID_HANDLE_VALUE;
 	SP_DEVINFO_DATA dev_info_data;
 	char* dev_path_no_guid = NULL;
 	char filter_path[] = "\\\\.\\libusb0-0000";
@@ -2683,15 +2712,15 @@ static int winusbx_claim_interface(int sub_api, struct libusb_device_handle *dev
 
 		if (!WinUSBX[sub_api].Initialize(file_handle, &winusb_handle)) {
 			handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
-
-			switch(GetLastError()) {
+			err = GetLastError();
+			switch(err) {
 			case ERROR_BAD_COMMAND:
 				// The device was disconnected
 				usbi_err(ctx, "could not access interface %d: %s", iface, windows_error_str(0));
 				return LIBUSB_ERROR_NO_DEVICE;
 			default:
 				// it may be that we're using the libusb0 filter driver.
-				// [TODO] can we move this whole business into the K/0 DLL?
+				// TODO: can we move this whole business into the K/0 DLL?
 				for (i = 0; ; i++) {
 					safe_free(dev_interface_details);
 					safe_free(dev_path_no_guid);
@@ -2717,7 +2746,7 @@ static int winusbx_claim_interface(int sub_api, struct libusb_device_handle *dev
 					}
 				}
 				if (!found_filter) {
-					usbi_err(ctx, "could not access interface %d: %s", iface, windows_error_str(0));
+					usbi_err(ctx, "could not access interface %d: %s", iface, windows_error_str(err));
 					return LIBUSB_ERROR_ACCESS;
 				}
 			}
@@ -2730,11 +2759,11 @@ static int winusbx_claim_interface(int sub_api, struct libusb_device_handle *dev
 		// must first claim the first interface before you claim the others
 		if ((winusb_handle == 0) || (winusb_handle == INVALID_HANDLE_VALUE)) {
 			file_handle = handle_priv->interface_handle[0].dev_handle;
-			if (!WinUSBX[sub_api].Initialize(file_handle, &winusb_handle)) {
+			if (WinUSBX[sub_api].Initialize(file_handle, &winusb_handle)) {
 				handle_priv->interface_handle[0].api_handle = winusb_handle;
 				usbi_warn(ctx, "auto-claimed interface 0 (required to claim %d with WinUSB)", iface);
 			} else {
-				usbi_warn(ctx, "failed to auto-claim interface 0 (required to claim %d with WinUSB)", iface);
+				usbi_warn(ctx, "failed to auto-claim interface 0 (required to claim %d with WinUSB): %s", iface, windows_error_str(0));
 				return LIBUSB_ERROR_ACCESS;
 			}
 		}
@@ -2860,7 +2889,7 @@ static int winusbx_submit_control_transfer(int sub_api, struct usbi_transfer *it
 	usbi_dbg("will use interface %d", current_interface);
 	winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
 
-	wfd = usbi_create_fd(winusb_handle, _O_RDONLY);
+	wfd = usbi_create_fd(winusb_handle, RW_READ, NULL, NULL);
 	// Always use the handle returned from usbi_create_fd (wfd.handle)
 	if (wfd.fd < 0) {
 		return LIBUSB_ERROR_NO_MEM;
@@ -2871,7 +2900,7 @@ static int winusbx_submit_control_transfer(int sub_api, struct usbi_transfer *it
 	  && (setup->request == LIBUSB_REQUEST_SET_CONFIGURATION) ) {
 		if (setup->value != priv->active_config) {
 			usbi_warn(ctx, "cannot set configuration other than the default one");
-			usbi_free_fd(wfd.fd);
+			usbi_free_fd(&wfd);
 			return LIBUSB_ERROR_INVALID_PARAM;
 		}
 		wfd.overlapped->Internal = STATUS_COMPLETED_SYNCHRONOUSLY;
@@ -2880,7 +2909,7 @@ static int winusbx_submit_control_transfer(int sub_api, struct usbi_transfer *it
 		if (!WinUSBX[sub_api].ControlTransfer(wfd.handle, *setup, transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, size, NULL, wfd.overlapped)) {
 			if(GetLastError() != ERROR_IO_PENDING) {
 				usbi_warn(ctx, "ControlTransfer failed: %s", windows_error_str(0));
-				usbi_free_fd(wfd.fd);
+				usbi_free_fd(&wfd);
 				return LIBUSB_ERROR_IO;
 			}
 		} else {
@@ -2949,7 +2978,7 @@ static int winusbx_submit_bulk_transfer(int sub_api, struct usbi_transfer *itran
 
 	winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
 
-	wfd = usbi_create_fd(winusb_handle, IS_XFERIN(transfer) ? _O_RDONLY : _O_WRONLY);
+	wfd = usbi_create_fd(winusb_handle, IS_XFERIN(transfer) ? RW_READ : RW_WRITE, NULL, NULL);
 	// Always use the handle returned from usbi_create_fd (wfd.handle)
 	if (wfd.fd < 0) {
 		return LIBUSB_ERROR_NO_MEM;
@@ -2965,7 +2994,7 @@ static int winusbx_submit_bulk_transfer(int sub_api, struct usbi_transfer *itran
 	if (!ret) {
 		if(GetLastError() != ERROR_IO_PENDING) {
 			usbi_err(ctx, "ReadPipe/WritePipe failed: %s", windows_error_str(0));
-			usbi_free_fd(wfd.fd);
+			usbi_free_fd(&wfd);
 			return LIBUSB_ERROR_IO;
 		}
 	} else {
@@ -3055,7 +3084,7 @@ static int winusbx_abort_transfers(int sub_api, struct usbi_transfer *itransfer)
  * IOCTL_USB_HUB_CYCLE_PORT ioctl was removed from Vista => the best we can do is
  * cycle the pipes (and even then, the control pipe can not be reset using WinUSB)
  */
-// TODO (post hotplug): see if we can force eject the device and redetect it (reuse hotplug?)
+// TODO: (post hotplug): see if we can force eject the device and redetect it (reuse hotplug?)
 static int winusbx_reset_device(int sub_api, struct libusb_device_handle *dev_handle)
 {
 	struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
@@ -3074,7 +3103,7 @@ static int winusbx_reset_device(int sub_api, struct libusb_device_handle *dev_ha
 		{
 			// Cancel any pollable I/O
 			usbi_remove_pollfd(ctx, wfd.fd);
-			usbi_free_fd(wfd.fd);
+			usbi_free_fd(&wfd);
 			wfd = handle_to_winfd(winusb_handle);
 		}
 
@@ -3214,8 +3243,7 @@ static int _hid_get_config_descriptor(struct hid_device_priv* dev, void *data, s
 		ed->bmAttributes = 3;
 		ed->wMaxPacketSize = dev->input_report_size - 1;
 		ed->bInterval = 10;
-
-		ed++;
+		ed = (struct libusb_endpoint_descriptor *)((char*)ed + LIBUSB_DT_ENDPOINT_SIZE);
 	}
 
 	if (dev->output_report_size) {
@@ -3626,7 +3654,7 @@ static int hid_open(int sub_api, struct libusb_device_handle *dev_handle)
 	int i, j;
 	// report IDs handling
 	ULONG size[3];
-	char* type[3] = {"input", "output", "feature"};
+	const char* type[3] = {"input", "output", "feature"};
 	int nb_ids[2];	// zero and nonzero report IDs
 
 	CHECK_HID_AVAILABLE;
@@ -3882,9 +3910,9 @@ static int hid_submit_control_transfer(int sub_api, struct usbi_transfer *itrans
 	usbi_dbg("will use interface %d", current_interface);
 	hid_handle = handle_priv->interface_handle[current_interface].api_handle;
 	// Always use the handle returned from usbi_create_fd (wfd.handle)
-	wfd = usbi_create_fd(hid_handle, _O_RDONLY);
+	wfd = usbi_create_fd(hid_handle, RW_READ, NULL, NULL);
 	if (wfd.fd < 0) {
-		return LIBUSB_ERROR_NO_MEM;
+		return LIBUSB_ERROR_NOT_FOUND;
 	}
 
 	switch(LIBUSB_REQ_TYPE(setup->request_type)) {
@@ -3952,7 +3980,7 @@ static int hid_submit_control_transfer(int sub_api, struct usbi_transfer *itrans
 		transfer_priv->pollable_fd = wfd;
 		transfer_priv->interface_number = (uint8_t)current_interface;
 	} else {
-		usbi_free_fd(wfd.fd);
+		usbi_free_fd(&wfd);
 	}
 
 	return r;
@@ -3988,7 +4016,7 @@ static int hid_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer
 	hid_handle = handle_priv->interface_handle[current_interface].api_handle;
 	direction_in = transfer->endpoint & LIBUSB_ENDPOINT_IN;
 
-	wfd = usbi_create_fd(hid_handle, direction_in?_O_RDONLY:_O_WRONLY);
+	wfd = usbi_create_fd(hid_handle, direction_in?RW_READ:RW_WRITE, NULL, NULL);
 	// Always use the handle returned from usbi_create_fd (wfd.handle)
 	if (wfd.fd < 0) {
 		return LIBUSB_ERROR_NO_MEM;
@@ -4010,7 +4038,7 @@ static int hid_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer
 
 	if (direction_in) {
 		transfer_priv->hid_dest = transfer->buffer;
-		usbi_dbg("reading %d bytes (report ID: 0x%02X)", length, transfer_priv->hid_buffer[0]);
+		usbi_dbg("reading %d bytes (report ID: 0x00)", length);
 		ret = ReadFile(wfd.handle, transfer_priv->hid_buffer, length+1, &size, wfd.overlapped);
 	} else {
 		if (!priv->hid->uses_report_ids[1]) {
@@ -4025,7 +4053,7 @@ static int hid_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer
 	if (!ret) {
 		if (GetLastError() != ERROR_IO_PENDING) {
 			usbi_err(ctx, "HID transfer failed: %s", windows_error_str(0));
-			usbi_free_fd(wfd.fd);
+			usbi_free_fd(&wfd);
 			safe_free(transfer_priv->hid_buffer);
 			return LIBUSB_ERROR_IO;
 		}
@@ -4169,30 +4197,37 @@ static int composite_exit(int sub_api)
 static int composite_open(int sub_api, struct libusb_device_handle *dev_handle)
 {
 	struct windows_device_priv *priv = _device_priv(dev_handle->dev);
-	int r;
+	int r = LIBUSB_ERROR_NOT_FOUND;
 	uint8_t i;
-	bool available[SUB_API_MAX];
-
-	for (i = 0; i<SUB_API_MAX; i++) {
-		available[i] = false;
-	}
+	// SUB_API_MAX+1 as the SUB_API_MAX pos is used to indicate availability of HID
+	bool available[SUB_API_MAX+1] = {0};
 
 	for (i=0; i<USB_MAXINTERFACES; i++) {
-		if ( (priv->usb_interface[i].apib->id == USB_API_WINUSBX)
-		  && (priv->usb_interface[i].sub_api != SUB_API_NOTSET) ) {
-			available[priv->usb_interface[i].sub_api] = true;
+		switch (priv->usb_interface[i].apib->id) {
+		case USB_API_WINUSBX:
+			if (priv->usb_interface[i].sub_api != SUB_API_NOTSET)
+				available[priv->usb_interface[i].sub_api] = true;
+			break;
+		case USB_API_HID:
+			available[SUB_API_MAX] = true;
+			break;
+		default:
+			break;
 		}
 	}
 
-	for (i=0; i<SUB_API_MAX; i++) {
+	for (i=0; i<SUB_API_MAX; i++) {	// WinUSB-like drivers
 		if (available[i]) {
-			r = usb_api_backend[USB_API_WINUSBX].open(SUB_API_NOTSET, dev_handle);
+			r = usb_api_backend[USB_API_WINUSBX].open(i, dev_handle);
 			if (r != LIBUSB_SUCCESS) {
 				return r;
 			}
 		}
 	}
-	return LIBUSB_SUCCESS;
+	if (available[SUB_API_MAX]) {	// HID driver
+		r = hid_open(SUB_API_NOTSET, dev_handle);
+	}
+	return r;
 }
 
 static void composite_close(int sub_api, struct libusb_device_handle *dev_handle)