libusb/os/linux_usbfs.c

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