usb: Implement device discovery using libusb hotplug events

1 files changed, 268 insertions, 202 deletions

diff --git a/src/usb.c b/src/usb.c
index f5e8092..3ce2abb 100644
--- a/src/usb.c
+++ b/src/usb.c
@@ -36,6 +36,10 @@
 #include "device.h"
 #include "utils.h"
 
+#if (defined(LIBUSB_API_VERSION) && (LIBUSB_API_VERSION >= 0x01000102)) || (defined(LIBUSBX_API_VERSION) && (LIBUSBX_API_VERSION >= 0x01000102))
+#define HAVE_LIBUSB_HOTPLUG_API 1
+#endif
+
 // interval for device connection/disconnection polling, in milliseconds
 // we need this because there is currently no asynchronous device discovery mechanism in libusb
 #define DEVICE_POLL_TIME 1000
@@ -65,6 +69,7 @@ static struct timeval next_dev_poll_time;
 
 static int devlist_failures;
 static int device_polling;
+static int device_hotplug = 1;
 
 static void usb_disconnect(struct usb_device *dev)
 {
@@ -253,9 +258,217 @@ static int start_rx_loop(struct usb_device *dev)
         return 0;
 }
 
+static int usb_device_add(libusb_device* dev)
+{
+        int j, res;
+        // the following are non-blocking operations on the device list
+        uint8_t bus = libusb_get_bus_number(dev);
+        uint8_t address = libusb_get_device_address(dev);
+        struct libusb_device_descriptor devdesc;
+        int found = 0;
+        FOREACH(struct usb_device *usbdev, &device_list) {
+                if(usbdev->bus == bus && usbdev->address == address) {
+                        usbdev->alive = 1;
+                        found = 1;
+                        break;
+                }
+        } ENDFOREACH
+        if(found)
+                return 0; //device already found
+
+        if((res = libusb_get_device_descriptor(dev, &devdesc)) != 0) {
+                usbmuxd_log(LL_WARNING, "Could not get device descriptor for device %d-%d: %d", bus, address, res);
+                return -1;
+        }
+        if(devdesc.idVendor != VID_APPLE)
+                return -1;
+        if((devdesc.idProduct < PID_RANGE_LOW) ||
+                (devdesc.idProduct > PID_RANGE_MAX))
+                return -1;
+        libusb_device_handle *handle;
+        usbmuxd_log(LL_INFO, "Found new device with v/p %04x:%04x at %d-%d", devdesc.idVendor, devdesc.idProduct, bus, address);
+        // potentially blocking operations follow; they will only run when new devices are detected, which is acceptable
+        if((res = libusb_open(dev, &handle)) != 0) {
+                usbmuxd_log(LL_WARNING, "Could not open device %d-%d: %d", bus, address, res);
+                return -1;
+        }
+
+        int current_config = 0;
+        if((res = libusb_get_configuration(handle, &current_config)) != 0) {
+                usbmuxd_log(LL_WARNING, "Could not get configuration for device %d-%d: %d", bus, address, res);
+                libusb_close(handle);
+                return -1;
+        }
+        if (current_config != devdesc.bNumConfigurations) {
+                struct libusb_config_descriptor *config;
+                if((res = libusb_get_active_config_descriptor(dev, &config)) != 0) {
+                        usbmuxd_log(LL_NOTICE, "Could not get old configuration descriptor for device %d-%d: %d", bus, address, res);
+                } else {
+                        for(j=0; j<config->bNumInterfaces; j++) {
+                                const struct libusb_interface_descriptor *intf = &config->interface[j].altsetting[0];
+                                if((res = libusb_kernel_driver_active(handle, intf->bInterfaceNumber)) < 0) {
+                                        usbmuxd_log(LL_NOTICE, "Could not check kernel ownership of interface %d for device %d-%d: %d", intf->bInterfaceNumber, bus, address, res);
+                                        continue;
+                                }
+                                if(res == 1) {
+                                        usbmuxd_log(LL_INFO, "Detaching kernel driver for device %d-%d, interface %d", bus, address, intf->bInterfaceNumber);
+                                        if((res = libusb_detach_kernel_driver(handle, intf->bInterfaceNumber)) < 0) {
+                                                usbmuxd_log(LL_WARNING, "Could not detach kernel driver (%d), configuration change will probably fail!", res);
+                                                continue;
+                                        }
+                                }
+                        }
+                        libusb_free_config_descriptor(config);
+                }
+
+                usbmuxd_log(LL_INFO, "Setting configuration for device %d-%d, from %d to %d", bus, address, current_config, devdesc.bNumConfigurations);
+                if((res = libusb_set_configuration(handle, devdesc.bNumConfigurations)) != 0) {
+                        usbmuxd_log(LL_WARNING, "Could not set configuration %d for device %d-%d: %d", devdesc.bNumConfigurations, bus, address, res);
+                        libusb_close(handle);
+                        return -1;
+                }
+        }
+
+        struct libusb_config_descriptor *config;
+        if((res = libusb_get_active_config_descriptor(dev, &config)) != 0) {
+                usbmuxd_log(LL_WARNING, "Could not get configuration descriptor for device %d-%d: %d", bus, address, res);
+                libusb_close(handle);
+                return -1;
+        }
+
+        struct usb_device *usbdev;
+        usbdev = malloc(sizeof(struct usb_device));
+        memset(usbdev, 0, sizeof(*usbdev));
+
+        for(j=0; j<config->bNumInterfaces; j++) {
+                const struct libusb_interface_descriptor *intf = &config->interface[j].altsetting[0];
+                if(intf->bInterfaceClass != INTERFACE_CLASS ||
+                   intf->bInterfaceSubClass != INTERFACE_SUBCLASS ||
+                   intf->bInterfaceProtocol != INTERFACE_PROTOCOL)
+                        continue;
+                if(intf->bNumEndpoints != 2) {
+                        usbmuxd_log(LL_WARNING, "Endpoint count mismatch for interface %d of device %d-%d", intf->bInterfaceNumber, bus, address);
+                        continue;
+                }
+                if((intf->endpoint[0].bEndpointAddress & 0x80) == LIBUSB_ENDPOINT_OUT &&
+                   (intf->endpoint[1].bEndpointAddress & 0x80) == LIBUSB_ENDPOINT_IN) {
+                        usbdev->interface = intf->bInterfaceNumber;
+                        usbdev->ep_out = intf->endpoint[0].bEndpointAddress;
+                        usbdev->ep_in = intf->endpoint[1].bEndpointAddress;
+                        usbmuxd_log(LL_INFO, "Found interface %d with endpoints %02x/%02x for device %d-%d", usbdev->interface, usbdev->ep_out, usbdev->ep_in, bus, address);
+                        break;
+                } else if((intf->endpoint[1].bEndpointAddress & 0x80) == LIBUSB_ENDPOINT_OUT &&
+                          (intf->endpoint[0].bEndpointAddress & 0x80) == LIBUSB_ENDPOINT_IN) {
+                        usbdev->interface = intf->bInterfaceNumber;
+                        usbdev->ep_out = intf->endpoint[1].bEndpointAddress;
+                        usbdev->ep_in = intf->endpoint[0].bEndpointAddress;
+                        usbmuxd_log(LL_INFO, "Found interface %d with swapped endpoints %02x/%02x for device %d-%d", usbdev->interface, usbdev->ep_out, usbdev->ep_in, bus, address);
+                        break;
+                } else {
+                        usbmuxd_log(LL_WARNING, "Endpoint type mismatch for interface %d of device %d-%d", intf->bInterfaceNumber, bus, address);
+                }
+        }
+
+        if(j == config->bNumInterfaces) {
+                usbmuxd_log(LL_WARNING, "Could not find a suitable USB interface for device %d-%d", bus, address);
+                libusb_free_config_descriptor(config);
+                libusb_close(handle);
+                free(usbdev);
+                return -1;
+        }
+
+        libusb_free_config_descriptor(config);
+
+        if((res = libusb_claim_interface(handle, usbdev->interface)) != 0) {
+                usbmuxd_log(LL_WARNING, "Could not claim interface %d for device %d-%d: %d", usbdev->interface, bus, address, res);
+                libusb_close(handle);
+                free(usbdev);
+                return -1;
+        }
+
+        if((res = libusb_get_string_descriptor_ascii(handle, devdesc.iSerialNumber, (uint8_t *)usbdev->serial, 256)) <= 0) {
+                usbmuxd_log(LL_WARNING, "Could not get serial number for device %d-%d: %d", bus, address, res);
+                libusb_release_interface(handle, usbdev->interface);
+                libusb_close(handle);
+                free(usbdev);
+                return -1;
+        }
+        usbdev->serial[res] = 0;
+        usbdev->bus = bus;
+        usbdev->address = address;
+        usbdev->vid = devdesc.idVendor;
+        usbdev->pid = devdesc.idProduct;
+        usbdev->speed = 480000000;
+        usbdev->dev = handle;
+        usbdev->alive = 1;
+        usbdev->wMaxPacketSize = libusb_get_max_packet_size(dev, usbdev->ep_out);
+        if (usbdev->wMaxPacketSize <= 0) {
+                usbmuxd_log(LL_ERROR, "Could not determine wMaxPacketSize for device %d-%d, setting to 64", usbdev->bus, usbdev->address);
+                usbdev->wMaxPacketSize = 64;
+        } else {
+                usbmuxd_log(LL_INFO, "Using wMaxPacketSize=%d for device %d-%d", usbdev->wMaxPacketSize, usbdev->bus, usbdev->address);
+        }
+
+        switch (libusb_get_device_speed(dev)) {
+                case LIBUSB_SPEED_LOW:
+                        usbdev->speed = 1500000;
+                        break;
+                case LIBUSB_SPEED_FULL:
+                        usbdev->speed = 12000000;
+                        break;
+                case LIBUSB_SPEED_SUPER:
+                        usbdev->speed = 5000000000;
+                        break;
+                case LIBUSB_SPEED_HIGH:
+                case LIBUSB_SPEED_UNKNOWN:
+                default:
+                        usbdev->speed = 480000000;
+                        break;
+        }
+
+        usbmuxd_log(LL_INFO, "USB Speed is %g MBit/s for device %d-%d", (double)(usbdev->speed / 1000000.0), usbdev->bus, usbdev->address);
+
+        collection_init(&usbdev->tx_xfers);
+        collection_init(&usbdev->rx_xfers);
+
+        collection_add(&device_list, usbdev);
+
+        if(device_add(usbdev) < 0) {
+                usb_disconnect(usbdev);
+                return -1;
+        }
+
+        // Spin up NUM_RX_LOOPS parallel usb data retrieval loops
+        // Old usbmuxds used only 1 rx loop, but that leaves the
+        // USB port sleeping most of the time
+        int rx_loops = NUM_RX_LOOPS;
+        for (rx_loops = NUM_RX_LOOPS; rx_loops > 0; rx_loops--) {
+                if(start_rx_loop(usbdev) < 0) {
+                        usbmuxd_log(LL_WARNING, "Failed to start RX loop number %d", NUM_RX_LOOPS - rx_loops);
+                }
+        }
+
+        // Ensure we have at least 1 RX loop going
+        if (rx_loops == NUM_RX_LOOPS) {
+                usbmuxd_log(LL_FATAL, "Failed to start any RX loop for device %d-%d",
+                                        usbdev->bus, usbdev->address);
+                device_remove(usbdev);
+                usb_disconnect(usbdev);
+                return -1;
+        } else if (rx_loops > 0) {
+                usbmuxd_log(LL_WARNING, "Failed to start all %d RX loops. Going on with %d loops. "
+                                        "This may have negative impact on device read speed.",
+                                        NUM_RX_LOOPS, NUM_RX_LOOPS - rx_loops);
+        } else {
+                usbmuxd_log(LL_DEBUG, "All %d RX loops started successfully", NUM_RX_LOOPS);
+        }
+
+        return 0;
+}
+
 int usb_discover(void)
 {
-        int cnt, i, j, res;
+        int cnt, i;
         int valid_count = 0;
         libusb_device **devs;
 
@@ -288,209 +501,10 @@ int usb_discover(void)
         // Enumerate all USB devices and mark the ones we already know
         // about as live, again
         for(i=0; i<cnt; i++) {
-                // the following are non-blocking operations on the device list
                 libusb_device *dev = devs[i];
-                uint8_t bus = libusb_get_bus_number(dev);
-                uint8_t address = libusb_get_device_address(dev);
-                struct libusb_device_descriptor devdesc;
-                int found = 0;
-                FOREACH(struct usb_device *usbdev, &device_list) {
-                        if(usbdev->bus == bus && usbdev->address == address) {
-                                valid_count++;
-                                usbdev->alive = 1;
-                                found = 1;
-                                break;
-                        }
-                } ENDFOREACH
-                if(found)
-                        continue; //device already found
-                if((res = libusb_get_device_descriptor(dev, &devdesc)) != 0) {
-                        usbmuxd_log(LL_WARNING, "Could not get device descriptor for device %d-%d: %d", bus, address, res);
-                        continue;
-                }
-                if(devdesc.idVendor != VID_APPLE)
-                        continue;
-                if((devdesc.idProduct < PID_RANGE_LOW) ||
-                        (devdesc.idProduct > PID_RANGE_MAX))
-                        continue;
-                libusb_device_handle *handle;
-                usbmuxd_log(LL_INFO, "Found new device with v/p %04x:%04x at %d-%d", devdesc.idVendor, devdesc.idProduct, bus, address);
-                // potentially blocking operations follow; they will only run when new devices are detected, which is acceptable
-                if((res = libusb_open(dev, &handle)) != 0) {
-                        usbmuxd_log(LL_WARNING, "Could not open device %d-%d: %d", bus, address, res);
+                if (usb_device_add(dev) < 0) {
                         continue;
                 }
-
-                int current_config = 0;
-                if((res = libusb_get_configuration(handle, &current_config)) != 0) {
-                        usbmuxd_log(LL_WARNING, "Could not get configuration for device %d-%d: %d", bus, address, res);
-                        libusb_close(handle);
-                        continue;
-                }
-                if (current_config != devdesc.bNumConfigurations) {
-                        struct libusb_config_descriptor *config;
-                        if((res = libusb_get_active_config_descriptor(dev, &config)) != 0) {
-                                usbmuxd_log(LL_NOTICE, "Could not get old configuration descriptor for device %d-%d: %d", bus, address, res);
-                        } else {
-                                for(j=0; j<config->bNumInterfaces; j++) {
-                                        const struct libusb_interface_descriptor *intf = &config->interface[j].altsetting[0];
-                                        if((res = libusb_kernel_driver_active(handle, intf->bInterfaceNumber)) < 0) {
-                                                usbmuxd_log(LL_NOTICE, "Could not check kernel ownership of interface %d for device %d-%d: %d", intf->bInterfaceNumber, bus, address, res);
-                                                continue;
-                                        }
-                                        if(res == 1) {
-                                                usbmuxd_log(LL_INFO, "Detaching kernel driver for device %d-%d, interface %d", bus, address, intf->bInterfaceNumber);
-                                                if((res = libusb_detach_kernel_driver(handle, intf->bInterfaceNumber)) < 0) {
-                                                        usbmuxd_log(LL_WARNING, "Could not detach kernel driver (%d), configuration change will probably fail!", res);
-                                                        continue;
-                                                }
-                                        }
-                                }
-                                libusb_free_config_descriptor(config);
-                        }
-
-                        usbmuxd_log(LL_INFO, "Setting configuration for device %d-%d, from %d to %d", bus, address, current_config, devdesc.bNumConfigurations);
-                        if((res = libusb_set_configuration(handle, devdesc.bNumConfigurations)) != 0) {
-                                usbmuxd_log(LL_WARNING, "Could not set configuration %d for device %d-%d: %d", devdesc.bNumConfigurations, bus, address, res);
-                                libusb_close(handle);
-                                continue;
-                        }
-                }
-
-                struct libusb_config_descriptor *config;
-                if((res = libusb_get_active_config_descriptor(dev, &config)) != 0) {
-                        usbmuxd_log(LL_WARNING, "Could not get configuration descriptor for device %d-%d: %d", bus, address, res);
-                        libusb_close(handle);
-                        continue;
-                }
-
-                struct usb_device *usbdev;
-                usbdev = malloc(sizeof(struct usb_device));
-                memset(usbdev, 0, sizeof(*usbdev));
-
-                for(j=0; j<config->bNumInterfaces; j++) {
-                        const struct libusb_interface_descriptor *intf = &config->interface[j].altsetting[0];
-                        if(intf->bInterfaceClass != INTERFACE_CLASS ||
-                           intf->bInterfaceSubClass != INTERFACE_SUBCLASS ||
-                           intf->bInterfaceProtocol != INTERFACE_PROTOCOL)
-                                continue;
-                        if(intf->bNumEndpoints != 2) {
-                                usbmuxd_log(LL_WARNING, "Endpoint count mismatch for interface %d of device %d-%d", intf->bInterfaceNumber, bus, address);
-                                continue;
-                        }
-                        if((intf->endpoint[0].bEndpointAddress & 0x80) == LIBUSB_ENDPOINT_OUT &&
-                           (intf->endpoint[1].bEndpointAddress & 0x80) == LIBUSB_ENDPOINT_IN) {
-                                usbdev->interface = intf->bInterfaceNumber;
-                                usbdev->ep_out = intf->endpoint[0].bEndpointAddress;
-                                usbdev->ep_in = intf->endpoint[1].bEndpointAddress;
-                                usbmuxd_log(LL_INFO, "Found interface %d with endpoints %02x/%02x for device %d-%d", usbdev->interface, usbdev->ep_out, usbdev->ep_in, bus, address);
-                                break;
-                        } else if((intf->endpoint[1].bEndpointAddress & 0x80) == LIBUSB_ENDPOINT_OUT &&
-                                  (intf->endpoint[0].bEndpointAddress & 0x80) == LIBUSB_ENDPOINT_IN) {
-                                usbdev->interface = intf->bInterfaceNumber;
-                                usbdev->ep_out = intf->endpoint[1].bEndpointAddress;
-                                usbdev->ep_in = intf->endpoint[0].bEndpointAddress;
-                                usbmuxd_log(LL_INFO, "Found interface %d with swapped endpoints %02x/%02x for device %d-%d", usbdev->interface, usbdev->ep_out, usbdev->ep_in, bus, address);
-                                break;
-                        } else {
-                                usbmuxd_log(LL_WARNING, "Endpoint type mismatch for interface %d of device %d-%d", intf->bInterfaceNumber, bus, address);
-                        }
-                }
-
-                if(j == config->bNumInterfaces) {
-                        usbmuxd_log(LL_WARNING, "Could not find a suitable USB interface for device %d-%d", bus, address);
-                        libusb_free_config_descriptor(config);
-                        libusb_close(handle);
-                        free(usbdev);
-                        continue;
-                }
-
-                libusb_free_config_descriptor(config);
-
-                if((res = libusb_claim_interface(handle, usbdev->interface)) != 0) {
-                        usbmuxd_log(LL_WARNING, "Could not claim interface %d for device %d-%d: %d", usbdev->interface, bus, address, res);
-                        libusb_close(handle);
-                        free(usbdev);
-                        continue;
-                }
-
-                if((res = libusb_get_string_descriptor_ascii(handle, devdesc.iSerialNumber, (uint8_t *)usbdev->serial, 256)) <= 0) {
-                        usbmuxd_log(LL_WARNING, "Could not get serial number for device %d-%d: %d", bus, address, res);
-                        libusb_release_interface(handle, usbdev->interface);
-                        libusb_close(handle);
-                        free(usbdev);
-                        continue;
-                }
-                usbdev->serial[res] = 0;
-                usbdev->bus = bus;
-                usbdev->address = address;
-                usbdev->vid = devdesc.idVendor;
-                usbdev->pid = devdesc.idProduct;
-                usbdev->speed = 480000000;
-                usbdev->dev = handle;
-                usbdev->alive = 1;
-                usbdev->wMaxPacketSize = libusb_get_max_packet_size(dev, usbdev->ep_out);
-                if (usbdev->wMaxPacketSize <= 0) {
-                        usbmuxd_log(LL_ERROR, "Could not determine wMaxPacketSize for device %d-%d, setting to 64", usbdev->bus, usbdev->address);
-                        usbdev->wMaxPacketSize = 64;
-                } else {
-                        usbmuxd_log(LL_INFO, "Using wMaxPacketSize=%d for device %d-%d", usbdev->wMaxPacketSize, usbdev->bus, usbdev->address);
-                }
-
-                switch (libusb_get_device_speed(dev)) {
-                        case LIBUSB_SPEED_LOW:
-                                usbdev->speed = 1500000;
-                                break;
-                        case LIBUSB_SPEED_FULL:
-                                usbdev->speed = 12000000;
-                                break;
-                        case LIBUSB_SPEED_SUPER:
-                                usbdev->speed = 5000000000;
-                                break;
-                        case LIBUSB_SPEED_HIGH:
-                        case LIBUSB_SPEED_UNKNOWN:
-                        default:
-                                usbdev->speed = 480000000;
-                                break;
-                }
-
-                usbmuxd_log(LL_INFO, "USB Speed is %g MBit/s for device %d-%d", (double)(usbdev->speed / 1000000.0), usbdev->bus, usbdev->address);
-
-                collection_init(&usbdev->tx_xfers);
-                collection_init(&usbdev->rx_xfers);
-
-                collection_add(&device_list, usbdev);
-
-                if(device_add(usbdev) < 0) {
-                        usb_disconnect(usbdev);
-                        continue;
-                }
-
-                // Spin up NUM_RX_LOOPS parallel usb data retrieval loops
-                // Old usbmuxds used only 1 rx loop, but that leaves the
-                // USB port sleeping most of the time
-                int rx_loops = NUM_RX_LOOPS;
-                for (rx_loops = NUM_RX_LOOPS; rx_loops > 0; rx_loops--) {
-                        if(start_rx_loop(usbdev) < 0) {
-                                usbmuxd_log(LL_WARNING, "Failed to start RX loop number %d", NUM_RX_LOOPS - rx_loops);
-                        }
-                }
-
-                // Ensure we have at least 1 RX loop going
-                if (rx_loops == NUM_RX_LOOPS) {
-                        usbmuxd_log(LL_FATAL, "Failed to start any RX loop for device %d-%d",
-                                                usbdev->bus, usbdev->address);
-                        device_remove(usbdev);
-                        usb_disconnect(usbdev);
-                        continue;
-                } else if (rx_loops > 0) {
-                        usbmuxd_log(LL_WARNING, "Failed to start all %d RX loops. Going on with %d loops. "
-                                                "This may have negative impact on device read speed.",
-                                                NUM_RX_LOOPS, NUM_RX_LOOPS - rx_loops);
-                } else {
-                        usbmuxd_log(LL_DEBUG, "All %d RX loops started successfully", NUM_RX_LOOPS);
-                }
-
                 valid_count++;
         }
 
@@ -560,6 +574,7 @@ void usb_autodiscover(int enable)
 {
         usbmuxd_log(LL_DEBUG, "usb polling enable: %d", enable);
         device_polling = enable;
+        device_hotplug = enable;
 }
 
 static int dev_poll_remain_ms(void)
@@ -649,6 +664,32 @@ int usb_process_timeout(int msec)
         return 0;
 }
 
+#ifdef HAVE_LIBUSB_HOTPLUG_API
+static libusb_hotplug_callback_handle usb_hotplug_cb_handle;
+
+static int usb_hotplug_cb(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data)
+{
+        if (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED == event) {
+                if (device_hotplug) {
+                        usb_device_add(device);
+                }
+        } else if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == event) {
+                uint8_t bus = libusb_get_bus_number(device);
+                uint8_t address = libusb_get_device_address(device);
+                FOREACH(struct usb_device *usbdev, &device_list) {
+                        if(usbdev->bus == bus && usbdev->address == address) {
+                                usbdev->alive = 0;
+                                device_remove(usbdev);
+                                break;
+                        }
+                } ENDFOREACH
+        } else {
+                usbmuxd_log(LL_ERROR, "Unhandled event %d", event);
+        }
+        return 0;
+}
+#endif
+
 int usb_init(void)
 {
         int res;
@@ -665,12 +706,37 @@ int usb_init(void)
 
         collection_init(&device_list);
 
-        return usb_discover();
+#ifdef HAVE_LIBUSB_HOTPLUG_API
+        if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+                usbmuxd_log(LL_INFO, "Registering for libusb hotplug events");
+                res = libusb_hotplug_register_callback(NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, LIBUSB_HOTPLUG_ENUMERATE, VID_APPLE, LIBUSB_HOTPLUG_MATCH_ANY, 0, usb_hotplug_cb, NULL, &usb_hotplug_cb_handle);
+                if (res == LIBUSB_SUCCESS) {
+                        device_polling = 0;
+                } else {
+                        usbmuxd_log(LL_ERROR, "ERROR: Could not register for libusb hotplug events (%d)", res);
+                }
+        } else {
+                usbmuxd_log(LL_ERROR, "libusb does not support hotplug events");
+        }
+#endif
+        if (device_polling) {
+                res = usb_discover();
+                if (res >= 0) {
+                }
+        } else {
+                res = collection_count(&device_list);
+        }
+        return res;
 }
 
 void usb_shutdown(void)
 {
         usbmuxd_log(LL_DEBUG, "usb_shutdown");
+
+#ifdef HAVE_LIBUSB_HOTPLUG_API
+        libusb_hotplug_deregister_callback(NULL, usb_hotplug_cb_handle);
+#endif
+
         FOREACH(struct usb_device *usbdev, &device_list) {
                 device_remove(usbdev);
                 usb_disconnect(usbdev);