libusb/os/darwin_usb.c

   1 /* -*- Mode: C; indent-tabs-mode:nil -*- */
   2 /*
   3  * darwin backend for libusb 1.0
   4  * Copyright © 2008-2020 Nathan Hjelm <hjelmn@cs.unm.edu>
   5  * Copyright © 2019-2020 Google LLC. All rights reserved.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <config.h>
  23 #include <assert.h>
  24 #include <time.h>
  25 #include <ctype.h>
  26 #include <pthread.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/types.h>
  31 #include <unistd.h>
  32 #include <fcntl.h>
  33 #include <sys/sysctl.h>
  34
  35 #include <mach/clock.h>
  36 #include <mach/clock_types.h>
  37 #include <mach/mach_host.h>
  38 #include <mach/mach_port.h>
  39
  40 /* Suppress warnings about the use of the deprecated objc_registerThreadWithCollector
  41  * function. Its use is also conditionalized to only older deployment targets. */
  42 #define OBJC_SILENCE_GC_DEPRECATIONS 1
  43
  44 /* Default timeout to 10s for reenumerate. This is needed because USBDeviceReEnumerate
  45  * does not return error status on macOS. */
  46 #define DARWIN_REENUMERATE_TIMEOUT_US 10000000
  47
  48 #include <AvailabilityMacros.h>
  49 #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 && MAC_OS_X_VERSION_MIN_REQUIRED < 101200
  50   #include <objc/objc-auto.h>
  51 #endif
  52
  53 #include "darwin_usb.h"
  54
  55 static int init_count = 0;
  56
  57 /* async event thread */
  58 static pthread_mutex_t libusb_darwin_at_mutex = PTHREAD_MUTEX_INITIALIZER;
  59 static pthread_cond_t  libusb_darwin_at_cond = PTHREAD_COND_INITIALIZER;
  60
  61 #if !defined(HAVE_CLOCK_GETTIME)
  62 static clock_serv_t clock_realtime;
  63 static clock_serv_t clock_monotonic;
  64 #endif
  65
  66 #define LIBUSB_DARWIN_STARTUP_FAILURE ((CFRunLoopRef) -1)
  67
  68 static CFRunLoopRef libusb_darwin_acfl = NULL; /* event cf loop */
  69 static CFRunLoopSourceRef libusb_darwin_acfls = NULL; /* shutdown signal for event cf loop */
  70
  71 static usbi_mutex_t darwin_cached_devices_lock = PTHREAD_MUTEX_INITIALIZER;
  72 static struct list_head darwin_cached_devices;
  73 static const char *darwin_device_class = "IOUSBDevice";
  74
  75 #define DARWIN_CACHED_DEVICE(a) (((struct darwin_device_priv *)usbi_get_device_priv((a)))->dev)
  76
  77 /* async event thread */
  78 static pthread_t libusb_darwin_at;
  79
  80 static int darwin_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, void *buffer, size_t len);
  81 static int darwin_claim_interface(struct libusb_device_handle *dev_handle, uint8_t iface);
  82 static int darwin_release_interface(struct libusb_device_handle *dev_handle, uint8_t iface);
  83 static int darwin_reenumerate_device(struct libusb_device_handle *dev_handle, bool capture);
  84 static int darwin_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint);
  85 static int darwin_reset_device(struct libusb_device_handle *dev_handle);
  86 static void darwin_async_io_callback (void *refcon, IOReturn result, void *arg0);
  87
  88 static enum libusb_error darwin_scan_devices(struct libusb_context *ctx);
  89 static enum libusb_error process_new_device (struct libusb_context *ctx, struct darwin_cached_device *cached_device,
  90                                              UInt64 old_session_id);
  91
  92 static enum libusb_error darwin_get_cached_device(io_service_t service, struct darwin_cached_device **cached_out,
  93                                                   UInt64 *old_session_id);
  94
  95 #if defined(ENABLE_LOGGING)
  96 static const char *darwin_error_str (IOReturn result) {
  97   static char string_buffer[50];
  98   switch (result) {
  99   case kIOReturnSuccess:
 100     return "no error";
 101   case kIOReturnNotOpen:
 102     return "device not opened for exclusive access";
 103   case kIOReturnNoDevice:
 104     return "no connection to an IOService";
 105   case kIOUSBNoAsyncPortErr:
 106     return "no async port has been opened for interface";
 107   case kIOReturnExclusiveAccess:
 108     return "another process has device opened for exclusive access";
 109   case kIOUSBPipeStalled:
 110     return "pipe is stalled";
 111   case kIOReturnError:
 112     return "could not establish a connection to the Darwin kernel";
 113   case kIOUSBTransactionTimeout:
 114     return "transaction timed out";
 115   case kIOReturnBadArgument:
 116     return "invalid argument";
 117   case kIOReturnAborted:
 118     return "transaction aborted";
 119   case kIOReturnNotResponding:
 120     return "device not responding";
 121   case kIOReturnOverrun:
 122     return "data overrun";
 123   case kIOReturnCannotWire:
 124     return "physical memory can not be wired down";
 125   case kIOReturnNoResources:
 126     return "out of resources";
 127   case kIOUSBHighSpeedSplitError:
 128     return "high speed split error";
 129   case kIOUSBUnknownPipeErr:
 130     return "pipe ref not recognized";
 131   default:
 132     snprintf(string_buffer, sizeof(string_buffer), "unknown error (0x%x)", result);
 133     return string_buffer;
 134   }
 135 }
 136 #endif
 137
 138 static enum libusb_error darwin_to_libusb (IOReturn result) {
 139   switch (result) {
 140   case kIOReturnUnderrun:
 141   case kIOReturnSuccess:
 142     return LIBUSB_SUCCESS;
 143   case kIOReturnNotOpen:
 144   case kIOReturnNoDevice:
 145     return LIBUSB_ERROR_NO_DEVICE;
 146   case kIOReturnExclusiveAccess:
 147     return LIBUSB_ERROR_ACCESS;
 148   case kIOUSBPipeStalled:
 149     return LIBUSB_ERROR_PIPE;
 150   case kIOReturnBadArgument:
 151     return LIBUSB_ERROR_INVALID_PARAM;
 152   case kIOUSBTransactionTimeout:
 153     return LIBUSB_ERROR_TIMEOUT;
 154   case kIOReturnNotResponding:
 155   case kIOReturnAborted:
 156   case kIOReturnError:
 157   case kIOUSBNoAsyncPortErr:
 158   case kIOUSBUnknownPipeErr:
 159   default:
 160     return LIBUSB_ERROR_OTHER;
 161   }
 162 }
 163
 164 /* this function must be called with the darwin_cached_devices_lock held */
 165 static void darwin_deref_cached_device(struct darwin_cached_device *cached_dev) {
 166   cached_dev->refcount--;
 167   /* free the device and remove it from the cache */
 168   if (0 == cached_dev->refcount) {
 169     list_del(&cached_dev->list);
 170
 171     if (cached_dev->device) {
 172       (*(cached_dev->device))->Release(cached_dev->device);
 173       cached_dev->device = NULL;
 174     }
 175     IOObjectRelease (cached_dev->service);
 176     free (cached_dev);
 177   }
 178 }
 179
 180 static void darwin_ref_cached_device(struct darwin_cached_device *cached_dev) {
 181   cached_dev->refcount++;
 182 }
 183
 184 static int ep_to_pipeRef(struct libusb_device_handle *dev_handle, uint8_t ep, uint8_t *pipep, uint8_t *ifcp, struct darwin_interface **interface_out) {
 185   struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
 186
 187   /* current interface */
 188   struct darwin_interface *cInterface;
 189
 190   uint8_t i, iface;
 191
 192   usbi_dbg ("converting ep address 0x%02x to pipeRef and interface", ep);
 193
 194   for (iface = 0 ; iface < USB_MAXINTERFACES ; iface++) {
 195     cInterface = &priv->interfaces[iface];
 196
 197     if (dev_handle->claimed_interfaces & (1U << iface)) {
 198       for (i = 0 ; i < cInterface->num_endpoints ; i++) {
 199         if (cInterface->endpoint_addrs[i] == ep) {
 200           *pipep = i + 1;
 201
 202           if (ifcp)
 203             *ifcp = iface;
 204
 205           if (interface_out)
 206             *interface_out = cInterface;
 207
 208           usbi_dbg ("pipe %d on interface %d matches", *pipep, iface);
 209           return LIBUSB_SUCCESS;
 210         }
 211       }
 212     }
 213   }
 214
 215   /* No pipe found with the correct endpoint address */
 216   usbi_warn (HANDLE_CTX(dev_handle), "no pipeRef found with endpoint address 0x%02x.", ep);
 217
 218   return LIBUSB_ERROR_NOT_FOUND;
 219 }
 220
 221 static IOReturn usb_setup_device_iterator (io_iterator_t *deviceIterator, UInt32 location) {
 222   CFMutableDictionaryRef matchingDict = IOServiceMatching(darwin_device_class);
 223
 224   if (!matchingDict)
 225     return kIOReturnError;
 226
 227   if (location) {
 228     CFMutableDictionaryRef propertyMatchDict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
 229                                                                          &kCFTypeDictionaryKeyCallBacks,
 230                                                                          &kCFTypeDictionaryValueCallBacks);
 231
 232     /* there are no unsigned CFNumber types so treat the value as signed. the OS seems to do this
 233          internally (CFNumberType of locationID is kCFNumberSInt32Type) */
 234     CFTypeRef locationCF = CFNumberCreate (NULL, kCFNumberSInt32Type, &location);
 235
 236     if (propertyMatchDict && locationCF) {
 237       CFDictionarySetValue (propertyMatchDict, CFSTR(kUSBDevicePropertyLocationID), locationCF);
 238       CFDictionarySetValue (matchingDict, CFSTR(kIOPropertyMatchKey), propertyMatchDict);
 239     }
 240     /* else we can still proceed as long as the caller accounts for the possibility of other devices in the iterator */
 241
 242     /* release our references as per the Create Rule */
 243     if (propertyMatchDict)
 244       CFRelease (propertyMatchDict);
 245     if (locationCF)
 246       CFRelease (locationCF);
 247   }
 248
 249   return IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, deviceIterator);
 250 }
 251
 252 /* Returns 1 on success, 0 on failure. */
 253 static bool get_ioregistry_value_number (io_service_t service, CFStringRef property, CFNumberType type, void *p) {
 254   CFTypeRef cfNumber = IORegistryEntryCreateCFProperty (service, property, kCFAllocatorDefault, 0);
 255   Boolean success = 0;
 256
 257   if (cfNumber) {
 258     if (CFGetTypeID(cfNumber) == CFNumberGetTypeID()) {
 259       success = CFNumberGetValue(cfNumber, type, p);
 260     }
 261
 262     CFRelease (cfNumber);
 263   }
 264
 265   return (success != 0);
 266 }
 267
 268 /* Returns 1 on success, 0 on failure. */
 269 static bool get_ioregistry_value_data (io_service_t service, CFStringRef property, ssize_t size, void *p) {
 270   CFTypeRef cfData = IORegistryEntryCreateCFProperty (service, property, kCFAllocatorDefault, 0);
 271   bool success = false;
 272
 273   if (cfData) {
 274     if (CFGetTypeID (cfData) == CFDataGetTypeID ()) {
 275       CFIndex length = CFDataGetLength (cfData);
 276       if (length < size) {
 277         size = length;
 278       }
 279
 280       CFDataGetBytes (cfData, CFRangeMake(0, size), p);
 281       success = true;
 282     }
 283
 284     CFRelease (cfData);
 285   }
 286
 287   return success;
 288 }
 289
 290 static usb_device_t **darwin_device_from_service (io_service_t service)
 291 {
 292   io_cf_plugin_ref_t *plugInInterface = NULL;
 293   usb_device_t **device;
 294   IOReturn kresult;
 295   SInt32 score;
 296   const int max_retries = 5;
 297
 298   /* The IOCreatePlugInInterfaceForService function might consistently return
 299      an "out of resources" error with certain USB devices the first time we run
 300      it. The reason is still unclear, but retrying fixes the problem */
 301   for (int count = 0; count < max_retries; count++) {
 302     kresult = IOCreatePlugInInterfaceForService(service, kIOUSBDeviceUserClientTypeID,
 303                                                 kIOCFPlugInInterfaceID, &plugInInterface,
 304                                                 &score);
 305     if (kIOReturnSuccess == kresult && plugInInterface) {
 306       break;
 307     }
 308
 309     usbi_dbg ("set up plugin for service retry: %s", darwin_error_str (kresult));
 310
 311     /* sleep for a little while before trying again */
 312     nanosleep(&(struct timespec){.tv_sec = 0, .tv_nsec = 1000}, NULL);
 313   }
 314
 315   if (kIOReturnSuccess != kresult || !plugInInterface) {
 316     usbi_dbg ("could not set up plugin for service: %s", darwin_error_str (kresult));
 317     return NULL;
 318   }
 319
 320   (void)(*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(DeviceInterfaceID),
 321                                            (LPVOID)&device);
 322   /* Use release instead of IODestroyPlugInInterface to avoid stopping IOServices associated with this device */
 323   (*plugInInterface)->Release (plugInInterface);
 324
 325   return device;
 326 }
 327
 328 static void darwin_devices_attached (void *ptr, io_iterator_t add_devices) {
 329   UNUSED(ptr);
 330   struct darwin_cached_device *cached_device;
 331   UInt64 old_session_id;
 332   struct libusb_context *ctx;
 333   io_service_t service;
 334   int ret;
 335
 336   usbi_mutex_lock(&active_contexts_lock);
 337
 338   while ((service = IOIteratorNext(add_devices))) {
 339     ret = darwin_get_cached_device (service, &cached_device, &old_session_id);
 340     if (ret < 0 || !cached_device->can_enumerate) {
 341       continue;
 342     }
 343
 344     /* add this device to each active context's device list */
 345     for_each_context(ctx) {
 346       process_new_device (ctx, cached_device, old_session_id);
 347     }
 348
 349     if (cached_device->in_reenumerate) {
 350       usbi_dbg ("cached device in reset state. reset complete...");
 351       cached_device->in_reenumerate = false;
 352     }
 353
 354     IOObjectRelease(service);
 355   }
 356
 357   usbi_mutex_unlock(&active_contexts_lock);
 358 }
 359
 360 static void darwin_devices_detached (void *ptr, io_iterator_t rem_devices) {
 361   UNUSED(ptr);
 362   struct libusb_device *dev = NULL;
 363   struct libusb_context *ctx;
 364   struct darwin_cached_device *old_device;
 365
 366   io_service_t device;
 367   UInt64 session;
 368   int ret;
 369
 370   usbi_mutex_lock(&active_contexts_lock);
 371
 372   while ((device = IOIteratorNext (rem_devices)) != 0) {
 373     bool is_reenumerating = false;
 374
 375     /* get the location from the i/o registry */
 376     ret = get_ioregistry_value_number (device, CFSTR("sessionID"), kCFNumberSInt64Type, &session);
 377     IOObjectRelease (device);
 378     if (!ret)
 379       continue;
 380
 381     /* we need to match darwin_ref_cached_device call made in darwin_get_cached_device function
 382        otherwise no cached device will ever get freed */
 383     usbi_mutex_lock(&darwin_cached_devices_lock);
 384     list_for_each_entry(old_device, &darwin_cached_devices, list, struct darwin_cached_device) {
 385       if (old_device->session == session) {
 386         if (old_device->in_reenumerate) {
 387           /* device is re-enumerating. do not dereference the device at this time. libusb_reset_device()
 388            * will deref if needed. */
 389           usbi_dbg ("detected device detached due to re-enumeration");
 390
 391           /* the device object is no longer usable so go ahead and release it */
 392           if (old_device->device) {
 393             (*(old_device->device))->Release(old_device->device);
 394             old_device->device = NULL;
 395           }
 396
 397           is_reenumerating = true;
 398         } else {
 399           darwin_deref_cached_device (old_device);
 400         }
 401
 402         break;
 403       }
 404     }
 405
 406     usbi_mutex_unlock(&darwin_cached_devices_lock);
 407     if (is_reenumerating) {
 408       continue;
 409     }
 410
 411     for_each_context(ctx) {
 412       usbi_dbg ("notifying context %p of device disconnect", ctx);
 413
 414       dev = usbi_get_device_by_session_id(ctx, (unsigned long) session);
 415       if (dev) {
 416         /* signal the core that this device has been disconnected. the core will tear down this device
 417            when the reference count reaches 0 */
 418         usbi_disconnect_device(dev);
 419         libusb_unref_device(dev);
 420       }
 421     }
 422   }
 423
 424   usbi_mutex_unlock(&active_contexts_lock);
 425 }
 426
 427 static void darwin_hotplug_poll (void)
 428 {
 429   /* not sure if 1 ms will be too long/short but it should work ok */
 430   mach_timespec_t timeout = {.tv_sec = 0, .tv_nsec = 1000000ul};
 431
 432   /* since a kernel thread may notify the IOIterators used for
 433    * hotplug notification we can't just clear the iterators.
 434    * instead just wait until all IOService providers are quiet */
 435   (void) IOKitWaitQuiet (kIOMasterPortDefault, &timeout);
 436 }
 437
 438 static void darwin_clear_iterator (io_iterator_t iter) {
 439   io_service_t device;
 440
 441   while ((device = IOIteratorNext (iter)) != 0)
 442     IOObjectRelease (device);
 443 }
 444
 445 static void darwin_fail_startup(void) {
 446   pthread_mutex_lock (&libusb_darwin_at_mutex);
 447   libusb_darwin_acfl = LIBUSB_DARWIN_STARTUP_FAILURE;
 448   pthread_cond_signal (&libusb_darwin_at_cond);
 449   pthread_mutex_unlock (&libusb_darwin_at_mutex);
 450   pthread_exit (NULL);
 451 }
 452
 453 static void *darwin_event_thread_main (void *arg0) {
 454   IOReturn kresult;
 455   struct libusb_context *ctx = (struct libusb_context *)arg0;
 456   CFRunLoopRef runloop;
 457   CFRunLoopSourceRef libusb_shutdown_cfsource;
 458   CFRunLoopSourceContext libusb_shutdown_cfsourcectx;
 459
 460 #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
 461   /* Set this thread's name, so it can be seen in the debugger
 462      and crash reports. */
 463   pthread_setname_np ("org.libusb.device-hotplug");
 464 #endif
 465
 466 #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 && MAC_OS_X_VERSION_MIN_REQUIRED < 101200
 467   /* Tell the Objective-C garbage collector about this thread.
 468      This is required because, unlike NSThreads, pthreads are
 469      not automatically registered. Although we don't use
 470      Objective-C, we use CoreFoundation, which does.
 471      Garbage collection support was entirely removed in 10.12,
 472      so don't bother there. */
 473   objc_registerThreadWithCollector();
 474 #endif
 475
 476   /* hotplug (device arrival/removal) sources */
 477   CFRunLoopSourceRef     libusb_notification_cfsource;
 478   io_notification_port_t libusb_notification_port;
 479   io_iterator_t          libusb_rem_device_iterator;
 480   io_iterator_t          libusb_add_device_iterator;
 481
 482   usbi_dbg ("creating hotplug event source");
 483
 484   runloop = CFRunLoopGetCurrent ();
 485   CFRetain (runloop);
 486
 487   /* add the shutdown cfsource to the run loop */
 488   memset(&libusb_shutdown_cfsourcectx, 0, sizeof(libusb_shutdown_cfsourcectx));
 489   libusb_shutdown_cfsourcectx.info = runloop;
 490   libusb_shutdown_cfsourcectx.perform = (void (*)(void *))CFRunLoopStop;
 491   libusb_shutdown_cfsource = CFRunLoopSourceCreate(NULL, 0, &libusb_shutdown_cfsourcectx);
 492   CFRunLoopAddSource(runloop, libusb_shutdown_cfsource, kCFRunLoopDefaultMode);
 493
 494   /* add the notification port to the run loop */
 495   libusb_notification_port     = IONotificationPortCreate (kIOMasterPortDefault);
 496   libusb_notification_cfsource = IONotificationPortGetRunLoopSource (libusb_notification_port);
 497   CFRunLoopAddSource(runloop, libusb_notification_cfsource, kCFRunLoopDefaultMode);
 498
 499   /* create notifications for removed devices */
 500   kresult = IOServiceAddMatchingNotification (libusb_notification_port, kIOTerminatedNotification,
 501                                               IOServiceMatching(darwin_device_class),
 502                                               darwin_devices_detached,
 503                                               ctx, &libusb_rem_device_iterator);
 504
 505   if (kresult != kIOReturnSuccess) {
 506     usbi_err (ctx, "could not add hotplug event source: %s", darwin_error_str (kresult));
 507     CFRelease (libusb_shutdown_cfsource);
 508     CFRelease (runloop);
 509     darwin_fail_startup ();
 510   }
 511
 512   /* create notifications for attached devices */
 513   kresult = IOServiceAddMatchingNotification(libusb_notification_port, kIOFirstMatchNotification,
 514                                               IOServiceMatching(darwin_device_class),
 515                                               darwin_devices_attached,
 516                                               ctx, &libusb_add_device_iterator);
 517
 518   if (kresult != kIOReturnSuccess) {
 519     usbi_err (ctx, "could not add hotplug event source: %s", darwin_error_str (kresult));
 520     CFRelease (libusb_shutdown_cfsource);
 521     CFRelease (runloop);
 522     darwin_fail_startup ();
 523   }
 524
 525   /* arm notifiers */
 526   darwin_clear_iterator (libusb_rem_device_iterator);
 527   darwin_clear_iterator (libusb_add_device_iterator);
 528
 529   usbi_dbg ("darwin event thread ready to receive events");
 530
 531   /* signal the main thread that the hotplug runloop has been created. */
 532   pthread_mutex_lock (&libusb_darwin_at_mutex);
 533   libusb_darwin_acfl = runloop;
 534   libusb_darwin_acfls = libusb_shutdown_cfsource;
 535   pthread_cond_signal (&libusb_darwin_at_cond);
 536   pthread_mutex_unlock (&libusb_darwin_at_mutex);
 537
 538   /* run the runloop */
 539   CFRunLoopRun();
 540
 541   usbi_dbg ("darwin event thread exiting");
 542
 543   /* signal the main thread that the hotplug runloop has finished. */
 544   pthread_mutex_lock (&libusb_darwin_at_mutex);
 545   libusb_darwin_acfls = NULL;
 546   libusb_darwin_acfl = NULL;
 547   pthread_cond_signal (&libusb_darwin_at_cond);
 548   pthread_mutex_unlock (&libusb_darwin_at_mutex);
 549
 550   /* remove the notification cfsource */
 551   CFRunLoopRemoveSource(runloop, libusb_notification_cfsource, kCFRunLoopDefaultMode);
 552
 553   /* remove the shutdown cfsource */
 554   CFRunLoopRemoveSource(runloop, libusb_shutdown_cfsource, kCFRunLoopDefaultMode);
 555
 556   /* delete notification port */
 557   IONotificationPortDestroy (libusb_notification_port);
 558
 559   /* delete iterators */
 560   IOObjectRelease (libusb_rem_device_iterator);
 561   IOObjectRelease (libusb_add_device_iterator);
 562
 563   CFRelease (libusb_shutdown_cfsource);
 564   CFRelease (runloop);
 565
 566   pthread_exit (NULL);
 567 }
 568
 569 /* cleanup function to destroy cached devices */
 570 static void darwin_cleanup_devices(void) {
 571   struct darwin_cached_device *dev, *next;
 572
 573   list_for_each_entry_safe(dev, next, &darwin_cached_devices, list, struct darwin_cached_device) {
 574     darwin_deref_cached_device(dev);
 575   }
 576 }
 577
 578 static int darwin_init(struct libusb_context *ctx) {
 579   bool first_init;
 580   int rc;
 581
 582   first_init = (1 == ++init_count);
 583
 584   do {
 585     if (first_init) {
 586       if (NULL == darwin_cached_devices.next) {
 587         list_init (&darwin_cached_devices);
 588       }
 589       assert(list_empty(&darwin_cached_devices));
 590 #if !defined(HAVE_CLOCK_GETTIME)
 591       /* create the clocks that will be used if clock_gettime() is not available */
 592       host_name_port_t host_self;
 593
 594       host_self = mach_host_self();
 595       host_get_clock_service(host_self, CALENDAR_CLOCK, &clock_realtime);
 596       host_get_clock_service(host_self, SYSTEM_CLOCK, &clock_monotonic);
 597       mach_port_deallocate(mach_task_self(), host_self);
 598 #endif
 599     }
 600
 601     rc = darwin_scan_devices (ctx);
 602     if (LIBUSB_SUCCESS != rc)
 603       break;
 604
 605     if (first_init) {
 606       rc = pthread_create (&libusb_darwin_at, NULL, darwin_event_thread_main, ctx);
 607       if (0 != rc) {
 608         usbi_err (ctx, "could not create event thread, error %d", rc);
 609         rc = LIBUSB_ERROR_OTHER;
 610         break;
 611       }
 612
 613       pthread_mutex_lock (&libusb_darwin_at_mutex);
 614       while (!libusb_darwin_acfl)
 615         pthread_cond_wait (&libusb_darwin_at_cond, &libusb_darwin_at_mutex);
 616       if (libusb_darwin_acfl == LIBUSB_DARWIN_STARTUP_FAILURE) {
 617         libusb_darwin_acfl = NULL;
 618         rc = LIBUSB_ERROR_OTHER;
 619       }
 620       pthread_mutex_unlock (&libusb_darwin_at_mutex);
 621
 622       if (0 != rc)
 623         pthread_join (libusb_darwin_at, NULL);
 624     }
 625   } while (0);
 626
 627   if (LIBUSB_SUCCESS != rc) {
 628     if (first_init) {
 629       darwin_cleanup_devices ();
 630 #if !defined(HAVE_CLOCK_GETTIME)
 631       mach_port_deallocate(mach_task_self(), clock_realtime);
 632       mach_port_deallocate(mach_task_self(), clock_monotonic);
 633 #endif
 634     }
 635     --init_count;
 636   }
 637
 638   return rc;
 639 }
 640
 641 static void darwin_exit (struct libusb_context *ctx) {
 642   UNUSED(ctx);
 643
 644   if (0 == --init_count) {
 645     /* stop the event runloop and wait for the thread to terminate. */
 646     pthread_mutex_lock (&libusb_darwin_at_mutex);
 647     CFRunLoopSourceSignal (libusb_darwin_acfls);
 648     CFRunLoopWakeUp (libusb_darwin_acfl);
 649     while (libusb_darwin_acfl)
 650       pthread_cond_wait (&libusb_darwin_at_cond, &libusb_darwin_at_mutex);
 651     pthread_mutex_unlock (&libusb_darwin_at_mutex);
 652     pthread_join (libusb_darwin_at, NULL);
 653
 654     darwin_cleanup_devices ();
 655
 656 #if !defined(HAVE_CLOCK_GETTIME)
 657     mach_port_deallocate(mach_task_self(), clock_realtime);
 658     mach_port_deallocate(mach_task_self(), clock_monotonic);
 659 #endif
 660   }
 661 }
 662
 663 static int get_configuration_index (struct libusb_device *dev, UInt8 config_value) {
 664   struct darwin_cached_device *priv = DARWIN_CACHED_DEVICE(dev);
 665   UInt8 i, numConfig;
 666   IOUSBConfigurationDescriptorPtr desc;
 667   IOReturn kresult;
 668
 669   /* is there a simpler way to determine the index? */
 670   kresult = (*(priv->device))->GetNumberOfConfigurations (priv->device, &numConfig);
 671   if (kresult != kIOReturnSuccess)
 672     return darwin_to_libusb (kresult);
 673
 674   for (i = 0 ; i < numConfig ; i++) {
 675     (*(priv->device))->GetConfigurationDescriptorPtr (priv->device, i, &desc);
 676
 677     if (desc->bConfigurationValue == config_value)
 678       return i;
 679   }
 680
 681   /* configuration not found */
 682   return LIBUSB_ERROR_NOT_FOUND;
 683 }
 684
 685 static int darwin_get_active_config_descriptor(struct libusb_device *dev, void *buffer, size_t len) {
 686   struct darwin_cached_device *priv = DARWIN_CACHED_DEVICE(dev);
 687   int config_index;
 688
 689   if (0 == priv->active_config)
 690     return LIBUSB_ERROR_NOT_FOUND;
 691
 692   config_index = get_configuration_index (dev, priv->active_config);
 693   if (config_index < 0)
 694     return config_index;
 695
 696   assert(config_index >= 0 && config_index <= UINT8_MAX);
 697   return darwin_get_config_descriptor (dev, (UInt8)config_index, buffer, len);
 698 }
 699
 700 static int darwin_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, void *buffer, size_t len) {
 701   struct darwin_cached_device *priv = DARWIN_CACHED_DEVICE(dev);
 702   IOUSBConfigurationDescriptorPtr desc;
 703   IOReturn kresult;
 704   int ret;
 705
 706   if (!priv || !priv->device)
 707     return LIBUSB_ERROR_OTHER;
 708
 709   kresult = (*priv->device)->GetConfigurationDescriptorPtr (priv->device, config_index, &desc);
 710   if (kresult == kIOReturnSuccess) {
 711     /* copy descriptor */
 712     if (libusb_le16_to_cpu(desc->wTotalLength) < len)
 713       len = libusb_le16_to_cpu(desc->wTotalLength);
 714
 715     memmove (buffer, desc, len);
 716   }
 717
 718   ret = darwin_to_libusb (kresult);
 719   if (ret != LIBUSB_SUCCESS)
 720     return ret;
 721
 722   return (int) len;
 723 }
 724
 725 /* check whether the os has configured the device */
 726 static enum libusb_error darwin_check_configuration (struct libusb_context *ctx, struct darwin_cached_device *dev) {
 727   usb_device_t **darwin_device = dev->device;
 728
 729   IOUSBConfigurationDescriptorPtr configDesc;
 730   IOUSBFindInterfaceRequest request;
 731   IOReturn                  kresult;
 732   io_iterator_t             interface_iterator;
 733   io_service_t              firstInterface;
 734
 735   if (dev->dev_descriptor.bNumConfigurations < 1) {
 736     usbi_err (ctx, "device has no configurations");
 737     return LIBUSB_ERROR_OTHER; /* no configurations at this speed so we can't use it */
 738   }
 739
 740   /* checking the configuration of a root hub simulation takes ~1 s in 10.11. the device is
 741      not usable anyway */
 742   if (0x05ac == libusb_le16_to_cpu (dev->dev_descriptor.idVendor) &&
 743       0x8005 == libusb_le16_to_cpu (dev->dev_descriptor.idProduct)) {
 744     usbi_dbg ("ignoring configuration on root hub simulation");
 745     dev->active_config = 0;
 746     return LIBUSB_SUCCESS;
 747   }
 748
 749   /* find the first configuration */
 750   kresult = (*darwin_device)->GetConfigurationDescriptorPtr (darwin_device, 0, &configDesc);
 751   dev->first_config = (kIOReturnSuccess == kresult) ? configDesc->bConfigurationValue : 1;
 752
 753   /* check if the device is already configured. there is probably a better way than iterating over the
 754      to accomplish this (the trick is we need to avoid a call to GetConfigurations since buggy devices
 755      might lock up on the device request) */
 756
 757   /* Setup the Interface Request */
 758   request.bInterfaceClass    = kIOUSBFindInterfaceDontCare;
 759   request.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
 760   request.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
 761   request.bAlternateSetting  = kIOUSBFindInterfaceDontCare;
 762
 763   kresult = (*(darwin_device))->CreateInterfaceIterator(darwin_device, &request, &interface_iterator);
 764   if (kresult != kIOReturnSuccess)
 765     return darwin_to_libusb (kresult);
 766
 767   /* iterate once */
 768   firstInterface = IOIteratorNext(interface_iterator);
 769
 770   /* done with the interface iterator */
 771   IOObjectRelease(interface_iterator);
 772
 773   if (firstInterface) {
 774     IOObjectRelease (firstInterface);
 775
 776     /* device is configured */
 777     if (dev->dev_descriptor.bNumConfigurations == 1)
 778       /* to avoid problems with some devices get the configurations value from the configuration descriptor */
 779       dev->active_config = dev->first_config;
 780     else
 781       /* devices with more than one configuration should work with GetConfiguration */
 782       (*darwin_device)->GetConfiguration (darwin_device, &dev->active_config);
 783   } else
 784     /* not configured */
 785     dev->active_config = 0;
 786
 787   usbi_dbg ("active config: %u, first config: %u", dev->active_config, dev->first_config);
 788
 789   return LIBUSB_SUCCESS;
 790 }
 791
 792 static IOReturn darwin_request_descriptor (usb_device_t **device, UInt8 desc, UInt8 desc_index, void *buffer, size_t buffer_size) {
 793   IOUSBDevRequestTO req;
 794
 795   assert(buffer_size <= UINT16_MAX);
 796
 797   memset (buffer, 0, buffer_size);
 798
 799   /* Set up request for descriptor/ */
 800   req.bmRequestType = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
 801   req.bRequest      = kUSBRqGetDescriptor;
 802   req.wValue        = (UInt16)(desc << 8);
 803   req.wIndex        = desc_index;
 804   req.wLength       = (UInt16)buffer_size;
 805   req.pData         = buffer;
 806   req.noDataTimeout = 20;
 807   req.completionTimeout = 100;
 808
 809   return (*device)->DeviceRequestTO (device, &req);
 810 }
 811
 812 static enum libusb_error darwin_cache_device_descriptor (struct darwin_cached_device *dev) {
 813   usb_device_t **device = dev->device;
 814   int retries = 1;
 815   long delay = 30000; // microseconds
 816   int unsuspended = 0, try_unsuspend = 1, try_reconfigure = 1;
 817   int is_open = 0;
 818   IOReturn ret = 0, ret2;
 819   UInt8 bDeviceClass;
 820   UInt16 idProduct, idVendor;
 821
 822   dev->can_enumerate = 0;
 823
 824   (*device)->GetDeviceClass (device, &bDeviceClass);
 825   (*device)->GetDeviceProduct (device, &idProduct);
 826   (*device)->GetDeviceVendor (device, &idVendor);
 827
 828   /* According to Apple's documentation the device must be open for DeviceRequest but we may not be able to open some
 829    * devices and Apple's USB Prober doesn't bother to open the device before issuing a descriptor request.  Still,
 830    * to follow the spec as closely as possible, try opening the device */
 831   is_open = ((*device)->USBDeviceOpenSeize(device) == kIOReturnSuccess);
 832
 833   do {
 834     /**** retrieve device descriptor ****/
 835     ret = darwin_request_descriptor (device, kUSBDeviceDesc, 0, &dev->dev_descriptor, sizeof(dev->dev_descriptor));
 836
 837     if (kIOReturnOverrun == ret && kUSBDeviceDesc == dev->dev_descriptor.bDescriptorType)
 838       /* received an overrun error but we still received a device descriptor */
 839       ret = kIOReturnSuccess;
 840
 841     if (kIOUSBVendorIDAppleComputer == idVendor) {
 842       /* NTH: don't bother retrying or unsuspending Apple devices */
 843       break;
 844     }
 845
 846     if (kIOReturnSuccess == ret && (0 == dev->dev_descriptor.bNumConfigurations ||
 847                                     0 == dev->dev_descriptor.bcdUSB)) {
 848       /* work around for incorrectly configured devices */
 849       if (try_reconfigure && is_open) {
 850         usbi_dbg("descriptor appears to be invalid. resetting configuration before trying again...");
 851
 852         /* set the first configuration */
 853         (*device)->SetConfiguration(device, 1);
 854
 855         /* don't try to reconfigure again */
 856         try_reconfigure = 0;
 857       }
 858
 859       ret = kIOUSBPipeStalled;
 860     }
 861
 862     if (kIOReturnSuccess != ret && is_open && try_unsuspend) {
 863       /* device may be suspended. unsuspend it and try again */
 864 #if DeviceVersion >= 320
 865       UInt32 info = 0;
 866
 867       /* IOUSBFamily 320+ provides a way to detect device suspension but earlier versions do not */
 868       (void)(*device)->GetUSBDeviceInformation (device, &info);
 869
 870       /* note that the device was suspended */
 871       if (info & (1U << kUSBInformationDeviceIsSuspendedBit) || 0 == info)
 872         try_unsuspend = 1;
 873 #endif
 874
 875       if (try_unsuspend) {
 876         /* try to unsuspend the device */
 877         ret2 = (*device)->USBDeviceSuspend (device, 0);
 878         if (kIOReturnSuccess != ret2) {
 879           /* prevent log spew from poorly behaving devices.  this indicates the
 880              os actually had trouble communicating with the device */
 881           usbi_dbg("could not retrieve device descriptor. failed to unsuspend: %s",darwin_error_str(ret2));
 882         } else
 883           unsuspended = 1;
 884
 885         try_unsuspend = 0;
 886       }
 887     }
 888
 889     if (kIOReturnSuccess != ret) {
 890       usbi_dbg("kernel responded with code: 0x%08x. sleeping for %ld ms before trying again", ret, delay/1000);
 891       /* sleep for a little while before trying again */
 892       nanosleep(&(struct timespec){delay / 1000000, (delay * 1000) % 1000000000}, NULL);
 893     }
 894   } while (kIOReturnSuccess != ret && retries--);
 895
 896   if (unsuspended)
 897     /* resuspend the device */
 898     (void)(*device)->USBDeviceSuspend (device, 1);
 899
 900   if (is_open)
 901     (void) (*device)->USBDeviceClose (device);
 902
 903   if (ret != kIOReturnSuccess) {
 904     /* a debug message was already printed out for this error */
 905     if (LIBUSB_CLASS_HUB == bDeviceClass)
 906       usbi_dbg ("could not retrieve device descriptor %.4x:%.4x: %s (%x). skipping device",
 907                 idVendor, idProduct, darwin_error_str (ret), ret);
 908     else
 909       usbi_warn (NULL, "could not retrieve device descriptor %.4x:%.4x: %s (%x). skipping device",
 910                  idVendor, idProduct, darwin_error_str (ret), ret);
 911     return darwin_to_libusb (ret);
 912   }
 913
 914   /* catch buggy hubs (which appear to be virtual). Apple's own USB prober has problems with these devices. */
 915   if (libusb_le16_to_cpu (dev->dev_descriptor.idProduct) != idProduct) {
 916     /* not a valid device */
 917     usbi_warn (NULL, "idProduct from iokit (%04x) does not match idProduct in descriptor (%04x). skipping device",
 918                idProduct, libusb_le16_to_cpu (dev->dev_descriptor.idProduct));
 919     return LIBUSB_ERROR_NO_DEVICE;
 920   }
 921
 922   usbi_dbg ("cached device descriptor:");
 923   usbi_dbg ("  bDescriptorType:    0x%02x", dev->dev_descriptor.bDescriptorType);
 924   usbi_dbg ("  bcdUSB:             0x%04x", libusb_le16_to_cpu (dev->dev_descriptor.bcdUSB));
 925   usbi_dbg ("  bDeviceClass:       0x%02x", dev->dev_descriptor.bDeviceClass);
 926   usbi_dbg ("  bDeviceSubClass:    0x%02x", dev->dev_descriptor.bDeviceSubClass);
 927   usbi_dbg ("  bDeviceProtocol:    0x%02x", dev->dev_descriptor.bDeviceProtocol);
 928   usbi_dbg ("  bMaxPacketSize0:    0x%02x", dev->dev_descriptor.bMaxPacketSize0);
 929   usbi_dbg ("  idVendor:           0x%04x", libusb_le16_to_cpu (dev->dev_descriptor.idVendor));
 930   usbi_dbg ("  idProduct:          0x%04x", libusb_le16_to_cpu (dev->dev_descriptor.idProduct));
 931   usbi_dbg ("  bcdDevice:          0x%04x", libusb_le16_to_cpu (dev->dev_descriptor.bcdDevice));
 932   usbi_dbg ("  iManufacturer:      0x%02x", dev->dev_descriptor.iManufacturer);
 933   usbi_dbg ("  iProduct:           0x%02x", dev->dev_descriptor.iProduct);
 934   usbi_dbg ("  iSerialNumber:      0x%02x", dev->dev_descriptor.iSerialNumber);
 935   usbi_dbg ("  bNumConfigurations: 0x%02x", dev->dev_descriptor.bNumConfigurations);
 936
 937   dev->can_enumerate = 1;
 938
 939   return LIBUSB_SUCCESS;
 940 }
 941
 942 /* Returns 1 on success, 0 on failure. */
 943 static bool get_device_port (io_service_t service, UInt8 *port) {
 944   IOReturn kresult;
 945   io_service_t parent;
 946   bool ret = false;
 947
 948   if (get_ioregistry_value_number (service, CFSTR("PortNum"), kCFNumberSInt8Type, port)) {
 949     return true;
 950   }
 951
 952   kresult = IORegistryEntryGetParentEntry (service, kIOServicePlane, &parent);
 953   if (kIOReturnSuccess == kresult) {
 954     ret = get_ioregistry_value_data (parent, CFSTR("port"), 1, port);
 955     IOObjectRelease (parent);
 956   }
 957
 958   return ret;
 959 }
 960
 961 /* Returns 1 on success, 0 on failure. */
 962 static bool get_device_parent_sessionID(io_service_t service, UInt64 *parent_sessionID) {
 963   IOReturn kresult;
 964   io_service_t parent;
 965
 966   /* Walk up the tree in the IOService plane until we find a parent that has a sessionID */
 967   parent = service;
 968   while((kresult = IORegistryEntryGetParentEntry (parent, kIOUSBPlane, &parent)) == kIOReturnSuccess) {
 969     if (get_ioregistry_value_number (parent, CFSTR("sessionID"), kCFNumberSInt64Type, parent_sessionID)) {
 970         /* Success */
 971         return true;
 972     }
 973   }
 974
 975   /* We ran out of parents */
 976   return false;
 977 }
 978
 979 static enum libusb_error darwin_get_cached_device(io_service_t service, struct darwin_cached_device **cached_out,
 980                                                   UInt64 *old_session_id) {
 981   struct darwin_cached_device *new_device;
 982   UInt64 sessionID = 0, parent_sessionID = 0;
 983   UInt32 locationID = 0;
 984   enum libusb_error ret = LIBUSB_SUCCESS;
 985   usb_device_t **device;
 986   UInt8 port = 0;
 987
 988   /* assuming sessionID != 0 normally (never seen it be 0) */
 989   *old_session_id = 0;
 990   *cached_out = NULL;
 991
 992   /* get some info from the io registry */
 993   (void) get_ioregistry_value_number (service, CFSTR("sessionID"), kCFNumberSInt64Type, &sessionID);
 994   (void) get_ioregistry_value_number (service, CFSTR("locationID"), kCFNumberSInt32Type, &locationID);
 995   if (!get_device_port (service, &port)) {
 996     usbi_dbg("could not get connected port number");
 997   }
 998
 999   usbi_dbg("finding cached device for sessionID 0x%" PRIx64, sessionID);
1000
1001   if (get_device_parent_sessionID(service, &parent_sessionID)) {
1002     usbi_dbg("parent sessionID: 0x%" PRIx64, parent_sessionID);
1003   }
1004
1005   usbi_mutex_lock(&darwin_cached_devices_lock);
1006   do {
1007     list_for_each_entry(new_device, &darwin_cached_devices, list, struct darwin_cached_device) {
1008       usbi_dbg("matching sessionID/locationID 0x%" PRIx64 "/0x%x against cached device with sessionID/locationID 0x%" PRIx64 "/0x%x",
1009                sessionID, locationID, new_device->session, new_device->location);
1010       if (new_device->location == locationID && new_device->in_reenumerate) {
1011         usbi_dbg ("found cached device with matching location that is being re-enumerated");
1012         *old_session_id = new_device->session;
1013         break;
1014       }
1015
1016       if (new_device->session == sessionID) {
1017         usbi_dbg("using cached device for device");
1018         *cached_out = new_device;
1019         break;
1020       }
1021     }
1022
1023     if (*cached_out)
1024       break;
1025
1026     usbi_dbg("caching new device with sessionID 0x%" PRIx64, sessionID);
1027
1028     device = darwin_device_from_service (service);
1029     if (!device) {
1030       ret = LIBUSB_ERROR_NO_DEVICE;
1031       break;
1032     }
1033
1034     if (!(*old_session_id)) {
1035       new_device = calloc (1, sizeof (*new_device));
1036       if (!new_device) {
1037         ret = LIBUSB_ERROR_NO_MEM;
1038         break;
1039       }
1040
1041       /* add this device to the cached device list */
1042       list_add(&new_device->list, &darwin_cached_devices);
1043
1044       (*device)->GetDeviceAddress (device, (USBDeviceAddress *)&new_device->address);
1045
1046       /* keep a reference to this device */
1047       darwin_ref_cached_device(new_device);
1048
1049       (*device)->GetLocationID (device, &new_device->location);
1050       new_device->port = port;
1051       new_device->parent_session = parent_sessionID;
1052     } else {
1053       /* release the ref to old device's service */
1054       IOObjectRelease (new_device->service);
1055     }
1056
1057     /* keep track of devices regardless of if we successfully enumerate them to
1058        prevent them from being enumerated multiple times */
1059     *cached_out = new_device;
1060
1061     new_device->session = sessionID;
1062     new_device->device = device;
1063     new_device->service = service;
1064
1065     /* retain the service */
1066     IOObjectRetain (service);
1067
1068     /* cache the device descriptor */
1069     ret = darwin_cache_device_descriptor(new_device);
1070     if (ret)
1071       break;
1072
1073     if (new_device->can_enumerate) {
1074       snprintf(new_device->sys_path, 20, "%03i-%04x-%04x-%02x-%02x", new_device->address,
1075                libusb_le16_to_cpu (new_device->dev_descriptor.idVendor),
1076                libusb_le16_to_cpu (new_device->dev_descriptor.idProduct),
1077                new_device->dev_descriptor.bDeviceClass, new_device->dev_descriptor.bDeviceSubClass);
1078     }
1079   } while (0);
1080
1081   usbi_mutex_unlock(&darwin_cached_devices_lock);
1082
1083   return ret;
1084 }
1085
1086 static enum libusb_error process_new_device (struct libusb_context *ctx, struct darwin_cached_device *cached_device,
1087                                              UInt64 old_session_id) {
1088   struct darwin_device_priv *priv;
1089   struct libusb_device *dev = NULL;
1090   UInt8 devSpeed;
1091   enum libusb_error ret = LIBUSB_SUCCESS;
1092
1093   do {
1094     /* check current active configuration (and cache the first configuration value--
1095        which may be used by claim_interface) */
1096     ret = darwin_check_configuration (ctx, cached_device);
1097     if (ret)
1098       break;
1099
1100     if (0 != old_session_id) {
1101       usbi_dbg ("re-using existing device from context %p for with session 0x%" PRIx64 " new session 0x%" PRIx64,
1102                 ctx, old_session_id, cached_device->session);
1103       /* save the libusb device before the session id is updated */
1104       dev = usbi_get_device_by_session_id (ctx, (unsigned long) old_session_id);
1105     }
1106
1107     if (!dev) {
1108       usbi_dbg ("allocating new device in context %p for with session 0x%" PRIx64,
1109                 ctx, cached_device->session);
1110
1111       dev = usbi_alloc_device(ctx, (unsigned long) cached_device->session);
1112       if (!dev) {
1113         return LIBUSB_ERROR_NO_MEM;
1114       }
1115
1116       priv = usbi_get_device_priv(dev);
1117
1118       priv->dev = cached_device;
1119       darwin_ref_cached_device (priv->dev);
1120       dev->port_number    = cached_device->port;
1121       dev->bus_number     = cached_device->location >> 24;
1122       assert(cached_device->address <= UINT8_MAX);
1123       dev->device_address = (uint8_t)cached_device->address;
1124     } else {
1125       priv = usbi_get_device_priv(dev);
1126     }
1127
1128     static_assert(sizeof(dev->device_descriptor) == sizeof(cached_device->dev_descriptor),
1129                   "mismatch between libusb and IOKit device descriptor sizes");
1130     memcpy(&dev->device_descriptor, &cached_device->dev_descriptor, LIBUSB_DT_DEVICE_SIZE);
1131     usbi_localize_device_descriptor(&dev->device_descriptor);
1132     dev->session_data = cached_device->session;
1133
1134     if (cached_device->parent_session > 0) {
1135       dev->parent_dev = usbi_get_device_by_session_id (ctx, (unsigned long) cached_device->parent_session);
1136     } else {
1137       dev->parent_dev = NULL;
1138     }
1139
1140     (*(priv->dev->device))->GetDeviceSpeed (priv->dev->device, &devSpeed);
1141
1142     switch (devSpeed) {
1143     case kUSBDeviceSpeedLow: dev->speed = LIBUSB_SPEED_LOW; break;
1144     case kUSBDeviceSpeedFull: dev->speed = LIBUSB_SPEED_FULL; break;
1145     case kUSBDeviceSpeedHigh: dev->speed = LIBUSB_SPEED_HIGH; break;
1146 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
1147     case kUSBDeviceSpeedSuper: dev->speed = LIBUSB_SPEED_SUPER; break;
1148 #endif
1149 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 101200
1150     case kUSBDeviceSpeedSuperPlus: dev->speed = LIBUSB_SPEED_SUPER_PLUS; break;
1151 #endif
1152     default:
1153       usbi_warn (ctx, "Got unknown device speed %d", devSpeed);
1154     }
1155
1156     ret = usbi_sanitize_device (dev);
1157     if (ret < 0)
1158       break;
1159
1160     usbi_dbg ("found device with address %d port = %d parent = %p at %p", dev->device_address,
1161               dev->port_number, (void *) dev->parent_dev, priv->dev->sys_path);
1162
1163   } while (0);
1164
1165   if (!cached_device->in_reenumerate && 0 == ret) {
1166     usbi_connect_device (dev);
1167   } else {
1168     libusb_unref_device (dev);
1169   }
1170
1171   return ret;
1172 }
1173
1174 static enum libusb_error darwin_scan_devices(struct libusb_context *ctx) {
1175   struct darwin_cached_device *cached_device;
1176   UInt64 old_session_id;
1177   io_iterator_t deviceIterator;
1178   io_service_t service;
1179   IOReturn kresult;
1180   int ret;
1181
1182   kresult = usb_setup_device_iterator (&deviceIterator, 0);
1183   if (kresult != kIOReturnSuccess)
1184     return darwin_to_libusb (kresult);
1185
1186   while ((service = IOIteratorNext (deviceIterator))) {
1187     ret = darwin_get_cached_device (service, &cached_device, &old_session_id);
1188     if (ret < 0 || !cached_device->can_enumerate) {
1189       continue;
1190     }
1191
1192     (void) process_new_device (ctx, cached_device, old_session_id);
1193
1194     IOObjectRelease(service);
1195   }
1196
1197   IOObjectRelease(deviceIterator);
1198
1199   return LIBUSB_SUCCESS;
1200 }
1201
1202 static int darwin_open (struct libusb_device_handle *dev_handle) {
1203   struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
1204   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
1205   IOReturn kresult;
1206
1207   if (0 == dpriv->open_count) {
1208     /* try to open the device */
1209     kresult = (*(dpriv->device))->USBDeviceOpenSeize (dpriv->device);
1210     if (kresult != kIOReturnSuccess) {
1211       usbi_warn (HANDLE_CTX (dev_handle), "USBDeviceOpen: %s", darwin_error_str(kresult));
1212
1213       if (kIOReturnExclusiveAccess != kresult) {
1214         return darwin_to_libusb (kresult);
1215       }
1216
1217       /* it is possible to perform some actions on a device that is not open so do not return an error */
1218       priv->is_open = false;
1219     } else {
1220       priv->is_open = true;
1221     }
1222
1223     /* create async event source */
1224     kresult = (*(dpriv->device))->CreateDeviceAsyncEventSource (dpriv->device, &priv->cfSource);
1225     if (kresult != kIOReturnSuccess) {
1226       usbi_err (HANDLE_CTX (dev_handle), "CreateDeviceAsyncEventSource: %s", darwin_error_str(kresult));
1227
1228       if (priv->is_open) {
1229         (*(dpriv->device))->USBDeviceClose (dpriv->device);
1230       }
1231
1232       priv->is_open = false;
1233
1234       return darwin_to_libusb (kresult);
1235     }
1236
1237     CFRetain (libusb_darwin_acfl);
1238
1239     /* add the cfSource to the aync run loop */
1240     CFRunLoopAddSource(libusb_darwin_acfl, priv->cfSource, kCFRunLoopCommonModes);
1241   }
1242
1243   /* device opened successfully */
1244   dpriv->open_count++;
1245
1246   usbi_dbg ("device open for access");
1247
1248   return 0;
1249 }
1250
1251 static void darwin_close (struct libusb_device_handle *dev_handle) {
1252   struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
1253   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
1254   IOReturn kresult;
1255   int i;
1256
1257   if (dpriv->open_count == 0) {
1258     /* something is probably very wrong if this is the case */
1259     usbi_err (HANDLE_CTX (dev_handle), "Close called on a device that was not open!");
1260     return;
1261   }
1262
1263   dpriv->open_count--;
1264
1265   /* make sure all interfaces are released */
1266   for (i = 0 ; i < USB_MAXINTERFACES ; i++)
1267     if (dev_handle->claimed_interfaces & (1U << i))
1268       libusb_release_interface (dev_handle, i);
1269
1270   if (0 == dpriv->open_count) {
1271     /* delete the device's async event source */
1272     if (priv->cfSource) {
1273       CFRunLoopRemoveSource (libusb_darwin_acfl, priv->cfSource, kCFRunLoopDefaultMode);
1274       CFRelease (priv->cfSource);
1275       priv->cfSource = NULL;
1276       CFRelease (libusb_darwin_acfl);
1277     }
1278
1279     if (priv->is_open) {
1280       /* close the device */
1281       kresult = (*(dpriv->device))->USBDeviceClose(dpriv->device);
1282       if (kresult != kIOReturnSuccess) {
1283         /* Log the fact that we had a problem closing the file, however failing a
1284          * close isn't really an error, so return success anyway */
1285         usbi_warn (HANDLE_CTX (dev_handle), "USBDeviceClose: %s", darwin_error_str(kresult));
1286       }
1287     }
1288   }
1289 }
1290
1291 static int darwin_get_configuration(struct libusb_device_handle *dev_handle, uint8_t *config) {
1292   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
1293
1294   *config = dpriv->active_config;
1295
1296   return LIBUSB_SUCCESS;
1297 }
1298
1299 static enum libusb_error darwin_set_configuration(struct libusb_device_handle *dev_handle, int config) {
1300   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
1301   IOReturn kresult;
1302   uint8_t i;
1303
1304   if (config == -1)
1305     config = 0;
1306
1307   /* Setting configuration will invalidate the interface, so we need
1308      to reclaim it. First, dispose of existing interfaces, if any. */
1309   for (i = 0 ; i < USB_MAXINTERFACES ; i++)
1310     if (dev_handle->claimed_interfaces & (1U << i))
1311       darwin_release_interface (dev_handle, i);
1312
1313   kresult = (*(dpriv->device))->SetConfiguration (dpriv->device, (UInt8)config);
1314   if (kresult != kIOReturnSuccess)
1315     return darwin_to_libusb (kresult);
1316
1317   /* Reclaim any interfaces. */
1318   for (i = 0 ; i < USB_MAXINTERFACES ; i++)
1319     if (dev_handle->claimed_interfaces & (1U << i))
1320       darwin_claim_interface (dev_handle, i);
1321
1322   dpriv->active_config = (UInt8)config;
1323
1324   return LIBUSB_SUCCESS;
1325 }
1326
1327 static IOReturn darwin_get_interface (usb_device_t **darwin_device, uint8_t ifc, io_service_t *usbInterfacep) {
1328   IOUSBFindInterfaceRequest request;
1329   IOReturn                  kresult;
1330   io_iterator_t             interface_iterator;
1331   UInt8                     bInterfaceNumber;
1332   bool                      ret;
1333
1334   *usbInterfacep = IO_OBJECT_NULL;
1335
1336   /* Setup the Interface Request */
1337   request.bInterfaceClass    = kIOUSBFindInterfaceDontCare;
1338   request.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
1339   request.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
1340   request.bAlternateSetting  = kIOUSBFindInterfaceDontCare;
1341
1342   kresult = (*(darwin_device))->CreateInterfaceIterator(darwin_device, &request, &interface_iterator);
1343   if (kresult != kIOReturnSuccess)
1344     return kresult;
1345
1346   while ((*usbInterfacep = IOIteratorNext(interface_iterator))) {
1347     /* find the interface number */
1348     ret = get_ioregistry_value_number (*usbInterfacep, CFSTR("bInterfaceNumber"), kCFNumberSInt8Type,
1349                                        &bInterfaceNumber);
1350
1351     if (ret && bInterfaceNumber == ifc) {
1352       break;
1353     }
1354
1355     (void) IOObjectRelease (*usbInterfacep);
1356   }
1357
1358   /* done with the interface iterator */
1359   IOObjectRelease(interface_iterator);
1360
1361   return kIOReturnSuccess;
1362 }
1363
1364 static enum libusb_error get_endpoints (struct libusb_device_handle *dev_handle, uint8_t iface) {
1365   struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
1366
1367   /* current interface */
1368   struct darwin_interface *cInterface = &priv->interfaces[iface];
1369
1370   IOReturn kresult;
1371
1372   UInt8 numep, direction, number;
1373   UInt8 dont_care1, dont_care3;
1374   UInt16 dont_care2;
1375   int rc;
1376
1377   usbi_dbg ("building table of endpoints.");
1378
1379   /* retrieve the total number of endpoints on this interface */
1380   kresult = (*(cInterface->interface))->GetNumEndpoints(cInterface->interface, &numep);
1381   if (kresult != kIOReturnSuccess) {
1382     usbi_err (HANDLE_CTX (dev_handle), "can't get number of endpoints for interface: %s", darwin_error_str(kresult));
1383     return darwin_to_libusb (kresult);
1384   }
1385
1386   /* iterate through pipe references */
1387   for (UInt8 i = 1 ; i <= numep ; i++) {
1388     kresult = (*(cInterface->interface))->GetPipeProperties(cInterface->interface, i, &direction, &number, &dont_care1,
1389                                                             &dont_care2, &dont_care3);
1390
1391     if (kresult != kIOReturnSuccess) {
1392       /* probably a buggy device. try to get the endpoint address from the descriptors */
1393       struct libusb_config_descriptor *config;
1394       const struct libusb_endpoint_descriptor *endpoint_desc;
1395       UInt8 alt_setting;
1396
1397       kresult = (*(cInterface->interface))->GetAlternateSetting (cInterface->interface, &alt_setting);
1398       if (kresult != kIOReturnSuccess) {
1399         usbi_err (HANDLE_CTX (dev_handle), "can't get alternate setting for interface");
1400         return darwin_to_libusb (kresult);
1401       }
1402
1403       rc = libusb_get_active_config_descriptor (dev_handle->dev, &config);
1404       if (LIBUSB_SUCCESS != rc) {
1405         return rc;
1406       }
1407
1408       endpoint_desc = config->interface[iface].altsetting[alt_setting].endpoint + i - 1;
1409
1410       cInterface->endpoint_addrs[i - 1] = endpoint_desc->bEndpointAddress;
1411     } else {
1412       cInterface->endpoint_addrs[i - 1] = (UInt8)(((kUSBIn == direction) << kUSBRqDirnShift) | (number & LIBUSB_ENDPOINT_ADDRESS_MASK));
1413     }
1414
1415     usbi_dbg ("interface: %i pipe %i: dir: %i number: %i", iface, i, cInterface->endpoint_addrs[i - 1] >> kUSBRqDirnShift,
1416               cInterface->endpoint_addrs[i - 1] & LIBUSB_ENDPOINT_ADDRESS_MASK);
1417   }
1418
1419   cInterface->num_endpoints = numep;
1420
1421   return LIBUSB_SUCCESS;
1422 }
1423
1424 static int darwin_claim_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
1425   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
1426   struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
1427   io_service_t          usbInterface = IO_OBJECT_NULL;
1428   IOReturn              kresult;
1429   enum libusb_error     ret;
1430   IOCFPlugInInterface **plugInInterface = NULL;
1431   SInt32                score;
1432
1433   /* current interface */
1434   struct darwin_interface *cInterface = &priv->interfaces[iface];
1435
1436   kresult = darwin_get_interface (dpriv->device, iface, &usbInterface);
1437   if (kresult != kIOReturnSuccess)
1438     return darwin_to_libusb (kresult);
1439
1440   /* make sure we have an interface */
1441   if (!usbInterface && dpriv->first_config != 0) {
1442     usbi_info (HANDLE_CTX (dev_handle), "no interface found; setting configuration: %d", dpriv->first_config);
1443
1444     /* set the configuration */
1445     ret = darwin_set_configuration (dev_handle, (int) dpriv->first_config);
1446     if (ret != LIBUSB_SUCCESS) {
1447       usbi_err (HANDLE_CTX (dev_handle), "could not set configuration");
1448       return ret;
1449     }
1450
1451     kresult = darwin_get_interface (dpriv->device, iface, &usbInterface);
1452     if (kresult != kIOReturnSuccess) {
1453       usbi_err (HANDLE_CTX (dev_handle), "darwin_get_interface: %s", darwin_error_str(kresult));
1454       return darwin_to_libusb (kresult);
1455     }
1456   }
1457
1458   if (!usbInterface) {
1459     usbi_err (HANDLE_CTX (dev_handle), "interface not found");
1460     return LIBUSB_ERROR_NOT_FOUND;
1461   }
1462
1463   /* get an interface to the device's interface */
1464   kresult = IOCreatePlugInInterfaceForService (usbInterface, kIOUSBInterfaceUserClientTypeID,
1465                                                kIOCFPlugInInterfaceID, &plugInInterface, &score);
1466
1467   /* ignore release error */
1468   (void)IOObjectRelease (usbInterface);
1469
1470   if (kresult != kIOReturnSuccess) {
1471     usbi_err (HANDLE_CTX (dev_handle), "IOCreatePlugInInterfaceForService: %s", darwin_error_str(kresult));
1472     return darwin_to_libusb (kresult);
1473   }
1474
1475   if (!plugInInterface) {
1476     usbi_err (HANDLE_CTX (dev_handle), "plugin interface not found");
1477     return LIBUSB_ERROR_NOT_FOUND;
1478   }
1479
1480   /* Do the actual claim */
1481   kresult = (*plugInInterface)->QueryInterface(plugInInterface,
1482                                                CFUUIDGetUUIDBytes(InterfaceInterfaceID),
1483                                                (LPVOID)&cInterface->interface);
1484   /* We no longer need the intermediate plug-in */
1485   /* Use release instead of IODestroyPlugInInterface to avoid stopping IOServices associated with this device */
1486   (*plugInInterface)->Release (plugInInterface);
1487   if (kresult != kIOReturnSuccess || !cInterface->interface) {
1488     usbi_err (HANDLE_CTX (dev_handle), "QueryInterface: %s", darwin_error_str(kresult));
1489     return darwin_to_libusb (kresult);
1490   }
1491
1492   /* claim the interface */
1493   kresult = (*(cInterface->interface))->USBInterfaceOpen(cInterface->interface);
1494   if (kresult != kIOReturnSuccess) {
1495     usbi_err (HANDLE_CTX (dev_handle), "USBInterfaceOpen: %s", darwin_error_str(kresult));
1496     return darwin_to_libusb (kresult);
1497   }
1498
1499   /* update list of endpoints */
1500   ret = get_endpoints (dev_handle, iface);
1501   if (ret) {
1502     /* this should not happen */
1503     darwin_release_interface (dev_handle, iface);
1504     usbi_err (HANDLE_CTX (dev_handle), "could not build endpoint table");
1505     return ret;
1506   }
1507
1508   cInterface->cfSource = NULL;
1509
1510   /* create async event source */
1511   kresult = (*(cInterface->interface))->CreateInterfaceAsyncEventSource (cInterface->interface, &cInterface->cfSource);
1512   if (kresult != kIOReturnSuccess) {
1513     usbi_err (HANDLE_CTX (dev_handle), "could not create async event source");
1514
1515     /* can't continue without an async event source */
1516     (void)darwin_release_interface (dev_handle, iface);
1517
1518     return darwin_to_libusb (kresult);
1519   }
1520
1521   /* add the cfSource to the async thread's run loop */
1522   CFRunLoopAddSource(libusb_darwin_acfl, cInterface->cfSource, kCFRunLoopDefaultMode);
1523
1524   usbi_dbg ("interface opened");
1525
1526   return LIBUSB_SUCCESS;
1527 }
1528
1529 static int darwin_release_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
1530   struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
1531   IOReturn kresult;
1532
1533   /* current interface */
1534   struct darwin_interface *cInterface = &priv->interfaces[iface];
1535
1536   /* Check to see if an interface is open */
1537   if (!cInterface->interface)
1538     return LIBUSB_SUCCESS;
1539
1540   /* clean up endpoint data */
1541   cInterface->num_endpoints = 0;
1542
1543   /* delete the interface's async event source */
1544   if (cInterface->cfSource) {
1545     CFRunLoopRemoveSource (libusb_darwin_acfl, cInterface->cfSource, kCFRunLoopDefaultMode);
1546     CFRelease (cInterface->cfSource);
1547   }
1548
1549   kresult = (*(cInterface->interface))->USBInterfaceClose(cInterface->interface);
1550   if (kresult != kIOReturnSuccess)
1551     usbi_warn (HANDLE_CTX (dev_handle), "USBInterfaceClose: %s", darwin_error_str(kresult));
1552
1553   kresult = (*(cInterface->interface))->Release(cInterface->interface);
1554   if (kresult != kIOReturnSuccess)
1555     usbi_warn (HANDLE_CTX (dev_handle), "Release: %s", darwin_error_str(kresult));
1556
1557   cInterface->interface = (usb_interface_t **) IO_OBJECT_NULL;
1558
1559   return darwin_to_libusb (kresult);
1560 }
1561
1562 static int darwin_set_interface_altsetting(struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting) {
1563   struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
1564   IOReturn kresult;
1565   enum libusb_error ret;
1566   int i;
1567   uint8_t old_alt_setting;
1568
1569   /* current interface */
1570   struct darwin_interface *cInterface = &priv->interfaces[iface];
1571
1572   if (!cInterface->interface)
1573     return LIBUSB_ERROR_NO_DEVICE;
1574
1575   kresult = (*(cInterface->interface))->SetAlternateInterface (cInterface->interface, altsetting);
1576   if (kresult != kIOReturnSuccess)
1577     usbi_warn (HANDLE_CTX (dev_handle), "SetAlternateInterface: %s", darwin_error_str(kresult));
1578
1579   if (kresult != kIOUSBPipeStalled)
1580     return darwin_to_libusb (kresult);
1581
1582   /* If a device only supports a default setting for the specified interface, then a STALL
1583      (kIOUSBPipeStalled) may be returned. Ref: USB 2.0 specs 9.4.10.
1584      Mimick the behaviour in e.g. the Linux kernel: in such case, reset all endpoints
1585      of the interface (as would have been done per 9.1.1.5) and return success. */
1586
1587   /* For some reason we need to reclaim the interface after the pipe error */
1588   ret = darwin_claim_interface (dev_handle, iface);
1589
1590   if (ret) {
1591     darwin_release_interface (dev_handle, iface);
1592     usbi_err (HANDLE_CTX (dev_handle), "could not reclaim interface");
1593   }
1594
1595   /* Return error if a change to another value was attempted */
1596   kresult = (*(cInterface->interface))->GetAlternateSetting (cInterface->interface, &old_alt_setting);
1597   if (kresult == kIOReturnSuccess && altsetting != old_alt_setting)
1598     return LIBUSB_ERROR_PIPE;
1599
1600   for (i = 0 ; i < cInterface->num_endpoints ; i++)
1601     darwin_clear_halt(dev_handle, cInterface->endpoint_addrs[i]);
1602
1603   return LIBUSB_SUCCESS;
1604 }
1605
1606 static int darwin_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint) {
1607   /* current interface */
1608   struct darwin_interface *cInterface;
1609   IOReturn kresult;
1610   uint8_t pipeRef;
1611
1612   /* determine the interface/endpoint to use */
1613   if (ep_to_pipeRef (dev_handle, endpoint, &pipeRef, NULL, &cInterface) != 0) {
1614     usbi_err (HANDLE_CTX (dev_handle), "endpoint not found on any open interface");
1615
1616     return LIBUSB_ERROR_NOT_FOUND;
1617   }
1618
1619   /* newer versions of darwin support clearing additional bits on the device's endpoint */
1620   kresult = (*(cInterface->interface))->ClearPipeStallBothEnds(cInterface->interface, pipeRef);
1621   if (kresult != kIOReturnSuccess)
1622     usbi_warn (HANDLE_CTX (dev_handle), "ClearPipeStall: %s", darwin_error_str (kresult));
1623
1624   return darwin_to_libusb (kresult);
1625 }
1626
1627 static int darwin_restore_state (struct libusb_device_handle *dev_handle, int8_t active_config,
1628                                  unsigned long claimed_interfaces) {
1629   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
1630   struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
1631   int open_count = dpriv->open_count;
1632   int ret;
1633
1634   /* clear claimed interfaces temporarily */
1635   dev_handle->claimed_interfaces = 0;
1636
1637   /* close and re-open the device */
1638   priv->is_open = false;
1639   dpriv->open_count = 1;
1640
1641   /* clean up open interfaces */
1642   (void) darwin_close (dev_handle);
1643
1644   /* re-open the device */
1645   ret = darwin_open (dev_handle);
1646   dpriv->open_count = open_count;
1647   if (LIBUSB_SUCCESS != ret) {
1648     /* could not restore configuration */
1649     return LIBUSB_ERROR_NOT_FOUND;
1650   }
1651
1652   if (dpriv->active_config != active_config) {
1653     usbi_dbg ("darwin/restore_state: restoring configuration %d...", active_config);
1654
1655     ret = darwin_set_configuration (dev_handle, active_config);
1656     if (LIBUSB_SUCCESS != ret) {
1657       usbi_dbg ("darwin/restore_state: could not restore configuration");
1658       return LIBUSB_ERROR_NOT_FOUND;
1659     }
1660   }
1661
1662   usbi_dbg ("darwin/restore_state: reclaiming interfaces");
1663
1664   if (claimed_interfaces) {
1665     for (uint8_t iface = 0 ; iface < USB_MAXINTERFACES ; ++iface) {
1666       if (!(claimed_interfaces & (1U << iface))) {
1667         continue;
1668       }
1669
1670       usbi_dbg ("darwin/restore_state: re-claiming interface %u", iface);
1671
1672       ret = darwin_claim_interface (dev_handle, iface);
1673       if (LIBUSB_SUCCESS != ret) {
1674         usbi_dbg ("darwin/restore_state: could not claim interface %u", iface);
1675         return LIBUSB_ERROR_NOT_FOUND;
1676       }
1677
1678       dev_handle->claimed_interfaces |= 1U << iface;
1679     }
1680   }
1681
1682   usbi_dbg ("darwin/restore_state: device state restored");
1683
1684   return LIBUSB_SUCCESS;
1685 }
1686
1687 static int darwin_reenumerate_device (struct libusb_device_handle *dev_handle, bool capture) {
1688   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
1689   unsigned long claimed_interfaces = dev_handle->claimed_interfaces;
1690   int8_t active_config = dpriv->active_config;
1691   UInt32 options = 0;
1692   IOUSBDeviceDescriptor descriptor;
1693   IOUSBConfigurationDescriptorPtr cached_configuration;
1694   IOUSBConfigurationDescriptor *cached_configurations;
1695   IOReturn kresult;
1696   UInt8 i;
1697   UInt32 time;
1698
1699   if (dpriv->in_reenumerate) {
1700     /* ack, two (or more) threads are trying to reset the device! abort! */
1701     return LIBUSB_ERROR_NOT_FOUND;
1702   }
1703
1704   dpriv->in_reenumerate = true;
1705
1706   /* store copies of descriptors so they can be compared after the reset */
1707   memcpy (&descriptor, &dpriv->dev_descriptor, sizeof (descriptor));
1708   cached_configurations = alloca (sizeof (*cached_configurations) * descriptor.bNumConfigurations);
1709
1710   for (i = 0 ; i < descriptor.bNumConfigurations ; ++i) {
1711     (*(dpriv->device))->GetConfigurationDescriptorPtr (dpriv->device, i, &cached_configuration);
1712     memcpy (cached_configurations + i, cached_configuration, sizeof (cached_configurations[i]));
1713   }
1714
1715   /* if we need to release capture */
1716   if (HAS_CAPTURE_DEVICE()) {
1717     if (capture) {
1718       options |= kUSBReEnumerateCaptureDeviceMask;
1719     }
1720   } else {
1721     capture = false;
1722   }
1723
1724   /* from macOS 10.11 ResetDevice no longer does anything so just use USBDeviceReEnumerate */
1725   kresult = (*(dpriv->device))->USBDeviceReEnumerate (dpriv->device, options);
1726   if (kresult != kIOReturnSuccess) {
1727     usbi_err (HANDLE_CTX (dev_handle), "USBDeviceReEnumerate: %s", darwin_error_str (kresult));
1728     dpriv->in_reenumerate = false;
1729     return darwin_to_libusb (kresult);
1730   }
1731
1732   /* capture mode does not re-enumerate but it does require re-open */
1733   if (capture) {
1734     usbi_dbg ("darwin/reenumerate_device: restoring state...");
1735     dpriv->in_reenumerate = false;
1736     return darwin_restore_state (dev_handle, active_config, claimed_interfaces);
1737   }
1738
1739   usbi_dbg ("darwin/reenumerate_device: waiting for re-enumeration to complete...");
1740
1741   time = 0;
1742   while (dpriv->in_reenumerate) {
1743     struct timespec delay = {.tv_sec = 0, .tv_nsec = 1000};
1744     nanosleep (&delay, NULL);
1745     if (time++ >= DARWIN_REENUMERATE_TIMEOUT_US) {
1746       usbi_err (HANDLE_CTX (dev_handle), "darwin/reenumerate_device: timeout waiting for reenumerate");
1747       dpriv->in_reenumerate = false;
1748       return LIBUSB_ERROR_TIMEOUT;
1749     }
1750   }
1751
1752   /* compare descriptors */
1753   usbi_dbg ("darwin/reenumerate_device: checking whether descriptors changed");
1754
1755   if (memcmp (&descriptor, &dpriv->dev_descriptor, sizeof (descriptor))) {
1756     /* device descriptor changed. need to return not found. */
1757     usbi_dbg ("darwin/reenumerate_device: device descriptor changed");
1758     return LIBUSB_ERROR_NOT_FOUND;
1759   }
1760
1761   for (i = 0 ; i < descriptor.bNumConfigurations ; ++i) {
1762     (void) (*(dpriv->device))->GetConfigurationDescriptorPtr (dpriv->device, i, &cached_configuration);
1763     if (memcmp (cached_configuration, cached_configurations + i, sizeof (cached_configurations[i]))) {
1764       usbi_dbg ("darwin/reenumerate_device: configuration descriptor %d changed", i);
1765       return LIBUSB_ERROR_NOT_FOUND;
1766     }
1767   }
1768
1769   usbi_dbg ("darwin/reenumerate_device: device reset complete. restoring state...");
1770
1771   return darwin_restore_state (dev_handle, active_config, claimed_interfaces);
1772 }
1773
1774 static int darwin_reset_device (struct libusb_device_handle *dev_handle) {
1775   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
1776   IOReturn kresult;
1777
1778   if (dpriv->capture_count > 0) {
1779     /* we have to use ResetDevice as USBDeviceReEnumerate() loses the authorization for capture */
1780     kresult = (*(dpriv->device))->ResetDevice (dpriv->device);
1781     return darwin_to_libusb (kresult);
1782   } else {
1783     return darwin_reenumerate_device (dev_handle, false);
1784   }
1785 }
1786
1787 static int darwin_kernel_driver_active(struct libusb_device_handle *dev_handle, uint8_t interface) {
1788   enum libusb_error ret = darwin_claim_interface (dev_handle, interface);
1789   if (ret == LIBUSB_SUCCESS) {
1790     darwin_release_interface (dev_handle, interface);
1791   }
1792   return (ret == LIBUSB_ERROR_ACCESS);
1793 }
1794
1795 static void darwin_destroy_device(struct libusb_device *dev) {
1796   struct darwin_device_priv *dpriv = usbi_get_device_priv(dev);
1797
1798   if (dpriv->dev) {
1799     /* need to hold the lock in case this is the last reference to the device */
1800     usbi_mutex_lock(&darwin_cached_devices_lock);
1801     darwin_deref_cached_device (dpriv->dev);
1802     dpriv->dev = NULL;
1803     usbi_mutex_unlock(&darwin_cached_devices_lock);
1804   }
1805 }
1806
1807 static int submit_bulk_transfer(struct usbi_transfer *itransfer) {
1808   struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1809
1810   IOReturn               ret;
1811   uint8_t                transferType;
1812   uint8_t                pipeRef;
1813   uint16_t               maxPacketSize;
1814
1815   struct darwin_interface *cInterface;
1816 #if InterfaceVersion >= 550
1817   IOUSBEndpointProperties pipeProperties = {.bVersion = kUSBEndpointPropertiesVersion3};
1818 #else
1819   /* None of the values below are used in libusb for bulk transfers */
1820   uint8_t                 direction, number, interval;
1821 #endif
1822
1823   if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
1824     usbi_err (TRANSFER_CTX (transfer), "endpoint not found on any open interface");
1825
1826     return LIBUSB_ERROR_NOT_FOUND;
1827   }
1828
1829 #if InterfaceVersion >= 550
1830   ret = (*(cInterface->interface))->GetPipePropertiesV3 (cInterface->interface, pipeRef, &pipeProperties);
1831
1832   transferType = pipeProperties.bTransferType;
1833   maxPacketSize = pipeProperties.wMaxPacketSize;
1834 #else
1835   ret = (*(cInterface->interface))->GetPipeProperties (cInterface->interface, pipeRef, &direction, &number,
1836                                                        &transferType, &maxPacketSize, &interval);
1837 #endif
1838
1839   if (ret) {
1840     usbi_err (TRANSFER_CTX (transfer), "bulk transfer failed (dir = %s): %s (code = 0x%08x)", IS_XFERIN(transfer) ? "In" : "Out",
1841               darwin_error_str(ret), ret);
1842     return darwin_to_libusb (ret);
1843   }
1844
1845   if (0 != (transfer->length % maxPacketSize)) {
1846     /* do not need a zero packet */
1847     transfer->flags &= ~LIBUSB_TRANSFER_ADD_ZERO_PACKET;
1848   }
1849
1850   /* submit the request */
1851   /* timeouts are unavailable on interrupt endpoints */
1852   if (transferType == kUSBInterrupt) {
1853     if (IS_XFERIN(transfer))
1854       ret = (*(cInterface->interface))->ReadPipeAsync(cInterface->interface, pipeRef, transfer->buffer,
1855                                                       (UInt32)transfer->length, darwin_async_io_callback, itransfer);
1856     else
1857       ret = (*(cInterface->interface))->WritePipeAsync(cInterface->interface, pipeRef, transfer->buffer,
1858                                                        (UInt32)transfer->length, darwin_async_io_callback, itransfer);
1859   } else {
1860     itransfer->timeout_flags |= USBI_TRANSFER_OS_HANDLES_TIMEOUT;
1861
1862     if (IS_XFERIN(transfer))
1863       ret = (*(cInterface->interface))->ReadPipeAsyncTO(cInterface->interface, pipeRef, transfer->buffer,
1864                                                         (UInt32)transfer->length, transfer->timeout, transfer->timeout,
1865                                                         darwin_async_io_callback, itransfer);
1866     else
1867       ret = (*(cInterface->interface))->WritePipeAsyncTO(cInterface->interface, pipeRef, transfer->buffer,
1868                                                          (UInt32)transfer->length, transfer->timeout, transfer->timeout,
1869                                                          darwin_async_io_callback, itransfer);
1870   }
1871
1872   if (ret)
1873     usbi_err (TRANSFER_CTX (transfer), "bulk transfer failed (dir = %s): %s (code = 0x%08x)", IS_XFERIN(transfer) ? "In" : "Out",
1874                darwin_error_str(ret), ret);
1875
1876   return darwin_to_libusb (ret);
1877 }
1878
1879 #if InterfaceVersion >= 550
1880 static int submit_stream_transfer(struct usbi_transfer *itransfer) {
1881   struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1882   struct darwin_interface *cInterface;
1883   uint8_t pipeRef;
1884   IOReturn ret;
1885
1886   if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
1887     usbi_err (TRANSFER_CTX (transfer), "endpoint not found on any open interface");
1888
1889     return LIBUSB_ERROR_NOT_FOUND;
1890   }
1891
1892   itransfer->timeout_flags |= USBI_TRANSFER_OS_HANDLES_TIMEOUT;
1893
1894   if (IS_XFERIN(transfer))
1895     ret = (*(cInterface->interface))->ReadStreamsPipeAsyncTO(cInterface->interface, pipeRef, itransfer->stream_id,
1896                                                              transfer->buffer, (UInt32)transfer->length, transfer->timeout,
1897                                                              transfer->timeout, darwin_async_io_callback, itransfer);
1898   else
1899     ret = (*(cInterface->interface))->WriteStreamsPipeAsyncTO(cInterface->interface, pipeRef, itransfer->stream_id,
1900                                                               transfer->buffer, (UInt32)transfer->length, transfer->timeout,
1901                                                               transfer->timeout, darwin_async_io_callback, itransfer);
1902
1903   if (ret)
1904     usbi_err (TRANSFER_CTX (transfer), "bulk stream transfer failed (dir = %s): %s (code = 0x%08x)", IS_XFERIN(transfer) ? "In" : "Out",
1905                darwin_error_str(ret), ret);
1906
1907   return darwin_to_libusb (ret);
1908 }
1909 #endif
1910
1911 static int submit_iso_transfer(struct usbi_transfer *itransfer) {
1912   struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1913   struct darwin_transfer_priv *tpriv = usbi_get_transfer_priv(itransfer);
1914
1915   IOReturn kresult;
1916   uint8_t direction, number, interval, pipeRef, transferType;
1917   uint16_t maxPacketSize;
1918   UInt64 frame;
1919   AbsoluteTime atTime;
1920   int i;
1921
1922   struct darwin_interface *cInterface;
1923
1924   /* construct an array of IOUSBIsocFrames, reuse the old one if the sizes are the same */
1925   if (tpriv->num_iso_packets != transfer->num_iso_packets) {
1926     free(tpriv->isoc_framelist);
1927     tpriv->isoc_framelist = NULL;
1928   }
1929
1930   if (!tpriv->isoc_framelist) {
1931     tpriv->num_iso_packets = transfer->num_iso_packets;
1932     tpriv->isoc_framelist = (IOUSBIsocFrame*) calloc ((size_t)transfer->num_iso_packets, sizeof(IOUSBIsocFrame));
1933     if (!tpriv->isoc_framelist)
1934       return LIBUSB_ERROR_NO_MEM;
1935   }
1936
1937   /* copy the frame list from the libusb descriptor (the structures differ only is member order) */
1938   for (i = 0 ; i < transfer->num_iso_packets ; i++) {
1939     unsigned int length = transfer->iso_packet_desc[i].length;
1940     assert(length <= UINT16_MAX);
1941     tpriv->isoc_framelist[i].frReqCount = (UInt16)length;
1942   }
1943
1944   /* determine the interface/endpoint to use */
1945   if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
1946     usbi_err (TRANSFER_CTX (transfer), "endpoint not found on any open interface");
1947
1948     return LIBUSB_ERROR_NOT_FOUND;
1949   }
1950
1951   /* determine the properties of this endpoint and the speed of the device */
1952   (*(cInterface->interface))->GetPipeProperties (cInterface->interface, pipeRef, &direction, &number,
1953                                                  &transferType, &maxPacketSize, &interval);
1954
1955   /* Last but not least we need the bus frame number */
1956   kresult = (*(cInterface->interface))->GetBusFrameNumber(cInterface->interface, &frame, &atTime);
1957   if (kresult != kIOReturnSuccess) {
1958     usbi_err (TRANSFER_CTX (transfer), "failed to get bus frame number: %d", kresult);
1959     free(tpriv->isoc_framelist);
1960     tpriv->isoc_framelist = NULL;
1961
1962     return darwin_to_libusb (kresult);
1963   }
1964
1965   (*(cInterface->interface))->GetPipeProperties (cInterface->interface, pipeRef, &direction, &number,
1966                                                  &transferType, &maxPacketSize, &interval);
1967
1968   /* schedule for a frame a little in the future */
1969   frame += 4;
1970
1971   if (cInterface->frames[transfer->endpoint] && frame < cInterface->frames[transfer->endpoint])
1972     frame = cInterface->frames[transfer->endpoint];
1973
1974   /* submit the request */
1975   if (IS_XFERIN(transfer))
1976     kresult = (*(cInterface->interface))->ReadIsochPipeAsync(cInterface->interface, pipeRef, transfer->buffer, frame,
1977                                                              (UInt32)transfer->num_iso_packets, tpriv->isoc_framelist, darwin_async_io_callback,
1978                                                              itransfer);
1979   else
1980     kresult = (*(cInterface->interface))->WriteIsochPipeAsync(cInterface->interface, pipeRef, transfer->buffer, frame,
1981                                                               (UInt32)transfer->num_iso_packets, tpriv->isoc_framelist, darwin_async_io_callback,
1982                                                               itransfer);
1983
1984   if (LIBUSB_SPEED_FULL == transfer->dev_handle->dev->speed)
1985     /* Full speed */
1986     cInterface->frames[transfer->endpoint] = frame + (UInt32)transfer->num_iso_packets * (1U << (interval - 1));
1987   else
1988     /* High/super speed */
1989     cInterface->frames[transfer->endpoint] = frame + (UInt32)transfer->num_iso_packets * (1U << (interval - 1)) / 8;
1990
1991   if (kresult != kIOReturnSuccess) {
1992     usbi_err (TRANSFER_CTX (transfer), "isochronous transfer failed (dir: %s): %s", IS_XFERIN(transfer) ? "In" : "Out",
1993                darwin_error_str(kresult));
1994     free (tpriv->isoc_framelist);
1995     tpriv->isoc_framelist = NULL;
1996   }
1997
1998   return darwin_to_libusb (kresult);
1999 }
2000
2001 static int submit_control_transfer(struct usbi_transfer *itransfer) {
2002   struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2003   struct libusb_control_setup *setup = (struct libusb_control_setup *) transfer->buffer;
2004   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(transfer->dev_handle->dev);
2005   struct darwin_transfer_priv *tpriv = usbi_get_transfer_priv(itransfer);
2006
2007   IOReturn               kresult;
2008
2009   memset(&tpriv->req, 0, sizeof(tpriv->req));
2010
2011   /* IOUSBDeviceInterface expects the request in cpu endianness */
2012   tpriv->req.bmRequestType     = setup->bmRequestType;
2013   tpriv->req.bRequest          = setup->bRequest;
2014   /* these values should be in bus order from libusb_fill_control_setup */
2015   tpriv->req.wValue            = OSSwapLittleToHostInt16 (setup->wValue);
2016   tpriv->req.wIndex            = OSSwapLittleToHostInt16 (setup->wIndex);
2017   tpriv->req.wLength           = OSSwapLittleToHostInt16 (setup->wLength);
2018   /* data is stored after the libusb control block */
2019   tpriv->req.pData             = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
2020   tpriv->req.completionTimeout = transfer->timeout;
2021   tpriv->req.noDataTimeout     = transfer->timeout;
2022
2023   itransfer->timeout_flags |= USBI_TRANSFER_OS_HANDLES_TIMEOUT;
2024
2025   /* all transfers in libusb-1.0 are async */
2026
2027   if (transfer->endpoint) {
2028     struct darwin_interface *cInterface;
2029     uint8_t                 pipeRef;
2030
2031     if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
2032       usbi_err (TRANSFER_CTX (transfer), "endpoint not found on any open interface");
2033
2034       return LIBUSB_ERROR_NOT_FOUND;
2035     }
2036
2037     kresult = (*(cInterface->interface))->ControlRequestAsyncTO (cInterface->interface, pipeRef, &(tpriv->req), darwin_async_io_callback, itransfer);
2038   } else
2039     /* control request on endpoint 0 */
2040     kresult = (*(dpriv->device))->DeviceRequestAsyncTO(dpriv->device, &(tpriv->req), darwin_async_io_callback, itransfer);
2041
2042   if (kresult != kIOReturnSuccess)
2043     usbi_err (TRANSFER_CTX (transfer), "control request failed: %s", darwin_error_str(kresult));
2044
2045   return darwin_to_libusb (kresult);
2046 }
2047
2048 static int darwin_submit_transfer(struct usbi_transfer *itransfer) {
2049   struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2050
2051   switch (transfer->type) {
2052   case LIBUSB_TRANSFER_TYPE_CONTROL:
2053     return submit_control_transfer(itransfer);
2054   case LIBUSB_TRANSFER_TYPE_BULK:
2055   case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2056     return submit_bulk_transfer(itransfer);
2057   case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2058     return submit_iso_transfer(itransfer);
2059   case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2060 #if InterfaceVersion >= 550
2061     return submit_stream_transfer(itransfer);
2062 #else
2063     usbi_err (TRANSFER_CTX(transfer), "IOUSBFamily version does not support bulk stream transfers");
2064     return LIBUSB_ERROR_NOT_SUPPORTED;
2065 #endif
2066   default:
2067     usbi_err (TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
2068     return LIBUSB_ERROR_INVALID_PARAM;
2069   }
2070 }
2071
2072 static int cancel_control_transfer(struct usbi_transfer *itransfer) {
2073   struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2074   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(transfer->dev_handle->dev);
2075   IOReturn kresult;
2076
2077   usbi_warn (ITRANSFER_CTX (itransfer), "aborting all transactions control pipe");
2078
2079   if (!dpriv->device)
2080     return LIBUSB_ERROR_NO_DEVICE;
2081
2082   kresult = (*(dpriv->device))->USBDeviceAbortPipeZero (dpriv->device);
2083
2084   return darwin_to_libusb (kresult);
2085 }
2086
2087 static int darwin_abort_transfers (struct usbi_transfer *itransfer) {
2088   struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2089   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(transfer->dev_handle->dev);
2090   struct darwin_interface *cInterface;
2091   uint8_t pipeRef, iface;
2092   IOReturn kresult;
2093
2094   if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, &iface, &cInterface) != 0) {
2095     usbi_err (TRANSFER_CTX (transfer), "endpoint not found on any open interface");
2096
2097     return LIBUSB_ERROR_NOT_FOUND;
2098   }
2099
2100   if (!dpriv->device)
2101     return LIBUSB_ERROR_NO_DEVICE;
2102
2103   usbi_warn (ITRANSFER_CTX (itransfer), "aborting all transactions on interface %d pipe %d", iface, pipeRef);
2104
2105   /* abort transactions */
2106 #if InterfaceVersion >= 550
2107   if (LIBUSB_TRANSFER_TYPE_BULK_STREAM == transfer->type)
2108     (*(cInterface->interface))->AbortStreamsPipe (cInterface->interface, pipeRef, itransfer->stream_id);
2109   else
2110 #endif
2111     (*(cInterface->interface))->AbortPipe (cInterface->interface, pipeRef);
2112
2113   usbi_dbg ("calling clear pipe stall to clear the data toggle bit");
2114
2115   /* newer versions of darwin support clearing additional bits on the device's endpoint */
2116   kresult = (*(cInterface->interface))->ClearPipeStallBothEnds(cInterface->interface, pipeRef);
2117
2118   return darwin_to_libusb (kresult);
2119 }
2120
2121 static int darwin_cancel_transfer(struct usbi_transfer *itransfer) {
2122   struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2123
2124   switch (transfer->type) {
2125   case LIBUSB_TRANSFER_TYPE_CONTROL:
2126     return cancel_control_transfer(itransfer);
2127   case LIBUSB_TRANSFER_TYPE_BULK:
2128   case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2129   case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2130     return darwin_abort_transfers (itransfer);
2131   default:
2132     usbi_err (TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
2133     return LIBUSB_ERROR_INVALID_PARAM;
2134   }
2135 }
2136
2137 static void darwin_async_io_callback (void *refcon, IOReturn result, void *arg0) {
2138   struct usbi_transfer *itransfer = (struct usbi_transfer *)refcon;
2139   struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2140   struct darwin_transfer_priv *tpriv = usbi_get_transfer_priv(itransfer);
2141
2142   usbi_dbg ("an async io operation has completed");
2143
2144   /* if requested write a zero packet */
2145   if (kIOReturnSuccess == result && IS_XFEROUT(transfer) && transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
2146     struct darwin_interface *cInterface;
2147     uint8_t pipeRef;
2148
2149     (void) ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface);
2150
2151     (*(cInterface->interface))->WritePipe (cInterface->interface, pipeRef, transfer->buffer, 0);
2152   }
2153
2154   tpriv->result = result;
2155   tpriv->size = (UInt32) (uintptr_t) arg0;
2156
2157   /* signal the core that this transfer is complete */
2158   usbi_signal_transfer_completion(itransfer);
2159 }
2160
2161 static enum libusb_transfer_status darwin_transfer_status (struct usbi_transfer *itransfer, IOReturn result) {
2162   if (itransfer->timeout_flags & USBI_TRANSFER_TIMED_OUT)
2163     result = kIOUSBTransactionTimeout;
2164
2165   switch (result) {
2166   case kIOReturnUnderrun:
2167   case kIOReturnSuccess:
2168     return LIBUSB_TRANSFER_COMPLETED;
2169   case kIOReturnAborted:
2170     return LIBUSB_TRANSFER_CANCELLED;
2171   case kIOUSBPipeStalled:
2172     usbi_dbg ("transfer error: pipe is stalled");
2173     return LIBUSB_TRANSFER_STALL;
2174   case kIOReturnOverrun:
2175     usbi_warn (ITRANSFER_CTX (itransfer), "transfer error: data overrun");
2176     return LIBUSB_TRANSFER_OVERFLOW;
2177   case kIOUSBTransactionTimeout:
2178     usbi_warn (ITRANSFER_CTX (itransfer), "transfer error: timed out");
2179     itransfer->timeout_flags |= USBI_TRANSFER_TIMED_OUT;
2180     return LIBUSB_TRANSFER_TIMED_OUT;
2181   default:
2182     usbi_warn (ITRANSFER_CTX (itransfer), "transfer error: %s (value = 0x%08x)", darwin_error_str (result), result);
2183     return LIBUSB_TRANSFER_ERROR;
2184   }
2185 }
2186
2187 static int darwin_handle_transfer_completion (struct usbi_transfer *itransfer) {
2188   struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2189   struct darwin_transfer_priv *tpriv = usbi_get_transfer_priv(itransfer);
2190   const unsigned char max_transfer_type = LIBUSB_TRANSFER_TYPE_BULK_STREAM;
2191   const char *transfer_types[] = {"control", "isoc", "bulk", "interrupt", "bulk-stream", NULL};
2192   bool is_isoc = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS == transfer->type;
2193
2194   if (transfer->type > max_transfer_type) {
2195     usbi_err (TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
2196     return LIBUSB_ERROR_INVALID_PARAM;
2197   }
2198
2199   if (NULL == tpriv) {
2200     usbi_err (TRANSFER_CTX(transfer), "malformed request is missing transfer priv");
2201     return LIBUSB_ERROR_INVALID_PARAM;
2202   }
2203
2204   usbi_dbg ("handling transfer completion type %s with kernel status %d", transfer_types[transfer->type], tpriv->result);
2205
2206   if (kIOReturnSuccess == tpriv->result || kIOReturnUnderrun == tpriv->result || kIOUSBTransactionTimeout == tpriv->result) {
2207     if (is_isoc && tpriv->isoc_framelist) {
2208       /* copy isochronous results back */
2209
2210       for (int i = 0; i < transfer->num_iso_packets ; i++) {
2211         struct libusb_iso_packet_descriptor *lib_desc = &transfer->iso_packet_desc[i];
2212         lib_desc->status = darwin_transfer_status (itransfer, tpriv->isoc_framelist[i].frStatus);
2213         lib_desc->actual_length = tpriv->isoc_framelist[i].frActCount;
2214       }
2215     } else if (!is_isoc) {
2216       itransfer->transferred += tpriv->size;
2217     }
2218   }
2219
2220   /* it is ok to handle cancelled transfers without calling usbi_handle_transfer_cancellation (we catch timeout transfers) */
2221   return usbi_handle_transfer_completion (itransfer, darwin_transfer_status (itransfer, tpriv->result));
2222 }
2223
2224 #if !defined(HAVE_CLOCK_GETTIME)
2225 void usbi_get_monotonic_time(struct timespec *tp) {
2226   mach_timespec_t sys_time;
2227
2228   /* use system boot time as reference for the monotonic clock */
2229   clock_get_time (clock_monotonic, &sys_time);
2230
2231   tp->tv_sec  = sys_time.tv_sec;
2232   tp->tv_nsec = sys_time.tv_nsec;
2233 }
2234
2235 void usbi_get_real_time(struct timespec *tp) {
2236   mach_timespec_t sys_time;
2237
2238   /* CLOCK_REALTIME represents time since the epoch */
2239   clock_get_time (clock_realtime, &sys_time);
2240
2241   tp->tv_sec  = sys_time.tv_sec;
2242   tp->tv_nsec = sys_time.tv_nsec;
2243 }
2244 #endif
2245
2246 #if InterfaceVersion >= 550
2247 static int darwin_alloc_streams (struct libusb_device_handle *dev_handle, uint32_t num_streams, unsigned char *endpoints,
2248                                  int num_endpoints) {
2249   struct darwin_interface *cInterface;
2250   UInt32 supportsStreams;
2251   uint8_t pipeRef;
2252   int rc, i;
2253
2254   /* find the minimum number of supported streams on the endpoint list */
2255   for (i = 0 ; i < num_endpoints ; ++i) {
2256     if (0 != (rc = ep_to_pipeRef (dev_handle, endpoints[i], &pipeRef, NULL, &cInterface))) {
2257       return rc;
2258     }
2259
2260     (*(cInterface->interface))->SupportsStreams (cInterface->interface, pipeRef, &supportsStreams);
2261     if (num_streams > supportsStreams)
2262       num_streams = supportsStreams;
2263   }
2264
2265   /* it is an error if any endpoint in endpoints does not support streams */
2266   if (0 == num_streams)
2267     return LIBUSB_ERROR_INVALID_PARAM;
2268
2269   /* create the streams */
2270   for (i = 0 ; i < num_endpoints ; ++i) {
2271     (void) ep_to_pipeRef (dev_handle, endpoints[i], &pipeRef, NULL, &cInterface);
2272
2273     rc = (*(cInterface->interface))->CreateStreams (cInterface->interface, pipeRef, num_streams);
2274     if (kIOReturnSuccess != rc)
2275       return darwin_to_libusb(rc);
2276   }
2277
2278   assert(num_streams <= INT_MAX);
2279   return (int)num_streams;
2280 }
2281
2282 static int darwin_free_streams (struct libusb_device_handle *dev_handle, unsigned char *endpoints, int num_endpoints) {
2283   struct darwin_interface *cInterface;
2284   UInt32 supportsStreams;
2285   uint8_t pipeRef;
2286   int rc;
2287
2288   for (int i = 0 ; i < num_endpoints ; ++i) {
2289     if (0 != (rc = ep_to_pipeRef (dev_handle, endpoints[i], &pipeRef, NULL, &cInterface)))
2290       return rc;
2291
2292     (*(cInterface->interface))->SupportsStreams (cInterface->interface, pipeRef, &supportsStreams);
2293     if (0 == supportsStreams)
2294       return LIBUSB_ERROR_INVALID_PARAM;
2295
2296     rc = (*(cInterface->interface))->CreateStreams (cInterface->interface, pipeRef, 0);
2297     if (kIOReturnSuccess != rc)
2298       return darwin_to_libusb(rc);
2299   }
2300
2301   return LIBUSB_SUCCESS;
2302 }
2303 #endif
2304
2305 #if InterfaceVersion >= 700
2306
2307 /* macOS APIs for getting entitlement values */
2308
2309 #if TARGET_OS_OSX
2310 #include <Security/Security.h>
2311 #else
2312 typedef struct __SecTask *SecTaskRef;
2313 extern SecTaskRef SecTaskCreateFromSelf(CFAllocatorRef allocator);
2314 extern CFTypeRef SecTaskCopyValueForEntitlement(SecTaskRef task, CFStringRef entitlement, CFErrorRef *error);
2315 #endif
2316
2317 static bool darwin_has_capture_entitlements (void) {
2318   SecTaskRef task;
2319   CFTypeRef value;
2320   bool entitled;
2321
2322   task = SecTaskCreateFromSelf (kCFAllocatorDefault);
2323   if (task == NULL) {
2324     return false;
2325   }
2326   value = SecTaskCopyValueForEntitlement(task, CFSTR("com.apple.vm.device-access"), NULL);
2327   CFRelease (task);
2328   entitled = value && (CFGetTypeID (value) == CFBooleanGetTypeID ()) && CFBooleanGetValue (value);
2329   if (value) {
2330     CFRelease (value);
2331   }
2332   return entitled;
2333 }
2334
2335 static int darwin_reload_device (struct libusb_device_handle *dev_handle) {
2336   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
2337   enum libusb_error err;
2338
2339   usbi_mutex_lock(&darwin_cached_devices_lock);
2340   (*(dpriv->device))->Release(dpriv->device);
2341   dpriv->device = darwin_device_from_service (dpriv->service);
2342   if (!dpriv->device) {
2343     err = LIBUSB_ERROR_NO_DEVICE;
2344   } else {
2345     err = LIBUSB_SUCCESS;
2346   }
2347   usbi_mutex_unlock(&darwin_cached_devices_lock);
2348
2349   return err;
2350 }
2351
2352 /* On macOS, we capture an entire device at once, not individual interfaces. */
2353
2354 static int darwin_detach_kernel_driver (struct libusb_device_handle *dev_handle, uint8_t interface) {
2355   UNUSED(interface);
2356   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
2357   IOReturn kresult;
2358   enum libusb_error err;
2359
2360   if (HAS_CAPTURE_DEVICE()) {
2361   } else {
2362     return LIBUSB_ERROR_NOT_SUPPORTED;
2363   }
2364
2365   if (dpriv->capture_count == 0) {
2366     /* request authorization */
2367     if (darwin_has_capture_entitlements ()) {
2368       kresult = IOServiceAuthorize (dpriv->service, kIOServiceInteractionAllowed);
2369       if (kresult != kIOReturnSuccess) {
2370         usbi_err (HANDLE_CTX (dev_handle), "IOServiceAuthorize: %s", darwin_error_str(kresult));
2371         return darwin_to_libusb (kresult);
2372       }
2373       /* we need start() to be called again for authorization status to refresh */
2374       err = darwin_reload_device (dev_handle);
2375       if (err != LIBUSB_SUCCESS) {
2376         return err;
2377       }
2378     }
2379     /* reset device to release existing drivers */
2380     err = darwin_reenumerate_device (dev_handle, true);
2381     if (err != LIBUSB_SUCCESS) {
2382       return err;
2383     }
2384   }
2385   dpriv->capture_count++;
2386   return LIBUSB_SUCCESS;
2387 }
2388
2389
2390 static int darwin_attach_kernel_driver (struct libusb_device_handle *dev_handle, uint8_t interface) {
2391   UNUSED(interface);
2392   struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
2393
2394   if (HAS_CAPTURE_DEVICE()) {
2395   } else {
2396     return LIBUSB_ERROR_NOT_SUPPORTED;
2397   }
2398
2399   dpriv->capture_count--;
2400   if (dpriv->capture_count > 0) {
2401     return LIBUSB_SUCCESS;
2402   } else {
2403     dpriv->capture_count = 0;
2404   }
2405   /* reset device to attach kernel drivers */
2406   return darwin_reenumerate_device (dev_handle, false);
2407 }
2408
2409 static int darwin_capture_claim_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
2410   enum libusb_error ret;
2411   if (dev_handle->auto_detach_kernel_driver) {
2412     ret = darwin_detach_kernel_driver (dev_handle, iface);
2413     if (ret != LIBUSB_SUCCESS) {
2414       return ret;
2415     }
2416   }
2417   return darwin_claim_interface (dev_handle, iface);
2418 }
2419
2420 static int darwin_capture_release_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
2421   enum libusb_error ret;
2422
2423   ret = darwin_release_interface (dev_handle, iface);
2424   if (ret != LIBUSB_SUCCESS) {
2425     return ret;
2426   }
2427   if (dev_handle->auto_detach_kernel_driver) {
2428     ret = darwin_attach_kernel_driver (dev_handle, iface);
2429   }
2430   return ret;
2431 }
2432
2433 #endif
2434
2435 const struct usbi_os_backend usbi_backend = {
2436         .name = "Darwin",
2437         .caps = USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER,
2438         .init = darwin_init,
2439         .exit = darwin_exit,
2440         .get_active_config_descriptor = darwin_get_active_config_descriptor,
2441         .get_config_descriptor = darwin_get_config_descriptor,
2442         .hotplug_poll = darwin_hotplug_poll,
2443
2444         .open = darwin_open,
2445         .close = darwin_close,
2446         .get_configuration = darwin_get_configuration,
2447         .set_configuration = darwin_set_configuration,
2448
2449         .set_interface_altsetting = darwin_set_interface_altsetting,
2450         .clear_halt = darwin_clear_halt,
2451         .reset_device = darwin_reset_device,
2452
2453 #if InterfaceVersion >= 550
2454         .alloc_streams = darwin_alloc_streams,
2455         .free_streams = darwin_free_streams,
2456 #endif
2457
2458         .kernel_driver_active = darwin_kernel_driver_active,
2459
2460 #if InterfaceVersion >= 700
2461         .detach_kernel_driver = darwin_detach_kernel_driver,
2462         .attach_kernel_driver = darwin_attach_kernel_driver,
2463         .claim_interface = darwin_capture_claim_interface,
2464         .release_interface = darwin_capture_release_interface,
2465 #else
2466         .claim_interface = darwin_claim_interface,
2467         .release_interface = darwin_release_interface,
2468 #endif
2469
2470         .destroy_device = darwin_destroy_device,
2471
2472         .submit_transfer = darwin_submit_transfer,
2473         .cancel_transfer = darwin_cancel_transfer,
2474
2475         .handle_transfer_completion = darwin_handle_transfer_completion,
2476
2477         .device_priv_size = sizeof(struct darwin_device_priv),
2478         .device_handle_priv_size = sizeof(struct darwin_device_handle_priv),
2479         .transfer_priv_size = sizeof(struct darwin_transfer_priv),
2480 };