src/third_party/libusb/src/libusb/os/linux_usbfs.c

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