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