libusb/os/linux_usbfs.c

   1 /* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
   2 /*
   3  * Linux usbfs backend for libusb
   4  * Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
   5  * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
   6  * Copyright © 2013 Nathan Hjelm <hjelmn@mac.com>
   7  * Copyright © 2012-2013 Hans de Goede <hdegoede@redhat.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include "config.h"
  25
  26 #include <assert.h>
  27 #include <ctype.h>
  28 #include <dirent.h>
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <poll.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/stat.h>
  37 #include <sys/types.h>
  38 #include <sys/utsname.h>
  39 #include <unistd.h>
  40
  41 #include "libusbi.h"
  42 #include "linux_usbfs.h"
  43
  44 /* sysfs vs usbfs:
  45  * opening a usbfs node causes the device to be resumed, so we attempt to
  46  * avoid this during enumeration.
  47  *
  48  * sysfs allows us to read the kernel's in-memory copies of device descriptors
  49  * and so forth, avoiding the need to open the device:
  50  *  - The binary "descriptors" file contains all config descriptors since
  51  *    2.6.26, commit 217a9081d8e69026186067711131b77f0ce219ed
  52  *  - The binary "descriptors" file was added in 2.6.23, commit
  53  *    69d42a78f935d19384d1f6e4f94b65bb162b36df, but it only contains the
  54  *    active config descriptors
  55  *  - The "busnum" file was added in 2.6.22, commit
  56  *    83f7d958eab2fbc6b159ee92bf1493924e1d0f72
  57  *  - The "devnum" file has been present since pre-2.6.18
  58  *  - the "bConfigurationValue" file has been present since pre-2.6.18
  59  *
  60  * If we have bConfigurationValue, busnum, and devnum, then we can determine
  61  * the active configuration without having to open the usbfs node in RDWR mode.
  62  * The busnum file is important as that is the only way we can relate sysfs
  63  * devices to usbfs nodes.
  64  *
  65  * If we also have all descriptors, we can obtain the device descriptor and
  66  * configuration without touching usbfs at all.
  67  */
  68
  69 /* endianness for multi-byte fields:
  70  *
  71  * Descriptors exposed by usbfs have the multi-byte fields in the device
  72  * descriptor as host endian. Multi-byte fields in the other descriptors are
  73  * bus-endian. The kernel documentation says otherwise, but it is wrong.
  74  *
  75  * In sysfs all descriptors are bus-endian.
  76  */
  77
  78 static const char *usbfs_path = NULL;
  79
  80 /* use usbdev*.* device names in /dev instead of the usbfs bus directories */
  81 static int usbdev_names = 0;
  82
  83 /* Linux 2.6.32 adds support for a bulk continuation URB flag. this basically
  84  * allows us to mark URBs as being part of a specific logical transfer when
  85  * we submit them to the kernel. then, on any error except a cancellation, all
  86  * URBs within that transfer will be cancelled and no more URBs will be
  87  * accepted for the transfer, meaning that no more data can creep in.
  88  *
  89  * The BULK_CONTINUATION flag must be set on all URBs within a bulk transfer
  90  * (in either direction) except the first.
  91  * For IN transfers, we must also set SHORT_NOT_OK on all URBs except the
  92  * last; it means that the kernel should treat a short reply as an error.
  93  * For OUT transfers, SHORT_NOT_OK must not be set. it isn't needed (OUT
  94  * transfers can't be short unless there's already some sort of error), and
  95  * setting this flag is disallowed (a kernel with USB debugging enabled will
  96  * reject such URBs).
  97  */
  98 static int supports_flag_bulk_continuation = -1;
  99
 100 /* Linux 2.6.31 fixes support for the zero length packet URB flag. This
 101  * allows us to mark URBs that should be followed by a zero length data
 102  * packet, which can be required by device- or class-specific protocols.
 103  */
 104 static int supports_flag_zero_packet = -1;
 105
 106 /* clock ID for monotonic clock, as not all clock sources are available on all
 107  * systems. appropriate choice made at initialization time. */
 108 static clockid_t monotonic_clkid = -1;
 109
 110 /* Linux 2.6.22 (commit 83f7d958eab2fbc6b159ee92bf1493924e1d0f72) adds a busnum
 111  * to sysfs, so we can relate devices. This also implies that we can read
 112  * the active configuration through bConfigurationValue */
 113 static int sysfs_can_relate_devices = -1;
 114
 115 /* Linux 2.6.26 (commit 217a9081d8e69026186067711131b77f0ce219ed) adds all
 116  * config descriptors (rather then just the active config) to the sysfs
 117  * descriptors file, so from then on we can use them. */
 118 static int sysfs_has_descriptors = -1;
 119
 120 /* how many times have we initted (and not exited) ? */
 121 static int init_count = 0;
 122
 123 /* Serialize hotplug start/stop */
 124 usbi_mutex_static_t linux_hotplug_startstop_lock = USBI_MUTEX_INITIALIZER;
 125 /* Serialize scan-devices, event-thread, and poll */
 126 usbi_mutex_static_t linux_hotplug_lock = USBI_MUTEX_INITIALIZER;
 127
 128 static int linux_start_event_monitor(void);
 129 static int linux_stop_event_monitor(void);
 130 static int linux_scan_devices(struct libusb_context *ctx);
 131 static int sysfs_scan_device(struct libusb_context *ctx, const char *devname);
 132 static int detach_kernel_driver_and_claim(struct libusb_device_handle *, int);
 133
 134 #if !defined(USE_UDEV)
 135 static int linux_default_scan_devices (struct libusb_context *ctx);
 136 #endif
 137
 138 struct linux_device_priv {
 139         char *sysfs_dir;
 140         unsigned char *descriptors;
 141         int descriptors_len;
 142         int active_config; /* cache val for !sysfs_can_relate_devices  */
 143 };
 144
 145 struct linux_device_handle_priv {
 146         int fd;
 147         uint32_t caps;
 148 };
 149
 150 enum reap_action {
 151         NORMAL = 0,
 152         /* submission failed after the first URB, so await cancellation/completion
 153          * of all the others */
 154         SUBMIT_FAILED,
 155
 156         /* cancelled by user or timeout */
 157         CANCELLED,
 158
 159         /* completed multi-URB transfer in non-final URB */
 160         COMPLETED_EARLY,
 161
 162         /* one or more urbs encountered a low-level error */
 163         ERROR,
 164 };
 165
 166 struct linux_transfer_priv {
 167         union {
 168                 struct usbfs_urb *urbs;
 169                 struct usbfs_urb **iso_urbs;
 170         };
 171
 172         enum reap_action reap_action;
 173         int num_urbs;
 174         int num_retired;
 175         enum libusb_transfer_status reap_status;
 176
 177         /* next iso packet in user-supplied transfer to be populated */
 178         int iso_packet_offset;
 179 };
 180
 181 static int _get_usbfs_fd(struct libusb_device *dev, mode_t mode, int silent)
 182 {
 183         struct libusb_context *ctx = DEVICE_CTX(dev);
 184         char path[PATH_MAX];
 185         int fd;
 186         int delay = 10000;
 187
 188         if (usbdev_names)
 189                 snprintf(path, PATH_MAX, "%s/usbdev%d.%d",
 190                         usbfs_path, dev->bus_number, dev->device_address);
 191         else
 192                 snprintf(path, PATH_MAX, "%s/%03d/%03d",
 193                         usbfs_path, dev->bus_number, dev->device_address);
 194
 195         fd = open(path, mode);
 196         if (fd != -1)
 197                 return fd; /* Success */
 198
 199         if (errno == ENOENT) {
 200                 if (!silent)
 201                         usbi_err(ctx, "File doesn't exist, wait %d ms and try again\n", delay/1000);
 202
 203                 /* Wait 10ms for USB device path creation.*/
 204                 usleep(delay);
 205
 206                 fd = open(path, mode);
 207                 if (fd != -1)
 208                         return fd; /* Success */
 209         }
 210
 211         if (!silent) {
 212                 usbi_err(ctx, "libusb couldn't open USB device %s: %s",
 213                          path, strerror(errno));
 214                 if (errno == EACCES && mode == O_RDWR)
 215                         usbi_err(ctx, "libusb requires write access to USB "
 216                                       "device nodes.");
 217         }
 218
 219         if (errno == EACCES)
 220                 return LIBUSB_ERROR_ACCESS;
 221         if (errno == ENOENT)
 222                 return LIBUSB_ERROR_NO_DEVICE;
 223         return LIBUSB_ERROR_IO;
 224 }
 225
 226 static struct linux_device_priv *_device_priv(struct libusb_device *dev)
 227 {
 228         return (struct linux_device_priv *) dev->os_priv;
 229 }
 230
 231 static struct linux_device_handle_priv *_device_handle_priv(
 232         struct libusb_device_handle *handle)
 233 {
 234         return (struct linux_device_handle_priv *) handle->os_priv;
 235 }
 236
 237 /* check dirent for a /dev/usbdev%d.%d name
 238  * optionally return bus/device on success */
 239 static int _is_usbdev_entry(struct dirent *entry, int *bus_p, int *dev_p)
 240 {
 241         int busnum, devnum;
 242
 243         if (sscanf(entry->d_name, "usbdev%d.%d", &busnum, &devnum) != 2)
 244                 return 0;
 245
 246         usbi_dbg("found: %s", entry->d_name);
 247         if (bus_p != NULL)
 248                 *bus_p = busnum;
 249         if (dev_p != NULL)
 250                 *dev_p = devnum;
 251         return 1;
 252 }
 253
 254 static int check_usb_vfs(const char *dirname)
 255 {
 256         DIR *dir;
 257         struct dirent *entry;
 258         int found = 0;
 259
 260         dir = opendir(dirname);
 261         if (!dir)
 262                 return 0;
 263
 264         while ((entry = readdir(dir)) != NULL) {
 265                 if (entry->d_name[0] == '.')
 266                         continue;
 267
 268                 /* We assume if we find any files that it must be the right place */
 269                 found = 1;
 270                 break;
 271         }
 272
 273         closedir(dir);
 274         return found;
 275 }
 276
 277 static const char *find_usbfs_path(void)
 278 {
 279         const char *path = "/dev/bus/usb";
 280         const char *ret = NULL;
 281
 282         if (check_usb_vfs(path)) {
 283                 ret = path;
 284         } else {
 285                 path = "/proc/bus/usb";
 286                 if (check_usb_vfs(path))
 287                         ret = path;
 288         }
 289
 290         /* look for /dev/usbdev*.* if the normal places fail */
 291         if (ret == NULL) {
 292                 struct dirent *entry;
 293                 DIR *dir;
 294
 295                 path = "/dev";
 296                 dir = opendir(path);
 297                 if (dir != NULL) {
 298                         while ((entry = readdir(dir)) != NULL) {
 299                                 if (_is_usbdev_entry(entry, NULL, NULL)) {
 300                                         /* found one; that's enough */
 301                                         ret = path;
 302                                         usbdev_names = 1;
 303                                         break;
 304                                 }
 305                         }
 306                         closedir(dir);
 307                 }
 308         }
 309
 310         if (ret != NULL)
 311                 usbi_dbg("found usbfs at %s", ret);
 312
 313         return ret;
 314 }
 315
 316 /* the monotonic clock is not usable on all systems (e.g. embedded ones often
 317  * seem to lack it). fall back to REALTIME if we have to. */
 318 static clockid_t find_monotonic_clock(void)
 319 {
 320 #ifdef CLOCK_MONOTONIC
 321         struct timespec ts;
 322         int r;
 323
 324         /* Linux 2.6.28 adds CLOCK_MONOTONIC_RAW but we don't use it
 325          * because it's not available through timerfd */
 326         r = clock_gettime(CLOCK_MONOTONIC, &ts);
 327         if (r == 0)
 328                 return CLOCK_MONOTONIC;
 329         usbi_dbg("monotonic clock doesn't work, errno %d", errno);
 330 #endif
 331
 332         return CLOCK_REALTIME;
 333 }
 334
 335 static int kernel_version_ge(int major, int minor, int sublevel)
 336 {
 337         struct utsname uts;
 338         int atoms, kmajor, kminor, ksublevel;
 339
 340         if (uname(&uts) < 0)
 341                 return -1;
 342         atoms = sscanf(uts.release, "%d.%d.%d", &kmajor, &kminor, &ksublevel);
 343         if (atoms < 1)
 344                 return -1;
 345
 346         if (kmajor > major)
 347                 return 1;
 348         if (kmajor < major)
 349                 return 0;
 350
 351         /* kmajor == major */
 352         if (atoms < 2)
 353                 return 0 == minor && 0 == sublevel;
 354         if (kminor > minor)
 355                 return 1;
 356         if (kminor < minor)
 357                 return 0;
 358
 359         /* kminor == minor */
 360         if (atoms < 3)
 361                 return 0 == sublevel;
 362
 363         return ksublevel >= sublevel;
 364 }
 365
 366 static int op_init(struct libusb_context *ctx)
 367 {
 368         struct stat statbuf;
 369         int r;
 370
 371         usbfs_path = find_usbfs_path();
 372         if (!usbfs_path) {
 373                 usbi_err(ctx, "could not find usbfs");
 374                 return LIBUSB_ERROR_OTHER;
 375         }
 376
 377         if (monotonic_clkid == -1)
 378                 monotonic_clkid = find_monotonic_clock();
 379
 380         if (supports_flag_bulk_continuation == -1) {
 381                 /* bulk continuation URB flag available from Linux 2.6.32 */
 382                 supports_flag_bulk_continuation = kernel_version_ge(2,6,32);
 383                 if (supports_flag_bulk_continuation == -1) {
 384                         usbi_err(ctx, "error checking for bulk continuation support");
 385                         return LIBUSB_ERROR_OTHER;
 386                 }
 387         }
 388
 389         if (supports_flag_bulk_continuation)
 390                 usbi_dbg("bulk continuation flag supported");
 391
 392         if (-1 == supports_flag_zero_packet) {
 393                 /* zero length packet URB flag fixed since Linux 2.6.31 */
 394                 supports_flag_zero_packet = kernel_version_ge(2,6,31);
 395                 if (-1 == supports_flag_zero_packet) {
 396                         usbi_err(ctx, "error checking for zero length packet support");
 397                         return LIBUSB_ERROR_OTHER;
 398                 }
 399         }
 400
 401         if (supports_flag_zero_packet)
 402                 usbi_dbg("zero length packet flag supported");
 403
 404         if (-1 == sysfs_has_descriptors) {
 405                 /* sysfs descriptors has all descriptors since Linux 2.6.26 */
 406                 sysfs_has_descriptors = kernel_version_ge(2,6,26);
 407                 if (-1 == sysfs_has_descriptors) {
 408                         usbi_err(ctx, "error checking for sysfs descriptors");
 409                         return LIBUSB_ERROR_OTHER;
 410                 }
 411         }
 412
 413         if (-1 == sysfs_can_relate_devices) {
 414                 /* sysfs has busnum since Linux 2.6.22 */
 415                 sysfs_can_relate_devices = kernel_version_ge(2,6,22);
 416                 if (-1 == sysfs_can_relate_devices) {
 417                         usbi_err(ctx, "error checking for sysfs busnum");
 418                         return LIBUSB_ERROR_OTHER;
 419                 }
 420         }
 421
 422         if (sysfs_can_relate_devices || sysfs_has_descriptors) {
 423                 r = stat(SYSFS_DEVICE_PATH, &statbuf);
 424                 if (r != 0 || !S_ISDIR(statbuf.st_mode)) {
 425                         usbi_warn(ctx, "sysfs not mounted");
 426                         sysfs_can_relate_devices = 0;
 427                         sysfs_has_descriptors = 0;
 428                 }
 429         }
 430
 431         if (sysfs_can_relate_devices)
 432                 usbi_dbg("sysfs can relate devices");
 433
 434         if (sysfs_has_descriptors)
 435                 usbi_dbg("sysfs has complete descriptors");
 436
 437         usbi_mutex_static_lock(&linux_hotplug_startstop_lock);
 438         r = LIBUSB_SUCCESS;
 439         if (init_count == 0) {
 440                 /* start up hotplug event handler */
 441                 r = linux_start_event_monitor();
 442         }
 443         if (r == LIBUSB_SUCCESS) {
 444                 r = linux_scan_devices(ctx);
 445                 if (r == LIBUSB_SUCCESS)
 446                         init_count++;
 447                 else if (init_count == 0)
 448                         linux_stop_event_monitor();
 449         } else
 450                 usbi_err(ctx, "error starting hotplug event monitor");
 451         usbi_mutex_static_unlock(&linux_hotplug_startstop_lock);
 452
 453         return r;
 454 }
 455
 456 static void op_exit(void)
 457 {
 458         usbi_mutex_static_lock(&linux_hotplug_startstop_lock);
 459         assert(init_count != 0);
 460         if (!--init_count) {
 461                 /* tear down event handler */
 462                 (void)linux_stop_event_monitor();
 463         }
 464         usbi_mutex_static_unlock(&linux_hotplug_startstop_lock);
 465 }
 466
 467 static int linux_start_event_monitor(void)
 468 {
 469 #if defined(USE_UDEV)
 470         return linux_udev_start_event_monitor();
 471 #else
 472         return linux_netlink_start_event_monitor();
 473 #endif
 474 }
 475
 476 static int linux_stop_event_monitor(void)
 477 {
 478 #if defined(USE_UDEV)
 479         return linux_udev_stop_event_monitor();
 480 #else
 481         return linux_netlink_stop_event_monitor();
 482 #endif
 483 }
 484
 485 static int linux_scan_devices(struct libusb_context *ctx)
 486 {
 487         int ret;
 488
 489         usbi_mutex_static_lock(&linux_hotplug_lock);
 490
 491 #if defined(USE_UDEV)
 492         ret = linux_udev_scan_devices(ctx);
 493 #else
 494         ret = linux_default_scan_devices(ctx);
 495 #endif
 496
 497         usbi_mutex_static_unlock(&linux_hotplug_lock);
 498
 499         return ret;
 500 }
 501
 502 static void op_hotplug_poll(void)
 503 {
 504 #if defined(USE_UDEV)
 505         linux_udev_hotplug_poll();
 506 #else
 507         linux_netlink_hotplug_poll();
 508 #endif
 509 }
 510
 511 static int _open_sysfs_attr(struct libusb_device *dev, const char *attr)
 512 {
 513         struct linux_device_priv *priv = _device_priv(dev);
 514         char filename[PATH_MAX];
 515         int fd;
 516
 517         snprintf(filename, PATH_MAX, "%s/%s/%s",
 518                 SYSFS_DEVICE_PATH, priv->sysfs_dir, attr);
 519         fd = open(filename, O_RDONLY);
 520         if (fd < 0) {
 521                 usbi_err(DEVICE_CTX(dev),
 522                         "open %s failed ret=%d errno=%d", filename, fd, errno);
 523                 return LIBUSB_ERROR_IO;
 524         }
 525
 526         return fd;
 527 }
 528
 529 /* Note only suitable for attributes which always read >= 0, < 0 is error */
 530 static int __read_sysfs_attr(struct libusb_context *ctx,
 531         const char *devname, const char *attr)
 532 {
 533         char filename[PATH_MAX];
 534         FILE *f;
 535         int r, value;
 536
 537         snprintf(filename, PATH_MAX, "%s/%s/%s", SYSFS_DEVICE_PATH,
 538                  devname, attr);
 539         f = fopen(filename, "r");
 540         if (f == NULL) {
 541                 if (errno == ENOENT) {
 542                         /* File doesn't exist. Assume the device has been
 543                            disconnected (see trac ticket #70). */
 544                         return LIBUSB_ERROR_NO_DEVICE;
 545                 }
 546                 usbi_err(ctx, "open %s failed errno=%d", filename, errno);
 547                 return LIBUSB_ERROR_IO;
 548         }
 549
 550         r = fscanf(f, "%d", &value);
 551         fclose(f);
 552         if (r != 1) {
 553                 usbi_err(ctx, "fscanf %s returned %d, errno=%d", attr, r, errno);
 554                 return LIBUSB_ERROR_NO_DEVICE; /* For unplug race (trac #70) */
 555         }
 556         if (value < 0) {
 557                 usbi_err(ctx, "%s contains a negative value", filename);
 558                 return LIBUSB_ERROR_IO;
 559         }
 560
 561         return value;
 562 }
 563
 564 static int op_get_device_descriptor(struct libusb_device *dev,
 565         unsigned char *buffer, int *host_endian)
 566 {
 567         struct linux_device_priv *priv = _device_priv(dev);
 568
 569         *host_endian = sysfs_has_descriptors ? 0 : 1;
 570         memcpy(buffer, priv->descriptors, DEVICE_DESC_LENGTH);
 571
 572         return 0;
 573 }
 574
 575 /* read the bConfigurationValue for a device */
 576 static int sysfs_get_active_config(struct libusb_device *dev, int *config)
 577 {
 578         char *endptr;
 579         char tmp[5] = {0, 0, 0, 0, 0};
 580         long num;
 581         int fd;
 582         ssize_t r;
 583
 584         fd = _open_sysfs_attr(dev, "bConfigurationValue");
 585         if (fd < 0)
 586                 return fd;
 587
 588         r = read(fd, tmp, sizeof(tmp));
 589         close(fd);
 590         if (r < 0) {
 591                 usbi_err(DEVICE_CTX(dev),
 592                         "read bConfigurationValue failed ret=%d errno=%d", r, errno);
 593                 return LIBUSB_ERROR_IO;
 594         } else if (r == 0) {
 595                 usbi_dbg("device unconfigured");
 596                 *config = -1;
 597                 return 0;
 598         }
 599
 600         if (tmp[sizeof(tmp) - 1] != 0) {
 601                 usbi_err(DEVICE_CTX(dev), "not null-terminated?");
 602                 return LIBUSB_ERROR_IO;
 603         } else if (tmp[0] == 0) {
 604                 usbi_err(DEVICE_CTX(dev), "no configuration value?");
 605                 return LIBUSB_ERROR_IO;
 606         }
 607
 608         num = strtol(tmp, &endptr, 10);
 609         if (endptr == tmp) {
 610                 usbi_err(DEVICE_CTX(dev), "error converting '%s' to integer", tmp);
 611                 return LIBUSB_ERROR_IO;
 612         }
 613
 614         *config = (int) num;
 615         return 0;
 616 }
 617
 618 int linux_get_device_address (struct libusb_context *ctx, int detached,
 619         uint8_t *busnum, uint8_t *devaddr,const char *dev_node,
 620         const char *sys_name)
 621 {
 622         int sysfs_attr;
 623
 624         usbi_dbg("getting address for device: %s detached: %d", sys_name, detached);
 625         /* can't use sysfs to read the bus and device number if the
 626          * device has been detached */
 627         if (!sysfs_can_relate_devices || detached || NULL == sys_name) {
 628                 if (NULL == dev_node) {
 629                         return LIBUSB_ERROR_OTHER;
 630                 }
 631
 632                 /* will this work with all supported kernel versions? */
 633                 if (!strncmp(dev_node, "/dev/bus/usb", 12)) {
 634                         sscanf (dev_node, "/dev/bus/usb/%hhu/%hhu", busnum, devaddr);
 635                 } else if (!strncmp(dev_node, "/proc/bus/usb", 13)) {
 636                         sscanf (dev_node, "/proc/bus/usb/%hhu/%hhu", busnum, devaddr);
 637                 }
 638
 639                 return LIBUSB_SUCCESS;
 640         }
 641
 642         usbi_dbg("scan %s", sys_name);
 643
 644         sysfs_attr = __read_sysfs_attr(ctx, sys_name, "busnum");
 645         if (0 > sysfs_attr)
 646                 return sysfs_attr;
 647         if (sysfs_attr > 255)
 648                 return LIBUSB_ERROR_INVALID_PARAM;
 649         *busnum = (uint8_t) sysfs_attr;
 650
 651         sysfs_attr = __read_sysfs_attr(ctx, sys_name, "devnum");
 652         if (0 > sysfs_attr)
 653                 return sysfs_attr;
 654         if (sysfs_attr > 255)
 655                 return LIBUSB_ERROR_INVALID_PARAM;
 656
 657         *devaddr = (uint8_t) sysfs_attr;
 658
 659         usbi_dbg("bus=%d dev=%d", *busnum, *devaddr);
 660
 661         return LIBUSB_SUCCESS;
 662 }
 663
 664 /* Return offset of the next descriptor with the given type */
 665 static int seek_to_next_descriptor(struct libusb_context *ctx,
 666         uint8_t descriptor_type, unsigned char *buffer, int size)
 667 {
 668         struct usb_descriptor_header header;
 669         int i;
 670
 671         for (i = 0; size >= 0; i += header.bLength, size -= header.bLength) {
 672                 if (size == 0)
 673                         return LIBUSB_ERROR_NOT_FOUND;
 674
 675                 if (size < 2) {
 676                         usbi_err(ctx, "short descriptor read %d/2", size);
 677                         return LIBUSB_ERROR_IO;
 678                 }
 679                 usbi_parse_descriptor(buffer + i, "bb", &header, 0);
 680
 681                 if (i && header.bDescriptorType == descriptor_type)
 682                         return i;
 683         }
 684         usbi_err(ctx, "bLength overflow by %d bytes", -size);
 685         return LIBUSB_ERROR_IO;
 686 }
 687
 688 /* Return offset to next config */
 689 static int seek_to_next_config(struct libusb_context *ctx,
 690         unsigned char *buffer, int size)
 691 {
 692         struct libusb_config_descriptor config;
 693
 694         if (size == 0)
 695                 return LIBUSB_ERROR_NOT_FOUND;
 696
 697         if (size < LIBUSB_DT_CONFIG_SIZE) {
 698                 usbi_err(ctx, "short descriptor read %d/%d",
 699                          size, LIBUSB_DT_CONFIG_SIZE);
 700                 return LIBUSB_ERROR_IO;
 701         }
 702
 703         usbi_parse_descriptor(buffer, "bbwbbbbb", &config, 0);
 704         if (config.bDescriptorType != LIBUSB_DT_CONFIG) {
 705                 usbi_err(ctx, "descriptor is not a config desc (type 0x%02x)",
 706                          config.bDescriptorType);
 707                 return LIBUSB_ERROR_IO;
 708         }
 709
 710         /*
 711          * In usbfs the config descriptors are config.wTotalLength bytes apart,
 712          * with any short reads from the device appearing as holes in the file.
 713          *
 714          * In sysfs wTotalLength is ignored, instead the kernel returns a
 715          * config descriptor with verified bLength fields, with descriptors
 716          * with an invalid bLength removed.
 717          */
 718         if (sysfs_has_descriptors) {
 719                 int next = seek_to_next_descriptor(ctx, LIBUSB_DT_CONFIG,
 720                                                    buffer, size);
 721                 if (next == LIBUSB_ERROR_NOT_FOUND)
 722                         next = size;
 723                 if (next < 0)
 724                         return next;
 725
 726                 if (next != config.wTotalLength)
 727                         usbi_warn(ctx, "config length mismatch wTotalLength "
 728                                   "%d real %d", config.wTotalLength, next);
 729                 return next;
 730         } else {
 731                 if (config.wTotalLength < LIBUSB_DT_CONFIG_SIZE) {
 732                         usbi_err(ctx, "invalid wTotalLength %d",
 733                                  config.wTotalLength);
 734                         return LIBUSB_ERROR_IO;
 735                 } else if (config.wTotalLength > size) {
 736                         usbi_warn(ctx, "short descriptor read %d/%d",
 737                                   size, config.wTotalLength);
 738                         return size;
 739                 } else
 740                         return config.wTotalLength;
 741         }
 742 }
 743
 744 static int op_get_config_descriptor_by_value(struct libusb_device *dev,
 745         uint8_t value, unsigned char **buffer, int *host_endian)
 746 {
 747         struct libusb_context *ctx = DEVICE_CTX(dev);
 748         struct linux_device_priv *priv = _device_priv(dev);
 749         unsigned char *descriptors = priv->descriptors;
 750         int size = priv->descriptors_len;
 751         struct libusb_config_descriptor *config;
 752
 753         *buffer = NULL;
 754         /* Unlike the device desc. config descs. are always in raw format */
 755         *host_endian = 0;
 756
 757         /* Skip device header */
 758         descriptors += DEVICE_DESC_LENGTH;
 759         size -= DEVICE_DESC_LENGTH;
 760
 761         /* Seek till the config is found, or till "EOF" */
 762         while (1) {
 763                 int next = seek_to_next_config(ctx, descriptors, size);
 764                 if (next < 0)
 765                         return next;
 766                 config = (struct libusb_config_descriptor *)descriptors;
 767                 if (config->bConfigurationValue == value) {
 768                         *buffer = descriptors;
 769                         return next;
 770                 }
 771                 size -= next;
 772                 descriptors += next;
 773         }
 774 }
 775
 776 static int op_get_active_config_descriptor(struct libusb_device *dev,
 777         unsigned char *buffer, size_t len, int *host_endian)
 778 {
 779         int r, config;
 780         unsigned char *config_desc;
 781
 782         if (sysfs_can_relate_devices) {
 783                 r = sysfs_get_active_config(dev, &config);
 784                 if (r < 0)
 785                         return r;
 786         } else {
 787                 /* Use cached bConfigurationValue */
 788                 struct linux_device_priv *priv = _device_priv(dev);
 789                 config = priv->active_config;
 790         }
 791         if (config == -1)
 792                 return LIBUSB_ERROR_NOT_FOUND;
 793
 794         r = op_get_config_descriptor_by_value(dev, config, &config_desc,
 795                                               host_endian);
 796         if (r < 0)
 797                 return r;
 798
 799         len = MIN(len, r);
 800         memcpy(buffer, config_desc, len);
 801         return len;
 802 }
 803
 804 static int op_get_config_descriptor(struct libusb_device *dev,
 805         uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
 806 {
 807         struct linux_device_priv *priv = _device_priv(dev);
 808         unsigned char *descriptors = priv->descriptors;
 809         int i, r, size = priv->descriptors_len;
 810
 811         /* Unlike the device desc. config descs. are always in raw format */
 812         *host_endian = 0;
 813
 814         /* Skip device header */
 815         descriptors += DEVICE_DESC_LENGTH;
 816         size -= DEVICE_DESC_LENGTH;
 817
 818         /* Seek till the config is found, or till "EOF" */
 819         for (i = 0; ; i++) {
 820                 r = seek_to_next_config(DEVICE_CTX(dev), descriptors, size);
 821                 if (r < 0)
 822                         return r;
 823                 if (i == config_index)
 824                         break;
 825                 size -= r;
 826                 descriptors += r;
 827         }
 828
 829         len = MIN(len, r);
 830         memcpy(buffer, descriptors, len);
 831         return len;
 832 }
 833
 834 /* send a control message to retrieve active configuration */
 835 static int usbfs_get_active_config(struct libusb_device *dev, int fd)
 836 {
 837         unsigned char active_config = 0;
 838         int r;
 839
 840         struct usbfs_ctrltransfer ctrl = {
 841                 .bmRequestType = LIBUSB_ENDPOINT_IN,
 842                 .bRequest = LIBUSB_REQUEST_GET_CONFIGURATION,
 843                 .wValue = 0,
 844                 .wIndex = 0,
 845                 .wLength = 1,
 846                 .timeout = 1000,
 847                 .data = &active_config
 848         };
 849
 850         r = ioctl(fd, IOCTL_USBFS_CONTROL, &ctrl);
 851         if (r < 0) {
 852                 if (errno == ENODEV)
 853                         return LIBUSB_ERROR_NO_DEVICE;
 854
 855                 /* we hit this error path frequently with buggy devices :( */
 856                 usbi_warn(DEVICE_CTX(dev),
 857                         "get_configuration failed ret=%d errno=%d", r, errno);
 858                 return LIBUSB_ERROR_IO;
 859         }
 860
 861         return active_config;
 862 }
 863
 864 static int initialize_device(struct libusb_device *dev, uint8_t busnum,
 865         uint8_t devaddr, const char *sysfs_dir)
 866 {
 867         struct linux_device_priv *priv = _device_priv(dev);
 868         struct libusb_context *ctx = DEVICE_CTX(dev);
 869         int descriptors_size = 512; /* Begin with a 1024 byte alloc */
 870         int fd, speed;
 871         ssize_t r;
 872
 873         dev->bus_number = busnum;
 874         dev->device_address = devaddr;
 875
 876         if (sysfs_dir) {
 877                 priv->sysfs_dir = malloc(strlen(sysfs_dir) + 1);
 878                 if (!priv->sysfs_dir)
 879                         return LIBUSB_ERROR_NO_MEM;
 880                 strcpy(priv->sysfs_dir, sysfs_dir);
 881
 882                 /* Note speed can contain 1.5, in this case __read_sysfs_attr
 883                    will stop parsing at the '.' and return 1 */
 884                 speed = __read_sysfs_attr(DEVICE_CTX(dev), sysfs_dir, "speed");
 885                 if (speed >= 0) {
 886                         switch (speed) {
 887                         case     1: dev->speed = LIBUSB_SPEED_LOW; break;
 888                         case    12: dev->speed = LIBUSB_SPEED_FULL; break;
 889                         case   480: dev->speed = LIBUSB_SPEED_HIGH; break;
 890                         case  5000: dev->speed = LIBUSB_SPEED_SUPER; break;
 891                         default:
 892                                 usbi_warn(DEVICE_CTX(dev), "Unknown device speed: %d Mbps", speed);
 893                         }
 894                 }
 895         }
 896
 897         /* cache descriptors in memory */
 898         if (sysfs_has_descriptors)
 899                 fd = _open_sysfs_attr(dev, "descriptors");
 900         else
 901                 fd = _get_usbfs_fd(dev, O_RDONLY, 0);
 902         if (fd < 0)
 903                 return fd;
 904
 905         do {
 906                 descriptors_size *= 2;
 907                 priv->descriptors = usbi_reallocf(priv->descriptors,
 908                                                   descriptors_size);
 909                 if (!priv->descriptors) {
 910                         close(fd);
 911                         return LIBUSB_ERROR_NO_MEM;
 912                 }
 913                 /* usbfs has holes in the file */
 914                 if (!sysfs_has_descriptors) {
 915                         memset(priv->descriptors + priv->descriptors_len,
 916                                0, descriptors_size - priv->descriptors_len);
 917                 }
 918                 r = read(fd, priv->descriptors + priv->descriptors_len,
 919                          descriptors_size - priv->descriptors_len);
 920                 if (r < 0) {
 921                         usbi_err(ctx, "read descriptor failed ret=%d errno=%d",
 922                                  fd, errno);
 923                         close(fd);
 924                         return LIBUSB_ERROR_IO;
 925                 }
 926                 priv->descriptors_len += r;
 927         } while (priv->descriptors_len == descriptors_size);
 928
 929         close(fd);
 930
 931         if (priv->descriptors_len < DEVICE_DESC_LENGTH) {
 932                 usbi_err(ctx, "short descriptor read (%d)",
 933                          priv->descriptors_len);
 934                 return LIBUSB_ERROR_IO;
 935         }
 936
 937         if (sysfs_can_relate_devices)
 938                 return LIBUSB_SUCCESS;
 939
 940         /* cache active config */
 941         fd = _get_usbfs_fd(dev, O_RDWR, 1);
 942         if (fd < 0) {
 943                 /* cannot send a control message to determine the active
 944                  * config. just assume the first one is active. */
 945                 usbi_warn(ctx, "Missing rw usbfs access; cannot determine "
 946                                "active configuration descriptor");
 947                 if (priv->descriptors_len >=
 948                                 (DEVICE_DESC_LENGTH + LIBUSB_DT_CONFIG_SIZE)) {
 949                         struct libusb_config_descriptor config;
 950                         usbi_parse_descriptor(
 951                                 priv->descriptors + DEVICE_DESC_LENGTH,
 952                                 "bbwbbbbb", &config, 0);
 953                         priv->active_config = config.bConfigurationValue;
 954                 } else
 955                         priv->active_config = -1; /* No config dt */
 956
 957                 return LIBUSB_SUCCESS;
 958         }
 959
 960         r = usbfs_get_active_config(dev, fd);
 961         if (r > 0) {
 962                 priv->active_config = r;
 963                 r = LIBUSB_SUCCESS;
 964         } else if (r == 0) {
 965                 /* some buggy devices have a configuration 0, but we're
 966                  * reaching into the corner of a corner case here, so let's
 967                  * not support buggy devices in these circumstances.
 968                  * stick to the specs: a configuration value of 0 means
 969                  * unconfigured. */
 970                 usbi_dbg("active cfg 0? assuming unconfigured device");
 971                 priv->active_config = -1;
 972                 r = LIBUSB_SUCCESS;
 973         } else if (r == LIBUSB_ERROR_IO) {
 974                 /* buggy devices sometimes fail to report their active config.
 975                  * assume unconfigured and continue the probing */
 976                 usbi_warn(ctx, "couldn't query active configuration, assuming"
 977                                " unconfigured");
 978                 priv->active_config = -1;
 979                 r = LIBUSB_SUCCESS;
 980         } /* else r < 0, just return the error code */
 981
 982         close(fd);
 983         return r;
 984 }
 985
 986 static int linux_get_parent_info(struct libusb_device *dev, const char *sysfs_dir)
 987 {
 988         struct libusb_context *ctx = DEVICE_CTX(dev);
 989         struct libusb_device *it;
 990         char *parent_sysfs_dir, *tmp;
 991         int ret, add_parent = 1;
 992
 993         /* XXX -- can we figure out the topology when using usbfs? */
 994         if (NULL == sysfs_dir || 0 == strncmp(sysfs_dir, "usb", 3)) {
 995                 /* either using usbfs or finding the parent of a root hub */
 996                 return LIBUSB_SUCCESS;
 997         }
 998
 999         parent_sysfs_dir = strdup(sysfs_dir);
1000         if (NULL != (tmp = strrchr(parent_sysfs_dir, '.')) ||
1001             NULL != (tmp = strrchr(parent_sysfs_dir, '-'))) {
1002                 dev->port_number = atoi(tmp + 1);
1003                 *tmp = '\0';
1004         } else {
1005                 usbi_warn(ctx, "Can not parse sysfs_dir: %s, no parent info",
1006                           parent_sysfs_dir);
1007                 free (parent_sysfs_dir);
1008                 return LIBUSB_SUCCESS;
1009         }
1010
1011         /* is the parent a root hub? */
1012         if (NULL == strchr(parent_sysfs_dir, '-')) {
1013                 tmp = parent_sysfs_dir;
1014                 ret = asprintf (&parent_sysfs_dir, "usb%s", tmp);
1015                 free (tmp);
1016                 if (0 > ret) {
1017                         return LIBUSB_ERROR_NO_MEM;
1018                 }
1019         }
1020
1021 retry:
1022         /* find the parent in the context */
1023         usbi_mutex_lock(&ctx->usb_devs_lock);
1024         list_for_each_entry(it, &ctx->usb_devs, list, struct libusb_device) {
1025                 struct linux_device_priv *priv = _device_priv(it);
1026                 if (0 == strcmp (priv->sysfs_dir, parent_sysfs_dir)) {
1027                         dev->parent_dev = libusb_ref_device(it);
1028                         break;
1029                 }
1030         }
1031         usbi_mutex_unlock(&ctx->usb_devs_lock);
1032
1033         if (!dev->parent_dev && add_parent) {
1034                 usbi_dbg("parent_dev %s not enumerated yet, enumerating now",
1035                          parent_sysfs_dir);
1036                 sysfs_scan_device(ctx, parent_sysfs_dir);
1037                 add_parent = 0;
1038                 goto retry;
1039         }
1040
1041         usbi_dbg("Dev %p (%s) has parent %p (%s) port %d", dev, sysfs_dir,
1042                  dev->parent_dev, parent_sysfs_dir, dev->port_number);
1043
1044         free (parent_sysfs_dir);
1045
1046         return LIBUSB_SUCCESS;
1047 }
1048
1049 int linux_enumerate_device(struct libusb_context *ctx,
1050         uint8_t busnum, uint8_t devaddr, const char *sysfs_dir)
1051 {
1052         unsigned long session_id;
1053         struct libusb_device *dev;
1054         int r = 0;
1055
1056         /* FIXME: session ID is not guaranteed unique as addresses can wrap and
1057          * will be reused. instead we should add a simple sysfs attribute with
1058          * a session ID. */
1059         session_id = busnum << 8 | devaddr;
1060         usbi_dbg("busnum %d devaddr %d session_id %ld", busnum, devaddr,
1061                 session_id);
1062
1063         dev = usbi_get_device_by_session_id(ctx, session_id);
1064         if (dev) {
1065                 /* device already exists in the context */
1066                 usbi_dbg("session_id %ld already exists", session_id);
1067                 libusb_unref_device(dev);
1068                 return LIBUSB_SUCCESS;
1069         }
1070
1071         usbi_dbg("allocating new device for %d/%d (session %ld)",
1072                  busnum, devaddr, session_id);
1073         dev = usbi_alloc_device(ctx, session_id);
1074         if (!dev)
1075                 return LIBUSB_ERROR_NO_MEM;
1076
1077         r = initialize_device(dev, busnum, devaddr, sysfs_dir);
1078         if (r < 0)
1079                 goto out;
1080         r = usbi_sanitize_device(dev);
1081         if (r < 0)
1082                 goto out;
1083
1084         r = linux_get_parent_info(dev, sysfs_dir);
1085         if (r < 0)
1086                 goto out;
1087 out:
1088         if (r < 0)
1089                 libusb_unref_device(dev);
1090         else
1091                 usbi_connect_device(dev);
1092
1093         return r;
1094 }
1095
1096 void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name)
1097 {
1098         struct libusb_context *ctx;
1099
1100         usbi_mutex_static_lock(&active_contexts_lock);
1101         list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
1102                 linux_enumerate_device(ctx, busnum, devaddr, sys_name);
1103         }
1104         usbi_mutex_static_unlock(&active_contexts_lock);
1105 }
1106
1107 void linux_device_disconnected(uint8_t busnum, uint8_t devaddr, const char *sys_name)
1108 {
1109         struct libusb_context *ctx;
1110         struct libusb_device *dev;
1111         unsigned long session_id = busnum << 8 | devaddr;
1112
1113         usbi_mutex_static_lock(&active_contexts_lock);
1114         list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
1115                 dev = usbi_get_device_by_session_id (ctx, session_id);
1116                 if (NULL != dev) {
1117                         usbi_disconnect_device (dev);
1118                         libusb_unref_device(dev);
1119                 } else {
1120                         usbi_dbg("device not found for session %x", session_id);
1121                 }
1122         }
1123         usbi_mutex_static_unlock(&active_contexts_lock);
1124 }
1125
1126 #if !defined(USE_UDEV)
1127 /* open a bus directory and adds all discovered devices to the context */
1128 static int usbfs_scan_busdir(struct libusb_context *ctx, uint8_t busnum)
1129 {
1130         DIR *dir;
1131         char dirpath[PATH_MAX];
1132         struct dirent *entry;
1133         int r = LIBUSB_ERROR_IO;
1134
1135         snprintf(dirpath, PATH_MAX, "%s/%03d", usbfs_path, busnum);
1136         usbi_dbg("%s", dirpath);
1137         dir = opendir(dirpath);
1138         if (!dir) {
1139                 usbi_err(ctx, "opendir '%s' failed, errno=%d", dirpath, errno);
1140                 /* FIXME: should handle valid race conditions like hub unplugged
1141                  * during directory iteration - this is not an error */
1142                 return r;
1143         }
1144
1145         while ((entry = readdir(dir))) {
1146                 int devaddr;
1147
1148                 if (entry->d_name[0] == '.')
1149                         continue;
1150
1151                 devaddr = atoi(entry->d_name);
1152                 if (devaddr == 0) {
1153                         usbi_dbg("unknown dir entry %s", entry->d_name);
1154                         continue;
1155                 }
1156
1157                 if (linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL)) {
1158                         usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1159                         continue;
1160                 }
1161
1162                 r = 0;
1163         }
1164
1165         closedir(dir);
1166         return r;
1167 }
1168
1169 static int usbfs_get_device_list(struct libusb_context *ctx)
1170 {
1171         struct dirent *entry;
1172         DIR *buses = opendir(usbfs_path);
1173         int r = 0;
1174
1175         if (!buses) {
1176                 usbi_err(ctx, "opendir buses failed errno=%d", errno);
1177                 return LIBUSB_ERROR_IO;
1178         }
1179
1180         while ((entry = readdir(buses))) {
1181                 int busnum;
1182
1183                 if (entry->d_name[0] == '.')
1184                         continue;
1185
1186                 if (usbdev_names) {
1187                         int devaddr;
1188                         if (!_is_usbdev_entry(entry, &busnum, &devaddr))
1189                                 continue;
1190
1191                         r = linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL);
1192                         if (r < 0) {
1193                                 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1194                                 continue;
1195                         }
1196                 } else {
1197                         busnum = atoi(entry->d_name);
1198                         if (busnum == 0) {
1199                                 usbi_dbg("unknown dir entry %s", entry->d_name);
1200                                 continue;
1201                         }
1202
1203                         r = usbfs_scan_busdir(ctx, busnum);
1204                         if (r < 0)
1205                                 break;
1206                 }
1207         }
1208
1209         closedir(buses);
1210         return r;
1211
1212 }
1213 #endif
1214
1215 static int sysfs_scan_device(struct libusb_context *ctx, const char *devname)
1216 {
1217         uint8_t busnum, devaddr;
1218         int ret;
1219
1220         ret = linux_get_device_address (ctx, 0, &busnum, &devaddr, NULL, devname);
1221         if (LIBUSB_SUCCESS != ret) {
1222                 return ret;
1223         }
1224
1225         return linux_enumerate_device(ctx, busnum & 0xff, devaddr & 0xff,
1226                 devname);
1227 }
1228
1229 #if !defined(USE_UDEV)
1230 static int sysfs_get_device_list(struct libusb_context *ctx)
1231 {
1232         DIR *devices = opendir(SYSFS_DEVICE_PATH);
1233         struct dirent *entry;
1234         int r = LIBUSB_ERROR_IO;
1235
1236         if (!devices) {
1237                 usbi_err(ctx, "opendir devices failed errno=%d", errno);
1238                 return r;
1239         }
1240
1241         while ((entry = readdir(devices))) {
1242                 if ((!isdigit(entry->d_name[0]) && strncmp(entry->d_name, "usb", 3))
1243                                 || strchr(entry->d_name, ':'))
1244                         continue;
1245
1246                 if (sysfs_scan_device(ctx, entry->d_name)) {
1247                         usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1248                         continue;
1249                 }
1250
1251                 r = 0;
1252         }
1253
1254         closedir(devices);
1255         return r;
1256 }
1257
1258 static int linux_default_scan_devices (struct libusb_context *ctx)
1259 {
1260         /* we can retrieve device list and descriptors from sysfs or usbfs.
1261          * sysfs is preferable, because if we use usbfs we end up resuming
1262          * any autosuspended USB devices. however, sysfs is not available
1263          * everywhere, so we need a usbfs fallback too.
1264          *
1265          * as described in the "sysfs vs usbfs" comment at the top of this
1266          * file, sometimes we have sysfs but not enough information to
1267          * relate sysfs devices to usbfs nodes.  op_init() determines the
1268          * adequacy of sysfs and sets sysfs_can_relate_devices.
1269          */
1270         if (sysfs_can_relate_devices != 0)
1271                 return sysfs_get_device_list(ctx);
1272         else
1273                 return usbfs_get_device_list(ctx);
1274 }
1275 #endif
1276
1277 static int op_open(struct libusb_device_handle *handle)
1278 {
1279         struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
1280         int r;
1281
1282         hpriv->fd = _get_usbfs_fd(handle->dev, O_RDWR, 0);
1283         if (hpriv->fd < 0) {
1284                 if (hpriv->fd == LIBUSB_ERROR_NO_DEVICE) {
1285                         /* device will still be marked as attached if hotplug monitor thread
1286                          * hasn't processed remove event yet */
1287                         usbi_mutex_static_lock(&linux_hotplug_lock);
1288                         if (handle->dev->attached) {
1289                                 usbi_dbg("open failed with no device, but device still attached");
1290                                 linux_device_disconnected(handle->dev->bus_number,
1291                                                 handle->dev->device_address, NULL);
1292                         }
1293                         usbi_mutex_static_unlock(&linux_hotplug_lock);
1294                 }
1295                 return hpriv->fd;
1296         }
1297
1298         r = ioctl(hpriv->fd, IOCTL_USBFS_GET_CAPABILITIES, &hpriv->caps);
1299         if (r < 0) {
1300                 if (errno == ENOTTY)
1301                         usbi_dbg("getcap not available");
1302                 else
1303                         usbi_err(HANDLE_CTX(handle), "getcap failed (%d)", errno);
1304                 hpriv->caps = 0;
1305                 if (supports_flag_zero_packet)
1306                         hpriv->caps |= USBFS_CAP_ZERO_PACKET;
1307                 if (supports_flag_bulk_continuation)
1308                         hpriv->caps |= USBFS_CAP_BULK_CONTINUATION;
1309         }
1310
1311         return usbi_add_pollfd(HANDLE_CTX(handle), hpriv->fd, POLLOUT);
1312 }
1313
1314 static void op_close(struct libusb_device_handle *dev_handle)
1315 {
1316         int fd = _device_handle_priv(dev_handle)->fd;
1317         usbi_remove_pollfd(HANDLE_CTX(dev_handle), fd);
1318         close(fd);
1319 }
1320
1321 static int op_get_configuration(struct libusb_device_handle *handle,
1322         int *config)
1323 {
1324         int r;
1325
1326         if (sysfs_can_relate_devices) {
1327                 r = sysfs_get_active_config(handle->dev, config);
1328         } else {
1329                 r = usbfs_get_active_config(handle->dev,
1330                                             _device_handle_priv(handle)->fd);
1331         }
1332         if (r < 0)
1333                 return r;
1334
1335         if (*config == -1) {
1336                 usbi_err(HANDLE_CTX(handle), "device unconfigured");
1337                 *config = 0;
1338         }
1339
1340         return 0;
1341 }
1342
1343 static int op_set_configuration(struct libusb_device_handle *handle, int config)
1344 {
1345         struct linux_device_priv *priv = _device_priv(handle->dev);
1346         int fd = _device_handle_priv(handle)->fd;
1347         int r = ioctl(fd, IOCTL_USBFS_SETCONFIG, &config);
1348         if (r) {
1349                 if (errno == EINVAL)
1350                         return LIBUSB_ERROR_NOT_FOUND;
1351                 else if (errno == EBUSY)
1352                         return LIBUSB_ERROR_BUSY;
1353                 else if (errno == ENODEV)
1354                         return LIBUSB_ERROR_NO_DEVICE;
1355
1356                 usbi_err(HANDLE_CTX(handle), "failed, error %d errno %d", r, errno);
1357                 return LIBUSB_ERROR_OTHER;
1358         }
1359
1360         /* update our cached active config descriptor */
1361         priv->active_config = config;
1362
1363         return LIBUSB_SUCCESS;
1364 }
1365
1366 static int claim_interface(struct libusb_device_handle *handle, int iface)
1367 {
1368         int fd = _device_handle_priv(handle)->fd;
1369         int r = ioctl(fd, IOCTL_USBFS_CLAIMINTF, &iface);
1370         if (r) {
1371                 if (errno == ENOENT)
1372                         return LIBUSB_ERROR_NOT_FOUND;
1373                 else if (errno == EBUSY)
1374                         return LIBUSB_ERROR_BUSY;
1375                 else if (errno == ENODEV)
1376                         return LIBUSB_ERROR_NO_DEVICE;
1377
1378                 usbi_err(HANDLE_CTX(handle),
1379                         "claim interface failed, error %d errno %d", r, errno);
1380                 return LIBUSB_ERROR_OTHER;
1381         }
1382         return 0;
1383 }
1384
1385 static int release_interface(struct libusb_device_handle *handle, int iface)
1386 {
1387         int fd = _device_handle_priv(handle)->fd;
1388         int r = ioctl(fd, IOCTL_USBFS_RELEASEINTF, &iface);
1389         if (r) {
1390                 if (errno == ENODEV)
1391                         return LIBUSB_ERROR_NO_DEVICE;
1392
1393                 usbi_err(HANDLE_CTX(handle),
1394                         "release interface failed, error %d errno %d", r, errno);
1395                 return LIBUSB_ERROR_OTHER;
1396         }
1397         return 0;
1398 }
1399
1400 static int op_set_interface(struct libusb_device_handle *handle, int iface,
1401         int altsetting)
1402 {
1403         int fd = _device_handle_priv(handle)->fd;
1404         struct usbfs_setinterface setintf;
1405         int r;
1406
1407         setintf.interface = iface;
1408         setintf.altsetting = altsetting;
1409         r = ioctl(fd, IOCTL_USBFS_SETINTF, &setintf);
1410         if (r) {
1411                 if (errno == EINVAL)
1412                         return LIBUSB_ERROR_NOT_FOUND;
1413                 else if (errno == ENODEV)
1414                         return LIBUSB_ERROR_NO_DEVICE;
1415
1416                 usbi_err(HANDLE_CTX(handle),
1417                         "setintf failed error %d errno %d", r, errno);
1418                 return LIBUSB_ERROR_OTHER;
1419         }
1420
1421         return 0;
1422 }
1423
1424 static int op_clear_halt(struct libusb_device_handle *handle,
1425         unsigned char endpoint)
1426 {
1427         int fd = _device_handle_priv(handle)->fd;
1428         unsigned int _endpoint = endpoint;
1429         int r = ioctl(fd, IOCTL_USBFS_CLEAR_HALT, &_endpoint);
1430         if (r) {
1431                 if (errno == ENOENT)
1432                         return LIBUSB_ERROR_NOT_FOUND;
1433                 else if (errno == ENODEV)
1434                         return LIBUSB_ERROR_NO_DEVICE;
1435
1436                 usbi_err(HANDLE_CTX(handle),
1437                         "clear_halt failed error %d errno %d", r, errno);
1438                 return LIBUSB_ERROR_OTHER;
1439         }
1440
1441         return 0;
1442 }
1443
1444 static int op_reset_device(struct libusb_device_handle *handle)
1445 {
1446         int fd = _device_handle_priv(handle)->fd;
1447         int i, r, ret = 0;
1448
1449         /* Doing a device reset will cause the usbfs driver to get unbound
1450            from any interfaces it is bound to. By voluntarily unbinding
1451            the usbfs driver ourself, we stop the kernel from rebinding
1452            the interface after reset (which would end up with the interface
1453            getting bound to the in kernel driver if any). */
1454         for (i = 0; i < USB_MAXINTERFACES; i++) {
1455                 if (handle->claimed_interfaces & (1L << i)) {
1456                         release_interface(handle, i);
1457                 }
1458         }
1459
1460         usbi_mutex_lock(&handle->lock);
1461         r = ioctl(fd, IOCTL_USBFS_RESET, NULL);
1462         if (r) {
1463                 if (errno == ENODEV) {
1464                         ret = LIBUSB_ERROR_NOT_FOUND;
1465                         goto out;
1466                 }
1467
1468                 usbi_err(HANDLE_CTX(handle),
1469                         "reset failed error %d errno %d", r, errno);
1470                 ret = LIBUSB_ERROR_OTHER;
1471                 goto out;
1472         }
1473
1474         /* And re-claim any interfaces which were claimed before the reset */
1475         for (i = 0; i < USB_MAXINTERFACES; i++) {
1476                 if (handle->claimed_interfaces & (1L << i)) {
1477                         /*
1478                          * A driver may have completed modprobing during
1479                          * IOCTL_USBFS_RESET, and bound itself as soon as
1480                          * IOCTL_USBFS_RESET released the device lock
1481                          */
1482                         r = detach_kernel_driver_and_claim(handle, i);
1483                         if (r) {
1484                                 usbi_warn(HANDLE_CTX(handle),
1485                                         "failed to re-claim interface %d after reset: %s",
1486                                         i, libusb_error_name(r));
1487                                 handle->claimed_interfaces &= ~(1L << i);
1488                                 ret = LIBUSB_ERROR_NOT_FOUND;
1489                         }
1490                 }
1491         }
1492 out:
1493         usbi_mutex_unlock(&handle->lock);
1494         return ret;
1495 }
1496
1497 static int do_streams_ioctl(struct libusb_device_handle *handle, long req,
1498         uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
1499 {
1500         int r, fd = _device_handle_priv(handle)->fd;
1501         struct usbfs_streams *streams;
1502
1503         if (num_endpoints > 30) /* Max 15 in + 15 out eps */
1504                 return LIBUSB_ERROR_INVALID_PARAM;
1505
1506         streams = malloc(sizeof(struct usbfs_streams) + num_endpoints);
1507         if (!streams)
1508                 return LIBUSB_ERROR_NO_MEM;
1509
1510         streams->num_streams = num_streams;
1511         streams->num_eps = num_endpoints;
1512         memcpy(streams->eps, endpoints, num_endpoints);
1513
1514         r = ioctl(fd, req, streams);
1515
1516         free(streams);
1517
1518         if (r < 0) {
1519                 if (errno == ENOTTY)
1520                         return LIBUSB_ERROR_NOT_SUPPORTED;
1521                 else if (errno == EINVAL)
1522                         return LIBUSB_ERROR_INVALID_PARAM;
1523                 else if (errno == ENODEV)
1524                         return LIBUSB_ERROR_NO_DEVICE;
1525
1526                 usbi_err(HANDLE_CTX(handle),
1527                         "streams-ioctl failed error %d errno %d", r, errno);
1528                 return LIBUSB_ERROR_OTHER;
1529         }
1530         return r;
1531 }
1532
1533 static int op_alloc_streams(struct libusb_device_handle *handle,
1534         uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
1535 {
1536         return do_streams_ioctl(handle, IOCTL_USBFS_ALLOC_STREAMS,
1537                                 num_streams, endpoints, num_endpoints);
1538 }
1539
1540 static int op_free_streams(struct libusb_device_handle *handle,
1541                 unsigned char *endpoints, int num_endpoints)
1542 {
1543         return do_streams_ioctl(handle, IOCTL_USBFS_FREE_STREAMS, 0,
1544                                 endpoints, num_endpoints);
1545 }
1546
1547 static int op_kernel_driver_active(struct libusb_device_handle *handle,
1548         int interface)
1549 {
1550         int fd = _device_handle_priv(handle)->fd;
1551         struct usbfs_getdriver getdrv;
1552         int r;
1553
1554         getdrv.interface = interface;
1555         r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1556         if (r) {
1557                 if (errno == ENODATA)
1558                         return 0;
1559                 else if (errno == ENODEV)
1560                         return LIBUSB_ERROR_NO_DEVICE;
1561
1562                 usbi_err(HANDLE_CTX(handle),
1563                         "get driver failed error %d errno %d", r, errno);
1564                 return LIBUSB_ERROR_OTHER;
1565         }
1566
1567         return (strcmp(getdrv.driver, "usbfs") == 0) ? 0 : 1;
1568 }
1569
1570 static int op_detach_kernel_driver(struct libusb_device_handle *handle,
1571         int interface)
1572 {
1573         int fd = _device_handle_priv(handle)->fd;
1574         struct usbfs_ioctl command;
1575         struct usbfs_getdriver getdrv;
1576         int r;
1577
1578         command.ifno = interface;
1579         command.ioctl_code = IOCTL_USBFS_DISCONNECT;
1580         command.data = NULL;
1581
1582         getdrv.interface = interface;
1583         r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1584         if (r == 0 && strcmp(getdrv.driver, "usbfs") == 0)
1585                 return LIBUSB_ERROR_NOT_FOUND;
1586
1587         r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1588         if (r) {
1589                 if (errno == ENODATA)
1590                         return LIBUSB_ERROR_NOT_FOUND;
1591                 else if (errno == EINVAL)
1592                         return LIBUSB_ERROR_INVALID_PARAM;
1593                 else if (errno == ENODEV)
1594                         return LIBUSB_ERROR_NO_DEVICE;
1595
1596                 usbi_err(HANDLE_CTX(handle),
1597                         "detach failed error %d errno %d", r, errno);
1598                 return LIBUSB_ERROR_OTHER;
1599         }
1600
1601         return 0;
1602 }
1603
1604 static int op_attach_kernel_driver(struct libusb_device_handle *handle,
1605         int interface)
1606 {
1607         int fd = _device_handle_priv(handle)->fd;
1608         struct usbfs_ioctl command;
1609         int r;
1610
1611         command.ifno = interface;
1612         command.ioctl_code = IOCTL_USBFS_CONNECT;
1613         command.data = NULL;
1614
1615         r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1616         if (r < 0) {
1617                 if (errno == ENODATA)
1618                         return LIBUSB_ERROR_NOT_FOUND;
1619                 else if (errno == EINVAL)
1620                         return LIBUSB_ERROR_INVALID_PARAM;
1621                 else if (errno == ENODEV)
1622                         return LIBUSB_ERROR_NO_DEVICE;
1623                 else if (errno == EBUSY)
1624                         return LIBUSB_ERROR_BUSY;
1625
1626                 usbi_err(HANDLE_CTX(handle),
1627                         "attach failed error %d errno %d", r, errno);
1628                 return LIBUSB_ERROR_OTHER;
1629         } else if (r == 0) {
1630                 return LIBUSB_ERROR_NOT_FOUND;
1631         }
1632
1633         return 0;
1634 }
1635
1636 static int detach_kernel_driver_and_claim(struct libusb_device_handle *handle,
1637         int interface)
1638 {
1639         struct usbfs_disconnect_claim dc;
1640         int r, fd = _device_handle_priv(handle)->fd;
1641
1642         dc.interface = interface;
1643         strcpy(dc.driver, "usbfs");
1644         dc.flags = USBFS_DISCONNECT_CLAIM_EXCEPT_DRIVER;
1645         r = ioctl(fd, IOCTL_USBFS_DISCONNECT_CLAIM, &dc);
1646         if (r == 0 || (r != 0 && errno != ENOTTY)) {
1647                 if (r == 0)
1648                         return 0;
1649
1650                 switch (errno) {
1651                 case EBUSY:
1652                         return LIBUSB_ERROR_BUSY;
1653                 case EINVAL:
1654                         return LIBUSB_ERROR_INVALID_PARAM;
1655                 case ENODEV:
1656                         return LIBUSB_ERROR_NO_DEVICE;
1657                 }
1658                 usbi_err(HANDLE_CTX(handle),
1659                         "disconnect-and-claim failed errno %d", errno);
1660                 return LIBUSB_ERROR_OTHER;
1661         }
1662
1663         /* Fallback code for kernels which don't support the
1664            disconnect-and-claim ioctl */
1665         r = op_detach_kernel_driver(handle, interface);
1666         if (r != 0 && r != LIBUSB_ERROR_NOT_FOUND)
1667                 return r;
1668
1669         return claim_interface(handle, interface);
1670 }
1671
1672 static int op_claim_interface(struct libusb_device_handle *handle, int iface)
1673 {
1674         if (handle->auto_detach_kernel_driver)
1675                 return detach_kernel_driver_and_claim(handle, iface);
1676         else
1677                 return claim_interface(handle, iface);
1678 }
1679
1680 static int op_release_interface(struct libusb_device_handle *handle, int iface)
1681 {
1682         int r;
1683
1684         r = release_interface(handle, iface);
1685         if (r)
1686                 return r;
1687
1688         if (handle->auto_detach_kernel_driver)
1689                 op_attach_kernel_driver(handle, iface);
1690
1691         return 0;
1692 }
1693
1694 static void op_destroy_device(struct libusb_device *dev)
1695 {
1696         struct linux_device_priv *priv = _device_priv(dev);
1697         if (priv->descriptors)
1698                 free(priv->descriptors);
1699         if (priv->sysfs_dir)
1700                 free(priv->sysfs_dir);
1701 }
1702
1703 /* URBs are discarded in reverse order of submission to avoid races. */
1704 static int discard_urbs(struct usbi_transfer *itransfer, int first, int last_plus_one)
1705 {
1706         struct libusb_transfer *transfer =
1707                 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1708         struct linux_transfer_priv *tpriv =
1709                 usbi_transfer_get_os_priv(itransfer);
1710         struct linux_device_handle_priv *dpriv =
1711                 _device_handle_priv(transfer->dev_handle);
1712         int i, ret = 0;
1713         struct usbfs_urb *urb;
1714
1715         for (i = last_plus_one - 1; i >= first; i--) {
1716                 if (LIBUSB_TRANSFER_TYPE_ISOCHRONOUS == transfer->type)
1717                         urb = tpriv->iso_urbs[i];
1718                 else
1719                         urb = &tpriv->urbs[i];
1720
1721                 if (0 == ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, urb))
1722                         continue;
1723
1724                 if (EINVAL == errno) {
1725                         usbi_dbg("URB not found --> assuming ready to be reaped");
1726                         if (i == (last_plus_one - 1))
1727                                 ret = LIBUSB_ERROR_NOT_FOUND;
1728                 } else if (ENODEV == errno) {
1729                         usbi_dbg("Device not found for URB --> assuming ready to be reaped");
1730                         ret = LIBUSB_ERROR_NO_DEVICE;
1731                 } else {
1732                         usbi_warn(TRANSFER_CTX(transfer),
1733                                 "unrecognised discard errno %d", errno);
1734                         ret = LIBUSB_ERROR_OTHER;
1735                 }
1736         }
1737         return ret;
1738 }
1739
1740 static void free_iso_urbs(struct linux_transfer_priv *tpriv)
1741 {
1742         int i;
1743         for (i = 0; i < tpriv->num_urbs; i++) {
1744                 struct usbfs_urb *urb = tpriv->iso_urbs[i];
1745                 if (!urb)
1746                         break;
1747                 free(urb);
1748         }
1749
1750         free(tpriv->iso_urbs);
1751         tpriv->iso_urbs = NULL;
1752 }
1753
1754 static int submit_bulk_transfer(struct usbi_transfer *itransfer)
1755 {
1756         struct libusb_transfer *transfer =
1757                 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1758         struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1759         struct linux_device_handle_priv *dpriv =
1760                 _device_handle_priv(transfer->dev_handle);
1761         struct usbfs_urb *urbs;
1762         int is_out = (transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK)
1763                 == LIBUSB_ENDPOINT_OUT;
1764         int bulk_buffer_len, use_bulk_continuation;
1765         int r;
1766         int i;
1767         size_t alloc_size;
1768
1769         if (is_out && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) &&
1770                         !(dpriv->caps & USBFS_CAP_ZERO_PACKET))
1771                 return LIBUSB_ERROR_NOT_SUPPORTED;
1772
1773         /*
1774          * Older versions of usbfs place a 16kb limit on bulk URBs. We work
1775          * around this by splitting large transfers into 16k blocks, and then
1776          * submit all urbs at once. it would be simpler to submit one urb at
1777          * a time, but there is a big performance gain doing it this way.
1778          *
1779          * Newer versions lift the 16k limit (USBFS_CAP_NO_PACKET_SIZE_LIM),
1780          * using arbritary large transfers can still be a bad idea though, as
1781          * the kernel needs to allocate physical contiguous memory for this,
1782          * which may fail for large buffers.
1783          *
1784          * The kernel solves this problem by splitting the transfer into
1785          * blocks itself when the host-controller is scatter-gather capable
1786          * (USBFS_CAP_BULK_SCATTER_GATHER), which most controllers are.
1787          *
1788          * Last, there is the issue of short-transfers when splitting, for
1789          * short split-transfers to work reliable USBFS_CAP_BULK_CONTINUATION
1790          * is needed, but this is not always available.
1791          */
1792         if (dpriv->caps & USBFS_CAP_BULK_SCATTER_GATHER) {
1793                 /* Good! Just submit everything in one go */
1794                 bulk_buffer_len = transfer->length ? transfer->length : 1;
1795                 use_bulk_continuation = 0;
1796         } else if (dpriv->caps & USBFS_CAP_BULK_CONTINUATION) {
1797                 /* Split the transfers and use bulk-continuation to
1798                    avoid issues with short-transfers */
1799                 bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
1800                 use_bulk_continuation = 1;
1801         } else if (dpriv->caps & USBFS_CAP_NO_PACKET_SIZE_LIM) {
1802                 /* Don't split, assume the kernel can alloc the buffer
1803                    (otherwise the submit will fail with -ENOMEM) */
1804                 bulk_buffer_len = transfer->length ? transfer->length : 1;
1805                 use_bulk_continuation = 0;
1806         } else {
1807                 /* Bad, splitting without bulk-continuation, short transfers
1808                    which end before the last urb will not work reliable! */
1809                 /* Note we don't warn here as this is "normal" on kernels <
1810                    2.6.32 and not a problem for most applications */
1811                 bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
1812                 use_bulk_continuation = 0;
1813         }
1814
1815         int num_urbs = transfer->length / bulk_buffer_len;
1816         int last_urb_partial = 0;
1817
1818         if (transfer->length == 0) {
1819                 num_urbs = 1;
1820         } else if ((transfer->length % bulk_buffer_len) > 0) {
1821                 last_urb_partial = 1;
1822                 num_urbs++;
1823         }
1824         usbi_dbg("need %d urbs for new transfer with length %d", num_urbs,
1825                 transfer->length);
1826         alloc_size = num_urbs * sizeof(struct usbfs_urb);
1827         urbs = calloc(1, alloc_size);
1828         if (!urbs)
1829                 return LIBUSB_ERROR_NO_MEM;
1830         tpriv->urbs = urbs;
1831         tpriv->num_urbs = num_urbs;
1832         tpriv->num_retired = 0;
1833         tpriv->reap_action = NORMAL;
1834         tpriv->reap_status = LIBUSB_TRANSFER_COMPLETED;
1835
1836         for (i = 0; i < num_urbs; i++) {
1837                 struct usbfs_urb *urb = &urbs[i];
1838                 urb->usercontext = itransfer;
1839                 switch (transfer->type) {
1840                 case LIBUSB_TRANSFER_TYPE_BULK:
1841                         urb->type = USBFS_URB_TYPE_BULK;
1842                         urb->stream_id = 0;
1843                         break;
1844                 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
1845                         urb->type = USBFS_URB_TYPE_BULK;
1846                         urb->stream_id = itransfer->stream_id;
1847                         break;
1848                 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1849                         urb->type = USBFS_URB_TYPE_INTERRUPT;
1850                         break;
1851                 }
1852                 urb->endpoint = transfer->endpoint;
1853                 urb->buffer = transfer->buffer + (i * bulk_buffer_len);
1854                 /* don't set the short not ok flag for the last URB */
1855                 if (use_bulk_continuation && !is_out && (i < num_urbs - 1))
1856                         urb->flags = USBFS_URB_SHORT_NOT_OK;
1857                 if (i == num_urbs - 1 && last_urb_partial)
1858                         urb->buffer_length = transfer->length % bulk_buffer_len;
1859                 else if (transfer->length == 0)
1860                         urb->buffer_length = 0;
1861                 else
1862                         urb->buffer_length = bulk_buffer_len;
1863
1864                 if (i > 0 && use_bulk_continuation)
1865                         urb->flags |= USBFS_URB_BULK_CONTINUATION;
1866
1867                 /* we have already checked that the flag is supported */
1868                 if (is_out && i == num_urbs - 1 &&
1869                     transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET)
1870                         urb->flags |= USBFS_URB_ZERO_PACKET;
1871
1872                 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
1873                 if (r < 0) {
1874                         if (errno == ENODEV) {
1875                                 r = LIBUSB_ERROR_NO_DEVICE;
1876                         } else {
1877                                 usbi_err(TRANSFER_CTX(transfer),
1878                                         "submiturb failed error %d errno=%d", r, errno);
1879                                 r = LIBUSB_ERROR_IO;
1880                         }
1881
1882                         /* if the first URB submission fails, we can simply free up and
1883                          * return failure immediately. */
1884                         if (i == 0) {
1885                                 usbi_dbg("first URB failed, easy peasy");
1886                                 free(urbs);
1887                                 tpriv->urbs = NULL;
1888                                 return r;
1889                         }
1890
1891                         /* if it's not the first URB that failed, the situation is a bit
1892                          * tricky. we may need to discard all previous URBs. there are
1893                          * complications:
1894                          *  - discarding is asynchronous - discarded urbs will be reaped
1895                          *    later. the user must not have freed the transfer when the
1896                          *    discarded URBs are reaped, otherwise libusb will be using
1897                          *    freed memory.
1898                          *  - the earlier URBs may have completed successfully and we do
1899                          *    not want to throw away any data.
1900                          *  - this URB failing may be no error; EREMOTEIO means that
1901                          *    this transfer simply didn't need all the URBs we submitted
1902                          * so, we report that the transfer was submitted successfully and
1903                          * in case of error we discard all previous URBs. later when
1904                          * the final reap completes we can report error to the user,
1905                          * or success if an earlier URB was completed successfully.
1906                          */
1907                         tpriv->reap_action = EREMOTEIO == errno ? COMPLETED_EARLY : SUBMIT_FAILED;
1908
1909                         /* The URBs we haven't submitted yet we count as already
1910                          * retired. */
1911                         tpriv->num_retired += num_urbs - i;
1912
1913                         /* If we completed short then don't try to discard. */
1914                         if (COMPLETED_EARLY == tpriv->reap_action)
1915                                 return 0;
1916
1917                         discard_urbs(itransfer, 0, i);
1918
1919                         usbi_dbg("reporting successful submission but waiting for %d "
1920                                 "discards before reporting error", i);
1921                         return 0;
1922                 }
1923         }
1924
1925         return 0;
1926 }
1927
1928 static int submit_iso_transfer(struct usbi_transfer *itransfer)
1929 {
1930         struct libusb_transfer *transfer =
1931                 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1932         struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1933         struct linux_device_handle_priv *dpriv =
1934                 _device_handle_priv(transfer->dev_handle);
1935         struct usbfs_urb **urbs;
1936         size_t alloc_size;
1937         int num_packets = transfer->num_iso_packets;
1938         int i;
1939         int this_urb_len = 0;
1940         int num_urbs = 1;
1941         int packet_offset = 0;
1942         unsigned int packet_len;
1943         unsigned char *urb_buffer = transfer->buffer;
1944
1945         /* usbfs places arbitrary limits on iso URBs. this limit has changed
1946          * at least three times, and it's difficult to accurately detect which
1947          * limit this running kernel might impose. so we attempt to submit
1948          * whatever the user has provided. if the kernel rejects the request
1949          * due to its size, we return an error indicating such to the user.
1950          */
1951
1952         /* calculate how many URBs we need */
1953         for (i = 0; i < num_packets; i++) {
1954                 unsigned int space_remaining = MAX_ISO_BUFFER_LENGTH - this_urb_len;
1955                 packet_len = transfer->iso_packet_desc[i].length;
1956
1957                 if (packet_len > space_remaining) {
1958                         num_urbs++;
1959                         this_urb_len = packet_len;
1960                         /* check that we can actually support this packet length */
1961                         if (this_urb_len > MAX_ISO_BUFFER_LENGTH)
1962                                 return LIBUSB_ERROR_INVALID_PARAM;
1963                 } else {
1964                         this_urb_len += packet_len;
1965                 }
1966         }
1967         usbi_dbg("need %d %dk URBs for transfer", num_urbs, MAX_ISO_BUFFER_LENGTH / 1024);
1968
1969         alloc_size = num_urbs * sizeof(*urbs);
1970         urbs = calloc(1, alloc_size);
1971         if (!urbs)
1972                 return LIBUSB_ERROR_NO_MEM;
1973
1974         tpriv->iso_urbs = urbs;
1975         tpriv->num_urbs = num_urbs;
1976         tpriv->num_retired = 0;
1977         tpriv->reap_action = NORMAL;
1978         tpriv->iso_packet_offset = 0;
1979
1980         /* allocate + initialize each URB with the correct number of packets */
1981         for (i = 0; i < num_urbs; i++) {
1982                 struct usbfs_urb *urb;
1983                 unsigned int space_remaining_in_urb = MAX_ISO_BUFFER_LENGTH;
1984                 int urb_packet_offset = 0;
1985                 unsigned char *urb_buffer_orig = urb_buffer;
1986                 int j;
1987                 int k;
1988
1989                 /* swallow up all the packets we can fit into this URB */
1990                 while (packet_offset < transfer->num_iso_packets) {
1991                         packet_len = transfer->iso_packet_desc[packet_offset].length;
1992                         if (packet_len <= space_remaining_in_urb) {
1993                                 /* throw it in */
1994                                 urb_packet_offset++;
1995                                 packet_offset++;
1996                                 space_remaining_in_urb -= packet_len;
1997                                 urb_buffer += packet_len;
1998                         } else {
1999                                 /* it can't fit, save it for the next URB */
2000                                 break;
2001                         }
2002                 }
2003
2004                 alloc_size = sizeof(*urb)
2005                         + (urb_packet_offset * sizeof(struct usbfs_iso_packet_desc));
2006                 urb = calloc(1, alloc_size);
2007                 if (!urb) {
2008                         free_iso_urbs(tpriv);
2009                         return LIBUSB_ERROR_NO_MEM;
2010                 }
2011                 urbs[i] = urb;
2012
2013                 /* populate packet lengths */
2014                 for (j = 0, k = packet_offset - urb_packet_offset;
2015                                 k < packet_offset; k++, j++) {
2016                         packet_len = transfer->iso_packet_desc[k].length;
2017                         urb->iso_frame_desc[j].length = packet_len;
2018                 }
2019
2020                 urb->usercontext = itransfer;
2021                 urb->type = USBFS_URB_TYPE_ISO;
2022                 /* FIXME: interface for non-ASAP data? */
2023                 urb->flags = USBFS_URB_ISO_ASAP;
2024                 urb->endpoint = transfer->endpoint;
2025                 urb->number_of_packets = urb_packet_offset;
2026                 urb->buffer = urb_buffer_orig;
2027         }
2028
2029         /* submit URBs */
2030         for (i = 0; i < num_urbs; i++) {
2031                 int r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urbs[i]);
2032                 if (r < 0) {
2033                         if (errno == ENODEV) {
2034                                 r = LIBUSB_ERROR_NO_DEVICE;
2035                         } else if (errno == EINVAL) {
2036                                 usbi_warn(TRANSFER_CTX(transfer),
2037                                         "submiturb failed, transfer too large");
2038                                 r = LIBUSB_ERROR_INVALID_PARAM;
2039                         } else {
2040                                 usbi_err(TRANSFER_CTX(transfer),
2041                                         "submiturb failed error %d errno=%d", r, errno);
2042                                 r = LIBUSB_ERROR_IO;
2043                         }
2044
2045                         /* if the first URB submission fails, we can simply free up and
2046                          * return failure immediately. */
2047                         if (i == 0) {
2048                                 usbi_dbg("first URB failed, easy peasy");
2049                                 free_iso_urbs(tpriv);
2050                                 return r;
2051                         }
2052
2053                         /* if it's not the first URB that failed, the situation is a bit
2054                          * tricky. we must discard all previous URBs. there are
2055                          * complications:
2056                          *  - discarding is asynchronous - discarded urbs will be reaped
2057                          *    later. the user must not have freed the transfer when the
2058                          *    discarded URBs are reaped, otherwise libusb will be using
2059                          *    freed memory.
2060                          *  - the earlier URBs may have completed successfully and we do
2061                          *    not want to throw away any data.
2062                          * so, in this case we discard all the previous URBs BUT we report
2063                          * that the transfer was submitted successfully. then later when
2064                          * the final discard completes we can report error to the user.
2065                          */
2066                         tpriv->reap_action = SUBMIT_FAILED;
2067
2068                         /* The URBs we haven't submitted yet we count as already
2069                          * retired. */
2070                         tpriv->num_retired = num_urbs - i;
2071                         discard_urbs(itransfer, 0, i);
2072
2073                         usbi_dbg("reporting successful submission but waiting for %d "
2074                                 "discards before reporting error", i);
2075                         return 0;
2076                 }
2077         }
2078
2079         return 0;
2080 }
2081
2082 static int submit_control_transfer(struct usbi_transfer *itransfer)
2083 {
2084         struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2085         struct libusb_transfer *transfer =
2086                 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2087         struct linux_device_handle_priv *dpriv =
2088                 _device_handle_priv(transfer->dev_handle);
2089         struct usbfs_urb *urb;
2090         int r;
2091
2092         if (transfer->length - LIBUSB_CONTROL_SETUP_SIZE > MAX_CTRL_BUFFER_LENGTH)
2093                 return LIBUSB_ERROR_INVALID_PARAM;
2094
2095         urb = calloc(1, sizeof(struct usbfs_urb));
2096         if (!urb)
2097                 return LIBUSB_ERROR_NO_MEM;
2098         tpriv->urbs = urb;
2099         tpriv->num_urbs = 1;
2100         tpriv->reap_action = NORMAL;
2101
2102         urb->usercontext = itransfer;
2103         urb->type = USBFS_URB_TYPE_CONTROL;
2104         urb->endpoint = transfer->endpoint;
2105         urb->buffer = transfer->buffer;
2106         urb->buffer_length = transfer->length;
2107
2108         r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
2109         if (r < 0) {
2110                 free(urb);
2111                 tpriv->urbs = NULL;
2112                 if (errno == ENODEV)
2113                         return LIBUSB_ERROR_NO_DEVICE;
2114
2115                 usbi_err(TRANSFER_CTX(transfer),
2116                         "submiturb failed error %d errno=%d", r, errno);
2117                 return LIBUSB_ERROR_IO;
2118         }
2119         return 0;
2120 }
2121
2122 static int op_submit_transfer(struct usbi_transfer *itransfer)
2123 {
2124         struct libusb_transfer *transfer =
2125                 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2126
2127         switch (transfer->type) {
2128         case LIBUSB_TRANSFER_TYPE_CONTROL:
2129                 return submit_control_transfer(itransfer);
2130         case LIBUSB_TRANSFER_TYPE_BULK:
2131         case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2132                 return submit_bulk_transfer(itransfer);
2133         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2134                 return submit_bulk_transfer(itransfer);
2135         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2136                 return submit_iso_transfer(itransfer);
2137         default:
2138                 usbi_err(TRANSFER_CTX(transfer),
2139                         "unknown endpoint type %d", transfer->type);
2140                 return LIBUSB_ERROR_INVALID_PARAM;
2141         }
2142 }
2143
2144 static int op_cancel_transfer(struct usbi_transfer *itransfer)
2145 {
2146         struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2147         struct libusb_transfer *transfer =
2148                 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2149
2150         switch (transfer->type) {
2151         case LIBUSB_TRANSFER_TYPE_BULK:
2152         case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2153                 if (tpriv->reap_action == ERROR)
2154                         break;
2155                 /* else, fall through */
2156         case LIBUSB_TRANSFER_TYPE_CONTROL:
2157         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2158         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2159                 tpriv->reap_action = CANCELLED;
2160                 break;
2161         default:
2162                 usbi_err(TRANSFER_CTX(transfer),
2163                         "unknown endpoint type %d", transfer->type);
2164                 return LIBUSB_ERROR_INVALID_PARAM;
2165         }
2166
2167         if (!tpriv->urbs)
2168                 return LIBUSB_ERROR_NOT_FOUND;
2169
2170         return discard_urbs(itransfer, 0, tpriv->num_urbs);
2171 }
2172
2173 static void op_clear_transfer_priv(struct usbi_transfer *itransfer)
2174 {
2175         struct libusb_transfer *transfer =
2176                 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2177         struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2178
2179         /* urbs can be freed also in submit_transfer so lock mutex first */
2180         switch (transfer->type) {
2181         case LIBUSB_TRANSFER_TYPE_CONTROL:
2182         case LIBUSB_TRANSFER_TYPE_BULK:
2183         case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2184         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2185                 if (tpriv->urbs) {
2186                         free(tpriv->urbs);
2187                         tpriv->urbs = NULL;
2188                 }
2189                 break;
2190         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2191                 if (tpriv->iso_urbs) {
2192                         free_iso_urbs(tpriv);
2193                         tpriv->iso_urbs = NULL;
2194                 }
2195                 break;
2196         default:
2197                 usbi_err(TRANSFER_CTX(transfer),
2198                         "unknown endpoint type %d", transfer->type);
2199         }
2200 }
2201
2202 static int handle_bulk_completion(struct usbi_transfer *itransfer,
2203         struct usbfs_urb *urb)
2204 {
2205         struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2206         struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2207         int urb_idx = urb - tpriv->urbs;
2208
2209         usbi_mutex_lock(&itransfer->lock);
2210         usbi_dbg("handling completion status %d of bulk urb %d/%d", urb->status,
2211                 urb_idx + 1, tpriv->num_urbs);
2212
2213         tpriv->num_retired++;
2214
2215         if (tpriv->reap_action != NORMAL) {
2216                 /* cancelled, submit_fail, or completed early */
2217                 usbi_dbg("abnormal reap: urb status %d", urb->status);
2218
2219                 /* even though we're in the process of cancelling, it's possible that
2220                  * we may receive some data in these URBs that we don't want to lose.
2221                  * examples:
2222                  * 1. while the kernel is cancelling all the packets that make up an
2223                  *    URB, a few of them might complete. so we get back a successful
2224                  *    cancellation *and* some data.
2225                  * 2. we receive a short URB which marks the early completion condition,
2226                  *    so we start cancelling the remaining URBs. however, we're too
2227                  *    slow and another URB completes (or at least completes partially).
2228                  *    (this can't happen since we always use BULK_CONTINUATION.)
2229                  *
2230                  * When this happens, our objectives are not to lose any "surplus" data,
2231                  * and also to stick it at the end of the previously-received data
2232                  * (closing any holes), so that libusb reports the total amount of
2233                  * transferred data and presents it in a contiguous chunk.
2234                  */
2235                 if (urb->actual_length > 0) {
2236                         unsigned char *target = transfer->buffer + itransfer->transferred;
2237                         usbi_dbg("received %d bytes of surplus data", urb->actual_length);
2238                         if (urb->buffer != target) {
2239                                 usbi_dbg("moving surplus data from offset %d to offset %d",
2240                                         (unsigned char *) urb->buffer - transfer->buffer,
2241                                         target - transfer->buffer);
2242                                 memmove(target, urb->buffer, urb->actual_length);
2243                         }
2244                         itransfer->transferred += urb->actual_length;
2245                 }
2246
2247                 if (tpriv->num_retired == tpriv->num_urbs) {
2248                         usbi_dbg("abnormal reap: last URB handled, reporting");
2249                         if (tpriv->reap_action != COMPLETED_EARLY &&
2250                             tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2251                                 tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
2252                         goto completed;
2253                 }
2254                 goto out_unlock;
2255         }
2256
2257         itransfer->transferred += urb->actual_length;
2258
2259         /* Many of these errors can occur on *any* urb of a multi-urb
2260          * transfer.  When they do, we tear down the rest of the transfer.
2261          */
2262         switch (urb->status) {
2263         case 0:
2264                 break;
2265         case -EREMOTEIO: /* short transfer */
2266                 break;
2267         case -ENOENT: /* cancelled */
2268         case -ECONNRESET:
2269                 break;
2270         case -ENODEV:
2271         case -ESHUTDOWN:
2272                 usbi_dbg("device removed");
2273                 tpriv->reap_status = LIBUSB_TRANSFER_NO_DEVICE;
2274                 goto cancel_remaining;
2275         case -EPIPE:
2276                 usbi_dbg("detected endpoint stall");
2277                 if (tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2278                         tpriv->reap_status = LIBUSB_TRANSFER_STALL;
2279                 goto cancel_remaining;
2280         case -EOVERFLOW:
2281                 /* overflow can only ever occur in the last urb */
2282                 usbi_dbg("overflow, actual_length=%d", urb->actual_length);
2283                 if (tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2284                         tpriv->reap_status = LIBUSB_TRANSFER_OVERFLOW;
2285                 goto completed;
2286         case -ETIME:
2287         case -EPROTO:
2288         case -EILSEQ:
2289         case -ECOMM:
2290         case -ENOSR:
2291                 usbi_dbg("low level error %d", urb->status);
2292                 tpriv->reap_action = ERROR;
2293                 goto cancel_remaining;
2294         default:
2295                 usbi_warn(ITRANSFER_CTX(itransfer),
2296                         "unrecognised urb status %d", urb->status);
2297                 tpriv->reap_action = ERROR;
2298                 goto cancel_remaining;
2299         }
2300
2301         /* if we're the last urb or we got less data than requested then we're
2302          * done */
2303         if (urb_idx == tpriv->num_urbs - 1) {
2304                 usbi_dbg("last URB in transfer --> complete!");
2305                 goto completed;
2306         } else if (urb->actual_length < urb->buffer_length) {
2307                 usbi_dbg("short transfer %d/%d --> complete!",
2308                         urb->actual_length, urb->buffer_length);
2309                 if (tpriv->reap_action == NORMAL)
2310                         tpriv->reap_action = COMPLETED_EARLY;
2311         } else
2312                 goto out_unlock;
2313
2314 cancel_remaining:
2315         if (ERROR == tpriv->reap_action && LIBUSB_TRANSFER_COMPLETED == tpriv->reap_status)
2316                 tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
2317
2318         if (tpriv->num_retired == tpriv->num_urbs) /* nothing to cancel */
2319                 goto completed;
2320
2321         /* cancel remaining urbs and wait for their completion before
2322          * reporting results */
2323         discard_urbs(itransfer, urb_idx + 1, tpriv->num_urbs);
2324
2325 out_unlock:
2326         usbi_mutex_unlock(&itransfer->lock);
2327         return 0;
2328
2329 completed:
2330         free(tpriv->urbs);
2331         tpriv->urbs = NULL;
2332         usbi_mutex_unlock(&itransfer->lock);
2333         return CANCELLED == tpriv->reap_action ?
2334                 usbi_handle_transfer_cancellation(itransfer) :
2335                 usbi_handle_transfer_completion(itransfer, tpriv->reap_status);
2336 }
2337
2338 static int handle_iso_completion(struct usbi_transfer *itransfer,
2339         struct usbfs_urb *urb)
2340 {
2341         struct libusb_transfer *transfer =
2342                 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2343         struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2344         int num_urbs = tpriv->num_urbs;
2345         int urb_idx = 0;
2346         int i;
2347         enum libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
2348
2349         usbi_mutex_lock(&itransfer->lock);
2350         for (i = 0; i < num_urbs; i++) {
2351                 if (urb == tpriv->iso_urbs[i]) {
2352                         urb_idx = i + 1;
2353                         break;
2354                 }
2355         }
2356         if (urb_idx == 0) {
2357                 usbi_err(TRANSFER_CTX(transfer), "could not locate urb!");
2358                 usbi_mutex_unlock(&itransfer->lock);
2359                 return LIBUSB_ERROR_NOT_FOUND;
2360         }
2361
2362         usbi_dbg("handling completion status %d of iso urb %d/%d", urb->status,
2363                 urb_idx, num_urbs);
2364
2365         /* copy isochronous results back in */
2366
2367         for (i = 0; i < urb->number_of_packets; i++) {
2368                 struct usbfs_iso_packet_desc *urb_desc = &urb->iso_frame_desc[i];
2369                 struct libusb_iso_packet_descriptor *lib_desc =
2370                         &transfer->iso_packet_desc[tpriv->iso_packet_offset++];
2371                 lib_desc->status = LIBUSB_TRANSFER_COMPLETED;
2372                 switch (urb_desc->status) {
2373                 case 0:
2374                         break;
2375                 case -ENOENT: /* cancelled */
2376                 case -ECONNRESET:
2377                         break;
2378                 case -ENODEV:
2379                 case -ESHUTDOWN:
2380                         usbi_dbg("device removed");
2381                         lib_desc->status = LIBUSB_TRANSFER_NO_DEVICE;
2382                         break;
2383                 case -EPIPE:
2384                         usbi_dbg("detected endpoint stall");
2385                         lib_desc->status = LIBUSB_TRANSFER_STALL;
2386                         break;
2387                 case -EOVERFLOW:
2388                         usbi_dbg("overflow error");
2389                         lib_desc->status = LIBUSB_TRANSFER_OVERFLOW;
2390                         break;
2391                 case -ETIME:
2392                 case -EPROTO:
2393                 case -EILSEQ:
2394                 case -ECOMM:
2395                 case -ENOSR:
2396                 case -EXDEV:
2397                         usbi_dbg("low-level USB error %d", urb_desc->status);
2398                         lib_desc->status = LIBUSB_TRANSFER_ERROR;
2399                         break;
2400                 default:
2401                         usbi_warn(TRANSFER_CTX(transfer),
2402                                 "unrecognised urb status %d", urb_desc->status);
2403                         lib_desc->status = LIBUSB_TRANSFER_ERROR;
2404                         break;
2405                 }
2406                 lib_desc->actual_length = urb_desc->actual_length;
2407         }
2408
2409         tpriv->num_retired++;
2410
2411         if (tpriv->reap_action != NORMAL) { /* cancelled or submit_fail */
2412                 usbi_dbg("CANCEL: urb status %d", urb->status);
2413
2414                 if (tpriv->num_retired == num_urbs) {
2415                         usbi_dbg("CANCEL: last URB handled, reporting");
2416                         free_iso_urbs(tpriv);
2417                         if (tpriv->reap_action == CANCELLED) {
2418                                 usbi_mutex_unlock(&itransfer->lock);
2419                                 return usbi_handle_transfer_cancellation(itransfer);
2420                         } else {
2421                                 usbi_mutex_unlock(&itransfer->lock);
2422                                 return usbi_handle_transfer_completion(itransfer,
2423                                         LIBUSB_TRANSFER_ERROR);
2424                         }
2425                 }
2426                 goto out;
2427         }
2428
2429         switch (urb->status) {
2430         case 0:
2431                 break;
2432         case -ENOENT: /* cancelled */
2433         case -ECONNRESET:
2434                 break;
2435         case -ESHUTDOWN:
2436                 usbi_dbg("device removed");
2437                 status = LIBUSB_TRANSFER_NO_DEVICE;
2438                 break;
2439         default:
2440                 usbi_warn(TRANSFER_CTX(transfer),
2441                         "unrecognised urb status %d", urb->status);
2442                 status = LIBUSB_TRANSFER_ERROR;
2443                 break;
2444         }
2445
2446         /* if we're the last urb then we're done */
2447         if (urb_idx == num_urbs) {
2448                 usbi_dbg("last URB in transfer --> complete!");
2449                 free_iso_urbs(tpriv);
2450                 usbi_mutex_unlock(&itransfer->lock);
2451                 return usbi_handle_transfer_completion(itransfer, status);
2452         }
2453
2454 out:
2455         usbi_mutex_unlock(&itransfer->lock);
2456         return 0;
2457 }
2458
2459 static int handle_control_completion(struct usbi_transfer *itransfer,
2460         struct usbfs_urb *urb)
2461 {
2462         struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2463         int status;
2464
2465         usbi_mutex_lock(&itransfer->lock);
2466         usbi_dbg("handling completion status %d", urb->status);
2467
2468         itransfer->transferred += urb->actual_length;
2469
2470         if (tpriv->reap_action == CANCELLED) {
2471                 if (urb->status != 0 && urb->status != -ENOENT)
2472                         usbi_warn(ITRANSFER_CTX(itransfer),
2473                                 "cancel: unrecognised urb status %d", urb->status);
2474                 free(tpriv->urbs);
2475                 tpriv->urbs = NULL;
2476                 usbi_mutex_unlock(&itransfer->lock);
2477                 return usbi_handle_transfer_cancellation(itransfer);
2478         }
2479
2480         switch (urb->status) {
2481         case 0:
2482                 status = LIBUSB_TRANSFER_COMPLETED;
2483                 break;
2484         case -ENOENT: /* cancelled */
2485                 status = LIBUSB_TRANSFER_CANCELLED;
2486                 break;
2487         case -ENODEV:
2488         case -ESHUTDOWN:
2489                 usbi_dbg("device removed");
2490                 status = LIBUSB_TRANSFER_NO_DEVICE;
2491                 break;
2492         case -EPIPE:
2493                 usbi_dbg("unsupported control request");
2494                 status = LIBUSB_TRANSFER_STALL;
2495                 break;
2496         case -EOVERFLOW:
2497                 usbi_dbg("control overflow error");
2498                 status = LIBUSB_TRANSFER_OVERFLOW;
2499                 break;
2500         case -ETIME:
2501         case -EPROTO:
2502         case -EILSEQ:
2503         case -ECOMM:
2504         case -ENOSR:
2505                 usbi_dbg("low-level bus error occurred");
2506                 status = LIBUSB_TRANSFER_ERROR;
2507                 break;
2508         default:
2509                 usbi_warn(ITRANSFER_CTX(itransfer),
2510                         "unrecognised urb status %d", urb->status);
2511                 status = LIBUSB_TRANSFER_ERROR;
2512                 break;
2513         }
2514
2515         free(tpriv->urbs);
2516         tpriv->urbs = NULL;
2517         usbi_mutex_unlock(&itransfer->lock);
2518         return usbi_handle_transfer_completion(itransfer, status);
2519 }
2520
2521 static int reap_for_handle(struct libusb_device_handle *handle)
2522 {
2523         struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
2524         int r;
2525         struct usbfs_urb *urb;
2526         struct usbi_transfer *itransfer;
2527         struct libusb_transfer *transfer;
2528
2529         r = ioctl(hpriv->fd, IOCTL_USBFS_REAPURBNDELAY, &urb);
2530         if (r == -1 && errno == EAGAIN)
2531                 return 1;
2532         if (r < 0) {
2533                 if (errno == ENODEV)
2534                         return LIBUSB_ERROR_NO_DEVICE;
2535
2536                 usbi_err(HANDLE_CTX(handle), "reap failed error %d errno=%d",
2537                         r, errno);
2538                 return LIBUSB_ERROR_IO;
2539         }
2540
2541         itransfer = urb->usercontext;
2542         transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2543
2544         usbi_dbg("urb type=%d status=%d transferred=%d", urb->type, urb->status,
2545                 urb->actual_length);
2546
2547         switch (transfer->type) {
2548         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2549                 return handle_iso_completion(itransfer, urb);
2550         case LIBUSB_TRANSFER_TYPE_BULK:
2551         case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2552         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2553                 return handle_bulk_completion(itransfer, urb);
2554         case LIBUSB_TRANSFER_TYPE_CONTROL:
2555                 return handle_control_completion(itransfer, urb);
2556         default:
2557                 usbi_err(HANDLE_CTX(handle), "unrecognised endpoint type %x",
2558                         transfer->type);
2559                 return LIBUSB_ERROR_OTHER;
2560         }
2561 }
2562
2563 static int op_handle_events(struct libusb_context *ctx,
2564         struct pollfd *fds, POLL_NFDS_TYPE nfds, int num_ready)
2565 {
2566         int r;
2567         unsigned int i = 0;
2568
2569         usbi_mutex_lock(&ctx->open_devs_lock);
2570         for (i = 0; i < nfds && num_ready > 0; i++) {
2571                 struct pollfd *pollfd = &fds[i];
2572                 struct libusb_device_handle *handle;
2573                 struct linux_device_handle_priv *hpriv = NULL;
2574
2575                 if (!pollfd->revents)
2576                         continue;
2577
2578                 num_ready--;
2579                 list_for_each_entry(handle, &ctx->open_devs, list, struct libusb_device_handle) {
2580                         hpriv = _device_handle_priv(handle);
2581                         if (hpriv->fd == pollfd->fd)
2582                                 break;
2583                 }
2584
2585                 if (!hpriv || hpriv->fd != pollfd->fd) {
2586                         usbi_err(ctx, "cannot find handle for fd %d\n",
2587                                  pollfd->fd);
2588                         continue;
2589                 }
2590
2591                 if (pollfd->revents & POLLERR) {
2592                         usbi_remove_pollfd(HANDLE_CTX(handle), hpriv->fd);
2593                         usbi_handle_disconnect(handle);
2594                         /* device will still be marked as attached if hotplug monitor thread
2595                          * hasn't processed remove event yet */
2596                         usbi_mutex_static_lock(&linux_hotplug_lock);
2597                         if (handle->dev->attached)
2598                                 linux_device_disconnected(handle->dev->bus_number,
2599                                                 handle->dev->device_address, NULL);
2600                         usbi_mutex_static_unlock(&linux_hotplug_lock);
2601                         continue;
2602                 }
2603
2604                 do {
2605                         r = reap_for_handle(handle);
2606                 } while (r == 0);
2607                 if (r == 1 || r == LIBUSB_ERROR_NO_DEVICE)
2608                         continue;
2609                 else if (r < 0)
2610                         goto out;
2611         }
2612
2613         r = 0;
2614 out:
2615         usbi_mutex_unlock(&ctx->open_devs_lock);
2616         return r;
2617 }
2618
2619 static int op_clock_gettime(int clk_id, struct timespec *tp)
2620 {
2621         switch (clk_id) {
2622         case USBI_CLOCK_MONOTONIC:
2623                 return clock_gettime(monotonic_clkid, tp);
2624         case USBI_CLOCK_REALTIME:
2625                 return clock_gettime(CLOCK_REALTIME, tp);
2626         default:
2627                 return LIBUSB_ERROR_INVALID_PARAM;
2628   }
2629 }
2630
2631 #ifdef USBI_TIMERFD_AVAILABLE
2632 static clockid_t op_get_timerfd_clockid(void)
2633 {
2634         return monotonic_clkid;
2635
2636 }
2637 #endif
2638
2639 const struct usbi_os_backend linux_usbfs_backend = {
2640         .name = "Linux usbfs",
2641         .caps = USBI_CAP_HAS_HID_ACCESS|USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER,
2642         .init = op_init,
2643         .exit = op_exit,
2644         .get_device_list = NULL,
2645         .hotplug_poll = op_hotplug_poll,
2646         .get_device_descriptor = op_get_device_descriptor,
2647         .get_active_config_descriptor = op_get_active_config_descriptor,
2648         .get_config_descriptor = op_get_config_descriptor,
2649         .get_config_descriptor_by_value = op_get_config_descriptor_by_value,
2650
2651         .open = op_open,
2652         .close = op_close,
2653         .get_configuration = op_get_configuration,
2654         .set_configuration = op_set_configuration,
2655         .claim_interface = op_claim_interface,
2656         .release_interface = op_release_interface,
2657
2658         .set_interface_altsetting = op_set_interface,
2659         .clear_halt = op_clear_halt,
2660         .reset_device = op_reset_device,
2661
2662         .alloc_streams = op_alloc_streams,
2663         .free_streams = op_free_streams,
2664
2665         .kernel_driver_active = op_kernel_driver_active,
2666         .detach_kernel_driver = op_detach_kernel_driver,
2667         .attach_kernel_driver = op_attach_kernel_driver,
2668
2669         .destroy_device = op_destroy_device,
2670
2671         .submit_transfer = op_submit_transfer,
2672         .cancel_transfer = op_cancel_transfer,
2673         .clear_transfer_priv = op_clear_transfer_priv,
2674
2675         .handle_events = op_handle_events,
2676
2677         .clock_gettime = op_clock_gettime,
2678
2679 #ifdef USBI_TIMERFD_AVAILABLE
2680         .get_timerfd_clockid = op_get_timerfd_clockid,
2681 #endif
2682
2683         .device_priv_size = sizeof(struct linux_device_priv),
2684         .device_handle_priv_size = sizeof(struct linux_device_handle_priv),
2685         .transfer_priv_size = sizeof(struct linux_transfer_priv),
2686         .add_iso_packet_size = 0,
2687 };