lib/libusb/libusb10_hotplug.c

   1 /* $FreeBSD$ */
   2 /*-
   3  * Copyright (c) 2016-2019 Hans Petter Selasky. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #ifdef LIBUSB_GLOBAL_INCLUDE_FILE
  28 #include LIBUSB_GLOBAL_INCLUDE_FILE
  29 #else
  30 #include <assert.h>
  31 #include <errno.h>
  32 #include <poll.h>
  33 #include <pthread.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <unistd.h>
  38 #include <time.h>
  39 #include <sys/fcntl.h>
  40 #include <sys/ioctl.h>
  41 #include <sys/queue.h>
  42 #include <sys/endian.h>
  43 #endif
  44
  45 #define libusb_device_handle libusb20_device
  46
  47 #include "libusb20.h"
  48 #include "libusb20_desc.h"
  49 #include "libusb20_int.h"
  50 #include "libusb.h"
  51 #include "libusb10.h"
  52
  53 static int
  54 libusb_hotplug_equal(libusb_device *_adev, libusb_device *_bdev)
  55 {
  56         struct libusb20_device *adev = _adev->os_priv;
  57         struct libusb20_device *bdev = _bdev->os_priv;
  58
  59         if (adev->bus_number != bdev->bus_number)
  60                 return (0);
  61         if (adev->device_address != bdev->device_address)
  62                 return (0);
  63         if (memcmp(&adev->ddesc, &bdev->ddesc, sizeof(adev->ddesc)))
  64                 return (0);
  65         if (memcmp(&adev->session_data, &bdev->session_data, sizeof(adev->session_data)))
  66                 return (0);
  67         return (1);
  68 }
  69
  70 static int
  71 libusb_hotplug_filter(libusb_context *ctx, libusb_hotplug_callback_handle pcbh,
  72     libusb_device *dev, libusb_hotplug_event event)
  73 {
  74         if (!(pcbh->events & event))
  75                 return (0);
  76         if (pcbh->vendor != LIBUSB_HOTPLUG_MATCH_ANY &&
  77             pcbh->vendor != libusb20_dev_get_device_desc(dev->os_priv)->idVendor)
  78                 return (0);
  79         if (pcbh->product != LIBUSB_HOTPLUG_MATCH_ANY &&
  80             pcbh->product != libusb20_dev_get_device_desc(dev->os_priv)->idProduct)
  81                 return (0);
  82         if (pcbh->devclass != LIBUSB_HOTPLUG_MATCH_ANY &&
  83             pcbh->devclass != libusb20_dev_get_device_desc(dev->os_priv)->bDeviceClass)
  84                 return (0);
  85         return (pcbh->fn(ctx, dev, event, pcbh->user_data));
  86 }
  87
  88 static int
  89 libusb_hotplug_enumerate(libusb_context *ctx, struct libusb_device_head *phead)
  90 {
  91         libusb_device **ppdev;
  92         ssize_t count;
  93         ssize_t x;
  94
  95         count = libusb_get_device_list(ctx, &ppdev);
  96         if (count < 0)
  97                 return (-1);
  98
  99         for (x = 0; x != count; x++)
 100                 TAILQ_INSERT_TAIL(phead, ppdev[x], hotplug_entry);
 101
 102         libusb_free_device_list(ppdev, 0);
 103         return (0);
 104 }
 105
 106 static void *
 107 libusb_hotplug_scan(void *arg)
 108 {
 109         struct libusb_device_head hotplug_devs;
 110         libusb_hotplug_callback_handle acbh;
 111         libusb_hotplug_callback_handle bcbh;
 112         libusb_context *ctx = arg;
 113         libusb_device *temp;
 114         libusb_device *adev;
 115         libusb_device *bdev;
 116         unsigned do_loop = 1;
 117
 118         while (do_loop) {
 119                 usleep(4000000);
 120
 121                 HOTPLUG_LOCK(ctx);
 122
 123                 TAILQ_INIT(&hotplug_devs);
 124
 125                 if (ctx->hotplug_handler != NO_THREAD) {
 126                         if (libusb_hotplug_enumerate(ctx, &hotplug_devs) < 0) {
 127                                 HOTPLUG_UNLOCK(ctx);
 128                                 continue;
 129                         }
 130                 } else {
 131                         do_loop = 0;
 132                 }
 133
 134                 /* figure out which devices are gone */
 135                 TAILQ_FOREACH_SAFE(adev, &ctx->hotplug_devs, hotplug_entry, temp) {
 136                         TAILQ_FOREACH(bdev, &hotplug_devs, hotplug_entry) {
 137                                 if (libusb_hotplug_equal(adev, bdev))
 138                                         break;
 139                         }
 140                         if (bdev == NULL) {
 141                                 TAILQ_REMOVE(&ctx->hotplug_devs, adev, hotplug_entry);
 142                                 TAILQ_FOREACH_SAFE(acbh, &ctx->hotplug_cbh, entry, bcbh) {
 143                                         if (libusb_hotplug_filter(ctx, acbh, adev,
 144                                             LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT) == 0)
 145                                                 continue;
 146                                         TAILQ_REMOVE(&ctx->hotplug_cbh, acbh, entry);
 147                                         free(acbh);
 148                                 }
 149                                 libusb_unref_device(adev);
 150                         }
 151                 }
 152
 153                 /* figure out which devices are new */
 154                 TAILQ_FOREACH_SAFE(adev, &hotplug_devs, hotplug_entry, temp) {
 155                         TAILQ_FOREACH(bdev, &ctx->hotplug_devs, hotplug_entry) {
 156                                 if (libusb_hotplug_equal(adev, bdev))
 157                                         break;
 158                         }
 159                         if (bdev == NULL) {
 160                                 TAILQ_REMOVE(&hotplug_devs, adev, hotplug_entry);
 161                                 TAILQ_INSERT_TAIL(&ctx->hotplug_devs, adev, hotplug_entry);
 162                                 TAILQ_FOREACH_SAFE(acbh, &ctx->hotplug_cbh, entry, bcbh) {
 163                                         if (libusb_hotplug_filter(ctx, acbh, adev,
 164                                             LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) == 0)
 165                                                 continue;
 166                                         TAILQ_REMOVE(&ctx->hotplug_cbh, acbh, entry);
 167                                         free(acbh);
 168                                 }
 169                         }
 170                 }
 171                 HOTPLUG_UNLOCK(ctx);
 172
 173                 /* unref remaining devices */
 174                 while ((adev = TAILQ_FIRST(&hotplug_devs)) != NULL) {
 175                         TAILQ_REMOVE(&hotplug_devs, adev, hotplug_entry);
 176                         libusb_unref_device(adev);
 177                 }
 178         }
 179         return (NULL);
 180 }
 181
 182 int libusb_hotplug_register_callback(libusb_context *ctx,
 183     libusb_hotplug_event events, libusb_hotplug_flag flags,
 184     int vendor_id, int product_id, int dev_class,
 185     libusb_hotplug_callback_fn cb_fn, void *user_data,
 186     libusb_hotplug_callback_handle *phandle)
 187 {
 188         libusb_hotplug_callback_handle handle;
 189         struct libusb_device *adev;
 190
 191         ctx = GET_CONTEXT(ctx);
 192
 193         if (ctx == NULL || cb_fn == NULL || events == 0 ||
 194             vendor_id < -1 || vendor_id > 0xffff ||
 195             product_id < -1 || product_id > 0xffff ||
 196             dev_class < -1 || dev_class > 0xff)
 197                 return (LIBUSB_ERROR_INVALID_PARAM);
 198
 199         handle = malloc(sizeof(*handle));
 200         if (handle == NULL)
 201                 return (LIBUSB_ERROR_NO_MEM);
 202
 203         HOTPLUG_LOCK(ctx);
 204         if (ctx->hotplug_handler == NO_THREAD) {
 205                 libusb_hotplug_enumerate(ctx, &ctx->hotplug_devs);
 206
 207                 if (pthread_create(&ctx->hotplug_handler, NULL,
 208                     &libusb_hotplug_scan, ctx) != 0)
 209                         ctx->hotplug_handler = NO_THREAD;
 210         }
 211         handle->events = events;
 212         handle->vendor = vendor_id;
 213         handle->product = product_id;
 214         handle->devclass = dev_class;
 215         handle->fn = cb_fn;
 216         handle->user_data = user_data;
 217
 218         if (flags & LIBUSB_HOTPLUG_ENUMERATE) {
 219                 TAILQ_FOREACH(adev, &ctx->hotplug_devs, hotplug_entry) {
 220                         if (libusb_hotplug_filter(ctx, handle, adev,
 221                             LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) == 0)
 222                                 continue;
 223                         free(handle);
 224                         handle = NULL;
 225                         break;
 226                 }
 227         }
 228         if (handle != NULL)
 229                 TAILQ_INSERT_TAIL(&ctx->hotplug_cbh, handle, entry);
 230         HOTPLUG_UNLOCK(ctx);
 231
 232         if (phandle != NULL)
 233                 *phandle = handle;
 234         return (LIBUSB_SUCCESS);
 235 }
 236
 237 void libusb_hotplug_deregister_callback(libusb_context *ctx,
 238     libusb_hotplug_callback_handle handle)
 239 {
 240         ctx = GET_CONTEXT(ctx);
 241
 242         if (ctx == NULL || handle == NULL)
 243                 return;
 244
 245         HOTPLUG_LOCK(ctx);
 246         TAILQ_REMOVE(&ctx->hotplug_cbh, handle, entry);
 247         HOTPLUG_UNLOCK(ctx);
 248
 249         free(handle);
 250 }