1 /* $FreeBSD$ */ 2 /*- 3 * Copyright (c) 2009 Sylvestre Gallon. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/queue.h> 28 29 #include <errno.h> 30 #include <poll.h> 31 #include <pthread.h> 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <time.h> 35 #include <unistd.h> 36 37 #include "libusb20.h" 38 #include "libusb20_desc.h" 39 #include "libusb20_int.h" 40 #include "libusb.h" 41 #include "libusb10.h" 42 43 UNEXPORTED void 44 libusb10_add_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd, 45 struct libusb20_device *pdev, int fd, short events) 46 { 47 if (ctx == NULL) 48 return; /* invalid */ 49 50 if (pollfd->entry.tqe_prev != NULL) 51 return; /* already queued */ 52 53 if (fd < 0) 54 return; /* invalid */ 55 56 pollfd->pdev = pdev; 57 pollfd->pollfd.fd = fd; 58 pollfd->pollfd.events = events; 59 60 CTX_LOCK(ctx); 61 TAILQ_INSERT_TAIL(&ctx->pollfds, pollfd, entry); 62 CTX_UNLOCK(ctx); 63 64 if (ctx->fd_added_cb) 65 ctx->fd_added_cb(fd, events, ctx->fd_cb_user_data); 66 } 67 68 UNEXPORTED void 69 libusb10_remove_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd) 70 { 71 if (ctx == NULL) 72 return; /* invalid */ 73 74 if (pollfd->entry.tqe_prev == NULL) 75 return; /* already dequeued */ 76 77 CTX_LOCK(ctx); 78 TAILQ_REMOVE(&ctx->pollfds, pollfd, entry); 79 pollfd->entry.tqe_prev = NULL; 80 CTX_UNLOCK(ctx); 81 82 if (ctx->fd_removed_cb) 83 ctx->fd_removed_cb(pollfd->pollfd.fd, ctx->fd_cb_user_data); 84 } 85 86 /* This function must be called locked */ 87 88 static int 89 libusb10_handle_events_sub(struct libusb_context *ctx, struct timeval *tv) 90 { 91 struct libusb_device *dev; 92 struct libusb20_device **ppdev; 93 struct libusb_super_pollfd *pfd; 94 struct pollfd *fds; 95 struct libusb_super_transfer *sxfer; 96 struct libusb_transfer *uxfer; 97 nfds_t nfds; 98 int timeout; 99 int i; 100 int err; 101 102 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb10_handle_events_sub enter"); 103 104 nfds = 0; 105 i = 0; 106 TAILQ_FOREACH(pfd, &ctx->pollfds, entry) 107 nfds++; 108 109 fds = alloca(sizeof(*fds) * nfds); 110 if (fds == NULL) 111 return (LIBUSB_ERROR_NO_MEM); 112 113 ppdev = alloca(sizeof(*ppdev) * nfds); 114 if (ppdev == NULL) 115 return (LIBUSB_ERROR_NO_MEM); 116 117 TAILQ_FOREACH(pfd, &ctx->pollfds, entry) { 118 fds[i].fd = pfd->pollfd.fd; 119 fds[i].events = pfd->pollfd.events; 120 fds[i].revents = 0; 121 ppdev[i] = pfd->pdev; 122 if (pfd->pdev != NULL) 123 libusb_get_device(pfd->pdev)->refcnt++; 124 i++; 125 } 126 127 if (tv == NULL) 128 timeout = -1; 129 else 130 timeout = (tv->tv_sec * 1000) + ((tv->tv_usec + 999) / 1000); 131 132 CTX_UNLOCK(ctx); 133 err = poll(fds, nfds, timeout); 134 CTX_LOCK(ctx); 135 136 if ((err == -1) && (errno == EINTR)) 137 err = LIBUSB_ERROR_INTERRUPTED; 138 else if (err < 0) 139 err = LIBUSB_ERROR_IO; 140 141 if (err < 1) { 142 for (i = 0; i != nfds; i++) { 143 if (ppdev[i] != NULL) { 144 CTX_UNLOCK(ctx); 145 libusb_unref_device(libusb_get_device(ppdev[i])); 146 CTX_LOCK(ctx); 147 } 148 } 149 goto do_done; 150 } 151 for (i = 0; i != nfds; i++) { 152 if (ppdev[i] != NULL) { 153 dev = libusb_get_device(ppdev[i]); 154 155 if (fds[i].revents == 0) 156 err = 0; /* nothing to do */ 157 else 158 err = libusb20_dev_process(ppdev[i]); 159 160 if (err) { 161 /* cancel all transfers - device is gone */ 162 libusb10_cancel_all_transfer(dev); 163 164 /* remove USB device from polling loop */ 165 libusb10_remove_pollfd(dev->ctx, &dev->dev_poll); 166 } 167 CTX_UNLOCK(ctx); 168 libusb_unref_device(dev); 169 CTX_LOCK(ctx); 170 171 } else { 172 uint8_t dummy; 173 174 while (1) { 175 if (read(fds[i].fd, &dummy, 1) != 1) 176 break; 177 } 178 } 179 } 180 181 err = 0; 182 183 do_done: 184 185 /* Do all done callbacks */ 186 187 while ((sxfer = TAILQ_FIRST(&ctx->tr_done))) { 188 TAILQ_REMOVE(&ctx->tr_done, sxfer, entry); 189 sxfer->entry.tqe_prev = NULL; 190 191 ctx->tr_done_ref++; 192 193 CTX_UNLOCK(ctx); 194 195 uxfer = (struct libusb_transfer *)( 196 ((uint8_t *)sxfer) + sizeof(*sxfer)); 197 198 if (uxfer->callback != NULL) 199 (uxfer->callback) (uxfer); 200 201 if (uxfer->flags & LIBUSB_TRANSFER_FREE_BUFFER) 202 free(uxfer->buffer); 203 204 if (uxfer->flags & LIBUSB_TRANSFER_FREE_TRANSFER) 205 libusb_free_transfer(uxfer); 206 207 CTX_LOCK(ctx); 208 209 ctx->tr_done_ref--; 210 ctx->tr_done_gen++; 211 } 212 213 /* Wakeup other waiters */ 214 pthread_cond_broadcast(&ctx->ctx_cond); 215 216 return (err); 217 } 218 219 /* Polling and timing */ 220 221 int 222 libusb_try_lock_events(libusb_context *ctx) 223 { 224 int err; 225 226 ctx = GET_CONTEXT(ctx); 227 if (ctx == NULL) 228 return (1); 229 230 err = CTX_TRYLOCK(ctx); 231 if (err) 232 return (1); 233 234 err = (ctx->ctx_handler != NO_THREAD); 235 if (err) 236 CTX_UNLOCK(ctx); 237 else 238 ctx->ctx_handler = pthread_self(); 239 240 return (err); 241 } 242 243 void 244 libusb_lock_events(libusb_context *ctx) 245 { 246 ctx = GET_CONTEXT(ctx); 247 CTX_LOCK(ctx); 248 if (ctx->ctx_handler == NO_THREAD) 249 ctx->ctx_handler = pthread_self(); 250 } 251 252 void 253 libusb_unlock_events(libusb_context *ctx) 254 { 255 ctx = GET_CONTEXT(ctx); 256 if (ctx->ctx_handler == pthread_self()) { 257 ctx->ctx_handler = NO_THREAD; 258 pthread_cond_broadcast(&ctx->ctx_cond); 259 } 260 CTX_UNLOCK(ctx); 261 } 262 263 int 264 libusb_event_handling_ok(libusb_context *ctx) 265 { 266 ctx = GET_CONTEXT(ctx); 267 return (ctx->ctx_handler == pthread_self()); 268 } 269 270 int 271 libusb_event_handler_active(libusb_context *ctx) 272 { 273 ctx = GET_CONTEXT(ctx); 274 return (ctx->ctx_handler != NO_THREAD); 275 } 276 277 void 278 libusb_lock_event_waiters(libusb_context *ctx) 279 { 280 ctx = GET_CONTEXT(ctx); 281 CTX_LOCK(ctx); 282 } 283 284 void 285 libusb_unlock_event_waiters(libusb_context *ctx) 286 { 287 ctx = GET_CONTEXT(ctx); 288 CTX_UNLOCK(ctx); 289 } 290 291 int 292 libusb_wait_for_event(libusb_context *ctx, struct timeval *tv) 293 { 294 struct timespec ts; 295 int err; 296 297 ctx = GET_CONTEXT(ctx); 298 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_wait_for_event enter"); 299 300 if (tv == NULL) { 301 pthread_cond_wait(&ctx->ctx_cond, 302 &ctx->ctx_lock); 303 return (0); 304 } 305 err = clock_gettime(CLOCK_REALTIME, &ts); 306 if (err < 0) 307 return (LIBUSB_ERROR_OTHER); 308 309 ts.tv_sec = tv->tv_sec; 310 ts.tv_nsec = tv->tv_usec * 1000; 311 if (ts.tv_nsec >= 1000000000) { 312 ts.tv_nsec -= 1000000000; 313 ts.tv_sec++; 314 } 315 err = pthread_cond_timedwait(&ctx->ctx_cond, 316 &ctx->ctx_lock, &ts); 317 318 if (err == ETIMEDOUT) 319 return (1); 320 321 return (0); 322 } 323 324 int 325 libusb_handle_events_timeout(libusb_context *ctx, struct timeval *tv) 326 { 327 int err; 328 329 ctx = GET_CONTEXT(ctx); 330 331 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout enter"); 332 333 libusb_lock_events(ctx); 334 335 err = libusb_handle_events_locked(ctx, tv); 336 337 libusb_unlock_events(ctx); 338 339 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout leave"); 340 341 return (err); 342 } 343 344 int 345 libusb_handle_events(libusb_context *ctx) 346 { 347 return (libusb_handle_events_timeout(ctx, NULL)); 348 } 349 350 int 351 libusb_handle_events_locked(libusb_context *ctx, struct timeval *tv) 352 { 353 int err; 354 355 ctx = GET_CONTEXT(ctx); 356 357 if (libusb_event_handling_ok(ctx)) { 358 err = libusb10_handle_events_sub(ctx, tv); 359 } else { 360 libusb_wait_for_event(ctx, tv); 361 err = 0; 362 } 363 return (err); 364 } 365 366 int 367 libusb_get_next_timeout(libusb_context *ctx, struct timeval *tv) 368 { 369 /* all timeouts are currently being done by the kernel */ 370 timerclear(tv); 371 return (0); 372 } 373 374 void 375 libusb_set_pollfd_notifiers(libusb_context *ctx, 376 libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb, 377 void *user_data) 378 { 379 ctx = GET_CONTEXT(ctx); 380 381 ctx->fd_added_cb = added_cb; 382 ctx->fd_removed_cb = removed_cb; 383 ctx->fd_cb_user_data = user_data; 384 } 385 386 struct libusb_pollfd ** 387 libusb_get_pollfds(libusb_context *ctx) 388 { 389 struct libusb_super_pollfd *pollfd; 390 libusb_pollfd **ret; 391 int i; 392 393 ctx = GET_CONTEXT(ctx); 394 395 CTX_LOCK(ctx); 396 397 i = 0; 398 TAILQ_FOREACH(pollfd, &ctx->pollfds, entry) 399 i++; 400 401 ret = calloc(i + 1, sizeof(struct libusb_pollfd *)); 402 if (ret == NULL) 403 goto done; 404 405 i = 0; 406 TAILQ_FOREACH(pollfd, &ctx->pollfds, entry) 407 ret[i++] = &pollfd->pollfd; 408 ret[i] = NULL; 409 410 done: 411 CTX_UNLOCK(ctx); 412 return (ret); 413 } 414 415 416 /* Synchronous device I/O */ 417 418 int 419 libusb_control_transfer(libusb_device_handle *devh, 420 uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, 421 uint8_t *data, uint16_t wLength, unsigned int timeout) 422 { 423 struct LIBUSB20_CONTROL_SETUP_DECODED req; 424 int err; 425 uint16_t actlen; 426 427 if (devh == NULL) 428 return (LIBUSB_ERROR_INVALID_PARAM); 429 430 if ((wLength != 0) && (data == NULL)) 431 return (LIBUSB_ERROR_INVALID_PARAM); 432 433 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req); 434 435 req.bmRequestType = bmRequestType; 436 req.bRequest = bRequest; 437 req.wValue = wValue; 438 req.wIndex = wIndex; 439 req.wLength = wLength; 440 441 err = libusb20_dev_request_sync(devh, &req, data, 442 &actlen, timeout, 0); 443 444 if (err == LIBUSB20_ERROR_PIPE) 445 return (LIBUSB_ERROR_PIPE); 446 else if (err == LIBUSB20_ERROR_TIMEOUT) 447 return (LIBUSB_ERROR_TIMEOUT); 448 else if (err) 449 return (LIBUSB_ERROR_NO_DEVICE); 450 451 return (actlen); 452 } 453 454 static void 455 libusb10_do_transfer_cb(struct libusb_transfer *transfer) 456 { 457 libusb_context *ctx; 458 int *pdone; 459 460 ctx = GET_CONTEXT(NULL); 461 462 DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "sync I/O done"); 463 464 pdone = transfer->user_data; 465 *pdone = 1; 466 } 467 468 /* 469 * TODO: Replace the following function. Allocating and freeing on a 470 * per-transfer basis is slow. --HPS 471 */ 472 static int 473 libusb10_do_transfer(libusb_device_handle *devh, 474 uint8_t endpoint, uint8_t *data, int length, 475 int *transferred, unsigned int timeout, int type) 476 { 477 libusb_context *ctx; 478 struct libusb_transfer *xfer; 479 volatile int complet; 480 int ret; 481 482 if (devh == NULL) 483 return (LIBUSB_ERROR_INVALID_PARAM); 484 485 if ((length != 0) && (data == NULL)) 486 return (LIBUSB_ERROR_INVALID_PARAM); 487 488 xfer = libusb_alloc_transfer(0); 489 if (xfer == NULL) 490 return (LIBUSB_ERROR_NO_MEM); 491 492 ctx = libusb_get_device(devh)->ctx; 493 494 xfer->dev_handle = devh; 495 xfer->endpoint = endpoint; 496 xfer->type = type; 497 xfer->timeout = timeout; 498 xfer->buffer = data; 499 xfer->length = length; 500 xfer->user_data = (void *)&complet; 501 xfer->callback = libusb10_do_transfer_cb; 502 complet = 0; 503 504 if ((ret = libusb_submit_transfer(xfer)) < 0) { 505 libusb_free_transfer(xfer); 506 return (ret); 507 } 508 while (complet == 0) { 509 if ((ret = libusb_handle_events(ctx)) < 0) { 510 libusb_cancel_transfer(xfer); 511 usleep(1000); /* nice it */ 512 } 513 } 514 515 *transferred = xfer->actual_length; 516 517 switch (xfer->status) { 518 case LIBUSB_TRANSFER_COMPLETED: 519 ret = 0; 520 break; 521 case LIBUSB_TRANSFER_TIMED_OUT: 522 ret = LIBUSB_ERROR_TIMEOUT; 523 break; 524 case LIBUSB_TRANSFER_OVERFLOW: 525 ret = LIBUSB_ERROR_OVERFLOW; 526 break; 527 case LIBUSB_TRANSFER_STALL: 528 ret = LIBUSB_ERROR_PIPE; 529 break; 530 case LIBUSB_TRANSFER_NO_DEVICE: 531 ret = LIBUSB_ERROR_NO_DEVICE; 532 break; 533 default: 534 ret = LIBUSB_ERROR_OTHER; 535 break; 536 } 537 538 libusb_free_transfer(xfer); 539 return (ret); 540 } 541 542 int 543 libusb_bulk_transfer(libusb_device_handle *devh, 544 uint8_t endpoint, uint8_t *data, int length, 545 int *transferred, unsigned int timeout) 546 { 547 libusb_context *ctx; 548 int ret; 549 550 ctx = GET_CONTEXT(NULL); 551 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer enter"); 552 553 ret = libusb10_do_transfer(devh, endpoint, data, length, transferred, 554 timeout, LIBUSB_TRANSFER_TYPE_BULK); 555 556 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer leave"); 557 return (ret); 558 } 559 560 int 561 libusb_interrupt_transfer(libusb_device_handle *devh, 562 uint8_t endpoint, uint8_t *data, int length, 563 int *transferred, unsigned int timeout) 564 { 565 libusb_context *ctx; 566 int ret; 567 568 ctx = GET_CONTEXT(NULL); 569 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer enter"); 570 571 ret = libusb10_do_transfer(devh, endpoint, data, length, transferred, 572 timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT); 573 574 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer leave"); 575 return (ret); 576 } 577 578 uint8_t * 579 libusb_get_iso_packet_buffer(struct libusb_transfer *transfer, uint32_t index) 580 { 581 uint8_t *ptr; 582 uint32_t n; 583 584 if (transfer->num_iso_packets < 0) 585 return (NULL); 586 587 if (index >= (uint32_t)transfer->num_iso_packets) 588 return (NULL); 589 590 ptr = transfer->buffer; 591 if (ptr == NULL) 592 return (NULL); 593 594 for (n = 0; n != index; n++) { 595 ptr += transfer->iso_packet_desc[n].length; 596 } 597 return (ptr); 598 } 599 600 uint8_t * 601 libusb_get_iso_packet_buffer_simple(struct libusb_transfer *transfer, uint32_t index) 602 { 603 uint8_t *ptr; 604 605 if (transfer->num_iso_packets < 0) 606 return (NULL); 607 608 if (index >= (uint32_t)transfer->num_iso_packets) 609 return (NULL); 610 611 ptr = transfer->buffer; 612 if (ptr == NULL) 613 return (NULL); 614 615 ptr += transfer->iso_packet_desc[0].length * index; 616 617 return (ptr); 618 } 619 620 void 621 libusb_set_iso_packet_lengths(struct libusb_transfer *transfer, uint32_t length) 622 { 623 int n; 624 625 if (transfer->num_iso_packets < 0) 626 return; 627 628 for (n = 0; n != transfer->num_iso_packets; n++) 629 transfer->iso_packet_desc[n].length = length; 630 } 631 632 uint8_t * 633 libusb_control_transfer_get_data(struct libusb_transfer *transfer) 634 { 635 if (transfer->buffer == NULL) 636 return (NULL); 637 638 return (transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE); 639 } 640 641 struct libusb_control_setup * 642 libusb_control_transfer_get_setup(struct libusb_transfer *transfer) 643 { 644 return ((struct libusb_control_setup *)transfer->buffer); 645 } 646 647 void 648 libusb_fill_control_setup(uint8_t *buf, uint8_t bmRequestType, 649 uint8_t bRequest, uint16_t wValue, 650 uint16_t wIndex, uint16_t wLength) 651 { 652 struct libusb_control_setup *req = (struct libusb_control_setup *)buf; 653 654 /* The alignment is OK for all fields below. */ 655 req->bmRequestType = bmRequestType; 656 req->bRequest = bRequest; 657 req->wValue = htole16(wValue); 658 req->wIndex = htole16(wIndex); 659 req->wLength = htole16(wLength); 660 } 661 662 void 663 libusb_fill_control_transfer(struct libusb_transfer *transfer, 664 libusb_device_handle *devh, uint8_t *buf, 665 libusb_transfer_cb_fn callback, void *user_data, 666 uint32_t timeout) 667 { 668 struct libusb_control_setup *setup = (struct libusb_control_setup *)buf; 669 670 transfer->dev_handle = devh; 671 transfer->endpoint = 0; 672 transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL; 673 transfer->timeout = timeout; 674 transfer->buffer = buf; 675 if (setup != NULL) 676 transfer->length = LIBUSB_CONTROL_SETUP_SIZE 677 + le16toh(setup->wLength); 678 else 679 transfer->length = 0; 680 transfer->user_data = user_data; 681 transfer->callback = callback; 682 683 } 684 685 void 686 libusb_fill_bulk_transfer(struct libusb_transfer *transfer, 687 libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf, 688 int length, libusb_transfer_cb_fn callback, void *user_data, 689 uint32_t timeout) 690 { 691 transfer->dev_handle = devh; 692 transfer->endpoint = endpoint; 693 transfer->type = LIBUSB_TRANSFER_TYPE_BULK; 694 transfer->timeout = timeout; 695 transfer->buffer = buf; 696 transfer->length = length; 697 transfer->user_data = user_data; 698 transfer->callback = callback; 699 } 700 701 void 702 libusb_fill_interrupt_transfer(struct libusb_transfer *transfer, 703 libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf, 704 int length, libusb_transfer_cb_fn callback, void *user_data, 705 uint32_t timeout) 706 { 707 transfer->dev_handle = devh; 708 transfer->endpoint = endpoint; 709 transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT; 710 transfer->timeout = timeout; 711 transfer->buffer = buf; 712 transfer->length = length; 713 transfer->user_data = user_data; 714 transfer->callback = callback; 715 } 716 717 void 718 libusb_fill_iso_transfer(struct libusb_transfer *transfer, 719 libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf, 720 int length, int npacket, libusb_transfer_cb_fn callback, 721 void *user_data, uint32_t timeout) 722 { 723 transfer->dev_handle = devh; 724 transfer->endpoint = endpoint; 725 transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS; 726 transfer->timeout = timeout; 727 transfer->buffer = buf; 728 transfer->length = length; 729 transfer->num_iso_packets = npacket; 730 transfer->user_data = user_data; 731 transfer->callback = callback; 732 } 733 734