Home | History | Annotate | Download | only in os
      1 /*
      2  * Linux usbfs backend for libusb
      3  * Copyright (C) 2007-2009 Daniel Drake <dsd (at) gentoo.org>
      4  * Copyright (c) 2001 Johannes Erdfelt <johannes (at) erdfelt.com>
      5  *
      6  * This library is free software; you can redistribute it and/or
      7  * modify it under the terms of the GNU Lesser General Public
      8  * License as published by the Free Software Foundation; either
      9  * version 2.1 of the License, or (at your option) any later version.
     10  *
     11  * This library is distributed in the hope that it will be useful,
     12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14  * Lesser General Public License for more details.
     15  *
     16  * You should have received a copy of the GNU Lesser General Public
     17  * License along with this library; if not, write to the Free Software
     18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
     19  */
     20 
     21 #include <config.h>
     22 #include <ctype.h>
     23 #include <dirent.h>
     24 #include <errno.h>
     25 #include <fcntl.h>
     26 #include <poll.h>
     27 #include <pthread.h>
     28 #include <stdio.h>
     29 #include <stdlib.h>
     30 #include <string.h>
     31 #include <sys/ioctl.h>
     32 #include <sys/stat.h>
     33 #include <sys/types.h>
     34 #include <sys/utsname.h>
     35 #include <unistd.h>
     36 
     37 #include "libusb.h"
     38 #include "libusbi.h"
     39 #include "linux_usbfs.h"
     40 
     41 /* sysfs vs usbfs:
     42  * opening a usbfs node causes the device to be resumed, so we attempt to
     43  * avoid this during enumeration.
     44  *
     45  * sysfs allows us to read the kernel's in-memory copies of device descriptors
     46  * and so forth, avoiding the need to open the device:
     47  *  - The binary "descriptors" file was added in 2.6.23.
     48  *  - The "busnum" file was added in 2.6.22
     49  *  - The "devnum" file has been present since pre-2.6.18
     50  *  - the "bConfigurationValue" file has been present since pre-2.6.18
     51  *
     52  * If we have bConfigurationValue, busnum, and devnum, then we can determine
     53  * the active configuration without having to open the usbfs node in RDWR mode.
     54  * We assume this is the case if we see the busnum file (indicates 2.6.22+).
     55  * The busnum file is important as that is the only way we can relate sysfs
     56  * devices to usbfs nodes.
     57  *
     58  * If we also have descriptors, we can obtain the device descriptor and active
     59  * configuration without touching usbfs at all.
     60  *
     61  * The descriptors file originally only contained the active configuration
     62  * descriptor alongside the device descriptor, but all configurations are
     63  * included as of Linux 2.6.26.
     64  */
     65 
     66 /* endianness for multi-byte fields:
     67  *
     68  * Descriptors exposed by usbfs have the multi-byte fields in the device
     69  * descriptor as host endian. Multi-byte fields in the other descriptors are
     70  * bus-endian. The kernel documentation says otherwise, but it is wrong.
     71  */
     72 
     73 static const char *usbfs_path = NULL;
     74 
     75 /* Linux 2.6.32 adds support for a bulk continuation URB flag. this basically
     76  * allows us to mark URBs as being part of a specific logical transfer when
     77  * we submit them to the kernel. then, on any error error except a
     78  * cancellation, all URBs within that transfer will be cancelled with the
     79  * endpoint is disabled, meaning that no more data can creep in during the
     80  * time it takes to cancel the remaining URBs.
     81  *
     82  * The BULK_CONTINUATION flag must be set on all URBs within a bulk transfer
     83  * (in either direction) except the first.
     84  * For IN transfers, we must also set SHORT_NOT_OK on all the URBs.
     85  * For OUT transfers, SHORT_NOT_OK must not be set. The effective behaviour
     86  * (where an OUT transfer does not complete, the rest of the URBs in the
     87  * transfer get cancelled) is already in effect, and setting this flag is
     88  * disallowed (a kernel with USB debugging enabled will reject such URBs).
     89  */
     90 static int supports_flag_bulk_continuation = -1;
     91 
     92 /* clock ID for monotonic clock, as not all clock sources are available on all
     93  * systems. appropriate choice made at initialization time. */
     94 static clockid_t monotonic_clkid = -1;
     95 
     96 /* do we have a busnum to relate devices? this also implies that we can read
     97  * the active configuration through bConfigurationValue */
     98 static int sysfs_can_relate_devices = -1;
     99 
    100 /* do we have a descriptors file? */
    101 static int sysfs_has_descriptors = -1;
    102 
    103 struct linux_device_priv {
    104 	char *sysfs_dir;
    105 	unsigned char *dev_descriptor;
    106 	unsigned char *config_descriptor;
    107 };
    108 
    109 struct linux_device_handle_priv {
    110 	int fd;
    111 };
    112 
    113 enum reap_action {
    114 	NORMAL = 0,
    115 	/* submission failed after the first URB, so await cancellation/completion
    116 	 * of all the others */
    117 	SUBMIT_FAILED,
    118 
    119 	/* cancelled by user or timeout */
    120 	CANCELLED,
    121 
    122 	/* completed multi-URB transfer in non-final URB */
    123 	COMPLETED_EARLY,
    124 };
    125 
    126 struct linux_transfer_priv {
    127 	union {
    128 		struct usbfs_urb *urbs;
    129 		struct usbfs_urb **iso_urbs;
    130 	};
    131 
    132 	enum reap_action reap_action;
    133 	int num_urbs;
    134 	unsigned int num_retired;
    135 
    136 	/* next iso packet in user-supplied transfer to be populated */
    137 	int iso_packet_offset;
    138 };
    139 
    140 static void __get_usbfs_path(struct libusb_device *dev, char *path)
    141 {
    142 	snprintf(path, PATH_MAX, "%s/%03d/%03d", usbfs_path, dev->bus_number,
    143 		dev->device_address);
    144 }
    145 
    146 static struct linux_device_priv *__device_priv(struct libusb_device *dev)
    147 {
    148 	return (struct linux_device_priv *) dev->os_priv;
    149 }
    150 
    151 static struct linux_device_handle_priv *__device_handle_priv(
    152 	struct libusb_device_handle *handle)
    153 {
    154 	return (struct linux_device_handle_priv *) handle->os_priv;
    155 }
    156 
    157 static int check_usb_vfs(const char *dirname)
    158 {
    159 	DIR *dir;
    160 	struct dirent *entry;
    161 	int found = 0;
    162 
    163 	dir = opendir(dirname);
    164 	if (!dir)
    165 		return 0;
    166 
    167 	while ((entry = readdir(dir)) != NULL) {
    168 		if (entry->d_name[0] == '.')
    169 			continue;
    170 
    171 		/* We assume if we find any files that it must be the right place */
    172 		found = 1;
    173 		break;
    174 	}
    175 
    176 	closedir(dir);
    177 	return found;
    178 }
    179 
    180 static const char *find_usbfs_path(void)
    181 {
    182 	const char *path = "/dev/bus/usb";
    183 	const char *ret = NULL;
    184 
    185 	if (check_usb_vfs(path)) {
    186 		ret = path;
    187 	} else {
    188 		path = "/proc/bus/usb";
    189 		if (check_usb_vfs(path))
    190 			ret = path;
    191 	}
    192 
    193 	usbi_dbg("found usbfs at %s", ret);
    194 	return ret;
    195 }
    196 
    197 /* the monotonic clock is not usable on all systems (e.g. embedded ones often
    198  * seem to lack it). fall back to REALTIME if we have to. */
    199 static clockid_t find_monotonic_clock(void)
    200 {
    201 	struct timespec ts;
    202 	int r;
    203 
    204 	/* Linux 2.6.28 adds CLOCK_MONOTONIC_RAW but we don't use it
    205 	 * because it's not available through timerfd */
    206 	r = clock_gettime(CLOCK_MONOTONIC, &ts);
    207 	if (r == 0) {
    208 		return CLOCK_MONOTONIC;
    209 	} else {
    210 		usbi_dbg("monotonic clock doesn't work, errno %d", errno);
    211 		return CLOCK_REALTIME;
    212 	}
    213 }
    214 
    215 /* bulk continuation URB flag available from Linux 2.6.32 */
    216 static int check_flag_bulk_continuation(void)
    217 {
    218 	struct utsname uts;
    219 	int sublevel;
    220 
    221 	if (uname(&uts) < 0)
    222 		return -1;
    223 	if (strlen(uts.release) < 4)
    224 		return 0;
    225 	if (strncmp(uts.release, "2.6.", 4) != 0)
    226 		return 0;
    227 
    228 	sublevel = atoi(uts.release + 4);
    229 	return sublevel >= 32;
    230 }
    231 
    232 static int op_init(struct libusb_context *ctx)
    233 {
    234 	struct stat statbuf;
    235 	int r;
    236 
    237 	usbfs_path = find_usbfs_path();
    238 	if (!usbfs_path) {
    239 		usbi_err(ctx, "could not find usbfs");
    240 		return LIBUSB_ERROR_OTHER;
    241 	}
    242 
    243 	if (monotonic_clkid == -1)
    244 		monotonic_clkid = find_monotonic_clock();
    245 
    246 	if (supports_flag_bulk_continuation == -1) {
    247 		supports_flag_bulk_continuation = check_flag_bulk_continuation();
    248 		if (supports_flag_bulk_continuation == -1) {
    249 			usbi_err(ctx, "error checking for bulk continuation support");
    250 			return LIBUSB_ERROR_OTHER;
    251 		}
    252 	}
    253 
    254 	if (supports_flag_bulk_continuation)
    255 		usbi_dbg("bulk continuation flag supported");
    256 
    257 	r = stat(SYSFS_DEVICE_PATH, &statbuf);
    258 	if (r == 0 && S_ISDIR(statbuf.st_mode)) {
    259 		usbi_dbg("found usb devices in sysfs");
    260 	} else {
    261 		usbi_dbg("sysfs usb info not available");
    262 		sysfs_has_descriptors = 0;
    263 		sysfs_can_relate_devices = 0;
    264 	}
    265 
    266 	return 0;
    267 }
    268 
    269 static int usbfs_get_device_descriptor(struct libusb_device *dev,
    270 	unsigned char *buffer)
    271 {
    272 	struct linux_device_priv *priv = __device_priv(dev);
    273 
    274 	/* return cached copy */
    275 	memcpy(buffer, priv->dev_descriptor, DEVICE_DESC_LENGTH);
    276 	return 0;
    277 }
    278 
    279 static int __open_sysfs_attr(struct libusb_device *dev, const char *attr)
    280 {
    281 	struct linux_device_priv *priv = __device_priv(dev);
    282 	char filename[PATH_MAX];
    283 	int fd;
    284 
    285 	snprintf(filename, PATH_MAX, "%s/%s/%s",
    286 		SYSFS_DEVICE_PATH, priv->sysfs_dir, attr);
    287 	fd = open(filename, O_RDONLY);
    288 	if (fd < 0) {
    289 		usbi_err(DEVICE_CTX(dev),
    290 			"open %s failed ret=%d errno=%d", filename, fd, errno);
    291 		return LIBUSB_ERROR_IO;
    292 	}
    293 
    294 	return fd;
    295 }
    296 
    297 static int sysfs_get_device_descriptor(struct libusb_device *dev,
    298 	unsigned char *buffer)
    299 {
    300 	int fd;
    301 	ssize_t r;
    302 
    303 	/* sysfs provides access to an in-memory copy of the device descriptor,
    304 	 * so we use that rather than keeping our own copy */
    305 
    306 	fd = __open_sysfs_attr(dev, "descriptors");
    307 	if (fd < 0)
    308 		return fd;
    309 
    310 	r = read(fd, buffer, DEVICE_DESC_LENGTH);;
    311 	close(fd);
    312 	if (r < 0) {
    313 		usbi_err(DEVICE_CTX(dev), "read failed, ret=%d errno=%d", fd, errno);
    314 		return LIBUSB_ERROR_IO;
    315 	} else if (r < DEVICE_DESC_LENGTH) {
    316 		usbi_err(DEVICE_CTX(dev), "short read %d/%d", r, DEVICE_DESC_LENGTH);
    317 		return LIBUSB_ERROR_IO;
    318 	}
    319 
    320 	return 0;
    321 }
    322 
    323 static int op_get_device_descriptor(struct libusb_device *dev,
    324 	unsigned char *buffer, int *host_endian)
    325 {
    326 	if (sysfs_has_descriptors) {
    327 		return sysfs_get_device_descriptor(dev, buffer);
    328 	} else {
    329 		*host_endian = 1;
    330 		return usbfs_get_device_descriptor(dev, buffer);
    331 	}
    332 }
    333 
    334 static int usbfs_get_active_config_descriptor(struct libusb_device *dev,
    335 	unsigned char *buffer, size_t len)
    336 {
    337 	struct linux_device_priv *priv = __device_priv(dev);
    338 	if (!priv->config_descriptor)
    339 		return LIBUSB_ERROR_NOT_FOUND; /* device is unconfigured */
    340 
    341 	/* retrieve cached copy */
    342 	memcpy(buffer, priv->config_descriptor, len);
    343 	return 0;
    344 }
    345 
    346 /* read the bConfigurationValue for a device */
    347 static int sysfs_get_active_config(struct libusb_device *dev, int *config)
    348 {
    349 	char *endptr;
    350 	char tmp[4] = {0, 0, 0, 0};
    351 	long num;
    352 	int fd;
    353 	size_t r;
    354 
    355 	fd = __open_sysfs_attr(dev, "bConfigurationValue");
    356 	if (fd < 0)
    357 		return fd;
    358 
    359 	r = read(fd, tmp, sizeof(tmp));
    360 	close(fd);
    361 	if (r < 0) {
    362 		usbi_err(DEVICE_CTX(dev),
    363 			"read bConfigurationValue failed ret=%d errno=%d", r, errno);
    364 		return LIBUSB_ERROR_IO;
    365 	} else if (r == 0) {
    366 		usbi_err(DEVICE_CTX(dev), "device unconfigured");
    367 		*config = -1;
    368 		return 0;
    369 	}
    370 
    371 	if (tmp[sizeof(tmp) - 1] != 0) {
    372 		usbi_err(DEVICE_CTX(dev), "not null-terminated?");
    373 		return LIBUSB_ERROR_IO;
    374 	} else if (tmp[0] == 0) {
    375 		usbi_err(DEVICE_CTX(dev), "no configuration value?");
    376 		return LIBUSB_ERROR_IO;
    377 	}
    378 
    379 	num = strtol(tmp, &endptr, 10);
    380 	if (endptr == tmp) {
    381 		usbi_err(DEVICE_CTX(dev), "error converting '%s' to integer", tmp);
    382 		return LIBUSB_ERROR_IO;
    383 	}
    384 
    385 	*config = (int) num;
    386 	return 0;
    387 }
    388 
    389 /* takes a usbfs/descriptors fd seeked to the start of a configuration, and
    390  * seeks to the next one. */
    391 static int seek_to_next_config(struct libusb_context *ctx, int fd,
    392 	int host_endian)
    393 {
    394 	struct libusb_config_descriptor config;
    395 	unsigned char tmp[6];
    396 	off_t off;
    397 	int r;
    398 
    399 	/* read first 6 bytes of descriptor */
    400 	r = read(fd, tmp, sizeof(tmp));
    401 	if (r < 0) {
    402 		usbi_err(ctx, "read failed ret=%d errno=%d", r, errno);
    403 		return LIBUSB_ERROR_IO;
    404 	} else if (r < sizeof(tmp)) {
    405 		usbi_err(ctx, "short descriptor read %d/%d", r, sizeof(tmp));
    406 		return LIBUSB_ERROR_IO;
    407 	}
    408 
    409 	/* seek forward to end of config */
    410 	usbi_parse_descriptor(tmp, "bbwbb", &config, host_endian);
    411 	off = lseek(fd, config.wTotalLength - sizeof(tmp), SEEK_CUR);
    412 	if (off < 0) {
    413 		usbi_err(ctx, "seek failed ret=%d errno=%d", off, errno);
    414 		return LIBUSB_ERROR_IO;
    415 	}
    416 
    417 	return 0;
    418 }
    419 
    420 static int sysfs_get_active_config_descriptor(struct libusb_device *dev,
    421 	unsigned char *buffer, size_t len)
    422 {
    423 	int fd;
    424 	ssize_t r;
    425 	off_t off;
    426 	int to_copy;
    427 	int config;
    428 	unsigned char tmp[6];
    429 
    430 	r = sysfs_get_active_config(dev, &config);
    431 	if (r < 0)
    432 		return r;
    433 	if (config == -1)
    434 		return LIBUSB_ERROR_NOT_FOUND;
    435 
    436 	usbi_dbg("active configuration %d", config);
    437 
    438 	/* sysfs provides access to an in-memory copy of the device descriptor,
    439 	 * so we use that rather than keeping our own copy */
    440 
    441 	fd = __open_sysfs_attr(dev, "descriptors");
    442 	if (fd < 0)
    443 		return fd;
    444 
    445 	/* device might have been unconfigured since we read bConfigurationValue,
    446 	 * so first check that there is any config descriptor data at all... */
    447 	off = lseek(fd, 0, SEEK_END);
    448 	if (off < 1) {
    449 		usbi_err(DEVICE_CTX(dev), "end seek failed, ret=%d errno=%d",
    450 			off, errno);
    451 		close(fd);
    452 		return LIBUSB_ERROR_IO;
    453 	} else if (off == DEVICE_DESC_LENGTH) {
    454 		close(fd);
    455 		return LIBUSB_ERROR_NOT_FOUND;
    456 	}
    457 
    458 	off = lseek(fd, DEVICE_DESC_LENGTH, SEEK_SET);
    459 	if (off < 0) {
    460 		usbi_err(DEVICE_CTX(dev), "seek failed, ret=%d errno=%d", off, errno);
    461 		close(fd);
    462 		return LIBUSB_ERROR_IO;
    463 	}
    464 
    465 	/* unbounded loop: we expect the descriptor to be present under all
    466 	 * circumstances */
    467 	while (1) {
    468 		r = read(fd, tmp, sizeof(tmp));
    469 		if (r < 0) {
    470 			usbi_err(DEVICE_CTX(dev), "read failed, ret=%d errno=%d",
    471 				fd, errno);
    472 			return LIBUSB_ERROR_IO;
    473 		} else if (r < sizeof(tmp)) {
    474 			usbi_err(DEVICE_CTX(dev), "short read %d/%d", r, sizeof(tmp));
    475 			return LIBUSB_ERROR_IO;
    476 		}
    477 
    478 		/* check bConfigurationValue */
    479 		if (tmp[5] == config)
    480 			break;
    481 
    482 		/* try the next descriptor */
    483 		off = lseek(fd, 0 - sizeof(tmp), SEEK_CUR);
    484 		if (off < 0)
    485 			return LIBUSB_ERROR_IO;
    486 
    487 		r = seek_to_next_config(DEVICE_CTX(dev), fd, 1);
    488 		if (r < 0)
    489 			return r;
    490 	}
    491 
    492 	to_copy = (len < sizeof(tmp)) ? len : sizeof(tmp);
    493 	memcpy(buffer, tmp, to_copy);
    494 	if (len > sizeof(tmp)) {
    495 		r = read(fd, buffer + sizeof(tmp), len - sizeof(tmp));
    496 		if (r < 0) {
    497 			usbi_err(DEVICE_CTX(dev), "read failed, ret=%d errno=%d",
    498 				fd, errno);
    499 			r = LIBUSB_ERROR_IO;
    500 		} else if (r == 0) {
    501 			usbi_dbg("device is unconfigured");
    502 			r = LIBUSB_ERROR_NOT_FOUND;
    503 		} else if (r < len - sizeof(tmp)) {
    504 			usbi_err(DEVICE_CTX(dev), "short read %d/%d", r, len);
    505 			r = LIBUSB_ERROR_IO;
    506 		}
    507 	} else {
    508 		r = 0;
    509 	}
    510 
    511 	close(fd);
    512 	return r;
    513 }
    514 
    515 static int op_get_active_config_descriptor(struct libusb_device *dev,
    516 	unsigned char *buffer, size_t len, int *host_endian)
    517 {
    518 	if (sysfs_has_descriptors) {
    519 		return sysfs_get_active_config_descriptor(dev, buffer, len);
    520 	} else {
    521 		return usbfs_get_active_config_descriptor(dev, buffer, len);
    522 	}
    523 }
    524 
    525 /* takes a usbfs fd, attempts to find the requested config and copy a certain
    526  * amount of it into an output buffer. */
    527 static int get_config_descriptor(struct libusb_context *ctx, int fd,
    528 	uint8_t config_index, unsigned char *buffer, size_t len)
    529 {
    530 	off_t off;
    531 	ssize_t r;
    532 
    533 	off = lseek(fd, DEVICE_DESC_LENGTH, SEEK_SET);
    534 	if (off < 0) {
    535 		usbi_err(ctx, "seek failed ret=%d errno=%d", off, errno);
    536 		return LIBUSB_ERROR_IO;
    537 	}
    538 
    539 	/* might need to skip some configuration descriptors to reach the
    540 	 * requested configuration */
    541 	while (config_index > 0) {
    542 		r = seek_to_next_config(ctx, fd, 0);
    543 		if (r < 0)
    544 			return r;
    545 		config_index--;
    546 	}
    547 
    548 	/* read the rest of the descriptor */
    549 	r = read(fd, buffer, len);
    550 	if (r < 0) {
    551 		usbi_err(ctx, "read failed ret=%d errno=%d", r, errno);
    552 		return LIBUSB_ERROR_IO;
    553 	} else if (r < len) {
    554 		usbi_err(ctx, "short output read %d/%d", r, len);
    555 		return LIBUSB_ERROR_IO;
    556 	}
    557 
    558 	return 0;
    559 }
    560 
    561 static int op_get_config_descriptor(struct libusb_device *dev,
    562 	uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
    563 {
    564 	char filename[PATH_MAX];
    565 	int fd;
    566 	int r;
    567 
    568 	/* always read from usbfs: sysfs only has the active descriptor
    569 	 * this will involve waking the device up, but oh well! */
    570 
    571 	/* FIXME: the above is no longer true, new kernels have all descriptors
    572 	 * in the descriptors file. but its kinda hard to detect if the kernel
    573 	 * is sufficiently new. */
    574 
    575 	__get_usbfs_path(dev, filename);
    576 	fd = open(filename, O_RDONLY);
    577 	if (fd < 0) {
    578 		usbi_err(DEVICE_CTX(dev),
    579 			"open '%s' failed, ret=%d errno=%d", filename, fd, errno);
    580 		return LIBUSB_ERROR_IO;
    581 	}
    582 
    583 	r = get_config_descriptor(DEVICE_CTX(dev), fd, config_index, buffer, len);
    584 	close(fd);
    585 	return r;
    586 }
    587 
    588 /* cache the active config descriptor in memory. a value of -1 means that
    589  * we aren't sure which one is active, so just assume the first one.
    590  * only for usbfs. */
    591 static int cache_active_config(struct libusb_device *dev, int fd,
    592 	int active_config)
    593 {
    594 	struct linux_device_priv *priv = __device_priv(dev);
    595 	struct libusb_config_descriptor config;
    596 	unsigned char tmp[8];
    597 	unsigned char *buf;
    598 	int idx;
    599 	int r;
    600 
    601 	if (active_config == -1) {
    602 		idx = 0;
    603 	} else {
    604 		r = usbi_get_config_index_by_value(dev, active_config, &idx);
    605 		if (r < 0)
    606 			return r;
    607 		if (idx == -1)
    608 			return LIBUSB_ERROR_NOT_FOUND;
    609 	}
    610 
    611 	r = get_config_descriptor(DEVICE_CTX(dev), fd, idx, tmp, sizeof(tmp));
    612 	if (r < 0) {
    613 		usbi_err(DEVICE_CTX(dev), "first read error %d", r);
    614 		return r;
    615 	}
    616 
    617 	usbi_parse_descriptor(tmp, "bbw", &config, 0);
    618 	buf = malloc(config.wTotalLength);
    619 	if (!buf)
    620 		return LIBUSB_ERROR_NO_MEM;
    621 
    622 	r = get_config_descriptor(DEVICE_CTX(dev), fd, idx, buf,
    623 		config.wTotalLength);
    624 	if (r < 0) {
    625 		free(buf);
    626 		return r;
    627 	}
    628 
    629 	if (priv->config_descriptor)
    630 		free(priv->config_descriptor);
    631 	priv->config_descriptor = buf;
    632 	return 0;
    633 }
    634 
    635 /* send a control message to retrieve active configuration */
    636 static int usbfs_get_active_config(struct libusb_device *dev, int fd)
    637 {
    638 	unsigned char active_config = 0;
    639 	int r;
    640 
    641 	struct usbfs_ctrltransfer ctrl = {
    642 		.bmRequestType = LIBUSB_ENDPOINT_IN,
    643 		.bRequest = LIBUSB_REQUEST_GET_CONFIGURATION,
    644 		.wValue = 0,
    645 		.wIndex = 0,
    646 		.wLength = 1,
    647 		.timeout = 1000,
    648 		.data = &active_config
    649 	};
    650 
    651 	r = ioctl(fd, IOCTL_USBFS_CONTROL, &ctrl);
    652 	if (r < 0) {
    653 		if (errno == ENODEV)
    654 			return LIBUSB_ERROR_NO_DEVICE;
    655 
    656 		/* we hit this error path frequently with buggy devices :( */
    657 		usbi_warn(DEVICE_CTX(dev),
    658 			"get_configuration failed ret=%d errno=%d", r, errno);
    659 		return LIBUSB_ERROR_IO;
    660 	}
    661 
    662 	return active_config;
    663 }
    664 
    665 static int initialize_device(struct libusb_device *dev, uint8_t busnum,
    666 	uint8_t devaddr, const char *sysfs_dir)
    667 {
    668 	struct linux_device_priv *priv = __device_priv(dev);
    669 	unsigned char *dev_buf;
    670 	char path[PATH_MAX];
    671 	int fd;
    672 	int active_config = 0;
    673 	int device_configured = 1;
    674 	ssize_t r;
    675 
    676 	dev->bus_number = busnum;
    677 	dev->device_address = devaddr;
    678 
    679 	if (sysfs_dir) {
    680 		priv->sysfs_dir = malloc(strlen(sysfs_dir) + 1);
    681 		if (!priv->sysfs_dir)
    682 			return LIBUSB_ERROR_NO_MEM;
    683 		strcpy(priv->sysfs_dir, sysfs_dir);
    684 	}
    685 
    686 	if (sysfs_has_descriptors)
    687 		return 0;
    688 
    689 	/* cache device descriptor in memory so that we can retrieve it later
    690 	 * without waking the device up (op_get_device_descriptor) */
    691 
    692 	priv->dev_descriptor = NULL;
    693 	priv->config_descriptor = NULL;
    694 
    695 	if (sysfs_can_relate_devices) {
    696 		int tmp = sysfs_get_active_config(dev, &active_config);
    697 		if (tmp < 0)
    698 			return tmp;
    699 		if (active_config == -1)
    700 			device_configured = 0;
    701 	}
    702 
    703 	__get_usbfs_path(dev, path);
    704 	fd = open(path, O_RDWR);
    705 	if (fd < 0 && errno == EACCES) {
    706 		fd = open(path, O_RDONLY);
    707 		/* if we only have read-only access to the device, we cannot
    708 		 * send a control message to determine the active config. just
    709 		 * assume the first one is active. */
    710 		active_config = -1;
    711 	}
    712 
    713 	if (fd < 0) {
    714 		usbi_err(DEVICE_CTX(dev), "open failed, ret=%d errno=%d", fd, errno);
    715 		return LIBUSB_ERROR_IO;
    716 	}
    717 
    718 	if (!sysfs_can_relate_devices) {
    719 		if (active_config == -1) {
    720 			/* if we only have read-only access to the device, we cannot
    721 			 * send a control message to determine the active config. just
    722 			 * assume the first one is active. */
    723 			usbi_warn(DEVICE_CTX(dev), "access to %s is read-only; cannot "
    724 				"determine active configuration descriptor", path);
    725 		} else {
    726 			active_config = usbfs_get_active_config(dev, fd);
    727 			if (active_config == LIBUSB_ERROR_IO) {
    728 				/* buggy devices sometimes fail to report their active config.
    729 				 * assume unconfigured and continue the probing */
    730 				usbi_warn(DEVICE_CTX(dev), "couldn't query active "
    731 					"configuration, assumung unconfigured");
    732 				device_configured = 0;
    733 			} else if (active_config < 0) {
    734 				close(fd);
    735 				return active_config;
    736 			} else if (active_config == 0) {
    737 				/* some buggy devices have a configuration 0, but we're
    738 				 * reaching into the corner of a corner case here, so let's
    739 				 * not support buggy devices in these circumstances.
    740 				 * stick to the specs: a configuration value of 0 means
    741 				 * unconfigured. */
    742 				usbi_dbg("active cfg 0? assuming unconfigured device");
    743 				device_configured = 0;
    744 			}
    745 		}
    746 	}
    747 
    748 	dev_buf = malloc(DEVICE_DESC_LENGTH);
    749 	if (!dev_buf) {
    750 		close(fd);
    751 		return LIBUSB_ERROR_NO_MEM;
    752 	}
    753 
    754 	r = read(fd, dev_buf, DEVICE_DESC_LENGTH);
    755 	if (r < 0) {
    756 		usbi_err(DEVICE_CTX(dev),
    757 			"read descriptor failed ret=%d errno=%d", fd, errno);
    758 		free(dev_buf);
    759 		close(fd);
    760 		return LIBUSB_ERROR_IO;
    761 	} else if (r < DEVICE_DESC_LENGTH) {
    762 		usbi_err(DEVICE_CTX(dev), "short descriptor read (%d)", r);
    763 		free(dev_buf);
    764 		close(fd);
    765 		return LIBUSB_ERROR_IO;
    766 	}
    767 
    768 	/* bit of a hack: set num_configurations now because cache_active_config()
    769 	 * calls usbi_get_config_index_by_value() which uses it */
    770 	dev->num_configurations = dev_buf[DEVICE_DESC_LENGTH - 1];
    771 
    772 	if (device_configured) {
    773 		r = cache_active_config(dev, fd, active_config);
    774 		if (r < 0) {
    775 			close(fd);
    776 			free(dev_buf);
    777 			return r;
    778 		}
    779 	}
    780 
    781 	close(fd);
    782 	priv->dev_descriptor = dev_buf;
    783 	return 0;
    784 }
    785 
    786 static int enumerate_device(struct libusb_context *ctx,
    787 	struct discovered_devs **_discdevs, uint8_t busnum, uint8_t devaddr,
    788 	const char *sysfs_dir)
    789 {
    790 	struct discovered_devs *discdevs;
    791 	unsigned long session_id;
    792 	int need_unref = 0;
    793 	struct libusb_device *dev;
    794 	int r = 0;
    795 
    796 	/* FIXME: session ID is not guaranteed unique as addresses can wrap and
    797 	 * will be reused. instead we should add a simple sysfs attribute with
    798 	 * a session ID. */
    799 	session_id = busnum << 8 | devaddr;
    800 	usbi_dbg("busnum %d devaddr %d session_id %ld", busnum, devaddr,
    801 		session_id);
    802 
    803 	dev = usbi_get_device_by_session_id(ctx, session_id);
    804 	if (dev) {
    805 		usbi_dbg("using existing device for %d/%d (session %ld)",
    806 			busnum, devaddr, session_id);
    807 	} else {
    808 		usbi_dbg("allocating new device for %d/%d (session %ld)",
    809 			busnum, devaddr, session_id);
    810 		dev = usbi_alloc_device(ctx, session_id);
    811 		if (!dev)
    812 			return LIBUSB_ERROR_NO_MEM;
    813 		need_unref = 1;
    814 		r = initialize_device(dev, busnum, devaddr, sysfs_dir);
    815 		if (r < 0)
    816 			goto out;
    817 		r = usbi_sanitize_device(dev);
    818 		if (r < 0)
    819 			goto out;
    820 	}
    821 
    822 	discdevs = discovered_devs_append(*_discdevs, dev);
    823 	if (!discdevs)
    824 		r = LIBUSB_ERROR_NO_MEM;
    825 	else
    826 		*_discdevs = discdevs;
    827 
    828 out:
    829 	if (need_unref)
    830 		libusb_unref_device(dev);
    831 	return r;
    832 }
    833 
    834 /* open a bus directory and adds all discovered devices to discdevs. on
    835  * failure (non-zero return) the pre-existing discdevs should be destroyed
    836  * (and devices freed). on success, the new discdevs pointer should be used
    837  * as it may have been moved. */
    838 static int usbfs_scan_busdir(struct libusb_context *ctx,
    839 	struct discovered_devs **_discdevs, uint8_t busnum)
    840 {
    841 	DIR *dir;
    842 	char dirpath[PATH_MAX];
    843 	struct dirent *entry;
    844 	struct discovered_devs *discdevs = *_discdevs;
    845 	int r = 0;
    846 
    847 	snprintf(dirpath, PATH_MAX, "%s/%03d", usbfs_path, busnum);
    848 	usbi_dbg("%s", dirpath);
    849 	dir = opendir(dirpath);
    850 	if (!dir) {
    851 		usbi_err(ctx, "opendir '%s' failed, errno=%d", dirpath, errno);
    852 		/* FIXME: should handle valid race conditions like hub unplugged
    853 		 * during directory iteration - this is not an error */
    854 		return LIBUSB_ERROR_IO;
    855 	}
    856 
    857 	while ((entry = readdir(dir))) {
    858 		int devaddr;
    859 
    860 		if (entry->d_name[0] == '.')
    861 			continue;
    862 
    863 		devaddr = atoi(entry->d_name);
    864 		if (devaddr == 0) {
    865 			usbi_dbg("unknown dir entry %s", entry->d_name);
    866 			continue;
    867 		}
    868 
    869 		r = enumerate_device(ctx, &discdevs, busnum, (uint8_t) devaddr, NULL);
    870 		if (r < 0)
    871 			goto out;
    872 	}
    873 
    874 	*_discdevs = discdevs;
    875 out:
    876 	closedir(dir);
    877 	return r;
    878 }
    879 
    880 static int usbfs_get_device_list(struct libusb_context *ctx,
    881 	struct discovered_devs **_discdevs)
    882 {
    883 	struct dirent *entry;
    884 	DIR *buses = opendir(usbfs_path);
    885 	struct discovered_devs *discdevs = *_discdevs;
    886 	int r = 0;
    887 
    888 	if (!buses) {
    889 		usbi_err(ctx, "opendir buses failed errno=%d", errno);
    890 		return LIBUSB_ERROR_IO;
    891 	}
    892 
    893 	while ((entry = readdir(buses))) {
    894 		struct discovered_devs *discdevs_new = discdevs;
    895 		int busnum;
    896 
    897 		if (entry->d_name[0] == '.')
    898 			continue;
    899 
    900 		busnum = atoi(entry->d_name);
    901 		if (busnum == 0) {
    902 			usbi_dbg("unknown dir entry %s", entry->d_name);
    903 			continue;
    904 		}
    905 
    906 		r = usbfs_scan_busdir(ctx, &discdevs_new, busnum);
    907 		if (r < 0)
    908 			goto out;
    909 		discdevs = discdevs_new;
    910 	}
    911 
    912 out:
    913 	closedir(buses);
    914 	*_discdevs = discdevs;
    915 	return r;
    916 
    917 }
    918 
    919 static int sysfs_scan_device(struct libusb_context *ctx,
    920 	struct discovered_devs **_discdevs, const char *devname,
    921 	int *usbfs_fallback)
    922 {
    923 	int r;
    924 	FILE *fd;
    925 	char filename[PATH_MAX];
    926 	int busnum;
    927 	int devaddr;
    928 
    929 	usbi_dbg("scan %s", devname);
    930 
    931 	/* determine descriptors presence ahead of time, we need to know this
    932 	 * when we reach initialize_device */
    933 	if (sysfs_has_descriptors == -1) {
    934 		struct stat statbuf;
    935 
    936 		snprintf(filename, PATH_MAX, "%s/%s/descriptors", SYSFS_DEVICE_PATH,
    937 			devname);
    938 		r = stat(filename, &statbuf);
    939 		if (r == 0 && S_ISREG(statbuf.st_mode)) {
    940 			usbi_dbg("sysfs descriptors available");
    941 			sysfs_has_descriptors = 1;
    942 		} else {
    943 			usbi_dbg("sysfs descriptors not available");
    944 			sysfs_has_descriptors = 0;
    945 		}
    946 	}
    947 
    948 	snprintf(filename, PATH_MAX, "%s/%s/busnum", SYSFS_DEVICE_PATH, devname);
    949 	fd = fopen(filename, "r");
    950 	if (!fd) {
    951 		if (errno == ENOENT) {
    952 			usbi_dbg("busnum not found, cannot relate sysfs to usbfs, "
    953 				"falling back on pure usbfs");
    954 			sysfs_can_relate_devices = 0;
    955 			*usbfs_fallback = 1;
    956 			return LIBUSB_ERROR_OTHER;
    957 		}
    958 		usbi_err(ctx, "open busnum failed, errno=%d", errno);
    959 		return LIBUSB_ERROR_IO;
    960 	}
    961 
    962 	sysfs_can_relate_devices = 1;
    963 
    964 	r = fscanf(fd, "%d", &busnum);
    965 	fclose(fd);
    966 	if (r != 1) {
    967 		usbi_err(ctx, "fscanf busnum returned %d, errno=%d", r, errno);
    968 		return LIBUSB_ERROR_IO;
    969 	}
    970 
    971 	snprintf(filename, PATH_MAX, "%s/%s/devnum", SYSFS_DEVICE_PATH, devname);
    972 	fd = fopen(filename, "r");
    973 	if (!fd) {
    974 		usbi_err(ctx, "open devnum failed, errno=%d", errno);
    975 		return LIBUSB_ERROR_IO;
    976 	}
    977 
    978 	r = fscanf(fd, "%d", &devaddr);
    979 	fclose(fd);
    980 	if (r != 1) {
    981 		usbi_err(ctx, "fscanf devnum returned %d, errno=%d", r, errno);
    982 		return LIBUSB_ERROR_IO;
    983 	}
    984 
    985 	usbi_dbg("bus=%d dev=%d", busnum, devaddr);
    986 	if (busnum > 255 || devaddr > 255)
    987 		return LIBUSB_ERROR_INVALID_PARAM;
    988 
    989 	return enumerate_device(ctx, _discdevs, busnum & 0xff, devaddr & 0xff,
    990 		devname);
    991 }
    992 
    993 static int sysfs_get_device_list(struct libusb_context *ctx,
    994 	struct discovered_devs **_discdevs, int *usbfs_fallback)
    995 {
    996 	struct discovered_devs *discdevs = *_discdevs;
    997 	DIR *devices = opendir(SYSFS_DEVICE_PATH);
    998 	struct dirent *entry;
    999 	int r = 0;
   1000 
   1001 	if (!devices) {
   1002 		usbi_err(ctx, "opendir devices failed errno=%d", errno);
   1003 		return LIBUSB_ERROR_IO;
   1004 	}
   1005 
   1006 	while ((entry = readdir(devices))) {
   1007 		struct discovered_devs *discdevs_new = discdevs;
   1008 
   1009 		if ((!isdigit(entry->d_name[0]) && strncmp(entry->d_name, "usb", 3))
   1010 				|| strchr(entry->d_name, ':'))
   1011 			continue;
   1012 
   1013 		r = sysfs_scan_device(ctx, &discdevs_new, entry->d_name,
   1014 			usbfs_fallback);
   1015 		if (r < 0)
   1016 			goto out;
   1017 		discdevs = discdevs_new;
   1018 	}
   1019 
   1020 out:
   1021 	closedir(devices);
   1022 	*_discdevs = discdevs;
   1023 	return r;
   1024 }
   1025 
   1026 static int op_get_device_list(struct libusb_context *ctx,
   1027 	struct discovered_devs **_discdevs)
   1028 {
   1029 	/* we can retrieve device list and descriptors from sysfs or usbfs.
   1030 	 * sysfs is preferable, because if we use usbfs we end up resuming
   1031 	 * any autosuspended USB devices. however, sysfs is not available
   1032 	 * everywhere, so we need a usbfs fallback too.
   1033 	 *
   1034 	 * as described in the "sysfs vs usbfs" comment, sometimes we have
   1035 	 * sysfs but not enough information to relate sysfs devices to usbfs
   1036 	 * nodes. the usbfs_fallback variable is used to indicate that we should
   1037 	 * fall back on usbfs.
   1038 	 */
   1039 	if (sysfs_can_relate_devices != 0) {
   1040 		int usbfs_fallback = 0;
   1041 		int r = sysfs_get_device_list(ctx, _discdevs, &usbfs_fallback);
   1042 		if (!usbfs_fallback)
   1043 			return r;
   1044 	}
   1045 
   1046 	return usbfs_get_device_list(ctx, _discdevs);
   1047 }
   1048 
   1049 static int op_open(struct libusb_device_handle *handle)
   1050 {
   1051 	struct linux_device_handle_priv *hpriv = __device_handle_priv(handle);
   1052 	char filename[PATH_MAX];
   1053 
   1054 	__get_usbfs_path(handle->dev, filename);
   1055 	hpriv->fd = open(filename, O_RDWR);
   1056 	if (hpriv->fd < 0) {
   1057 		if (errno == EACCES) {
   1058 			fprintf(stderr, "libusb couldn't open USB device %s: "
   1059 				"Permission denied.\n"
   1060 				"libusb requires write access to USB device nodes.\n",
   1061 				filename);
   1062 			return LIBUSB_ERROR_ACCESS;
   1063 		} else if (errno == ENOENT) {
   1064 			return LIBUSB_ERROR_NO_DEVICE;
   1065 		} else {
   1066 			usbi_err(HANDLE_CTX(handle),
   1067 				"open failed, code %d errno %d", hpriv->fd, errno);
   1068 			return LIBUSB_ERROR_IO;
   1069 		}
   1070 	}
   1071 
   1072 	return usbi_add_pollfd(HANDLE_CTX(handle), hpriv->fd, POLLOUT);
   1073 }
   1074 
   1075 static void op_close(struct libusb_device_handle *dev_handle)
   1076 {
   1077 	int fd = __device_handle_priv(dev_handle)->fd;
   1078 	usbi_remove_pollfd(HANDLE_CTX(dev_handle), fd);
   1079 	close(fd);
   1080 }
   1081 
   1082 static int op_get_configuration(struct libusb_device_handle *handle,
   1083 	int *config)
   1084 {
   1085 	int r;
   1086 	if (sysfs_can_relate_devices != 1)
   1087 		return LIBUSB_ERROR_NOT_SUPPORTED;
   1088 
   1089 	r = sysfs_get_active_config(handle->dev, config);
   1090 	if (*config == -1)
   1091 		*config = 0;
   1092 
   1093 	return 0;
   1094 }
   1095 
   1096 static int op_set_configuration(struct libusb_device_handle *handle, int config)
   1097 {
   1098 	struct linux_device_priv *priv = __device_priv(handle->dev);
   1099 	int fd = __device_handle_priv(handle)->fd;
   1100 	int r = ioctl(fd, IOCTL_USBFS_SETCONFIG, &config);
   1101 	if (r) {
   1102 		if (errno == EINVAL)
   1103 			return LIBUSB_ERROR_NOT_FOUND;
   1104 		else if (errno == EBUSY)
   1105 			return LIBUSB_ERROR_BUSY;
   1106 		else if (errno == ENODEV)
   1107 			return LIBUSB_ERROR_NO_DEVICE;
   1108 
   1109 		usbi_err(HANDLE_CTX(handle), "failed, error %d errno %d", r, errno);
   1110 		return LIBUSB_ERROR_OTHER;
   1111 	}
   1112 
   1113 	if (!sysfs_has_descriptors) {
   1114 		/* update our cached active config descriptor */
   1115 		if (config == -1) {
   1116 			if (priv->config_descriptor) {
   1117 				free(priv->config_descriptor);
   1118 				priv->config_descriptor = NULL;
   1119 			}
   1120 		} else {
   1121 			r = cache_active_config(handle->dev, fd, config);
   1122 			if (r < 0)
   1123 				usbi_warn(HANDLE_CTX(handle),
   1124 					"failed to update cached config descriptor, error %d", r);
   1125 		}
   1126 	}
   1127 
   1128 	return 0;
   1129 }
   1130 
   1131 static int op_claim_interface(struct libusb_device_handle *handle, int iface)
   1132 {
   1133 	int fd = __device_handle_priv(handle)->fd;
   1134 	int r = ioctl(fd, IOCTL_USBFS_CLAIMINTF, &iface);
   1135 	if (r) {
   1136 		if (errno == ENOENT)
   1137 			return LIBUSB_ERROR_NOT_FOUND;
   1138 		else if (errno == EBUSY)
   1139 			return LIBUSB_ERROR_BUSY;
   1140 		else if (errno == ENODEV)
   1141 			return LIBUSB_ERROR_NO_DEVICE;
   1142 
   1143 		usbi_err(HANDLE_CTX(handle),
   1144 			"claim interface failed, error %d errno %d", r, errno);
   1145 		return LIBUSB_ERROR_OTHER;
   1146 	}
   1147 	return 0;
   1148 }
   1149 
   1150 static int op_release_interface(struct libusb_device_handle *handle, int iface)
   1151 {
   1152 	int fd = __device_handle_priv(handle)->fd;
   1153 	int r = ioctl(fd, IOCTL_USBFS_RELEASEINTF, &iface);
   1154 	if (r) {
   1155 		if (errno == ENODEV)
   1156 			return LIBUSB_ERROR_NO_DEVICE;
   1157 
   1158 		usbi_err(HANDLE_CTX(handle),
   1159 			"release interface failed, error %d errno %d", r, errno);
   1160 		return LIBUSB_ERROR_OTHER;
   1161 	}
   1162 	return 0;
   1163 }
   1164 
   1165 static int op_set_interface(struct libusb_device_handle *handle, int iface,
   1166 	int altsetting)
   1167 {
   1168 	int fd = __device_handle_priv(handle)->fd;
   1169 	struct usbfs_setinterface setintf;
   1170 	int r;
   1171 
   1172 	setintf.interface = iface;
   1173 	setintf.altsetting = altsetting;
   1174 	r = ioctl(fd, IOCTL_USBFS_SETINTF, &setintf);
   1175 	if (r) {
   1176 		if (errno == EINVAL)
   1177 			return LIBUSB_ERROR_NOT_FOUND;
   1178 		else if (errno == ENODEV)
   1179 			return LIBUSB_ERROR_NO_DEVICE;
   1180 
   1181 		usbi_err(HANDLE_CTX(handle),
   1182 			"setintf failed error %d errno %d", r, errno);
   1183 		return LIBUSB_ERROR_OTHER;
   1184 	}
   1185 
   1186 	return 0;
   1187 }
   1188 
   1189 static int op_clear_halt(struct libusb_device_handle *handle,
   1190 	unsigned char endpoint)
   1191 {
   1192 	int fd = __device_handle_priv(handle)->fd;
   1193 	unsigned int _endpoint = endpoint;
   1194 	int r = ioctl(fd, IOCTL_USBFS_CLEAR_HALT, &_endpoint);
   1195 	if (r) {
   1196 		if (errno == ENOENT)
   1197 			return LIBUSB_ERROR_NOT_FOUND;
   1198 		else if (errno == ENODEV)
   1199 			return LIBUSB_ERROR_NO_DEVICE;
   1200 
   1201 		usbi_err(HANDLE_CTX(handle),
   1202 			"clear_halt failed error %d errno %d", r, errno);
   1203 		return LIBUSB_ERROR_OTHER;
   1204 	}
   1205 
   1206 	return 0;
   1207 }
   1208 
   1209 static int op_reset_device(struct libusb_device_handle *handle)
   1210 {
   1211 	int fd = __device_handle_priv(handle)->fd;
   1212 	int r = ioctl(fd, IOCTL_USBFS_RESET, NULL);
   1213 	if (r) {
   1214 		if (errno == ENODEV)
   1215 			return LIBUSB_ERROR_NOT_FOUND;
   1216 
   1217 		usbi_err(HANDLE_CTX(handle),
   1218 			"reset failed error %d errno %d", r, errno);
   1219 		return LIBUSB_ERROR_OTHER;
   1220 	}
   1221 
   1222 	return 0;
   1223 }
   1224 
   1225 static int op_kernel_driver_active(struct libusb_device_handle *handle,
   1226 	int interface)
   1227 {
   1228 	int fd = __device_handle_priv(handle)->fd;
   1229 	struct usbfs_getdriver getdrv;
   1230 	int r;
   1231 
   1232 	getdrv.interface = interface;
   1233 	r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
   1234 	if (r) {
   1235 		if (errno == ENODATA)
   1236 			return 0;
   1237 		else if (errno == ENODEV)
   1238 			return LIBUSB_ERROR_NO_DEVICE;
   1239 
   1240 		usbi_err(HANDLE_CTX(handle),
   1241 			"get driver failed error %d errno %d", r, errno);
   1242 		return LIBUSB_ERROR_OTHER;
   1243 	}
   1244 
   1245 	return 1;
   1246 }
   1247 
   1248 static int op_detach_kernel_driver(struct libusb_device_handle *handle,
   1249 	int interface)
   1250 {
   1251 	int fd = __device_handle_priv(handle)->fd;
   1252 	struct usbfs_ioctl command;
   1253 	int r;
   1254 
   1255 	command.ifno = interface;
   1256 	command.ioctl_code = IOCTL_USBFS_DISCONNECT;
   1257 	command.data = NULL;
   1258 
   1259 	r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
   1260 	if (r) {
   1261 		if (errno == ENODATA)
   1262 			return LIBUSB_ERROR_NOT_FOUND;
   1263 		else if (errno == EINVAL)
   1264 			return LIBUSB_ERROR_INVALID_PARAM;
   1265 		else if (errno == ENODEV)
   1266 			return LIBUSB_ERROR_NO_DEVICE;
   1267 
   1268 		usbi_err(HANDLE_CTX(handle),
   1269 			"detach failed error %d errno %d", r, errno);
   1270 		return LIBUSB_ERROR_OTHER;
   1271 	}
   1272 
   1273 	return 0;
   1274 }
   1275 
   1276 static int op_attach_kernel_driver(struct libusb_device_handle *handle,
   1277 	int interface)
   1278 {
   1279 	int fd = __device_handle_priv(handle)->fd;
   1280 	struct usbfs_ioctl command;
   1281 	int r;
   1282 
   1283 	command.ifno = interface;
   1284 	command.ioctl_code = IOCTL_USBFS_CONNECT;
   1285 	command.data = NULL;
   1286 
   1287 	r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
   1288 	if (r < 0) {
   1289 		if (errno == ENODATA)
   1290 			return LIBUSB_ERROR_NOT_FOUND;
   1291 		else if (errno == EINVAL)
   1292 			return LIBUSB_ERROR_INVALID_PARAM;
   1293 		else if (errno == ENODEV)
   1294 			return LIBUSB_ERROR_NO_DEVICE;
   1295 		else if (errno == EBUSY)
   1296 			return LIBUSB_ERROR_BUSY;
   1297 
   1298 		usbi_err(HANDLE_CTX(handle),
   1299 			"attach failed error %d errno %d", r, errno);
   1300 		return LIBUSB_ERROR_OTHER;
   1301 	} else if (r == 0) {
   1302 		return LIBUSB_ERROR_NOT_FOUND;
   1303 	}
   1304 
   1305 	return 0;
   1306 }
   1307 
   1308 static void op_destroy_device(struct libusb_device *dev)
   1309 {
   1310 	struct linux_device_priv *priv = __device_priv(dev);
   1311 	if (!sysfs_has_descriptors) {
   1312 		if (priv->dev_descriptor)
   1313 			free(priv->dev_descriptor);
   1314 		if (priv->config_descriptor)
   1315 			free(priv->config_descriptor);
   1316 	}
   1317 	if (priv->sysfs_dir)
   1318 		free(priv->sysfs_dir);
   1319 }
   1320 
   1321 static void free_iso_urbs(struct linux_transfer_priv *tpriv)
   1322 {
   1323 	int i;
   1324 	for (i = 0; i < tpriv->num_urbs; i++) {
   1325 		struct usbfs_urb *urb = tpriv->iso_urbs[i];
   1326 		if (!urb)
   1327 			break;
   1328 		free(urb);
   1329 	}
   1330 
   1331 	free(tpriv->iso_urbs);
   1332 	tpriv->iso_urbs = NULL;
   1333 }
   1334 
   1335 static int submit_bulk_transfer(struct usbi_transfer *itransfer,
   1336 	unsigned char urb_type)
   1337 {
   1338 	struct libusb_transfer *transfer =
   1339 		__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1340 	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
   1341 	struct linux_device_handle_priv *dpriv =
   1342 		__device_handle_priv(transfer->dev_handle);
   1343 	struct usbfs_urb *urbs;
   1344 	int is_out = (transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK)
   1345 		== LIBUSB_ENDPOINT_OUT;
   1346 	int r;
   1347 	int i;
   1348 	size_t alloc_size;
   1349 
   1350 	if (tpriv->urbs)
   1351 		return LIBUSB_ERROR_BUSY;
   1352 
   1353 	/* usbfs places a 16kb limit on bulk URBs. we divide up larger requests
   1354 	 * into smaller units to meet such restriction, then fire off all the
   1355 	 * units at once. it would be simpler if we just fired one unit at a time,
   1356 	 * but there is a big performance gain through doing it this way. */
   1357 	int num_urbs = transfer->length / MAX_BULK_BUFFER_LENGTH;
   1358 	int last_urb_partial = 0;
   1359 
   1360 	if (transfer->length == 0) {
   1361 		num_urbs = 1;
   1362 	} else if ((transfer->length % MAX_BULK_BUFFER_LENGTH) > 0) {
   1363 		last_urb_partial = 1;
   1364 		num_urbs++;
   1365 	}
   1366 	usbi_dbg("need %d urbs for new transfer with length %d", num_urbs,
   1367 		transfer->length);
   1368 	alloc_size = num_urbs * sizeof(struct usbfs_urb);
   1369 	urbs = malloc(alloc_size);
   1370 	if (!urbs)
   1371 		return LIBUSB_ERROR_NO_MEM;
   1372 	memset(urbs, 0, alloc_size);
   1373 	tpriv->urbs = urbs;
   1374 	tpriv->num_urbs = num_urbs;
   1375 	tpriv->num_retired = 0;
   1376 	tpriv->reap_action = NORMAL;
   1377 
   1378 	for (i = 0; i < num_urbs; i++) {
   1379 		struct usbfs_urb *urb = &urbs[i];
   1380 		urb->usercontext = itransfer;
   1381 		urb->type = urb_type;
   1382 		urb->endpoint = transfer->endpoint;
   1383 		urb->buffer = transfer->buffer + (i * MAX_BULK_BUFFER_LENGTH);
   1384 		if (supports_flag_bulk_continuation && !is_out)
   1385 			urb->flags = USBFS_URB_SHORT_NOT_OK;
   1386 		if (i == num_urbs - 1 && last_urb_partial)
   1387 			urb->buffer_length = transfer->length % MAX_BULK_BUFFER_LENGTH;
   1388 		else if (transfer->length == 0)
   1389 			urb->buffer_length = 0;
   1390 		else
   1391 			urb->buffer_length = MAX_BULK_BUFFER_LENGTH;
   1392 
   1393 		if (i > 0 && supports_flag_bulk_continuation)
   1394 			urb->flags |= USBFS_URB_BULK_CONTINUATION;
   1395 
   1396 		r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
   1397 		if (r < 0) {
   1398 			int j;
   1399 
   1400 			if (errno == ENODEV) {
   1401 				r = LIBUSB_ERROR_NO_DEVICE;
   1402 			} else {
   1403 				usbi_err(TRANSFER_CTX(transfer),
   1404 					"submiturb failed error %d errno=%d", r, errno);
   1405 				r = LIBUSB_ERROR_IO;
   1406 			}
   1407 
   1408 			/* if the first URB submission fails, we can simply free up and
   1409 			 * return failure immediately. */
   1410 			if (i == 0) {
   1411 				usbi_dbg("first URB failed, easy peasy");
   1412 				free(urbs);
   1413 				tpriv->urbs = NULL;
   1414 				return r;
   1415 			}
   1416 
   1417 			/* if it's not the first URB that failed, the situation is a bit
   1418 			 * tricky. we must discard all previous URBs. there are
   1419 			 * complications:
   1420 			 *  - discarding is asynchronous - discarded urbs will be reaped
   1421 			 *    later. the user must not have freed the transfer when the
   1422 			 *    discarded URBs are reaped, otherwise libusb will be using
   1423 			 *    freed memory.
   1424 			 *  - the earlier URBs may have completed successfully and we do
   1425 			 *    not want to throw away any data.
   1426 			 * so, in this case we discard all the previous URBs BUT we report
   1427 			 * that the transfer was submitted successfully. then later when
   1428 			 * the final discard completes we can report error to the user.
   1429 			 */
   1430 			tpriv->reap_action = SUBMIT_FAILED;
   1431 
   1432 			/* The URBs we haven't submitted yet we count as already
   1433 			 * retired. */
   1434 			tpriv->num_retired += num_urbs - i;
   1435 			for (j = 0; j < i; j++) {
   1436 				int tmp = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, &urbs[j]);
   1437 				if (tmp && errno != EINVAL)
   1438 					usbi_warn(TRANSFER_CTX(transfer),
   1439 						"unrecognised discard errno %d", errno);
   1440 			}
   1441 
   1442 			usbi_dbg("reporting successful submission but waiting for %d "
   1443 				"discards before reporting error", i);
   1444 			return 0;
   1445 		}
   1446 	}
   1447 
   1448 	return 0;
   1449 }
   1450 
   1451 static int submit_iso_transfer(struct usbi_transfer *itransfer)
   1452 {
   1453 	struct libusb_transfer *transfer =
   1454 		__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1455 	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
   1456 	struct linux_device_handle_priv *dpriv =
   1457 		__device_handle_priv(transfer->dev_handle);
   1458 	struct usbfs_urb **urbs;
   1459 	size_t alloc_size;
   1460 	int num_packets = transfer->num_iso_packets;
   1461 	int i;
   1462 	int this_urb_len = 0;
   1463 	int num_urbs = 1;
   1464 	int packet_offset = 0;
   1465 	unsigned int packet_len;
   1466 	unsigned char *urb_buffer = transfer->buffer;
   1467 
   1468 	if (tpriv->iso_urbs)
   1469 		return LIBUSB_ERROR_BUSY;
   1470 
   1471 	/* usbfs places a 32kb limit on iso URBs. we divide up larger requests
   1472 	 * into smaller units to meet such restriction, then fire off all the
   1473 	 * units at once. it would be simpler if we just fired one unit at a time,
   1474 	 * but there is a big performance gain through doing it this way. */
   1475 
   1476 	/* calculate how many URBs we need */
   1477 	for (i = 0; i < num_packets; i++) {
   1478 		int space_remaining = MAX_ISO_BUFFER_LENGTH - this_urb_len;
   1479 		packet_len = transfer->iso_packet_desc[i].length;
   1480 
   1481 		if (packet_len > space_remaining) {
   1482 			num_urbs++;
   1483 			this_urb_len = packet_len;
   1484 		} else {
   1485 			this_urb_len += packet_len;
   1486 		}
   1487 	}
   1488 	usbi_dbg("need %d 32k URBs for transfer", num_urbs);
   1489 
   1490 	alloc_size = num_urbs * sizeof(*urbs);
   1491 	urbs = malloc(alloc_size);
   1492 	if (!urbs)
   1493 		return LIBUSB_ERROR_NO_MEM;
   1494 	memset(urbs, 0, alloc_size);
   1495 
   1496 	tpriv->iso_urbs = urbs;
   1497 	tpriv->num_urbs = num_urbs;
   1498 	tpriv->num_retired = 0;
   1499 	tpriv->reap_action = NORMAL;
   1500 	tpriv->iso_packet_offset = 0;
   1501 
   1502 	/* allocate + initialize each URB with the correct number of packets */
   1503 	for (i = 0; i < num_urbs; i++) {
   1504 		struct usbfs_urb *urb;
   1505 		int space_remaining_in_urb = MAX_ISO_BUFFER_LENGTH;
   1506 		int urb_packet_offset = 0;
   1507 		unsigned char *urb_buffer_orig = urb_buffer;
   1508 		int j;
   1509 		int k;
   1510 
   1511 		/* swallow up all the packets we can fit into this URB */
   1512 		while (packet_offset < transfer->num_iso_packets) {
   1513 			packet_len = transfer->iso_packet_desc[packet_offset].length;
   1514 			if (packet_len <= space_remaining_in_urb) {
   1515 				/* throw it in */
   1516 				urb_packet_offset++;
   1517 				packet_offset++;
   1518 				space_remaining_in_urb -= packet_len;
   1519 				urb_buffer += packet_len;
   1520 			} else {
   1521 				/* it can't fit, save it for the next URB */
   1522 				break;
   1523 			}
   1524 		}
   1525 
   1526 		alloc_size = sizeof(*urb)
   1527 			+ (urb_packet_offset * sizeof(struct usbfs_iso_packet_desc));
   1528 		urb = malloc(alloc_size);
   1529 		if (!urb) {
   1530 			free_iso_urbs(tpriv);
   1531 			return LIBUSB_ERROR_NO_MEM;
   1532 		}
   1533 		memset(urb, 0, alloc_size);
   1534 		urbs[i] = urb;
   1535 
   1536 		/* populate packet lengths */
   1537 		for (j = 0, k = packet_offset - urb_packet_offset;
   1538 				k < packet_offset; k++, j++) {
   1539 			packet_len = transfer->iso_packet_desc[k].length;
   1540 			urb->iso_frame_desc[j].length = packet_len;
   1541 		}
   1542 
   1543 		urb->usercontext = itransfer;
   1544 		urb->type = USBFS_URB_TYPE_ISO;
   1545 		/* FIXME: interface for non-ASAP data? */
   1546 		urb->flags = USBFS_URB_ISO_ASAP;
   1547 		urb->endpoint = transfer->endpoint;
   1548 		urb->number_of_packets = urb_packet_offset;
   1549 		urb->buffer = urb_buffer_orig;
   1550 	}
   1551 
   1552 	/* submit URBs */
   1553 	for (i = 0; i < num_urbs; i++) {
   1554 		int r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urbs[i]);
   1555 		if (r < 0) {
   1556 			int j;
   1557 
   1558 			if (errno == ENODEV) {
   1559 				r = LIBUSB_ERROR_NO_DEVICE;
   1560 			} else {
   1561 				usbi_err(TRANSFER_CTX(transfer),
   1562 					"submiturb failed error %d errno=%d", r, errno);
   1563 				r = LIBUSB_ERROR_IO;
   1564 			}
   1565 
   1566 			/* if the first URB submission fails, we can simply free up and
   1567 			 * return failure immediately. */
   1568 			if (i == 0) {
   1569 				usbi_dbg("first URB failed, easy peasy");
   1570 				free_iso_urbs(tpriv);
   1571 				return r;
   1572 			}
   1573 
   1574 			/* if it's not the first URB that failed, the situation is a bit
   1575 			 * tricky. we must discard all previous URBs. there are
   1576 			 * complications:
   1577 			 *  - discarding is asynchronous - discarded urbs will be reaped
   1578 			 *    later. the user must not have freed the transfer when the
   1579 			 *    discarded URBs are reaped, otherwise libusb will be using
   1580 			 *    freed memory.
   1581 			 *  - the earlier URBs may have completed successfully and we do
   1582 			 *    not want to throw away any data.
   1583 			 * so, in this case we discard all the previous URBs BUT we report
   1584 			 * that the transfer was submitted successfully. then later when
   1585 			 * the final discard completes we can report error to the user.
   1586 			 */
   1587 			tpriv->reap_action = SUBMIT_FAILED;
   1588 
   1589 			/* The URBs we haven't submitted yet we count as already
   1590 			 * retired. */
   1591 			tpriv->num_retired = num_urbs - i;
   1592 			for (j = 0; j < i; j++) {
   1593 				int tmp = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, urbs[j]);
   1594 				if (tmp && errno != EINVAL)
   1595 					usbi_warn(TRANSFER_CTX(transfer),
   1596 						"unrecognised discard errno %d", errno);
   1597 			}
   1598 
   1599 			usbi_dbg("reporting successful submission but waiting for %d "
   1600 				"discards before reporting error", i);
   1601 			return 0;
   1602 		}
   1603 	}
   1604 
   1605 	return 0;
   1606 }
   1607 
   1608 static int submit_control_transfer(struct usbi_transfer *itransfer)
   1609 {
   1610 	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
   1611 	struct libusb_transfer *transfer =
   1612 		__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1613 	struct linux_device_handle_priv *dpriv =
   1614 		__device_handle_priv(transfer->dev_handle);
   1615 	struct usbfs_urb *urb;
   1616 	int r;
   1617 
   1618 	if (tpriv->urbs)
   1619 		return LIBUSB_ERROR_BUSY;
   1620 
   1621 	if (transfer->length - LIBUSB_CONTROL_SETUP_SIZE > MAX_CTRL_BUFFER_LENGTH)
   1622 		return LIBUSB_ERROR_INVALID_PARAM;
   1623 
   1624 	urb = malloc(sizeof(struct usbfs_urb));
   1625 	if (!urb)
   1626 		return LIBUSB_ERROR_NO_MEM;
   1627 	memset(urb, 0, sizeof(struct usbfs_urb));
   1628 	tpriv->urbs = urb;
   1629 	tpriv->reap_action = NORMAL;
   1630 
   1631 	urb->usercontext = itransfer;
   1632 	urb->type = USBFS_URB_TYPE_CONTROL;
   1633 	urb->endpoint = transfer->endpoint;
   1634 	urb->buffer = transfer->buffer;
   1635 	urb->buffer_length = transfer->length;
   1636 
   1637 	r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
   1638 	if (r < 0) {
   1639 		free(urb);
   1640 		tpriv->urbs = NULL;
   1641 		if (errno == ENODEV)
   1642 			return LIBUSB_ERROR_NO_DEVICE;
   1643 
   1644 		usbi_err(TRANSFER_CTX(transfer),
   1645 			"submiturb failed error %d errno=%d", r, errno);
   1646 		return LIBUSB_ERROR_IO;
   1647 	}
   1648 	return 0;
   1649 }
   1650 
   1651 static int op_submit_transfer(struct usbi_transfer *itransfer)
   1652 {
   1653 	struct libusb_transfer *transfer =
   1654 		__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1655 
   1656 	switch (transfer->type) {
   1657 	case LIBUSB_TRANSFER_TYPE_CONTROL:
   1658 		return submit_control_transfer(itransfer);
   1659 	case LIBUSB_TRANSFER_TYPE_BULK:
   1660 		return submit_bulk_transfer(itransfer, USBFS_URB_TYPE_BULK);
   1661 	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
   1662 		return submit_bulk_transfer(itransfer, USBFS_URB_TYPE_INTERRUPT);
   1663 	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
   1664 		return submit_iso_transfer(itransfer);
   1665 	default:
   1666 		usbi_err(TRANSFER_CTX(transfer),
   1667 			"unknown endpoint type %d", transfer->type);
   1668 		return LIBUSB_ERROR_INVALID_PARAM;
   1669 	}
   1670 }
   1671 
   1672 static int cancel_control_transfer(struct usbi_transfer *itransfer)
   1673 {
   1674 	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
   1675 	struct libusb_transfer *transfer =
   1676 		__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1677 	struct linux_device_handle_priv *dpriv =
   1678 		__device_handle_priv(transfer->dev_handle);
   1679 	int r;
   1680 
   1681 	if (!tpriv->urbs)
   1682 		return LIBUSB_ERROR_NOT_FOUND;
   1683 
   1684 	tpriv->reap_action = CANCELLED;
   1685 	r = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, tpriv->urbs);
   1686 	if(r) {
   1687 		if (errno == EINVAL) {
   1688 			usbi_dbg("URB not found --> assuming ready to be reaped");
   1689 			return 0;
   1690 		} else {
   1691 			usbi_err(TRANSFER_CTX(transfer),
   1692 				"unrecognised DISCARD code %d", errno);
   1693 			return LIBUSB_ERROR_OTHER;
   1694 		}
   1695 	}
   1696 
   1697 	return 0;
   1698 }
   1699 
   1700 static int cancel_bulk_transfer(struct usbi_transfer *itransfer)
   1701 {
   1702 	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
   1703 	struct libusb_transfer *transfer =
   1704 		__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1705 	struct linux_device_handle_priv *dpriv =
   1706 		__device_handle_priv(transfer->dev_handle);
   1707 	int i;
   1708 
   1709 	if (!tpriv->urbs)
   1710 		return LIBUSB_ERROR_NOT_FOUND;
   1711 
   1712 	tpriv->reap_action = CANCELLED;
   1713 	for (i = 0; i < tpriv->num_urbs; i++) {
   1714 		int tmp = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, &tpriv->urbs[i]);
   1715 		if (tmp && errno != EINVAL)
   1716 			usbi_warn(TRANSFER_CTX(transfer),
   1717 				"unrecognised discard errno %d", errno);
   1718 	}
   1719 	return 0;
   1720 }
   1721 
   1722 static int cancel_iso_transfer(struct usbi_transfer *itransfer)
   1723 {
   1724 	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
   1725 	struct libusb_transfer *transfer =
   1726 		__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1727 	struct linux_device_handle_priv *dpriv =
   1728 		__device_handle_priv(transfer->dev_handle);
   1729 	int i;
   1730 
   1731 	if (!tpriv->iso_urbs)
   1732 		return LIBUSB_ERROR_NOT_FOUND;
   1733 
   1734 	tpriv->reap_action = CANCELLED;
   1735 	for (i = 0; i < tpriv->num_urbs; i++) {
   1736 		int tmp = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, tpriv->iso_urbs[i]);
   1737 		if (tmp && errno != EINVAL)
   1738 			usbi_warn(TRANSFER_CTX(transfer),
   1739 				"unrecognised discard errno %d", errno);
   1740 	}
   1741 	return 0;
   1742 }
   1743 
   1744 static int op_cancel_transfer(struct usbi_transfer *itransfer)
   1745 {
   1746 	struct libusb_transfer *transfer =
   1747 		__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1748 
   1749 	switch (transfer->type) {
   1750 	case LIBUSB_TRANSFER_TYPE_CONTROL:
   1751 		return cancel_control_transfer(itransfer);
   1752 	case LIBUSB_TRANSFER_TYPE_BULK:
   1753 	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
   1754 		return cancel_bulk_transfer(itransfer);
   1755 	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
   1756 		return cancel_iso_transfer(itransfer);
   1757 	default:
   1758 		usbi_err(TRANSFER_CTX(transfer),
   1759 			"unknown endpoint type %d", transfer->type);
   1760 		return LIBUSB_ERROR_INVALID_PARAM;
   1761 	}
   1762 }
   1763 
   1764 static void op_clear_transfer_priv(struct usbi_transfer *itransfer)
   1765 {
   1766 	struct libusb_transfer *transfer =
   1767 		__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1768 	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
   1769 
   1770 	switch (transfer->type) {
   1771 	case LIBUSB_TRANSFER_TYPE_CONTROL:
   1772 	case LIBUSB_TRANSFER_TYPE_BULK:
   1773 	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
   1774 		free(tpriv->urbs);
   1775 		tpriv->urbs = NULL;
   1776 		break;
   1777 	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
   1778 		free_iso_urbs(tpriv);
   1779 		break;
   1780 	default:
   1781 		usbi_err(TRANSFER_CTX(transfer),
   1782 			"unknown endpoint type %d", transfer->type);
   1783 	}
   1784 }
   1785 
   1786 static int handle_bulk_completion(struct usbi_transfer *itransfer,
   1787 	struct usbfs_urb *urb)
   1788 {
   1789 	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
   1790 	int num_urbs = tpriv->num_urbs;
   1791 	int urb_idx = urb - tpriv->urbs;
   1792 	enum libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
   1793 	int r = 0;
   1794 
   1795 	pthread_mutex_lock(&itransfer->lock);
   1796 	usbi_dbg("handling completion status %d of bulk urb %d/%d", urb->status,
   1797 		urb_idx + 1, num_urbs);
   1798 
   1799 	tpriv->num_retired++;
   1800 
   1801 	if (tpriv->reap_action != NORMAL) {
   1802 		/* cancelled, submit_fail, or completed early */
   1803 		usbi_dbg("abnormal reap: urb status %d", urb->status);
   1804 
   1805 		/* even though we're in the process of cancelling, it's possible that
   1806 		 * we may receive some data in these URBs that we don't want to lose.
   1807 		 * examples:
   1808 		 * 1. while the kernel is cancelling all the packets that make up an
   1809 		 *    URB, a few of them might complete. so we get back a successful
   1810 		 *    cancellation *and* some data.
   1811 		 * 2. we receive a short URB which marks the early completion condition,
   1812 		 *    so we start cancelling the remaining URBs. however, we're too
   1813 		 *    slow and another URB completes (or at least completes partially).
   1814 		 *
   1815 		 * When this happens, our objectives are not to lose any "surplus" data,
   1816 		 * and also to stick it at the end of the previously-received data
   1817 		 * (closing any holes), so that libusb reports the total amount of
   1818 		 * transferred data and presents it in a contiguous chunk.
   1819 		 */
   1820 		if (urb->actual_length > 0) {
   1821 			struct libusb_transfer *transfer =
   1822 				__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1823 			unsigned char *target = transfer->buffer + itransfer->transferred;
   1824 			usbi_dbg("received %d bytes of surplus data", urb->actual_length);
   1825 			if (urb->buffer != target) {
   1826 				usbi_dbg("moving surplus data from offset %d to offset %d",
   1827 					(unsigned char *) urb->buffer - transfer->buffer,
   1828 					target - transfer->buffer);
   1829 				memmove(target, urb->buffer, urb->actual_length);
   1830 			}
   1831 			itransfer->transferred += urb->actual_length;
   1832 		}
   1833 
   1834 		if (tpriv->num_retired == num_urbs) {
   1835 			usbi_dbg("abnormal reap: last URB handled, reporting");
   1836 			if (tpriv->reap_action == CANCELLED) {
   1837 				free(tpriv->urbs);
   1838 				tpriv->urbs = NULL;
   1839 				pthread_mutex_unlock(&itransfer->lock);
   1840 				r = usbi_handle_transfer_cancellation(itransfer);
   1841 				goto out_unlock;
   1842 			}
   1843 			if (tpriv->reap_action != COMPLETED_EARLY)
   1844 				status = LIBUSB_TRANSFER_ERROR;
   1845 			goto completed;
   1846 		}
   1847 		goto out_unlock;
   1848 	}
   1849 
   1850 	if (urb->status == 0 || urb->status == -EREMOTEIO ||
   1851 			(urb->status == -EOVERFLOW && urb->actual_length > 0))
   1852 		itransfer->transferred += urb->actual_length;
   1853 
   1854 
   1855 	switch (urb->status) {
   1856 	case 0:
   1857 		break;
   1858 	case -EREMOTEIO: /* short transfer */
   1859 		break;
   1860 	case -EPIPE:
   1861 		usbi_dbg("detected endpoint stall");
   1862 		status = LIBUSB_TRANSFER_STALL;
   1863 		goto completed;
   1864 	case -EOVERFLOW:
   1865 		/* overflow can only ever occur in the last urb */
   1866 		usbi_dbg("overflow, actual_length=%d", urb->actual_length);
   1867 		status = LIBUSB_TRANSFER_OVERFLOW;
   1868 		goto completed;
   1869 	case -ETIME:
   1870 	case -EPROTO:
   1871 	case -EILSEQ:
   1872 		usbi_dbg("low level error %d", urb->status);
   1873 		status = LIBUSB_TRANSFER_ERROR;
   1874 		goto completed;
   1875 	default:
   1876 		usbi_warn(ITRANSFER_CTX(itransfer),
   1877 			"unrecognised urb status %d", urb->status);
   1878 		status = LIBUSB_TRANSFER_ERROR;
   1879 		goto completed;
   1880 	}
   1881 
   1882 	/* if we're the last urb or we got less data than requested then we're
   1883 	 * done */
   1884 	if (urb_idx == num_urbs - 1) {
   1885 		usbi_dbg("last URB in transfer --> complete!");
   1886 	} else if (urb->actual_length < urb->buffer_length) {
   1887 		struct libusb_transfer *transfer =
   1888 			__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1889 		struct linux_device_handle_priv *dpriv =
   1890 			__device_handle_priv(transfer->dev_handle);
   1891 		int i;
   1892 
   1893 		usbi_dbg("short transfer %d/%d --> complete!", urb->actual_length,
   1894 			urb->buffer_length);
   1895 
   1896 		/* we have to cancel the remaining urbs and wait for their completion
   1897 		 * before reporting results */
   1898 		tpriv->reap_action = COMPLETED_EARLY;
   1899 		for (i = urb_idx + 1; i < tpriv->num_urbs; i++) {
   1900 			/* remaining URBs with continuation flag are automatically
   1901 			 * cancelled by the kernel */
   1902 			if (tpriv->urbs[i].flags & USBFS_URB_BULK_CONTINUATION)
   1903 				continue;
   1904 			int tmp = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, &tpriv->urbs[i]);
   1905 			if (tmp && errno != EINVAL)
   1906 				usbi_warn(TRANSFER_CTX(transfer),
   1907 					"unrecognised discard errno %d", errno);
   1908 		}
   1909 		goto out_unlock;
   1910 	} else {
   1911 		goto out_unlock;
   1912 	}
   1913 
   1914 completed:
   1915 	free(tpriv->urbs);
   1916 	tpriv->urbs = NULL;
   1917 	pthread_mutex_unlock(&itransfer->lock);
   1918 	return usbi_handle_transfer_completion(itransfer, status);
   1919 out_unlock:
   1920 	pthread_mutex_unlock(&itransfer->lock);
   1921 	return r;
   1922 }
   1923 
   1924 static int handle_iso_completion(struct usbi_transfer *itransfer,
   1925 	struct usbfs_urb *urb)
   1926 {
   1927 	struct libusb_transfer *transfer =
   1928 		__USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   1929 	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
   1930 	int num_urbs = tpriv->num_urbs;
   1931 	int urb_idx = 0;
   1932 	int i;
   1933 
   1934 	pthread_mutex_lock(&itransfer->lock);
   1935 	for (i = 0; i < num_urbs; i++) {
   1936 		if (urb == tpriv->iso_urbs[i]) {
   1937 			urb_idx = i + 1;
   1938 			break;
   1939 		}
   1940 	}
   1941 	if (urb_idx == 0) {
   1942 		usbi_err(TRANSFER_CTX(transfer), "could not locate urb!");
   1943 		pthread_mutex_unlock(&itransfer->lock);
   1944 		return LIBUSB_ERROR_NOT_FOUND;
   1945 	}
   1946 
   1947 	usbi_dbg("handling completion status %d of iso urb %d/%d", urb->status,
   1948 		urb_idx, num_urbs);
   1949 
   1950 	if (urb->status == 0) {
   1951 		/* copy isochronous results back in */
   1952 
   1953 		for (i = 0; i < urb->number_of_packets; i++) {
   1954 			struct usbfs_iso_packet_desc *urb_desc = &urb->iso_frame_desc[i];
   1955 			struct libusb_iso_packet_descriptor *lib_desc =
   1956 				&transfer->iso_packet_desc[tpriv->iso_packet_offset++];
   1957 			lib_desc->status = urb_desc->status;
   1958 			lib_desc->actual_length = urb_desc->actual_length;
   1959 		}
   1960 	}
   1961 
   1962 	tpriv->num_retired++;
   1963 
   1964 	if (tpriv->reap_action != NORMAL) { /* cancelled or submit_fail */
   1965 		usbi_dbg("CANCEL: urb status %d", urb->status);
   1966 
   1967 		if (tpriv->num_retired == num_urbs) {
   1968 			usbi_dbg("CANCEL: last URB handled, reporting");
   1969 			free_iso_urbs(tpriv);
   1970 			if (tpriv->reap_action == CANCELLED) {
   1971 				pthread_mutex_unlock(&itransfer->lock);
   1972 				return usbi_handle_transfer_cancellation(itransfer);
   1973 			} else {
   1974 				pthread_mutex_unlock(&itransfer->lock);
   1975 				return usbi_handle_transfer_completion(itransfer,
   1976 					LIBUSB_TRANSFER_ERROR);
   1977 			}
   1978 		}
   1979 		goto out;
   1980 	}
   1981 
   1982 	switch (urb->status) {
   1983 	case 0:
   1984 		break;
   1985 	case -ETIME:
   1986 	case -EPROTO:
   1987 	case -EILSEQ:
   1988 		usbi_dbg("low-level USB error %d", urb->status);
   1989 		break;
   1990 	default:
   1991 		usbi_warn(TRANSFER_CTX(transfer),
   1992 			"unrecognised urb status %d", urb->status);
   1993 		break;
   1994 	}
   1995 
   1996 	/* if we're the last urb or we got less data than requested then we're
   1997 	 * done */
   1998 	if (urb_idx == num_urbs) {
   1999 		usbi_dbg("last URB in transfer --> complete!");
   2000 		free_iso_urbs(tpriv);
   2001 		pthread_mutex_unlock(&itransfer->lock);
   2002 		return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
   2003 	}
   2004 
   2005 out:
   2006 	pthread_mutex_unlock(&itransfer->lock);
   2007 	return 0;
   2008 }
   2009 
   2010 static int handle_control_completion(struct usbi_transfer *itransfer,
   2011 	struct usbfs_urb *urb)
   2012 {
   2013 	struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
   2014 	int status;
   2015 
   2016 	pthread_mutex_lock(&itransfer->lock);
   2017 	usbi_dbg("handling completion status %d", urb->status);
   2018 
   2019 	if (urb->status == 0)
   2020 		itransfer->transferred += urb->actual_length;
   2021 
   2022 	if (tpriv->reap_action == CANCELLED) {
   2023 		if (urb->status != 0 && urb->status != -ENOENT)
   2024 			usbi_warn(ITRANSFER_CTX(itransfer),
   2025 				"cancel: unrecognised urb status %d", urb->status);
   2026 		free(tpriv->urbs);
   2027 		tpriv->urbs = NULL;
   2028 		pthread_mutex_unlock(&itransfer->lock);
   2029 		return usbi_handle_transfer_cancellation(itransfer);
   2030 	}
   2031 
   2032 	switch (urb->status) {
   2033 	case 0:
   2034 		itransfer->transferred = urb->actual_length;
   2035 		status = LIBUSB_TRANSFER_COMPLETED;
   2036 		break;
   2037 	case -EPIPE:
   2038 		usbi_dbg("unsupported control request");
   2039 		status = LIBUSB_TRANSFER_STALL;
   2040 		break;
   2041 	case -ETIME:
   2042 	case -EPROTO:
   2043 	case -EILSEQ:
   2044 		usbi_dbg("low-level bus error occurred");
   2045 		status = LIBUSB_TRANSFER_ERROR;
   2046 		break;
   2047 	default:
   2048 		usbi_warn(ITRANSFER_CTX(itransfer),
   2049 			"unrecognised urb status %d", urb->status);
   2050 		status = LIBUSB_TRANSFER_ERROR;
   2051 		break;
   2052 	}
   2053 
   2054 	free(tpriv->urbs);
   2055 	tpriv->urbs = NULL;
   2056 	pthread_mutex_unlock(&itransfer->lock);
   2057 	return usbi_handle_transfer_completion(itransfer, status);
   2058 }
   2059 
   2060 static int reap_for_handle(struct libusb_device_handle *handle)
   2061 {
   2062 	struct linux_device_handle_priv *hpriv = __device_handle_priv(handle);
   2063 	int r;
   2064 	struct usbfs_urb *urb;
   2065 	struct usbi_transfer *itransfer;
   2066 	struct libusb_transfer *transfer;
   2067 
   2068 	r = ioctl(hpriv->fd, IOCTL_USBFS_REAPURBNDELAY, &urb);
   2069 	if (r == -1 && errno == EAGAIN)
   2070 		return 1;
   2071 	if (r < 0) {
   2072 		if (errno == ENODEV)
   2073 			return LIBUSB_ERROR_NO_DEVICE;
   2074 
   2075 		usbi_err(HANDLE_CTX(handle), "reap failed error %d errno=%d",
   2076 			r, errno);
   2077 		return LIBUSB_ERROR_IO;
   2078 	}
   2079 
   2080 	itransfer = urb->usercontext;
   2081 	transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
   2082 
   2083 	usbi_dbg("urb type=%d status=%d transferred=%d", urb->type, urb->status,
   2084 		urb->actual_length);
   2085 
   2086 	switch (transfer->type) {
   2087 	case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
   2088 		return handle_iso_completion(itransfer, urb);
   2089 	case LIBUSB_TRANSFER_TYPE_BULK:
   2090 	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
   2091 		return handle_bulk_completion(itransfer, urb);
   2092 	case LIBUSB_TRANSFER_TYPE_CONTROL:
   2093 		return handle_control_completion(itransfer, urb);
   2094 	default:
   2095 		usbi_err(HANDLE_CTX(handle), "unrecognised endpoint type %x",
   2096 			transfer->type);
   2097 		return LIBUSB_ERROR_OTHER;
   2098 	}
   2099 }
   2100 
   2101 static int op_handle_events(struct libusb_context *ctx,
   2102 	struct pollfd *fds, nfds_t nfds, int num_ready)
   2103 {
   2104 	int r;
   2105 	int i = 0;
   2106 
   2107 	pthread_mutex_lock(&ctx->open_devs_lock);
   2108 	for (i = 0; i < nfds && num_ready > 0; i++) {
   2109 		struct pollfd *pollfd = &fds[i];
   2110 		struct libusb_device_handle *handle;
   2111 		struct linux_device_handle_priv *hpriv = NULL;
   2112 
   2113 		if (!pollfd->revents)
   2114 			continue;
   2115 
   2116 		num_ready--;
   2117 		list_for_each_entry(handle, &ctx->open_devs, list) {
   2118 			hpriv =  __device_handle_priv(handle);
   2119 			if (hpriv->fd == pollfd->fd)
   2120 				break;
   2121 		}
   2122 
   2123 		if (pollfd->revents & POLLERR) {
   2124 			usbi_remove_pollfd(HANDLE_CTX(handle), hpriv->fd);
   2125 			usbi_handle_disconnect(handle);
   2126 			continue;
   2127 		}
   2128 
   2129 		r = reap_for_handle(handle);
   2130 		if (r == 1 || r == LIBUSB_ERROR_NO_DEVICE)
   2131 			continue;
   2132 		else if (r < 0)
   2133 			goto out;
   2134 	}
   2135 
   2136 	r = 0;
   2137 out:
   2138 	pthread_mutex_unlock(&ctx->open_devs_lock);
   2139 	return r;
   2140 }
   2141 
   2142 static int op_clock_gettime(int clk_id, struct timespec *tp)
   2143 {
   2144 	switch (clk_id) {
   2145 	case USBI_CLOCK_MONOTONIC:
   2146 		return clock_gettime(monotonic_clkid, tp);
   2147 	case USBI_CLOCK_REALTIME:
   2148 		return clock_gettime(CLOCK_REALTIME, tp);
   2149 	default:
   2150 		return LIBUSB_ERROR_INVALID_PARAM;
   2151   }
   2152 }
   2153 
   2154 #ifdef USBI_TIMERFD_AVAILABLE
   2155 static clockid_t op_get_timerfd_clockid(void)
   2156 {
   2157 	return monotonic_clkid;
   2158 
   2159 }
   2160 #endif
   2161 
   2162 const struct usbi_os_backend linux_usbfs_backend = {
   2163 	.name = "Linux usbfs",
   2164 	.init = op_init,
   2165 	.exit = NULL,
   2166 	.get_device_list = op_get_device_list,
   2167 	.get_device_descriptor = op_get_device_descriptor,
   2168 	.get_active_config_descriptor = op_get_active_config_descriptor,
   2169 	.get_config_descriptor = op_get_config_descriptor,
   2170 
   2171 	.open = op_open,
   2172 	.close = op_close,
   2173 	.get_configuration = op_get_configuration,
   2174 	.set_configuration = op_set_configuration,
   2175 	.claim_interface = op_claim_interface,
   2176 	.release_interface = op_release_interface,
   2177 
   2178 	.set_interface_altsetting = op_set_interface,
   2179 	.clear_halt = op_clear_halt,
   2180 	.reset_device = op_reset_device,
   2181 
   2182 	.kernel_driver_active = op_kernel_driver_active,
   2183 	.detach_kernel_driver = op_detach_kernel_driver,
   2184 	.attach_kernel_driver = op_attach_kernel_driver,
   2185 
   2186 	.destroy_device = op_destroy_device,
   2187 
   2188 	.submit_transfer = op_submit_transfer,
   2189 	.cancel_transfer = op_cancel_transfer,
   2190 	.clear_transfer_priv = op_clear_transfer_priv,
   2191 
   2192 	.handle_events = op_handle_events,
   2193 
   2194 	.clock_gettime = op_clock_gettime,
   2195 
   2196 #ifdef USBI_TIMERFD_AVAILABLE
   2197 	.get_timerfd_clockid = op_get_timerfd_clockid,
   2198 #endif
   2199 
   2200 	.device_priv_size = sizeof(struct linux_device_priv),
   2201 	.device_handle_priv_size = sizeof(struct linux_device_handle_priv),
   2202 	.transfer_priv_size = sizeof(struct linux_transfer_priv),
   2203 	.add_iso_packet_size = 0,
   2204 };
   2205 
   2206