libusb/io.c

   1 /*
   2  * I/O functions for libusb
   3  * Copyright (C) 2007 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
  23 #include <errno.h>
  24 #include <signal.h>
  25 #include <stdint.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <sys/select.h>
  29 #include <sys/time.h>
  30 #include <time.h>
  31 #include <unistd.h>
  32
  33 /* signalfd() support is present in glibc-2.7 onwards, but glibc-2.7 contains
  34  * a bug where the header is neither installed or compilable. This will be
  35  * fixed for glibc-2.8. */
  36 #if __GLIBC_PREREQ(2, 8)
  37 #include <sys/signalfd.h>
  38 #else
  39 #include "signalfd.h"
  40 #endif
  41
  42 #include "libusbi.h"
  43
  44 static int sigfd;
  45 static int signum;
  46
  47 /* this is a list of in-flight fp_urb_handles, sorted by timeout expiration.
  48  * URBs to timeout the soonest are placed at the beginning of the list, URBs
  49  * that will time out later are placed after, and urbs with infinite timeout
  50  * are always placed at the very end. */
  51 static struct list_head flying_urbs;
  52
  53 static int setup_signalfd(int _signum)
  54 {
  55         sigset_t sigset;
  56         if (_signum == 0)
  57                 _signum = SIGRTMIN;
  58         fp_dbg("signal %d", _signum);
  59
  60         sigemptyset(&sigset);
  61         sigaddset(&sigset, _signum);
  62         sigfd = signalfd(-1, &sigset, 0);
  63         if (sigfd < 0) {
  64                 fp_err("signalfd failed, code=%d errno=%d", sigfd, errno);
  65                 return sigfd;
  66         }
  67         fp_dbg("got signalfd %d", sigfd);
  68         signum = _signum;
  69
  70         sigemptyset(&sigset);
  71         sigaddset(&sigset, _signum);
  72         return sigprocmask(SIG_BLOCK, &sigset, NULL);
  73 }
  74
  75 int usbi_io_init(int _signum)
  76 {
  77         list_init(&flying_urbs);
  78         return setup_signalfd(signum);
  79 }
  80
  81 void usbi_io_exit(void)
  82 {
  83         close(sigfd);
  84 }
  85
  86 static int calculate_timeout(struct libusb_urb_handle *urbh,
  87         unsigned int timeout)
  88 {
  89         int r;
  90         struct timespec current_time;
  91         struct sigevent sigevt = {
  92                 .sigev_notify = SIGEV_SIGNAL,
  93                 .sigev_signo = signum,
  94         };
  95         struct itimerspec itspec;
  96         struct timespec *it_value = &itspec.it_value;
  97
  98         if (!timeout)
  99                 return 0;
 100
 101         r = clock_gettime(CLOCK_MONOTONIC, &current_time);
 102         if (r < 0) {
 103                 fp_err("failed to read monotonic clock, errno=%d", errno);
 104                 return r;
 105         }
 106
 107         r = timer_create(CLOCK_MONOTONIC, &sigevt, &urbh->timer);
 108         if (r < 0) {
 109                 fp_err("failed to create monotonic timer");
 110                 return r;
 111         }
 112
 113         memset(&itspec, 0, sizeof(itspec));
 114         it_value->tv_sec = current_time.tv_sec + (timeout / 1000);
 115         it_value->tv_nsec = current_time.tv_nsec +
 116                 ((timeout % 1000) * 1000000);
 117
 118         if (it_value->tv_nsec > 1000000000) {
 119                 it_value->tv_nsec -= 1000000000;
 120                 it_value->tv_sec++;
 121         }
 122
 123         r = timer_settime(&urbh->timer, TIMER_ABSTIME, &itspec, NULL);
 124         if (r < 0) {
 125                 fp_err("failed to arm monotonic timer");
 126                 return r;
 127         }
 128
 129         urbh->timeout = itspec.it_value;
 130
 131         return 0;
 132 }
 133
 134 static void add_to_flying_list(struct libusb_urb_handle *urbh)
 135 {
 136         struct libusb_urb_handle *cur;
 137         struct timespec *timeout = &urbh->timeout;
 138
 139         /* if we have no other flying urbs, start the list with this one */
 140         if (list_empty(&flying_urbs)) {
 141                 list_add(&urbh->list, &flying_urbs);
 142                 return;
 143         }
 144
 145         /* if we have infinite timeout, append to end of list */
 146         if (!TIMESPEC_IS_SET(timeout)) {
 147                 list_add_tail(&urbh->list, &flying_urbs);
 148                 return;
 149         }
 150
 151         /* otherwise, find appropriate place in list */
 152         list_for_each_entry(cur, &flying_urbs, list) {
 153                 /* find first timeout that occurs after the urbh in question */
 154                 struct timespec *cur_ts = &cur->timeout;
 155
 156                 if (!TIMESPEC_IS_SET(cur_ts) || (cur_ts->tv_sec > timeout->tv_sec) ||
 157                                 (cur_ts->tv_sec == timeout->tv_sec &&
 158                                         cur_ts->tv_nsec > timeout->tv_nsec)) {
 159                         list_add_tail(&urbh->list, &cur->list);
 160                         return;
 161                 }
 162         }
 163
 164         /* otherwise we need to be inserted at the end */
 165         list_add_tail(&urbh->list, &flying_urbs);
 166 }
 167
 168 static int submit_urb(struct libusb_dev_handle *devh,
 169         struct libusb_urb_handle *urbh)
 170 {
 171         int r;
 172         struct usb_urb *urb = &urbh->urb;
 173         int to_be_transferred = urbh->transfer_len - urbh->transferred;
 174
 175         urb->type = urbh->urb_type;
 176         urb->endpoint = urbh->endpoint;
 177         urb->buffer = urbh->buffer + urbh->transferred;
 178         urb->buffer_length = MIN(to_be_transferred, MAX_URB_BUFFER_LENGTH);
 179         urb->signr = signum;
 180
 181         /* FIXME: for requests that we have to split into multiple URBs, we should
 182          * submit all the URBs instantly: submit, submit, submit, reap, reap, reap
 183          * rather than: submit, reap, submit, reap, submit, reap
 184          * this will improve performance and fix bugs concerning behaviour when
 185          * the user submits two similar multiple-urb requests */
 186         fp_dbg("transferring %d from %d bytes", urb->buffer_length,
 187                 to_be_transferred);
 188
 189         r = ioctl(devh->fd, IOCTL_USB_SUBMITURB, &urbh->urb);
 190         if (r < 0) {
 191                 fp_err("submiturb failed error %d errno=%d", r, errno);
 192                 return r;
 193         }
 194
 195         add_to_flying_list(urbh);
 196         return 0;
 197 }
 198
 199 API_EXPORTED struct libusb_urb_handle *libusb_submit_ctrl_msg(
 200         struct libusb_dev_handle *devh, struct libusb_ctrl_msg *msg,
 201         libusb_ctrl_cb_fn callback, void *user_data, unsigned int timeout)
 202 {
 203         struct libusb_urb_handle *urbh = malloc(sizeof(*urbh));
 204         struct libusb_ctrl_setup *setup;
 205         unsigned char *urbdata;
 206         int urbdata_length = sizeof(struct libusb_ctrl_setup) + msg->length;
 207         int r;
 208
 209         if (!urbh)
 210                 return NULL;
 211         memset(urbh, 0, sizeof(*urbh));
 212         urbh->devh = devh;
 213         urbh->callback = callback;
 214         urbh->user_data = user_data;
 215         r = calculate_timeout(urbh, timeout);
 216         if (r < 0) {
 217                 free(urbh);
 218                 return NULL;
 219         }
 220
 221         urbdata = malloc(urbdata_length);
 222         if (!urbdata) {
 223                 free(urbh);
 224                 return NULL;
 225         }
 226
 227         fp_dbg("RQT=%02x RQ=%02x VAL=%04x IDX=%04x length=%d",
 228                 msg->requesttype, msg->request, msg->value, msg->index, msg->length);
 229
 230         setup = (struct libusb_ctrl_setup *) urbdata;
 231         setup->bRequestType = msg->requesttype;
 232         setup->bRequest = msg->request;
 233         setup->wValue = cpu_to_le16(msg->value);
 234         setup->wIndex = cpu_to_le16(msg->index);
 235         setup->wLength = cpu_to_le16(msg->length);
 236
 237         if ((msg->requesttype & 0x80) == LIBUSB_ENDPOINT_OUT)
 238                 memcpy(urbdata + sizeof(struct libusb_ctrl_setup), msg->data, msg->length);
 239
 240         urbh->urb_type = USB_URB_TYPE_CONTROL;
 241         urbh->buffer = urbdata;
 242         urbh->transfer_len = urbdata_length;
 243
 244         r = submit_urb(devh, urbh);
 245         if (r < 0) {
 246                 free(urbh);
 247                 free(urbdata);
 248                 return NULL;
 249         }
 250
 251         return urbh;
 252 }
 253
 254 static struct libusb_urb_handle *submit_bulk_msg(struct libusb_dev_handle *devh,
 255         struct libusb_bulk_msg *msg, libusb_bulk_cb_fn callback, void *user_data,
 256         unsigned int timeout, unsigned char urbtype)
 257 {
 258         struct libusb_urb_handle *urbh = malloc(sizeof(*urbh));
 259         int r;
 260
 261         fp_dbg("length %d timeout %d", msg->length, timeout);
 262
 263         if (!urbh)
 264                 return NULL;
 265         memset(urbh, 0, sizeof(*urbh));
 266         r = calculate_timeout(urbh, timeout);
 267         if (r < 0) {
 268                 free(urbh);
 269                 return NULL;
 270         }
 271         urbh->devh = devh;
 272         urbh->callback = callback;
 273         urbh->user_data = user_data;
 274         urbh->flags |= LIBUSB_URBH_DATA_BELONGS_TO_USER;
 275         urbh->endpoint = msg->endpoint;
 276         urbh->urb_type = urbtype;
 277         urbh->buffer = msg->data;
 278         urbh->transfer_len = msg->length;
 279
 280         r = submit_urb(devh, urbh);
 281         if (r < 0) {
 282                 free(urbh);
 283                 return NULL;
 284         }
 285
 286         return urbh;
 287 }
 288
 289 API_EXPORTED struct libusb_urb_handle *libusb_submit_bulk_msg(
 290         struct libusb_dev_handle *devh, struct libusb_bulk_msg *msg,
 291         libusb_bulk_cb_fn callback, void *user_data, unsigned int timeout)
 292 {
 293         return submit_bulk_msg(devh, msg, callback, user_data, timeout,
 294                 USB_URB_TYPE_BULK);
 295 }
 296
 297 API_EXPORTED struct libusb_urb_handle *libusb_submit_intr_msg(
 298         struct libusb_dev_handle *devh, struct libusb_bulk_msg *msg,
 299         libusb_bulk_cb_fn callback, void *user_data, unsigned int timeout)
 300 {
 301         return submit_bulk_msg(devh, msg, callback, user_data, timeout,
 302                 USB_URB_TYPE_INTERRUPT);
 303 }
 304
 305 API_EXPORTED int libusb_urb_handle_cancel(struct libusb_dev_handle *devh,
 306         struct libusb_urb_handle *urbh)
 307 {
 308         int r;
 309         fp_dbg("");
 310         r = ioctl(devh->fd, IOCTL_USB_DISCARDURB, &urbh->urb);
 311         if (r < 0)
 312                 fp_err("cancel urb failed error %d", r);
 313         return r;
 314 }
 315
 316 API_EXPORTED int libusb_urb_handle_cancel_sync(struct libusb_dev_handle *devh,
 317         struct libusb_urb_handle *urbh)
 318 {
 319         int r;
 320         fp_dbg("");
 321         r = ioctl(devh->fd, IOCTL_USB_DISCARDURB, &urbh->urb);
 322         if (r < 0) {
 323                 fp_err("cancel urb failed error %d", r);
 324                 return r;
 325         }
 326
 327         urbh->flags |= LIBUSB_URBH_SYNC_CANCELLED;
 328         while (urbh->flags & LIBUSB_URBH_SYNC_CANCELLED) {
 329                 r = libusb_poll();
 330                 if (r < 0)
 331                         return r;
 332         }
 333
 334         return 0;
 335 }
 336
 337 int handle_transfer_completion(struct libusb_dev_handle *devh,
 338         struct libusb_urb_handle *urbh, enum fp_urb_cb_status status)
 339 {
 340         struct usb_urb *urb = &urbh->urb;
 341
 342         if (TIMESPEC_IS_SET(&urbh->timeout))
 343                 timer_delete(urbh->timer);
 344
 345         if (status == FP_URB_SILENT_COMPLETION)
 346                 return 0;
 347
 348         if (urb->type == USB_URB_TYPE_CONTROL) {
 349                 libusb_ctrl_cb_fn callback = urbh->callback;
 350                 if (callback)
 351                         callback(devh, urbh, status, urb->buffer,
 352                                 urb->buffer + sizeof(struct libusb_ctrl_setup), urbh->transferred,
 353                                 urbh->user_data);
 354         } else if (urb->type == USB_URB_TYPE_BULK ||
 355                         urb->type == USB_URB_TYPE_INTERRUPT) {
 356                 libusb_bulk_cb_fn callback = urbh->callback;
 357                 if (callback)
 358                         callback(devh, urbh, status, urbh->endpoint, urbh->transfer_len,
 359                                 urbh->buffer, urbh->transferred, urbh->user_data);
 360         }
 361         return 0;
 362 }
 363
 364 static int handle_transfer_cancellation(struct libusb_dev_handle *devh,
 365         struct libusb_urb_handle *urbh)
 366 {
 367         /* if the URB is being cancelled synchronously, raise cancellation
 368          * completion event by unsetting flag, and ensure that user callback does
 369          * not get called.
 370          */
 371         if (urbh->flags & LIBUSB_URBH_SYNC_CANCELLED) {
 372                 urbh->flags &= ~LIBUSB_URBH_SYNC_CANCELLED;
 373                 fp_dbg("detected sync. cancel");
 374                 return handle_transfer_completion(devh, urbh, FP_URB_SILENT_COMPLETION);
 375         }
 376
 377         /* if the URB was cancelled due to timeout, report timeout to the user */
 378         if (urbh->flags & LIBUSB_URBH_TIMED_OUT) {
 379                 fp_dbg("detected timeout cancellation");
 380                 return handle_transfer_completion(devh, urbh, FP_URB_TIMEOUT);
 381         }
 382
 383         /* otherwise its a normal async cancel */
 384         return handle_transfer_completion(devh, urbh, FP_URB_CANCELLED);
 385 }
 386
 387 static int reap_for_devh(struct libusb_dev_handle *devh)
 388 {
 389         int r;
 390         struct usb_urb *urb;
 391         struct libusb_urb_handle *urbh;
 392         int trf_requested;
 393
 394         r = ioctl(devh->fd, IOCTL_USB_REAPURBNDELAY, &urb);
 395         if (r == -1 && errno == EAGAIN)
 396                 return r;
 397         if (r < 0) {
 398                 fp_err("reap failed error %d errno=%d", r, errno);
 399                 return r;
 400         }
 401
 402         urbh = container_of(urb, struct libusb_urb_handle, urb);
 403
 404         fp_dbg("urb type=%d status=%d transferred=%d", urb->type, urb->status,
 405                 urb->actual_length);
 406         list_del(&urbh->list);
 407
 408         if (urb->status == -2)
 409                 return handle_transfer_cancellation(devh, urbh);
 410         /* FIXME: research what other status codes may exist */
 411         if (urb->status != 0)
 412                 fp_warn("unrecognised urb status %d", urb->status);
 413
 414         /* determine how much data was asked for */
 415         trf_requested = MIN(urbh->transfer_len - urbh->transferred,
 416                 MAX_URB_BUFFER_LENGTH);
 417
 418         urbh->transferred += urb->actual_length;
 419
 420         /* if we were provided less data than requested, then our transfer is
 421          * done */
 422         if (urb->actual_length < trf_requested) {
 423                 fp_dbg("less data than requested (%d/%d) --> all done",
 424                         urb->actual_length, trf_requested);
 425                 return handle_transfer_completion(devh, urbh, FP_URB_COMPLETED);
 426         }
 427
 428         /* if we've transferred all data, we're done */
 429         if (urbh->transferred == urbh->transfer_len) {
 430                 fp_dbg("transfer complete --> all done");
 431                 return handle_transfer_completion(devh, urbh, FP_URB_COMPLETED);
 432         }
 433
 434         /* otherwise, we have more data to transfer */
 435         fp_dbg("more data to transfer...");
 436         memset(urb, 0, sizeof(*urb));
 437         return submit_urb(devh, urbh);
 438 }
 439
 440 static void handle_timeout(struct libusb_urb_handle *urbh)
 441 {
 442         /* handling timeouts is tricky, as we may race with the kernel: we may
 443          * detect a timeout racing with the condition that the urb has actually
 444          * completed. we asynchronously cancel the URB and report timeout
 445          * to the user when the URB cancellation completes (or not at all if the
 446          * URB actually gets delivered as per this race) */
 447         int r;
 448
 449
 450         urbh->flags |= LIBUSB_URBH_TIMED_OUT;
 451         r = libusb_urb_handle_cancel(urbh->devh, urbh);
 452         if (r < 0)
 453                 fp_warn("async cancel failed %d errno=%d", r, errno);
 454 }
 455
 456 static int handle_timeouts(void)
 457 {
 458         struct timespec systime;
 459         struct libusb_urb_handle *urbh;
 460         int r;
 461
 462         if (list_empty(&flying_urbs))
 463                 return 0;
 464
 465         /* get current time */
 466         r = clock_gettime(CLOCK_MONOTONIC, &systime);
 467         if (r < 0)
 468                 return r;
 469
 470         /* iterate through flying urbs list, finding all urbs that have expired
 471          * timeouts */
 472         list_for_each_entry(urbh, &flying_urbs, list) {
 473                 struct timespec *cur_ts = &urbh->timeout;
 474
 475                 /* if we've reached urbs of infinite timeout, we're all done */
 476                 if (!TIMESPEC_IS_SET(cur_ts))
 477                         return 0;
 478
 479                 /* if urb has non-expired timeout, nothing more to do */
 480                 if ((cur_ts->tv_sec > systime.tv_sec) ||
 481                                 (cur_ts->tv_sec == systime.tv_sec &&
 482                                         cur_ts->tv_nsec > systime.tv_nsec))
 483                         return 0;
 484
 485                 /* otherwise, we've got an expired timeout to handle */
 486                 handle_timeout(urbh);
 487         }
 488
 489         return 0;
 490 }
 491
 492 static int reap(void)
 493 {
 494         struct libusb_dev_handle *devh;
 495         int r;
 496
 497         list_for_each_entry(devh, &open_devs, list) {
 498                 r = reap_for_devh(devh);
 499                 if (r == -1 && errno == EAGAIN)
 500                         continue;
 501                 if (r < 0)
 502                         return r;
 503         }
 504
 505         r = handle_timeouts();
 506
 507         return 0;
 508 }
 509
 510 static int flush_sigfd(void)
 511 {
 512         int r;
 513         struct signalfd_siginfo siginfo;
 514         r = read(sigfd, &siginfo, sizeof(siginfo));
 515         if (r < 0) {
 516                 fp_err("sigfd read failed %d %d", r, errno);
 517                 return r;
 518         }
 519         if ((unsigned int) r < sizeof(siginfo)) {
 520                 fp_err("sigfd short read (%d/%d)", r, sizeof(siginfo));
 521                 return -1;
 522         }
 523         return 0;
 524 }
 525
 526 static int poll_io(struct timeval *tv)
 527 {
 528         int r;
 529         fd_set fds;
 530
 531         FD_ZERO(&fds);
 532         FD_SET(sigfd, &fds);
 533         r = select(sigfd + 1, &fds, NULL, NULL, tv);
 534         if (r == -1 && errno == EINTR)
 535                 return 0;
 536         if (r < 0) {
 537                 fp_err("select failed %d err=%d\n", r, errno);
 538                 return r;
 539         }
 540
 541         if (r > 0) {
 542                 flush_sigfd();
 543                 return reap();
 544         }
 545
 546         return 0;
 547 }
 548
 549 API_EXPORTED int libusb_poll_timeout(struct timeval *tv)
 550 {
 551         return poll_io(tv);
 552 }
 553
 554 API_EXPORTED int libusb_poll(void)
 555 {
 556         struct timeval tv;
 557         tv.tv_sec = 0;
 558         tv.tv_usec = 500000;
 559         return poll_io(&tv);
 560 }
 561
 562 struct sync_ctrl_handle {
 563         enum fp_urb_cb_status status;
 564         unsigned char *data;
 565         int actual_length;
 566 };
 567
 568 static void ctrl_msg_cb(struct libusb_dev_handle *devh,
 569         struct libusb_urb_handle *urbh, enum fp_urb_cb_status status,
 570         struct libusb_ctrl_setup *setup, unsigned char *data, int actual_length,
 571         void *user_data)
 572 {
 573         struct sync_ctrl_handle *ctrlh = (struct sync_ctrl_handle *) user_data;
 574         fp_dbg("actual_length=%d", actual_length);
 575
 576         if (status == FP_URB_COMPLETED) {
 577                 /* copy results into user-defined buffer */
 578                 if (setup->bRequestType & LIBUSB_ENDPOINT_IN)
 579                         memcpy(ctrlh->data, data, actual_length);
 580         }
 581
 582         ctrlh->status = status;
 583         ctrlh->actual_length = actual_length;
 584         /* caller frees urbh */
 585 }
 586
 587 API_EXPORTED int libusb_ctrl_msg(struct libusb_dev_handle *devh,
 588         struct libusb_ctrl_msg *msg, unsigned int timeout)
 589 {
 590         struct libusb_urb_handle *urbh;
 591         struct sync_ctrl_handle ctrlh;
 592
 593         memset(&ctrlh, 0, sizeof(ctrlh));
 594         ctrlh.data = msg->data;
 595
 596         urbh = libusb_submit_ctrl_msg(devh, msg, ctrl_msg_cb, &ctrlh, timeout);
 597         if (!urbh)
 598                 return -1;
 599
 600         while (!ctrlh.status) {
 601                 int r = libusb_poll();
 602                 if (r < 0) {
 603                         libusb_urb_handle_cancel_sync(devh, urbh);
 604                         libusb_urb_handle_free(urbh);
 605                         return r;
 606                 }
 607         }
 608
 609         libusb_urb_handle_free(urbh);
 610         switch (ctrlh.status) {
 611         case FP_URB_COMPLETED:
 612                 return ctrlh.actual_length;
 613         case FP_URB_TIMEOUT:
 614                 return -ETIMEDOUT;
 615         default:
 616                 fp_warn("unrecognised status code %d", ctrlh.status);
 617                 return -1;
 618         }
 619 }
 620
 621 struct sync_bulk_handle {
 622         enum fp_urb_cb_status status;
 623         int actual_length;
 624 };
 625
 626 static void bulk_msg_cb(struct libusb_dev_handle *devh,
 627         struct libusb_urb_handle *urbh, enum fp_urb_cb_status status,
 628         unsigned char endpoint, int rqlength, unsigned char *data,
 629         int actual_length, void *user_data)
 630 {
 631         struct sync_bulk_handle *bulkh = (struct sync_bulk_handle *) user_data;
 632         fp_dbg("");
 633         bulkh->status = status;
 634         bulkh->actual_length = actual_length;
 635         /* caller frees urbh */
 636 }
 637
 638 static int do_sync_bulk_msg(struct libusb_dev_handle *devh,
 639         struct libusb_bulk_msg *msg, int *transferred, unsigned int timeout,
 640         unsigned char urbtype)
 641 {
 642         struct libusb_urb_handle *urbh;
 643         struct sync_bulk_handle bulkh;
 644
 645         memset(&bulkh, 0, sizeof(bulkh));
 646
 647         urbh = submit_bulk_msg(devh, msg, bulk_msg_cb, &bulkh, timeout, urbtype);
 648         if (!urbh)
 649                 return -1;
 650
 651         while (!bulkh.status) {
 652                 int r = libusb_poll();
 653                 if (r < 0) {
 654                         libusb_urb_handle_cancel_sync(devh, urbh);
 655                         libusb_urb_handle_free(urbh);
 656                         return r;
 657                 }
 658         }
 659
 660         *transferred = bulkh.actual_length;
 661         libusb_urb_handle_free(urbh);
 662
 663         switch (bulkh.status) {
 664         case FP_URB_COMPLETED:
 665                 return 0;
 666         case FP_URB_TIMEOUT:
 667                 return -ETIMEDOUT;
 668         default:
 669                 fp_warn("unrecognised status code %d", bulkh.status);
 670                 return -1;
 671         }
 672 }
 673
 674 API_EXPORTED int libusb_intr_msg(struct libusb_dev_handle *devh,
 675         struct libusb_bulk_msg *msg, int *transferred, unsigned int timeout)
 676 {
 677         return do_sync_bulk_msg(devh, msg, transferred, timeout,
 678                 USB_URB_TYPE_INTERRUPT);
 679 }
 680
 681 API_EXPORTED int libusb_bulk_msg(struct libusb_dev_handle *devh,
 682         struct libusb_bulk_msg *msg, int *transferred, unsigned int timeout)
 683 {
 684         return do_sync_bulk_msg(devh, msg, transferred, timeout,
 685                 USB_URB_TYPE_BULK);
 686 }
 687
 688 API_EXPORTED void libusb_urb_handle_free(struct libusb_urb_handle *urbh)
 689 {
 690         if (!urbh)
 691                 return;
 692
 693         if (!(urbh->flags & LIBUSB_URBH_DATA_BELONGS_TO_USER))
 694                 free(urbh->urb.buffer);
 695         free(urbh);
 696 }
 697
 698 API_EXPORTED int libusb_get_pollfd(void)
 699 {
 700         return sigfd;
 701 }
 702