libusb/os/linux_usbfs.c

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