Re: [spice-gtk v2 1/1] usb-redirection: implementation of usb backend layer

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Sun, Sep 30, 2018 at 06:13:04PM +0300, Yuri Benditovich wrote:
> This layer communicates with libusb and libusbredir and
> provides the API for USB redirection procedures.
> All the modules of spice-gtk communicate only with usb
> backend instead of calling libusb and usbredirhost directly.
> This is prerequisite of further implementation of
> cd-sharing via USB redirection.
> 
> Signed-off-by: Yuri Benditovich <yuri.benditovich@xxxxxxxxxx>
> ---
>  src/Makefile.am               |   2 +
>  src/channel-usbredir-priv.h   |   9 +-
>  src/channel-usbredir.c        | 232 ++++--------
>  src/meson.build               |   1 +
>  src/usb-backend-common.c      | 688 ++++++++++++++++++++++++++++++++++
>  src/usb-backend.h             | 115 ++++++
>  src/usb-device-manager-priv.h |   3 +-
>  src/usb-device-manager.c      | 398 +++++++-------------
>  src/usb-device-manager.h      |   1 +
>  src/usbutil.c                 |  36 --
>  src/usbutil.h                 |   2 -
>  src/win-usb-dev.c             |  59 +--
>  12 files changed, 1044 insertions(+), 502 deletions(-)
>  create mode 100644 src/usb-backend-common.c
>  create mode 100644 src/usb-backend.h
> 
> diff --git a/src/Makefile.am b/src/Makefile.am
> index 1bb6f9b..3431459 100644
> --- a/src/Makefile.am
> +++ b/src/Makefile.am
> @@ -253,6 +253,8 @@ libspice_client_glib_2_0_la_SOURCES =			\
>  	spice-uri-priv.h				\
>  	usb-device-manager.c				\
>  	usb-device-manager-priv.h			\
> +	usb-backend.h			        \
> +	usb-backend-common.c			\
>  	usbutil.c					\
>  	usbutil.h					\
>  	$(USB_ACL_HELPER_SRCS)				\
> diff --git a/src/channel-usbredir-priv.h b/src/channel-usbredir-priv.h
> index 17e9716..4064f36 100644
> --- a/src/channel-usbredir-priv.h
> +++ b/src/channel-usbredir-priv.h
> @@ -21,9 +21,8 @@
>  #ifndef __SPICE_CLIENT_USBREDIR_CHANNEL_PRIV_H__
>  #define __SPICE_CLIENT_USBREDIR_CHANNEL_PRIV_H__
>  
> -#include <libusb.h>
> -#include <usbredirfilter.h>
>  #include "spice-client.h"
> +#include "usb-backend.h"
>  
>  G_BEGIN_DECLS
>  
> @@ -31,7 +30,7 @@ G_BEGIN_DECLS
>     context should not be destroyed before the last device has been
>     disconnected */
>  void spice_usbredir_channel_set_context(SpiceUsbredirChannel *channel,
> -                                        libusb_context       *context);
> +                                        SpiceUsbBackend      *context);
>  
>  void spice_usbredir_channel_disconnect_device_async(SpiceUsbredirChannel *channel,
>                                                      GCancellable *cancellable,
> @@ -46,7 +45,7 @@ gboolean spice_usbredir_channel_disconnect_device_finish(SpiceUsbredirChannel *c
>     (through spice_channel_connect()), before calling this. */
>  void spice_usbredir_channel_connect_device_async(
>                                          SpiceUsbredirChannel *channel,
> -                                        libusb_device        *device,
> +                                        SpiceUsbBackendDevice  *device,
>                                          SpiceUsbDevice       *spice_device,
>                                          GCancellable         *cancellable,
>                                          GAsyncReadyCallback   callback,
> @@ -58,7 +57,7 @@ gboolean spice_usbredir_channel_connect_device_finish(
>  
>  void spice_usbredir_channel_disconnect_device(SpiceUsbredirChannel *channel);
>  
> -libusb_device *spice_usbredir_channel_get_device(SpiceUsbredirChannel *channel);
> +SpiceUsbBackendDevice *spice_usbredir_channel_get_device(SpiceUsbredirChannel *channel);
>  
>  void spice_usbredir_channel_lock(SpiceUsbredirChannel *channel);
>  
> diff --git a/src/channel-usbredir.c b/src/channel-usbredir.c
> index 182edc4..0eba954 100644
> --- a/src/channel-usbredir.c
> +++ b/src/channel-usbredir.c
> @@ -23,7 +23,6 @@
>  
>  #ifdef USE_USBREDIR
>  #include <glib/gi18n-lib.h>
> -#include <usbredirhost.h>
>  #ifdef USE_LZ4
>  #include <lz4.h>
>  #endif
> @@ -66,15 +65,12 @@ enum SpiceUsbredirChannelState {
>  };
>  
>  struct _SpiceUsbredirChannelPrivate {
> -    libusb_device *device;
> +    SpiceUsbBackendDevice *device;
>      SpiceUsbDevice *spice_device;
> -    libusb_context *context;
> -    struct usbredirhost *host;
> +    SpiceUsbBackend *context;
> +    SpiceUsbBackendChannel *host;
>      /* To catch usbredirhost error messages and report them as a GError */
>      GError **catch_error;
> -    /* Data passed from channel handle msg to the usbredirhost read cb */
> -    const uint8_t *read_buf;
> -    int read_buf_size;
>      enum SpiceUsbredirChannelState state;
>  #ifdef USE_POLKIT
>      GTask *task;
> @@ -90,18 +86,10 @@ static void spice_usbredir_channel_dispose(GObject *obj);
>  static void spice_usbredir_channel_finalize(GObject *obj);
>  static void usbredir_handle_msg(SpiceChannel *channel, SpiceMsgIn *in);
>  
> -static void usbredir_log(void *user_data, int level, const char *msg);
> -static int usbredir_read_callback(void *user_data, uint8_t *data, int count);
> +static void usbredir_error(void *user_data, const char *msg);
>  static int usbredir_write_callback(void *user_data, uint8_t *data, int count);
> -static void usbredir_write_flush_callback(void *user_data);
> -#if USBREDIR_VERSION >= 0x000701
> -static uint64_t usbredir_buffered_output_size_callback(void *user_data);
> -#endif
> -
> -static void *usbredir_alloc_lock(void);
> -static void usbredir_lock_lock(void *user_data);
> -static void usbredir_unlock_lock(void *user_data);
> -static void usbredir_free_lock(void *user_data);
> +static gboolean usbredir_is_channel_ready(void *user_data);
> +static uint64_t usbredir_get_queue_size(void *user_data);
>  
>  #else
>  struct _SpiceUsbredirChannelPrivate {
> @@ -128,7 +116,7 @@ static void _channel_reset_finish(SpiceUsbredirChannel *channel, gboolean migrat
>  
>      spice_usbredir_channel_lock(channel);
>  
> -    usbredirhost_close(priv->host);
> +    spice_usb_backend_channel_finalize(priv->host);

I'd call this _free rather than _finalize to avoid confusion with
GObject terminology.

>      priv->host = NULL;
>  
>      /* Call set_context to re-create the host */
> @@ -238,7 +226,7 @@ static void spice_usbredir_channel_finalize(GObject *obj)
>      SpiceUsbredirChannel *channel = SPICE_USBREDIR_CHANNEL(obj);
>  
>      if (channel->priv->host)
> -        usbredirhost_close(channel->priv->host);
> +        spice_usb_backend_channel_finalize(channel->priv->host);
>  #ifdef USE_USBREDIR
>      g_mutex_clear(&channel->priv->device_connect_mutex);
>  #endif
> @@ -262,33 +250,25 @@ static void channel_set_handlers(SpiceChannelClass *klass)
>  /* private api                                                        */
>  
>  G_GNUC_INTERNAL
> -void spice_usbredir_channel_set_context(SpiceUsbredirChannel *channel,
> -                                        libusb_context       *context)
> +void spice_usbredir_channel_set_context(
> +    SpiceUsbredirChannel *channel,
> +    SpiceUsbBackend      *context)

You could keep the initial indentation.

>  {
>      SpiceUsbredirChannelPrivate *priv = channel->priv;
> +    SpiceUsbBackendChannelInitData init_data;
> +    init_data.user_data = channel;
> +    init_data.get_queue_size = usbredir_get_queue_size;
> +    init_data.is_channel_ready = usbredir_is_channel_ready;
> +    init_data.on_error = usbredir_error;
> +    init_data.write_callback = usbredir_write_callback;
>  
>      g_return_if_fail(priv->host == NULL);
>  
>      priv->context = context;
> -    priv->host = usbredirhost_open_full(
> -                                   context, NULL,
> -                                   usbredir_log,
> -                                   usbredir_read_callback,
> -                                   usbredir_write_callback,
> -                                   usbredir_write_flush_callback,
> -                                   usbredir_alloc_lock,
> -                                   usbredir_lock_lock,
> -                                   usbredir_unlock_lock,
> -                                   usbredir_free_lock,
> -                                   channel, PACKAGE_STRING,
> -                                   spice_util_get_debug() ? usbredirparser_debug : usbredirparser_warning,
> -                                   usbredirhost_fl_write_cb_owns_buffer);
> +    priv->host = spice_usb_backend_channel_initialize(context, &init_data);

spice_usb_backend_channel_new() ?


>      if (!priv->host)
> -        g_error("Out of memory allocating usbredirhost");
> +        g_error("Out of memory initializing redirection support");
>  
> -#if USBREDIR_VERSION >= 0x000701
> -    usbredirhost_set_buffered_output_size_cb(priv->host, usbredir_buffered_output_size_callback);
> -#endif
>  #ifdef USE_LZ4
>      spice_channel_set_capability(channel, SPICE_SPICEVMC_CAP_DATA_COMPRESS_LZ4);
>  #endif
> @@ -299,8 +279,6 @@ static gboolean spice_usbredir_channel_open_device(
>  {
>      SpiceUsbredirChannelPrivate *priv = channel->priv;
>      SpiceSession *session;
> -    libusb_device_handle *handle = NULL;
> -    int rc, status;
>      SpiceUsbDeviceManager *manager;
>  
>      g_return_val_if_fail(priv->state == STATE_DISCONNECTED
> @@ -309,21 +287,16 @@ static gboolean spice_usbredir_channel_open_device(
>  #endif
>                           , FALSE);
>  
> -    rc = libusb_open(priv->device, &handle);
> -    if (rc != 0) {
> -        g_set_error(err, SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
> -                    "Could not open usb device: %s [%i]",
> -                    spice_usbutil_libusb_strerror(rc), rc);
> -        return FALSE;
> -    }
> -
>      priv->catch_error = err;
> -    status = usbredirhost_set_device(priv->host, handle);
> -    priv->catch_error = NULL;
> -    if (status != usb_redir_success) {
> -        g_return_val_if_fail(err == NULL || *err != NULL, FALSE);
> +    if (!spice_usb_backend_channel_attach(priv->host, priv->device, err)) {
> +        priv->catch_error = NULL;
> +        if (*err == NULL) {
> +            g_set_error(err, SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
> +                "Error attaching device: (no error information)");

You could line up the "Error .." with the opening parenthesis.

> +        }
>          return FALSE;
>      }
> +    priv->catch_error = NULL;
>  
>      session = spice_channel_get_session(SPICE_CHANNEL(channel));
>      manager = spice_usb_device_manager_get(session, NULL);
> @@ -331,7 +304,7 @@ static gboolean spice_usbredir_channel_open_device(
>  
>      priv->usb_device_manager = g_object_ref(manager);
>      if (!spice_usb_device_manager_start_event_listening(priv->usb_device_manager, err)) {
> -        usbredirhost_set_device(priv->host, NULL);
> +        spice_usb_backend_channel_detach(priv->host);
>          return FALSE;
>      }
>  
> @@ -362,8 +335,7 @@ static void spice_usbredir_channel_open_acl_cb(
>          spice_usbredir_channel_open_device(channel, &err);
>      }
>      if (err) {
> -        libusb_unref_device(priv->device);
> -        priv->device = NULL;
> +        g_clear_pointer(&priv->device, spice_usb_backend_device_release);

_unref rather than _release?

>          g_boxed_free(spice_usb_device_get_type(), priv->spice_device);
>          priv->spice_device = NULL;
>          priv->state  = STATE_DISCONNECTED;
> @@ -394,8 +366,7 @@ _open_device_async_cb(GTask *task,
>      spice_usbredir_channel_lock(channel);
>  
>      if (!spice_usbredir_channel_open_device(channel, &err)) {
> -        libusb_unref_device(priv->device);
> -        priv->device = NULL;
> +        g_clear_pointer(&priv->device, spice_usb_backend_device_release);
>          g_boxed_free(spice_usb_device_get_type(), priv->spice_device);
>          priv->spice_device = NULL;
>      }
> @@ -413,13 +384,16 @@ _open_device_async_cb(GTask *task,
>  G_GNUC_INTERNAL
>  void spice_usbredir_channel_connect_device_async(
>                                            SpiceUsbredirChannel *channel,
> -                                          libusb_device        *device,
> +                                          SpiceUsbBackendDevice *device,
>                                            SpiceUsbDevice       *spice_device,
>                                            GCancellable         *cancellable,
>                                            GAsyncReadyCallback   callback,
>                                            gpointer              user_data)
>  {
>      SpiceUsbredirChannelPrivate *priv = channel->priv;
> +#ifdef USE_POLKIT
> +    const UsbDeviceInformation *info = spice_usb_backend_device_get_info(device);
> +#endif
>      GTask *task;
>  
>      g_return_if_fail(SPICE_IS_USBREDIR_CHANNEL(channel));
> @@ -446,7 +420,8 @@ void spice_usbredir_channel_connect_device_async(
>          goto done;
>      }
>  
> -    priv->device = libusb_ref_device(device);
> +    spice_usb_backend_device_acquire(device);
> +    priv->device = device;

You could mimic libusb API actually,
priv->device = spice_usb_backend_device_ref(device);

>      priv->spice_device = g_boxed_copy(spice_usb_device_get_type(),
>                                        spice_device);
>  #ifdef USE_POLKIT
> @@ -456,8 +431,8 @@ void spice_usbredir_channel_connect_device_async(
>      g_object_set(spice_channel_get_session(SPICE_CHANNEL(channel)),
>                   "inhibit-keyboard-grab", TRUE, NULL);
>      spice_usb_acl_helper_open_acl_async(priv->acl_helper,
> -                                        libusb_get_bus_number(device),
> -                                        libusb_get_device_address(device),
> +                                        info->bus,
> +                                        info->address,
>                                          cancellable,
>                                          spice_usbredir_channel_open_acl_cb,
>                                          channel);
> @@ -515,9 +490,8 @@ void spice_usbredir_channel_disconnect_device(SpiceUsbredirChannel *channel)
>          g_clear_object(&priv->usb_device_manager);
>  
>          /* This also closes the libusb handle we passed from open_device */
> -        usbredirhost_set_device(priv->host, NULL);
> -        libusb_unref_device(priv->device);
> -        priv->device = NULL;
> +        spice_usb_backend_channel_detach(priv->host);
> +        g_clear_pointer(&priv->device, spice_usb_backend_device_release);
>          g_boxed_free(spice_usb_device_get_type(), priv->spice_device);
>          priv->spice_device = NULL;
>          priv->state  = STATE_DISCONNECTED;
> @@ -568,7 +542,7 @@ spice_usbredir_channel_get_spice_usb_device(SpiceUsbredirChannel *channel)
>  #endif
>  
>  G_GNUC_INTERNAL
> -libusb_device *spice_usbredir_channel_get_device(SpiceUsbredirChannel *channel)
> +SpiceUsbBackendDevice *spice_usbredir_channel_get_device(SpiceUsbredirChannel *channel)
>  {
>      return channel->priv->device;
>  }
> @@ -583,85 +557,45 @@ void spice_usbredir_channel_get_guest_filter(
>  
>      g_return_if_fail(priv->host != NULL);
>  
> -    usbredirhost_get_guest_filter(priv->host, rules_ret, rules_count_ret);
> +    spice_usb_backend_channel_get_guest_filter(priv->host, rules_ret, rules_count_ret);
>  }
>  
>  /* ------------------------------------------------------------------ */
>  /* callbacks (any context)                                            */
>  
> -#if USBREDIR_VERSION >= 0x000701
> -static uint64_t usbredir_buffered_output_size_callback(void *user_data)
> +static uint64_t usbredir_get_queue_size(void *user_data)
>  {
>      g_return_val_if_fail(SPICE_IS_USBREDIR_CHANNEL(user_data), 0);
>      return spice_channel_get_queue_size(SPICE_CHANNEL(user_data));
>  }
> -#endif
>  
> -/* Note that this function must be re-entrant safe, as it can get called
> -   from both the main thread as well as from the usb event handling thread */
> -static void usbredir_write_flush_callback(void *user_data)
> +static gboolean usbredir_is_channel_ready(void *user_data)
>  {
>      SpiceUsbredirChannel *channel = SPICE_USBREDIR_CHANNEL(user_data);
>      SpiceUsbredirChannelPrivate *priv = channel->priv;
> -
> -    if (spice_channel_get_state(SPICE_CHANNEL(channel)) !=
> -            SPICE_CHANNEL_STATE_READY)
> -        return;
> -
> +    if (spice_channel_get_state(SPICE_CHANNEL(channel)) != SPICE_CHANNEL_STATE_READY)
> +        return FALSE;
>      if (!priv->host)
> -        return;
> -
> -    usbredirhost_write_guest_data(priv->host);
> -}
> -
> -static void usbredir_log(void *user_data, int level, const char *msg)
> -{
> -    SpiceUsbredirChannel *channel = user_data;
> -    SpiceUsbredirChannelPrivate *priv = channel->priv;
> -
> -    if (priv->catch_error && level == usbredirparser_error) {
> -        CHANNEL_DEBUG(channel, "%s", msg);
> -        /* Remove "usbredirhost: " prefix from usbredirhost messages */
> -        if (strncmp(msg, "usbredirhost: ", 14) == 0)
> -            g_set_error_literal(priv->catch_error, SPICE_CLIENT_ERROR,
> -                                SPICE_CLIENT_ERROR_FAILED, msg + 14);
> -        else
> -            g_set_error_literal(priv->catch_error, SPICE_CLIENT_ERROR,
> -                                SPICE_CLIENT_ERROR_FAILED, msg);
> -        return;
> -    }
> +        return FALSE;
>  
> -    switch (level) {
> -        case usbredirparser_error:
> -            g_critical("%s", msg);
> -            break;
> -        case usbredirparser_warning:
> -            g_warning("%s", msg);
> -            break;
> -        default:
> -            CHANNEL_DEBUG(channel, "%s", msg);
> -    }
> +    return TRUE;
>  }
>  
> -static int usbredir_read_callback(void *user_data, uint8_t *data, int count)
> +static void usbredir_error(void *user_data, const char *msg)
>  {
>      SpiceUsbredirChannel *channel = user_data;
>      SpiceUsbredirChannelPrivate *priv = channel->priv;
>  
> -    count = MIN(priv->read_buf_size, count);
> -
> -    if (count != 0) {
> -        memcpy(data, priv->read_buf, count);
> -    }
> -
> -    priv->read_buf_size -= count;
> -    if (priv->read_buf_size) {
> -        priv->read_buf += count;
> -    } else {
> -        priv->read_buf = NULL;
> +    if (priv->catch_error) {
> +        g_set_error_literal(priv->catch_error, SPICE_CLIENT_ERROR,
> +            SPICE_CLIENT_ERROR_FAILED, msg);
> +        /*
> +           if catch_error was set once, it is correct to prevent
> +           further attempts to set it, they will overwrite already
> +           used GError, cause memory leaks and GLib warnings.
> +        */
> +        priv->catch_error = NULL;
>      }
> -
> -    return count;
>  }
>  
>  static void usbredir_free_write_cb_data(uint8_t *data, void *user_data)
> @@ -669,7 +603,7 @@ static void usbredir_free_write_cb_data(uint8_t *data, void *user_data)
>      SpiceUsbredirChannel *channel = user_data;
>      SpiceUsbredirChannelPrivate *priv = channel->priv;
>  
> -    usbredirhost_free_write_buffer(priv->host, data);
> +    spice_usb_backend_return_write_data(priv->host, data);
>  }
>  
>  #ifdef USE_LZ4
> @@ -741,7 +675,7 @@ static int usbredir_write_callback(void *user_data, uint8_t *data, int count)
>  
>  #ifdef USE_LZ4
>      if (try_write_compress_LZ4(channel, data, count)) {
> -        usbredirhost_free_write_buffer(channel->priv->host, data);
> +        spice_usb_backend_return_write_data(channel->priv->host, data);
>          return count;
>      }
>  #endif
> @@ -754,15 +688,6 @@ static int usbredir_write_callback(void *user_data, uint8_t *data, int count)
>      return count;
>  }
>  
> -static void *usbredir_alloc_lock(void) {
> -    GMutex *mutex;
> -
> -    mutex = g_new0(GMutex, 1);
> -    g_mutex_init(mutex);
> -
> -    return mutex;
> -}
> -
>  G_GNUC_INTERNAL
>  void spice_usbredir_channel_lock(SpiceUsbredirChannel *channel)
>  {
> @@ -775,25 +700,6 @@ void spice_usbredir_channel_unlock(SpiceUsbredirChannel *channel)
>      g_mutex_unlock(&channel->priv->device_connect_mutex);
>  }
>  
> -static void usbredir_lock_lock(void *user_data) {
> -    GMutex *mutex = user_data;
> -
> -    g_mutex_lock(mutex);
> -}
> -
> -static void usbredir_unlock_lock(void *user_data) {
> -    GMutex *mutex = user_data;
> -
> -    g_mutex_unlock(mutex);
> -}
> -
> -static void usbredir_free_lock(void *user_data) {
> -    GMutex *mutex = user_data;
> -
> -    g_mutex_clear(mutex);
> -    g_free(mutex);
> -}
> -
>  /* --------------------------------------------------------------------- */
>  
>  typedef struct device_error_data {
> @@ -832,7 +738,7 @@ static void spice_usbredir_channel_up(SpiceChannel *c)
>  
>      g_return_if_fail(priv->host != NULL);
>      /* Flush any pending writes */
> -    usbredirhost_write_guest_data(priv->host);
> +    spice_usb_backend_channel_up(priv->host);
>  }
>  
>  static int try_handle_compressed_msg(SpiceMsgCompressedData *compressed_data_msg,
> @@ -882,26 +788,20 @@ static void usbredir_handle_msg(SpiceChannel *c, SpiceMsgIn *in)
>  
>      g_return_if_fail(priv->host != NULL);
>  
> -    /* No recursion allowed! */
> -    g_return_if_fail(priv->read_buf == NULL);
> -
>      if (spice_msg_in_type(in) == SPICE_MSG_SPICEVMC_COMPRESSED_DATA) {
>          SpiceMsgCompressedData *compressed_data_msg = spice_msg_in_parsed(in);
>          if (try_handle_compressed_msg(compressed_data_msg, &buf, &size)) {
> -            priv->read_buf_size = size;
> -            priv->read_buf = buf;
> +            /* uncompressed ok*/
>          } else {
> -            r = usbredirhost_read_parse_error;
> +            r = USB_REDIR_ERROR_READ_PARSE;
>          }
>      } else { /* Regular SPICE_MSG_SPICEVMC_DATA msg */
>          buf = spice_msg_in_raw(in, &size);
> -        priv->read_buf_size = size;
> -        priv->read_buf = buf;
>      }
>  
>      spice_usbredir_channel_lock(channel);
>      if (r == 0)
> -        r = usbredirhost_read_guest_data(priv->host);
> +        r = spice_usb_backend_provide_read_data(priv->host, buf, size);
>      if (r != 0) {
>          SpiceUsbDevice *spice_device = priv->spice_device;
>          device_error_data err_data;
> @@ -915,16 +815,16 @@ static void usbredir_handle_msg(SpiceChannel *c, SpiceMsgIn *in)
>  
>          desc = spice_usb_device_get_description(spice_device, NULL);
>          switch (r) {
> -        case usbredirhost_read_parse_error:
> +        case USB_REDIR_ERROR_READ_PARSE:
>              err = g_error_new(SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
>                                _("usbredir protocol parse error for %s"), desc);
>              break;
> -        case usbredirhost_read_device_rejected:
> +        case USB_REDIR_ERROR_DEV_REJECTED:
>              err = g_error_new(SPICE_CLIENT_ERROR,
>                                SPICE_CLIENT_ERROR_USB_DEVICE_REJECTED,
>                                _("%s rejected by host"), desc);
>              break;
> -        case usbredirhost_read_device_lost:
> +        case USB_REDIR_ERROR_DEV_LOST:
>              err = g_error_new(SPICE_CLIENT_ERROR,
>                                SPICE_CLIENT_ERROR_USB_DEVICE_LOST,
>                                _("%s disconnected (fatal IO error)"), desc);
> diff --git a/src/meson.build b/src/meson.build
> index dcf4dcc..62a4c51 100644
> --- a/src/meson.build
> +++ b/src/meson.build
> @@ -80,6 +80,7 @@ spice_client_glib_introspection_sources = [
>    'spice-session.c',
>    'spice-util.c',
>    'usb-device-manager.c',
> +  'usb-backend-common.c',

This should go in spice_client_glib_sources together with usb-backend.h
imo as suggested here https://lists.freedesktop.org/archives/spice-devel/2018-September/045818.html

>  ]
>  
>  spice_client_glib_sources = [
> diff --git a/src/usb-backend-common.c b/src/usb-backend-common.c
> new file mode 100644
> index 0000000..6f61193
> --- /dev/null
> +++ b/src/usb-backend-common.c
> @@ -0,0 +1,688 @@
> +/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
> +/*
> +    Copyright (C) 2012-2018 Red Hat, Inc.
> +
> +    Red Hat Authors:
> +    Yuri Benditovich<ybendito@xxxxxxxxxx>
> +    Hans de Goede <hdegoede@xxxxxxxxxx>
> +
> +    This library is free software; you can redistribute it and/or
> +    modify it under the terms of the GNU Lesser General Public
> +    License as published by the Free Software Foundation; either
> +    version 2.1 of the License, or (at your option) any later version.
> +
> +    This library is distributed in the hope that it will be useful,
> +    but WITHOUT ANY WARRANTY; without even the implied warranty of
> +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> +    Lesser General Public License for more details.
> +
> +    You should have received a copy of the GNU Lesser General Public
> +    License along with this library; if not, see <http://www.gnu.org/licenses/>.
> +*/
> +
> +#include "config.h"
> +
> +#ifdef USE_USBREDIR
> +
> +#include <glib-object.h>
> +#include <inttypes.h>
> +#include <gio/gio.h>
> +#include <errno.h>
> +#include <libusb.h>
> +#include <string.h>
> +#include <fcntl.h>
> +#include "usbredirhost.h"
> +#include "usbredirparser.h"
> +#include "spice-util.h"
> +#include "usb-backend.h"
> +#if defined(G_OS_WIN32)
> +#include <windows.h>
> +#include "win-usb-dev.h"
> +#else
> +#include <sys/stat.h>
> +#include <sys/ioctl.h>
> +#include <linux/fs.h>
> +#endif
> +
> +//#define LOUD_DEBUG SPICE_DEBUG
> +#define LOUD_DEBUG(x, ...)
> +
> +struct _SpiceUsbBackendDevice
> +{
> +    union
> +    {
> +        libusb_device *libusb_device;

In _SpiceUsbDeviceManagerPrivate, you replaced
#ifndef G_OS_WIN32
    libusb_device *libdev;
#endif

with

#ifndef G_OS_WIN32
    SpiceUsbBackendDevice *bdev;
#endif

The #ifdef is there because of this comment in
spice_usb_device_manager_device_to_bdev:

  /*
   * On win32 we need to do this the hard and slow way, by asking libusb to
   * re-enumerate all devices and then finding a matching device.
   * We cannot cache the libusb_device like we do under Linux since the
   * driver swap we do under windows invalidates the cached libdev.
   */

After your patch, spice_usb_device_manager_device_to_bdev is no longer
at the right level of indirection imo, it looks up the 'bdev' when
needed on Windows in usb-device-manager.c, but my understanding of that
comment is that any libusb call within SpiceUsbBackendDevice should not
use a cached libusb_device?



> +        void *msc;
> +    } d;
> +    gboolean is_libusb;
> +    gint ref_count;
> +    SpiceUsbBackendChannel *attached_to;

You don't need 'msc' just yet, nor 'is_libusb', and I'm not sure about
'attached_to'

> +    UsbDeviceInformation device_info;
> +};
> +
> +struct _SpiceUsbBackend
> +{
> +    libusb_context *libusb_context;
> +    usb_hot_plug_callback hotplug_callback;

"usb_hotplug_callback"

> +    void *hotplug_user_data;
> +    libusb_hotplug_callback_handle hotplug_handle;
> +};
> +
> +struct _SpiceUsbBackendChannel
> +{
> +    struct usbredirhost *usbredirhost;
> +    uint8_t *read_buf;
> +    int read_buf_size;
> +    struct usbredirfilter_rule *rules;
> +    int rules_count;
> +    SpiceUsbBackendDevice *attached;

I don't think this is used.

> +    SpiceUsbBackendChannelInitData channel_data;

I don't think 'channel_data' is a much more descriptive than the
previously used 'data'. SpiceUsbBackendChannelInitData is a bunch of
vfuncs/callbacks, so maybe use one of these words in the naming?

> +};
> +
> +// it's unclear why we use this procedure instead of libusb_error_name,
> +// which by definition supports any error that libusb returns

Why not add a commit before this one switching libusb_error_name() then?

> +static const char *spice_usbutil_libusb_strerror(enum libusb_error error_code)
> +{
> +    switch (error_code) {
> +    case LIBUSB_SUCCESS:
> +        return "Success";
> +    case LIBUSB_ERROR_IO:
> +        return "Input/output error";
> +    case LIBUSB_ERROR_INVALID_PARAM:
> +        return "Invalid parameter";
> +    case LIBUSB_ERROR_ACCESS:
> +        return "Access denied (insufficient permissions)";
> +    case LIBUSB_ERROR_NO_DEVICE:
> +        return "No such device (it may have been disconnected)";
> +    case LIBUSB_ERROR_NOT_FOUND:
> +        return "Entity not found";
> +    case LIBUSB_ERROR_BUSY:
> +        return "Resource busy";
> +    case LIBUSB_ERROR_TIMEOUT:
> +        return "Operation timed out";
> +    case LIBUSB_ERROR_OVERFLOW:
> +        return "Overflow";
> +    case LIBUSB_ERROR_PIPE:
> +        return "Pipe error";
> +    case LIBUSB_ERROR_INTERRUPTED:
> +        return "System call interrupted (perhaps due to signal)";
> +    case LIBUSB_ERROR_NO_MEM:
> +        return "Insufficient memory";
> +    case LIBUSB_ERROR_NOT_SUPPORTED:
> +        return "Operation not supported or unimplemented on this platform";
> +    case LIBUSB_ERROR_OTHER:
> +        return "Other error";
> +    }
> +    return "Unknown error";
> +}
> +
> +// lock functions for usbredirhost and usbredirparser
> +static void *usbredir_alloc_lock(void) {
> +    GMutex *mutex;
> +
> +    mutex = g_new0(GMutex, 1);
> +    g_mutex_init(mutex);
> +
> +    return mutex;
> +}
> +
> +static void usbredir_free_lock(void *user_data) {
> +    GMutex *mutex = user_data;
> +
> +    g_mutex_clear(mutex);
> +    g_free(mutex);
> +}
> +
> +static void usbredir_lock_lock(void *user_data) {
> +    GMutex *mutex = user_data;
> +
> +    g_mutex_lock(mutex);
> +}
> +
> +static void usbredir_unlock_lock(void *user_data) {
> +    GMutex *mutex = user_data;
> +
> +    g_mutex_unlock(mutex);
> +}
> +
> +static uint8_t is_libusb_isochronous(libusb_device *libdev)
> +{
> +    struct libusb_config_descriptor *conf_desc;
> +    uint8_t isoc_found = FALSE;
> +    gint i, j, k;
> +
> +    g_return_val_if_fail(libdev != NULL, 0);
> +
> +    if (libusb_get_active_config_descriptor(libdev, &conf_desc) != 0) {
> +        g_return_val_if_reached(0);
> +    }
> +
> +    for (i = 0; !isoc_found && i < conf_desc->bNumInterfaces; i++) {
> +        for (j = 0; !isoc_found && j < conf_desc->interface[i].num_altsetting; j++) {
> +            for (k = 0; !isoc_found && k < conf_desc->interface[i].altsetting[j].bNumEndpoints;k++) {
> +                gint attributes = conf_desc->interface[i].altsetting[j].endpoint[k].bmAttributes;
> +                gint type = attributes & LIBUSB_TRANSFER_TYPE_MASK;
> +                if (type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS)
> +                    isoc_found = TRUE;
> +            }
> +        }
> +    }
> +
> +    libusb_free_config_descriptor(conf_desc);
> +    return isoc_found;
> +}
> +
> +static gboolean fill_usb_info(SpiceUsbBackendDevice *bdev)
> +{
> +    UsbDeviceInformation *info = &bdev->device_info;
> +
> +    if (bdev->is_libusb)
> +    {
> +        struct libusb_device_descriptor desc;
> +        libusb_device *libdev = bdev->d.libusb_device;
> +        int res = libusb_get_device_descriptor(libdev, &desc);
> +        info->bus = libusb_get_bus_number(libdev);
> +        info->address = libusb_get_device_address(libdev);
> +        if (res < 0) {
> +            g_warning("cannot get device descriptor for (%p) %d.%d",
> +                libdev, info->bus, info->address);
> +            return FALSE;
> +        }
> +        info->vid = desc.idVendor;
> +        info->pid = desc.idProduct;
> +        info->class = desc.bDeviceClass;
> +        info->subclass = desc.bDeviceSubClass;
> +        info->protocol = desc.bDeviceProtocol;
> +        info->isochronous = is_libusb_isochronous(libdev);
> +    }
> +    return TRUE;
> +}
> +
> +static SpiceUsbBackendDevice *allocate_backend_device(libusb_device *libdev)
> +{
> +    SpiceUsbBackendDevice *dev = g_new0(SpiceUsbBackendDevice, 1);
> +    dev->is_libusb = 1;
> +    dev->ref_count = 1;
> +    dev->d.libusb_device = libdev;
> +    if (!fill_usb_info(dev)) {
> +        g_free(dev);
> +        dev = NULL;
> +    }
> +    return dev;
> +}
> +
> +/* Note that this function must be re-entrant safe, as it can get called
> +from both the main thread as well as from the usb event handling thread */
> +static void usbredir_write_flush_callback(void *user_data)
> +{
> +    SpiceUsbBackendChannel *ch = user_data;
> +    gboolean ok = ch->channel_data.is_channel_ready(ch->channel_data.user_data);
> +    if (ok && ch->usbredirhost) {
> +        SPICE_DEBUG("%s ch %p -> usbredirhost", __FUNCTION__, ch);
> +        usbredirhost_write_guest_data(ch->usbredirhost);
> +    } else {
> +        SPICE_DEBUG("%s ch %p (not ready)", __FUNCTION__, ch);
> +    }
> +}
> +
> +SpiceUsbBackend *spice_usb_backend_initialize(GError **error)
> +{
> +    int rc;
> +    SpiceUsbBackend *be;
> +    SPICE_DEBUG("%s >>", __FUNCTION__);
> +    be = (SpiceUsbBackend *)g_new0(SpiceUsbBackend, 1);
> +    rc = libusb_init(&be->libusb_context);
> +    if (rc < 0) {
> +        const char *desc = spice_usbutil_libusb_strerror(rc);
> +        g_warning("Error initializing LIBUSB support: %s [%i]", desc, rc);
> +        g_set_error(error, SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
> +            "Error initializing LIBUSB support: %s [%i]", desc, rc);

We usually align with the opening (

> +        g_free(be);
> +        be = NULL;
> +    } else {
> +#ifdef G_OS_WIN32
> +#if LIBUSB_API_VERSION >= 0x01000106
> +    libusb_set_option(be->libusb_context, LIBUSB_OPTION_USE_USBDK);

This could be indented one more level.

> +#endif
> +#endif
> +    }
> +    SPICE_DEBUG("%s <<", __FUNCTION__);
> +    return be;
> +}
> +
> +gboolean spice_usb_backend_handle_events(SpiceUsbBackend *be)
> +{
> +    SPICE_DEBUG("%s >>", __FUNCTION__);
> +    gboolean ok = FALSE;
> +    if (be->libusb_context) {
> +        SPICE_DEBUG("%s >> libusb", __FUNCTION__);
> +        int res = libusb_handle_events(be->libusb_context);
> +        ok = res == 0;
> +        if (res && res != LIBUSB_ERROR_INTERRUPTED) {
> +            const char *desc = spice_usbutil_libusb_strerror(res);
> +            g_warning("Error handling USB events: %s [%i]", desc, res);
> +            ok = FALSE;

You don't really need 'ok' in that method, just return FALSE; here...

> +        }
> +    }
> +    SPICE_DEBUG("%s << %s %d", __FUNCTION__,
> +        be->libusb_context ? "libusb" : "no libusb", ok);
> +    return ok;

... and return TRUE; there (and I'm not sure how useful the SPICE_DEBUG
are going to be?)

> +}
> +
> +static int LIBUSB_CALL hotplug_callback(libusb_context *ctx,
> +                                        libusb_device *device,
> +                                        libusb_hotplug_event event,
> +                                        void *user_data)
> +{
> +    SpiceUsbBackend *be = (SpiceUsbBackend *)user_data;
> +    if (be->hotplug_callback) {
> +        SpiceUsbBackendDevice *dev;
> +        gboolean val = event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED;
> +        dev = allocate_backend_device(device);
> +        if (dev) {
> +            SPICE_DEBUG("created dev %p, usblib dev %p", dev, device);
> +            libusb_ref_device(device);
> +            be->hotplug_callback(be->hotplug_user_data, dev, val);
> +            spice_usb_backend_device_release(dev);
> +        }
> +    }
> +    return 0;
> +}
> +
> +gboolean spice_usb_backend_handle_hotplug(SpiceUsbBackend *be,
> +                                          void *user_data,
> +                                          usb_hot_plug_callback proc)

Why not
spice_usb_backend_enable_hotplug/spice_usb_backend_disable_hotplug?
(and now that we have a proper SpiceUsbBackend struct wrapping the
libusb stuff, I wonder if it would not make sense to just turn it into a
gobject, and emit signals when we get new devices).

> +{
> +    int rc;
> +    g_return_val_if_fail(be != NULL, FALSE);
> +    if (!proc) {
> +        if (be->hotplug_handle) {
> +            libusb_hotplug_deregister_callback(be->libusb_context, be->hotplug_handle);
> +            be->hotplug_handle = 0;
> +        }
> +        be->hotplug_callback = proc;
> +        return TRUE;
> +    }
> +
> +    be->hotplug_callback = proc;
> +    be->hotplug_user_data = user_data;
> +    rc = libusb_hotplug_register_callback(be->libusb_context,
> +        LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT,
> +        LIBUSB_HOTPLUG_ENUMERATE, LIBUSB_HOTPLUG_MATCH_ANY,
> +        LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
> +        hotplug_callback, be, &be->hotplug_handle);
> +    if (rc != LIBUSB_SUCCESS) {
> +        const char *desc = spice_usbutil_libusb_strerror(rc);
> +        g_warning("Error initializing USB hotplug support: %s [%i]", desc, rc);
> +        be->hotplug_callback = NULL;
> +        return FALSE;
> +    }
> +    return TRUE;
> +}
> +
> +void spice_usb_backend_finalize(SpiceUsbBackend *be)
> +{
> +    g_return_if_fail(be != NULL);
> +    SPICE_DEBUG("%s >>", __FUNCTION__);
> +    if (be->libusb_context) {
> +        libusb_exit(be->libusb_context);
> +    }
> +    g_free(be);
> +    SPICE_DEBUG("%s <<", __FUNCTION__);
> +}
> +
> +SpiceUsbBackendDevice **spice_usb_backend_get_device_list(SpiceUsbBackend *be)
> +{
> +    LOUD_DEBUG("%s >>", __FUNCTION__);
> +    libusb_device **devlist = NULL, **dev;
> +    SpiceUsbBackendDevice *d, **list;
> +
> +    int n = 0, index;
> +
> +    if (be && be->libusb_context) {
> +        libusb_get_device_list(be->libusb_context, &devlist);
> +    }
> +
> +    // add all the libusb device that not present in our list
> +    for (dev = devlist; dev && *dev; dev++) {
> +        n++;
> +    }
> +
> +    list = g_new0(SpiceUsbBackendDevice*, n + 1);
> +
> +    index = 0;
> +
> +    for (dev = devlist; dev && *dev; dev++) {
> +        d = allocate_backend_device(*dev);
> +        if (!d) {
> +            libusb_unref_device(*dev);
> +        } else {
> +            SPICE_DEBUG("created dev %p, usblib dev %p", d, *dev);
> +            list[index++] = d;
> +        }
> +    }
> +
> +    if (devlist) {
> +        libusb_free_device_list(devlist, 0);
> +    }
> +
> +    LOUD_DEBUG("%s <<", __FUNCTION__);
> +    return list;
> +}

I still think this could be made slightly simpler with GArray/GPtrArray.

> +
> +gboolean spice_usb_backend_device_is_hub(SpiceUsbBackendDevice *dev)
> +{
> +    return dev->device_info.class == LIBUSB_CLASS_HUB;
> +}
> +
> +const UsbDeviceInformation* spice_usb_backend_device_get_info(SpiceUsbBackendDevice *dev)
> +{
> +    return &dev->device_info;
> +}
> +
> +gboolean spice_usb_backend_devices_same(SpiceUsbBackendDevice *dev1,
> +                                        SpiceUsbBackendDevice *dev2)
> +{
> +    if (dev1->is_libusb != dev2->is_libusb) {
> +        return FALSE;
> +    }
> +    if (dev1->is_libusb) {
> +        return dev1->d.libusb_device == dev2->d.libusb_device;
> +    }
> +    return dev1 == dev2;
> +}
> +
> +gconstpointer spice_usb_backend_device_get_libdev(SpiceUsbBackendDevice *dev)
> +{
> +    if (dev->is_libusb) {
> +        return dev->d.libusb_device;
> +    }
> +    return NULL;
> +}
> +
> +void spice_usb_backend_free_device_list(SpiceUsbBackendDevice **devlist)
> +{
> +    LOUD_DEBUG("%s >>", __FUNCTION__);
> +    SpiceUsbBackendDevice **dev;
> +    for (dev = devlist; *dev; dev++) {
> +        SpiceUsbBackendDevice *d = *dev;
> +        spice_usb_backend_device_release(d);
> +    }
> +    g_free(devlist);
> +    LOUD_DEBUG("%s <<", __FUNCTION__);
> +}
> +
> +void spice_usb_backend_device_acquire(SpiceUsbBackendDevice *dev)
> +{
> +    LOUD_DEBUG("%s >> %p", __FUNCTION__, dev);
> +    g_atomic_int_inc(&dev->ref_count);
> +}
> +
> +void spice_usb_backend_device_release(SpiceUsbBackendDevice *dev)
> +{
> +    LOUD_DEBUG("%s >> %p(%d)", __FUNCTION__, dev, dev->ref_count);
> +    if (g_atomic_int_dec_and_test(&dev->ref_count)) {
> +        if (dev->is_libusb) {
> +            libusb_unref_device(dev->d.libusb_device);
> +            LOUD_DEBUG("%s freeing %p (libusb %p)", __FUNCTION__, dev, dev->d.libusb_device);
> +            g_free(dev);
> +        }
> +    }
> +}
> +
> +int spice_usb_backend_device_check_filter(
> +    SpiceUsbBackendDevice *dev,
> +    const struct usbredirfilter_rule *rules,
> +    int count)
> +{
> +    if (dev->is_libusb) {
> +        return usbredirhost_check_device_filter(
> +            rules, count, dev->d.libusb_device, 0);
> +    }
> +    return -1;
> +}
> +
> +static int usbredir_read_callback(void *user_data, uint8_t *data, int count)
> +{
> +    SpiceUsbBackendChannel *ch = user_data;
> +
> +    count = MIN(ch->read_buf_size, count);
> +
> +    if (count != 0) {
> +        memcpy(data, ch->read_buf, count);
> +    }
> +
> +    ch->read_buf_size -= count;
> +    if (ch->read_buf_size) {
> +        ch->read_buf += count;
> +    }
> +    else {
> +        ch->read_buf = NULL;
> +    }
> +    SPICE_DEBUG("%s ch %p, %d bytes", __FUNCTION__, ch, count);
> +
> +    return count;
> +}
> +
> +static const char *strip_usbredir_prefix(const char *msg)
> +{
> +    if (strncmp(msg, "usbredirhost: ", 14) == 0) {
> +        msg += 14;
> +    }
> +    return msg;
> +}
> +
> +static void usbredir_log(void *user_data, int level, const char *msg)
> +{
> +    SpiceUsbBackendChannel *ch = (SpiceUsbBackendChannel *)user_data;
> +    const char *stripped_msg = strip_usbredir_prefix(msg);
> +    switch (level) {
> +    case usbredirparser_error:
> +        g_critical("%s", msg);
> +        ch->channel_data.on_error(ch->channel_data.user_data, stripped_msg);
> +        break;
> +    case usbredirparser_warning:
> +        g_warning("%s", msg);
> +        ch->channel_data.on_error(ch->channel_data.user_data, stripped_msg);
> +        break;
> +    default:
> +        break;
> +    }
> +}
> +
> +static int usbredir_write_callback(void *user_data, uint8_t *data, int count)
> +{
> +    SpiceUsbBackendChannel *ch = user_data;
> +    int res;
> +    SPICE_DEBUG("%s ch %p, %d bytes", __FUNCTION__, ch, count);
> +    res = ch->channel_data.write_callback(ch->channel_data.user_data, data, count);
> +    return res;
> +}
> +
> +#if USBREDIR_VERSION >= 0x000701
> +static uint64_t usbredir_buffered_output_size_callback(void *user_data)
> +{
> +    SpiceUsbBackendChannel *ch = user_data;
> +    return ch->channel_data.get_queue_size(ch->channel_data.user_data);
> +}
> +#endif
> +
> +int spice_usb_backend_provide_read_data(SpiceUsbBackendChannel *ch, uint8_t *data, int count)
> +{
> +    int res = 0;
> +
> +    g_return_val_if_fail(ch->read_buf == NULL, USB_REDIR_ERROR_READ_PARSE);
> +
> +    ch->read_buf = data;
> +    ch->read_buf_size = count;
> +    if (ch->usbredirhost) {
> +        res = usbredirhost_read_guest_data(ch->usbredirhost);
> +    } else {
> +        res = USB_REDIR_ERROR_IO;
> +    }
> +    switch (res)
> +    {
> +    case usbredirhost_read_io_error:
> +        res = USB_REDIR_ERROR_IO;
> +        break;
> +    case usbredirhost_read_parse_error:
> +        res = USB_REDIR_ERROR_READ_PARSE;
> +        break;
> +    case usbredirhost_read_device_rejected:
> +        res = USB_REDIR_ERROR_DEV_REJECTED;
> +        break;
> +    case usbredirhost_read_device_lost:
> +        res = USB_REDIR_ERROR_DEV_LOST;
> +        break;
> +    }
> +    SPICE_DEBUG("%s ch %p, %d bytes, res %d", __FUNCTION__, ch, count, res);
> +
> +    return res;
> +}
> +
> +void spice_usb_backend_return_write_data(SpiceUsbBackendChannel *ch, void *data)
> +{
> +    if (ch->usbredirhost) {
> +        SPICE_DEBUG("%s ch %p", __FUNCTION__, ch);
> +        usbredirhost_free_write_buffer(ch->usbredirhost, data);
> +    } else {
> +        SPICE_DEBUG("%s ch %p - NOBODY TO CALL", __FUNCTION__, ch);
> +    }
> +}
> +
> +gboolean spice_usb_backend_channel_attach(SpiceUsbBackendChannel *ch,
> +                                          SpiceUsbBackendDevice *dev,
> +                                          GError **error)
> +{
> +    SPICE_DEBUG("%s >> ch %p, dev %p (was attached %p)", __FUNCTION__, ch, dev, ch->attached);
> +    gboolean ok = FALSE;
> +    if (!dev) {
> +        return ok;
> +    }
> +
> +    if (dev->is_libusb) {
> +        libusb_device_handle *handle = NULL;
> +        int rc = libusb_open(dev->d.libusb_device, &handle);
> +        ok = rc == 0;
> +        if (ok) {
> +            rc = usbredirhost_set_device(ch->usbredirhost, handle);
> +            if (rc) {
> +                SPICE_DEBUG("%s ch %p, dev %p usbredirhost error %d", __FUNCTION__, ch, dev, rc);
> +                ok = FALSE;
> +            } else {
> +                ch->attached = dev;
> +                dev->attached_to = ch;
> +            }
> +        } else {
> +            const char *desc = spice_usbutil_libusb_strerror(rc);
> +            g_set_error(error, SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
> +                "Error libusb_open: %s [%i]", desc, rc);
> +        }
> +    }
> +
> +    return ok;
> +}
> +
> +void spice_usb_backend_channel_detach(SpiceUsbBackendChannel *ch)
> +{
> +    SPICE_DEBUG("%s >> ch %p, was attached %p", __FUNCTION__, ch, ch->attached);
> +    if (!ch->attached) {
> +        SPICE_DEBUG("%s: nothing to detach", __FUNCTION__);
> +        return;
> +    }
> +    if (ch->usbredirhost) {
> +        // it will call libusb_close internally
> +        usbredirhost_set_device(ch->usbredirhost, NULL);
> +    }
> +    SPICE_DEBUG("%s ch %p, detach done", __FUNCTION__, ch);
> +    ch->attached->attached_to = NULL;
> +    ch->attached = NULL;
> +}
> +
> +SpiceUsbBackendChannel *spice_usb_backend_channel_initialize(SpiceUsbBackend *be,
> +                                                             const SpiceUsbBackendChannelInitData *init_data)
> +{
> +    SpiceUsbBackendChannel *ch = g_new0(SpiceUsbBackendChannel, 1);
> +    SPICE_DEBUG("%s >>", __FUNCTION__);
> +    ch->channel_data = *init_data;
> +    if (be->libusb_context) {

You probably can just have g_return_val_if_fail(be->libusb_context != NULL, NULL) at the very beginning of that method,
and only do the allocation after that.

> +        ch->usbredirhost = usbredirhost_open_full(
> +            be->libusb_context,
> +            NULL,
> +            usbredir_log,
> +            usbredir_read_callback,
> +            usbredir_write_callback,
> +            usbredir_write_flush_callback,
> +            usbredir_alloc_lock,
> +            usbredir_lock_lock,
> +            usbredir_unlock_lock,
> +            usbredir_free_lock,
> +            ch, PACKAGE_STRING,
> +            spice_util_get_debug() ? usbredirparser_debug : usbredirparser_warning,
> +            usbredirhost_fl_write_cb_owns_buffer);
> +        g_warn_if_fail(ch->usbredirhost != NULL);
> +    }
> +    if (ch->usbredirhost) {
> +#if USBREDIR_VERSION >= 0x000701
> +        usbredirhost_set_buffered_output_size_cb(ch->usbredirhost, usbredir_buffered_output_size_callback);
> +#endif
> +    } else {
> +        g_free(ch);
> +        ch = NULL;
> +    }
> +
> +    SPICE_DEBUG("%s << %p", __FUNCTION__, ch);
> +    return ch;
> +}
> +
> +void spice_usb_backend_channel_up(SpiceUsbBackendChannel *ch)
> +{
> +    SPICE_DEBUG("%s %p, host %p", __FUNCTION__, ch, ch->usbredirhost);
> +    if (ch->usbredirhost) {
> +        usbredirhost_write_guest_data(ch->usbredirhost);
> +    }
> +}
> +
> +void spice_usb_backend_channel_finalize(SpiceUsbBackendChannel *ch)
> +{
> +    SPICE_DEBUG("%s >> %p", __FUNCTION__, ch);
> +    if (ch->usbredirhost) {
> +        usbredirhost_close(ch->usbredirhost);
> +    }
> +
> +    if (ch->rules) {
> +        g_free(ch->rules);

Should be 'free(ch->rules);' as this was allocated by libusbredir.

> +    }
> +
> +    g_free(ch);
> +    SPICE_DEBUG("%s << %p", __FUNCTION__, ch);
> +}
> +
> +void spice_usb_backend_channel_get_guest_filter(
> +    SpiceUsbBackendChannel *ch,
> +    const struct usbredirfilter_rule **r,
> +    int *count)
> +{
> +    int i;
> +    *r = NULL;
> +    *count = 0;
> +    if (ch->usbredirhost) {
> +        usbredirhost_get_guest_filter(ch->usbredirhost, r, count);
> +    }
> +    if (*r == NULL) {
> +        *r = ch->rules;
> +        *count = ch->rules_count;
> +    }
> +
> +    if (*count) {
> +        SPICE_DEBUG("%s ch %p: %d filters", __FUNCTION__, ch, *count);
> +    }
> +    for (i = 0; i < *count; i++) {
> +        const struct usbredirfilter_rule *ra = *r;
> +        SPICE_DEBUG("%s class %d, %X:%X",
> +            ra[i].allow ? "allowed" : "denied", ra[i].device_class,
> +            (uint32_t)ra[i].vendor_id, (uint32_t)ra[i].product_id);
> +    }
> +}
> +
> +#endif // USB_REDIR
> diff --git a/src/usb-backend.h b/src/usb-backend.h
> new file mode 100644
> index 0000000..31c31eb
> --- /dev/null
> +++ b/src/usb-backend.h
> @@ -0,0 +1,115 @@
> +/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
> +/*
> +    Copyright (C) 2018 Red Hat, Inc.
> +
> +    Red Hat Authors:
> +    Yuri Benditovich<ybendito@xxxxxxxxxx>
> +
> +    This library is free software; you can redistribute it and/or
> +    modify it under the terms of the GNU Lesser General Public
> +    License as published by the Free Software Foundation; either
> +    version 2.1 of the License, or (at your option) any later version.
> +
> +    This library is distributed in the hope that it will be useful,
> +    but WITHOUT ANY WARRANTY; without even the implied warranty of
> +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> +    Lesser General Public License for more details.
> +
> +    You should have received a copy of the GNU Lesser General Public
> +    License along with this library; if not, see <http://www.gnu.org/licenses/>.
> +*/
> +
> +#ifndef __SPICE_USB_BACKEND_H__
> +#define __SPICE_USB_BACKEND_H__
> +
> +#include <usbredirfilter.h>
> +#include "usb-device-manager.h"
> +
> +G_BEGIN_DECLS
> +
> +typedef struct _SpiceUsbBackend SpiceUsbBackend;
> +typedef struct _SpiceUsbBackendDevice SpiceUsbBackendDevice;
> +typedef struct _SpiceUsbBackendChannel SpiceUsbBackendChannel;
> +
> +typedef struct UsbDeviceInformation
> +{
> +    uint16_t bus;
> +    uint16_t address;
> +    uint16_t vid;
> +    uint16_t pid;
> +    uint8_t class;
> +    uint8_t subclass;
> +    uint8_t protocol;
> +    uint8_t isochronous;
> +} UsbDeviceInformation;

As already mentioned in the past, please let's not duplicate very similar
information with different names/different types in 2 structures with
very close names (UsbDeviceInformation and SpiceUsbDeviceInfo)


> +
> +typedef void (*usb_channel_error_callback)(void *user_data, const char *msg);
> +typedef int (*usb_channel_write_callback)(void *user_data, uint8_t *data, int count);
> +typedef gboolean (*usb_channel_is_ready_callback)(void *user_data);
> +typedef uint64_t (*usb_channel_get_queue_size)(void *user_data);
> +
> +typedef struct SpiceUsbBackendChannelInitData
> +{
> +    void *user_data;
> +    usb_channel_error_callback on_error;
> +    usb_channel_write_callback write_callback;
> +    usb_channel_is_ready_callback is_channel_ready;
> +    usb_channel_get_queue_size get_queue_size;

I would not add typedef for these vfuncs, I think the types are only
used here, so I'd directly use:
    void *user_data;
    void (*on_error)(void *user_data, const char *msg);
    ...

> +} SpiceUsbBackendChannelInitData;
> +
> +typedef void(*usb_hot_plug_callback)(void *user_data, SpiceUsbBackendDevice *dev, gboolean added);

usb_hotplug_callback.

> +
> +enum {
> +    USB_REDIR_ERROR_IO = -1,
> +    USB_REDIR_ERROR_READ_PARSE = -2,
> +    USB_REDIR_ERROR_DEV_REJECTED = -3,
> +    USB_REDIR_ERROR_DEV_LOST = -4,
> +};
> +
> +/* Spice USB backend API */
> +/* sets error on failure */
> +SpiceUsbBackend *spice_usb_backend_initialize(GError **error);
> +void spice_usb_backend_finalize(SpiceUsbBackend *context);
> +
> +/*
> +returns newly-allocated null-terminated list of

s/list/array/

> +SpiceUsbBackendDevice pointers.
> +The caller must call spice_usb_backend_free_device_list
> +after it finishes list processing

"processing the list"

> +*/
> +SpiceUsbBackendDevice **spice_usb_backend_get_device_list(SpiceUsbBackend *backend);
> +void spice_usb_backend_free_device_list(SpiceUsbBackendDevice **devlist);
> +gboolean spice_usb_backend_handle_events(SpiceUsbBackend *be);
> +gboolean spice_usb_backend_handle_hotplug(SpiceUsbBackend *be,
> +                                          void *user_data, usb_hot_plug_callback proc);
> +
> +/* Spice USB backend device API */
> +gboolean spice_usb_backend_device_is_hub(SpiceUsbBackendDevice *dev);
> +void spice_usb_backend_device_acquire(SpiceUsbBackendDevice *dev);
> +void spice_usb_backend_device_release(SpiceUsbBackendDevice *dev);
> +gboolean spice_usb_backend_devices_same(SpiceUsbBackendDevice *dev1, SpiceUsbBackendDevice *dev2);
> +gconstpointer spice_usb_backend_device_get_libdev(SpiceUsbBackendDevice *dev);
> +const UsbDeviceInformation* spice_usb_backend_device_get_info(SpiceUsbBackendDevice *dev);
> +/* returns 0 if the device passes the filter */
> +int spice_usb_backend_device_check_filter(SpiceUsbBackendDevice *dev,
> +                                          const struct usbredirfilter_rule *rules, int count);
> +
> +/* Spice USB backend channel API */
> +SpiceUsbBackendChannel *spice_usb_backend_channel_initialize(SpiceUsbBackend *context,
> +                                                             const SpiceUsbBackendChannelInitData *init_data);
> +void spice_usb_backend_channel_finalize(SpiceUsbBackendChannel *ch);
> +/* returns 0 for success or error code */
> +int spice_usb_backend_provide_read_data(SpiceUsbBackendChannel *ch, uint8_t *data, int count);
> +gboolean spice_usb_backend_channel_attach(SpiceUsbBackendChannel *ch,
> +                                          SpiceUsbBackendDevice *dev,
> +                                          GError **error);
> +void spice_usb_backend_channel_detach(SpiceUsbBackendChannel *ch);
> +void spice_usb_backend_channel_up(SpiceUsbBackendChannel *ch);
> +void spice_usb_backend_channel_get_guest_filter(SpiceUsbBackendChannel *ch,
> +                                                const struct usbredirfilter_rule  **rules,
> +                                                int *count);
> +void spice_usb_backend_return_write_data(SpiceUsbBackendChannel *ch, void *data);
> +
> +G_END_DECLS
> +
> +#endif
> diff --git a/src/usb-device-manager-priv.h b/src/usb-device-manager-priv.h
> index 83884d7..4a1b592 100644
> --- a/src/usb-device-manager-priv.h
> +++ b/src/usb-device-manager-priv.h
> @@ -22,6 +22,7 @@
>  #define __SPICE_USB_DEVICE_MANAGER_PRIV_H__
>  
>  #include "usb-device-manager.h"
> +#include "usb-backend.h"
>  
>  G_BEGIN_DECLS
>  
> @@ -32,7 +33,7 @@ void spice_usb_device_manager_stop_event_listening(
>      SpiceUsbDeviceManager *manager);
>  
>  #ifdef USE_USBREDIR
> -#include <libusb.h>
> +
>  void spice_usb_device_manager_device_error(
>      SpiceUsbDeviceManager *manager, SpiceUsbDevice *device, GError *err);
>  
> diff --git a/src/usb-device-manager.c b/src/usb-device-manager.c
> index 354038a..e7c363a 100644
> --- a/src/usb-device-manager.c
> +++ b/src/usb-device-manager.c
> @@ -24,10 +24,11 @@
>  #include <glib-object.h>
>  
>  #ifdef USE_USBREDIR
> +
>  #include <errno.h>
> -#include <libusb.h>
>  
>  #ifdef G_OS_WIN32
> +#include <windows.h>
>  #include "usbdk_api.h"
>  #endif
>  
> @@ -41,8 +42,8 @@
>  #endif
>  
>  #include "channel-usbredir-priv.h"
> -#include "usbredirhost.h"
>  #include "usbutil.h"
> +
>  #endif
>  
>  #include "spice-session-priv.h"
> @@ -102,7 +103,7 @@ struct _SpiceUsbDeviceManagerPrivate {
>      gchar *auto_connect_filter;
>      gchar *redirect_on_connect;
>  #ifdef USE_USBREDIR
> -    libusb_context *context;
> +    SpiceUsbBackend *context;
>      int event_listeners;
>      GThread *event_thread;
>      gint event_thread_run;
> @@ -112,10 +113,9 @@ struct _SpiceUsbDeviceManagerPrivate {
>      int redirect_on_connect_rules_count;
>  #ifdef USE_GUDEV
>      GUdevClient *udev;
> -    libusb_device **coldplug_list; /* Avoid needless reprobing during init */
> +    SpiceUsbBackendDevice **coldplug_list; /* Avoid needless reprobing during init */
>  #else
>      gboolean redirecting; /* Handled by GUdevClient in the gudev case */
> -    libusb_hotplug_callback_handle hp_handle;
>  #endif
>  #ifdef G_OS_WIN32
>      usbdk_api_wrapper     *usbdk_api;
> @@ -148,7 +148,7 @@ typedef struct _SpiceUsbDeviceInfo {
>  #ifdef G_OS_WIN32
>      guint8  state;
>  #else
> -    libusb_device *libdev;
> +    SpiceUsbBackendDevice *bdev;
>  #endif
>      gint    ref;
>  } SpiceUsbDeviceInfo;
> @@ -168,15 +168,14 @@ static void spice_usb_device_manager_uevent_cb(GUdevClient     *client,
>  static void spice_usb_device_manager_add_udev(SpiceUsbDeviceManager  *self,
>                                                GUdevDevice            *udev);
>  #else
> -static int spice_usb_device_manager_hotplug_cb(libusb_context       *ctx,
> -                                               libusb_device        *device,
> -                                               libusb_hotplug_event  event,
> -                                               void                 *data);
> +static void spice_usb_device_manager_hotplug_cb(void                  *data,
> +                                                SpiceUsbBackendDevice *bdev,
> +                                                gboolean              added);
>  #endif
>  static void spice_usb_device_manager_check_redir_on_connect(
>      SpiceUsbDeviceManager *self, SpiceChannel *channel);
>  
> -static SpiceUsbDeviceInfo *spice_usb_device_new(libusb_device *libdev);
> +static SpiceUsbDeviceInfo *spice_usb_device_new(SpiceUsbBackendDevice *bdev);
>  static SpiceUsbDevice *spice_usb_device_ref(SpiceUsbDevice *device);
>  static void spice_usb_device_unref(SpiceUsbDevice *device);
>  
> @@ -185,12 +184,12 @@ static void _usbdk_hider_update(SpiceUsbDeviceManager *manager);
>  static void _usbdk_hider_clear(SpiceUsbDeviceManager *manager);
>  #endif
>  
> -static gboolean spice_usb_manager_device_equal_libdev(SpiceUsbDeviceManager *manager,
> -                                                      SpiceUsbDevice *device,
> -                                                      libusb_device *libdev);
> -static libusb_device *
> -spice_usb_device_manager_device_to_libdev(SpiceUsbDeviceManager *self,
> -                                          SpiceUsbDevice *device);
> +static gboolean spice_usb_manager_device_equal_bdev(SpiceUsbDeviceManager *manager,
> +                                                    SpiceUsbDevice *device,
> +                                                    SpiceUsbBackendDevice *bdev);
> +static SpiceUsbBackendDevice*
> +spice_usb_device_manager_device_to_bdev(SpiceUsbDeviceManager *self,
> +                                        SpiceUsbDevice        *device);
>  
>  static void
>  _spice_usb_device_manager_connect_device_async(SpiceUsbDeviceManager *self,
> @@ -290,27 +289,15 @@ static gboolean spice_usb_device_manager_initable_init(GInitable  *initable,
>      SpiceUsbDeviceManagerPrivate *priv = self->priv;
>      GList *list;
>      GList *it;
> -    int rc;
>  #ifdef USE_GUDEV
>      const gchar *const subsystems[] = {"usb", NULL};
>  #endif
>  
> -    /* Initialize libusb */
> -    rc = libusb_init(&priv->context);
> -    if (rc < 0) {
> -        const char *desc = spice_usbutil_libusb_strerror(rc);
> -        g_warning("Error initializing USB support: %s [%i]", desc, rc);
> -        g_set_error(err, SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
> -                    "Error initializing USB support: %s [%i]", desc, rc);
> +    /* Initialize spice backend */
> +    priv->context = spice_usb_backend_initialize(err);
> +    if (!priv->context) {
>          return FALSE;
>      }
> -
> -#ifdef G_OS_WIN32
> -#if LIBUSB_API_VERSION >= 0x01000106
> -    libusb_set_option(priv->context, LIBUSB_OPTION_USE_USBDK);
> -#endif
> -#endif
> -
>      /* Start listening for usb devices plug / unplug */
>  #ifdef USE_GUDEV
>      priv->udev = g_udev_client_new(subsystems);
> @@ -321,26 +308,20 @@ static gboolean spice_usb_device_manager_initable_init(GInitable  *initable,
>      g_signal_connect(G_OBJECT(priv->udev), "uevent",
>                       G_CALLBACK(spice_usb_device_manager_uevent_cb), self);
>      /* Do coldplug (detection of already connected devices) */
> -    libusb_get_device_list(priv->context, &priv->coldplug_list);
> +    priv->coldplug_list = spice_usb_backend_get_device_list(priv->context);
>      list = g_udev_client_query_by_subsystem(priv->udev, "usb");
>      for (it = g_list_first(list); it; it = g_list_next(it)) {
>          spice_usb_device_manager_add_udev(self, it->data);
>          g_object_unref(it->data);
>      }
>      g_list_free(list);
> -    libusb_free_device_list(priv->coldplug_list, 1);
> +    spice_usb_backend_free_device_list(priv->coldplug_list);
>      priv->coldplug_list = NULL;
>  #else
> -    rc = libusb_hotplug_register_callback(priv->context,
> -        LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT,
> -        LIBUSB_HOTPLUG_ENUMERATE, LIBUSB_HOTPLUG_MATCH_ANY,
> -        LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
> -        spice_usb_device_manager_hotplug_cb, self, &priv->hp_handle);
> -    if (rc < 0) {
> -        const char *desc = spice_usbutil_libusb_strerror(rc);
> -        g_warning("Error initializing USB hotplug support: %s [%i]", desc, rc);
> +    if (!spice_usb_backend_handle_hotplug(priv->context,
> +        self, spice_usb_device_manager_hotplug_cb)) {
>          g_set_error(err, SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
> -                  "Error initializing USB hotplug support: %s [%i]", desc, rc);
> +            "Error initializing USB hotplug support");

You don't need to change the indentation here

>          return FALSE;
>      }
>      spice_usb_device_manager_start_event_listening(self, NULL);
> @@ -371,21 +352,19 @@ static void spice_usb_device_manager_dispose(GObject *gobject)
>      SpiceUsbDeviceManagerPrivate *priv = self->priv;
>  
>  #ifdef USE_LIBUSB_HOTPLUG
> -    if (priv->hp_handle) {
> -        spice_usb_device_manager_stop_event_listening(self);
> -        if (g_atomic_int_get(&priv->event_thread_run)) {
> -            /* Force termination of the event thread even if there were some
> -             * mismatched spice_usb_device_manager_{start,stop}_event_listening
> -             * calls. Otherwise, the usb event thread will be leaked, and will
> -             * try to use the libusb context we destroy in finalize(), which would
> -             * cause a crash */
> -             g_warn_if_reached();
> -             g_atomic_int_set(&priv->event_thread_run, FALSE);
> -        }
> -        /* This also wakes up the libusb_handle_events() in the event_thread */
> -        libusb_hotplug_deregister_callback(priv->context, priv->hp_handle);
> -        priv->hp_handle = 0;
> +    spice_usb_device_manager_stop_event_listening(self);
> +    if (g_atomic_int_get(&priv->event_thread_run)) {
> +        /* Force termination of the event thread even if there were some
> +            * mismatched spice_usb_device_manager_{start,stop}_event_listening
> +            * calls. Otherwise, the usb event thread will be leaked, and will
> +            * try to use the libusb context we destroy in finalize(), which would
> +            * cause a crash */

Indentation

> +            g_warn_if_reached();
> +            g_atomic_int_set(&priv->event_thread_run, FALSE);
> +
>      }
> +    /* This also wakes up the libusb_handle_events() in the event_thread */
> +    spice_usb_backend_handle_hotplug(priv->context, NULL, NULL);
>  #endif
>      if (priv->event_thread) {
>          g_warn_if_fail(g_atomic_int_get(&priv->event_thread_run) == FALSE);
> @@ -413,8 +392,9 @@ static void spice_usb_device_manager_finalize(GObject *gobject)
>      g_clear_object(&priv->udev);
>  #endif
>      g_return_if_fail(priv->event_thread == NULL);
> -    if (priv->context)
> -        libusb_exit(priv->context);
> +    if (priv->context) {
> +        spice_usb_backend_finalize(priv->context);
> +    }
>      free(priv->auto_conn_filter_rules);
>      free(priv->redirect_on_connect_rules);
>  #ifdef G_OS_WIN32
> @@ -739,7 +719,7 @@ static void spice_usb_device_manager_class_init(SpiceUsbDeviceManagerClass *klas
>  #ifdef USE_USBREDIR
>  
>  /* ------------------------------------------------------------------ */
> -/* gudev / libusb Helper functions                                    */
> +/* gudev / backend Helper functions                                    */
>  
>  #ifdef USE_GUDEV
>  static gboolean spice_usb_device_manager_get_udev_bus_n_address(
> @@ -763,40 +743,16 @@ static gboolean spice_usb_device_manager_get_udev_bus_n_address(
>  }
>  #endif
>  
> -static gboolean spice_usb_device_manager_get_device_descriptor(
> -    libusb_device *libdev,
> -    struct libusb_device_descriptor *desc)
> -{
> -    int errcode;
> -    const gchar *errstr;
> -
> -    g_return_val_if_fail(libdev != NULL, FALSE);
> -    g_return_val_if_fail(desc   != NULL, FALSE);
> -
> -    errcode = libusb_get_device_descriptor(libdev, desc);
> -    if (errcode < 0) {
> -        int bus, addr;
> -
> -        bus = libusb_get_bus_number(libdev);
> -        addr = libusb_get_device_address(libdev);
> -        errstr = spice_usbutil_libusb_strerror(errcode);
> -        g_warning("cannot get device descriptor for (%p) %d.%d -- %s(%d)",
> -                  libdev, bus, addr, errstr, errcode);
> -        return FALSE;
> -    }
> -    return TRUE;
> -}
> -
>  #endif // USE_USBREDIR
>  
>  /**
>   * spice_usb_device_get_libusb_device:
> - * @device: #SpiceUsbDevice to get the descriptor information of
> + * @device: #SpiceUsbDevice to get the libusb device of (if exists)
>   *
>   * Finds the %libusb_device associated with the @device.
>   *
> - * Returns: (transfer none): the %libusb_device associated to %SpiceUsbDevice.
> - *
> + * Returns: (transfer none): the %libusb_device associated to %SpiceUsbDevice
> + *    or NULL (if the device does not have associated libusb device)
>   * Since: 0.27
>   **/
>  gconstpointer
> @@ -808,34 +764,13 @@ spice_usb_device_get_libusb_device(const SpiceUsbDevice *device G_GNUC_UNUSED)
>  
>      g_return_val_if_fail(info != NULL, FALSE);
>  
> -    return info->libdev;
> +    return spice_usb_backend_device_get_libdev(info->bdev);
>  #endif
>  #endif
>      return NULL;
>  }
>  
>  #ifdef USE_USBREDIR
> -static gboolean spice_usb_device_manager_get_libdev_vid_pid(
> -    libusb_device *libdev, int *vid, int *pid)
> -{
> -    struct libusb_device_descriptor desc;
> -
> -    g_return_val_if_fail(libdev != NULL, FALSE);
> -    g_return_val_if_fail(vid != NULL, FALSE);
> -    g_return_val_if_fail(pid != NULL, FALSE);
> -
> -    *vid = *pid = 0;
> -
> -    if (!spice_usb_device_manager_get_device_descriptor(libdev, &desc)) {
> -        return FALSE;
> -    }
> -    *vid = desc.idVendor;
> -    *pid = desc.idProduct;
> -
> -    return TRUE;
> -}
> -
> -/* ------------------------------------------------------------------ */
>  /* callbacks                                                          */
>  
>  static void channel_new(SpiceSession *session, SpiceChannel *channel,
> @@ -854,9 +789,8 @@ static void channel_new(SpiceSession *session, SpiceChannel *channel,
>      g_signal_connect(channel, "channel-event", G_CALLBACK(channel_event), self);
>  
>      spice_usb_device_manager_check_redir_on_connect(self, channel);
> -
>      /*
> -     * add a reference to ourself, to make sure the libusb context is
> +     * add a reference to ourself, to make sure the backend device context is
>       * alive as long as the channel is.
>       * TODO: moving to gusb could help here too.
>       */
> @@ -933,12 +867,12 @@ spice_usb_device_manager_device_match(SpiceUsbDeviceManager *self, SpiceUsbDevic
>  
>  #ifdef USE_GUDEV
>  static gboolean
> -spice_usb_device_manager_libdev_match(SpiceUsbDeviceManager *self, libusb_device *libdev,
> +spice_usb_device_manager_bdev_match(SpiceUsbDeviceManager *self, SpiceUsbBackendDevice *dev,
>                                        const int bus, const int address)

Indentation

>  {
> +    const UsbDeviceInformation* info = spice_usb_backend_device_get_info(dev);
>      /* match functions for Linux/UsbDk -- match by bus.addr */
> -    return (libusb_get_bus_number(libdev) == bus &&
> -            libusb_get_device_address(libdev) == address);
> +    return (info->bus == bus && info->address == address);
>  }
>  #endif
>  
> @@ -960,21 +894,17 @@ spice_usb_device_manager_find_device(SpiceUsbDeviceManager *self,
>      return device;
>  }
>  
> -static void spice_usb_device_manager_add_dev(SpiceUsbDeviceManager  *self,
> -                                             libusb_device          *libdev)
> +static void spice_usb_device_manager_add_dev(SpiceUsbDeviceManager          *self,
> +                                             SpiceUsbBackendDevice          *bdev)

Here I don't think you need that many spaces before *self and *bdev

>  {
>      SpiceUsbDeviceManagerPrivate *priv = self->priv;
> -    struct libusb_device_descriptor desc;
>      SpiceUsbDevice *device;
>  
> -    if (!spice_usb_device_manager_get_device_descriptor(libdev, &desc))
> -        return;
> -
>      /* Skip hubs */
> -    if (desc.bDeviceClass == LIBUSB_CLASS_HUB)
> +    if (spice_usb_backend_device_is_hub(bdev))
>          return;
>  
> -    device = (SpiceUsbDevice*)spice_usb_device_new(libdev);
> +    device = (SpiceUsbDevice*)spice_usb_device_new(bdev);
>      if (!device)
>          return;
>  
> @@ -986,10 +916,10 @@ static void spice_usb_device_manager_add_dev(SpiceUsbDeviceManager  *self,
>          can_redirect = spice_usb_device_manager_can_redirect_device(
>                                          self, device, NULL);
>  
> -        auto_ok = usbredirhost_check_device_filter(
> -                            priv->auto_conn_filter_rules,
> -                            priv->auto_conn_filter_rules_count,
> -                            libdev, 0) == 0;
> +        auto_ok = spice_usb_backend_device_check_filter(
> +            bdev,
> +            priv->auto_conn_filter_rules,
> +            priv->auto_conn_filter_rules_count) == 0;
>  
>          if (can_redirect && auto_ok)
>              spice_usb_device_manager_connect_device_async(self,
> @@ -1036,7 +966,7 @@ static void spice_usb_device_manager_add_udev(SpiceUsbDeviceManager  *self,
>                                                GUdevDevice            *udev)
>  {
>      SpiceUsbDeviceManagerPrivate *priv = self->priv;
> -    libusb_device *libdev = NULL, **dev_list = NULL;
> +    SpiceUsbBackendDevice *bdev = NULL, **dev_list = NULL;
>      SpiceUsbDevice *device;
>      const gchar *devtype;
>      int i, bus, address;
> @@ -1064,23 +994,23 @@ static void spice_usb_device_manager_add_udev(SpiceUsbDeviceManager  *self,
>      if (priv->coldplug_list)
>          dev_list = priv->coldplug_list;
>      else
> -        libusb_get_device_list(priv->context, &dev_list);
> +        dev_list = spice_usb_backend_get_device_list(priv->context);
>  
>      for (i = 0; dev_list && dev_list[i]; i++) {
> -        if (spice_usb_device_manager_libdev_match(self, dev_list[i], bus, address)) {
> -            libdev = dev_list[i];
> +        if (spice_usb_device_manager_bdev_match(self, dev_list[i], bus, address)) {
> +            bdev = dev_list[i];
>              break;
>          }
>      }
>  
> -    if (libdev)
> -        spice_usb_device_manager_add_dev(self, libdev);
> +    if (bdev)
> +        spice_usb_device_manager_add_dev(self, bdev);
>      else
>          g_warning("Could not find USB device to add " DEV_ID_FMT,
>                    (guint) bus, (guint) address);
>  
>      if (!priv->coldplug_list)
> -        libusb_free_device_list(dev_list, 1);
> +        spice_usb_backend_free_device_list(dev_list);
>  }
>  
>  static void spice_usb_device_manager_remove_udev(SpiceUsbDeviceManager  *self,
> @@ -1109,8 +1039,8 @@ static void spice_usb_device_manager_uevent_cb(GUdevClient     *client,
>  #else
>  struct hotplug_idle_cb_args {
>      SpiceUsbDeviceManager *self;
> -    libusb_device *device;
> -    libusb_hotplug_event event;
> +    SpiceUsbBackendDevice *device;
> +    gboolean device_added;
>  };
>  
>  static gboolean spice_usb_device_manager_hotplug_idle_cb(gpointer user_data)
> @@ -1118,36 +1048,31 @@ static gboolean spice_usb_device_manager_hotplug_idle_cb(gpointer user_data)
>      struct hotplug_idle_cb_args *args = user_data;
>      SpiceUsbDeviceManager *self = SPICE_USB_DEVICE_MANAGER(args->self);
>  
> -    switch (args->event) {
> -    case LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED:
> +    if (args->device_added) {
>          spice_usb_device_manager_add_dev(self, args->device);
> -        break;
> -    case LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT:
> -        spice_usb_device_manager_remove_dev(self,
> -                                    libusb_get_bus_number(args->device),
> -                                    libusb_get_device_address(args->device));
> -        break;
> +    } else {
> +        const UsbDeviceInformation *info = spice_usb_backend_device_get_info(args->device);
> +        spice_usb_device_manager_remove_dev(self, info->bus, info->address);
>      }
> -    libusb_unref_device(args->device);
> +    spice_usb_backend_device_release(args->device);
>      g_object_unref(self);
>      g_free(args);
>      return FALSE;
>  }
>  
>  /* Can be called from both the main-thread as well as the event_thread */
> -static int spice_usb_device_manager_hotplug_cb(libusb_context       *ctx,
> -                                               libusb_device        *device,
> -                                               libusb_hotplug_event  event,
> -                                               void                 *user_data)
> +static void spice_usb_device_manager_hotplug_cb(void                  *user_data,
> +                                                SpiceUsbBackendDevice *bdev,
> +                                                gboolean              added)
>  {
>      SpiceUsbDeviceManager *self = SPICE_USB_DEVICE_MANAGER(user_data);
>      struct hotplug_idle_cb_args *args = g_malloc0(sizeof(*args));
>  
>      args->self = g_object_ref(self);
> -    args->device = libusb_ref_device(device);
> -    args->event = event;
> +    spice_usb_backend_device_acquire(bdev);
> +    args->device_added = added;
> +    args->device = bdev;
>      g_idle_add(spice_usb_device_manager_hotplug_idle_cb, args);
> -    return 0;
>  }
>  #endif // USE_USBREDIR
>  
> @@ -1174,13 +1099,9 @@ static gpointer spice_usb_device_manager_usb_ev_thread(gpointer user_data)
>  {
>      SpiceUsbDeviceManager *self = SPICE_USB_DEVICE_MANAGER(user_data);
>      SpiceUsbDeviceManagerPrivate *priv = self->priv;
> -    int rc;
>  
>      while (g_atomic_int_get(&priv->event_thread_run)) {
> -        rc = libusb_handle_events(priv->context);
> -        if (rc && rc != LIBUSB_ERROR_INTERRUPTED) {
> -            const char *desc = spice_usbutil_libusb_strerror(rc);
> -            g_warning("Error handling USB events: %s [%i]", desc, rc);
> +        if (!spice_usb_backend_handle_events(priv->context)) {
>              break;
>          }
>      }
> @@ -1231,7 +1152,7 @@ static void spice_usb_device_manager_check_redir_on_connect(
>      SpiceUsbDeviceManagerPrivate *priv = self->priv;
>      GTask *task;
>      SpiceUsbDevice *device;
> -    libusb_device *libdev;
> +    SpiceUsbBackendDevice *dev;
>      guint i;
>  
>      if (priv->redirect_on_connect == NULL)
> @@ -1243,15 +1164,15 @@ static void spice_usb_device_manager_check_redir_on_connect(
>          if (spice_usb_device_manager_is_device_connected(self, device))
>              continue;
>  
> -        libdev = spice_usb_device_manager_device_to_libdev(self, device);
> +        dev = spice_usb_device_manager_device_to_bdev(self, device);
>  #ifdef G_OS_WIN32
> -        if (libdev == NULL)
> +        if (dev == NULL)
>              continue;
>  #endif
> -        if (usbredirhost_check_device_filter(
> -                            priv->redirect_on_connect_rules,
> -                            priv->redirect_on_connect_rules_count,
> -                            libdev, 0) == 0) {
> +        if (spice_usb_backend_device_check_filter(
> +            dev,
> +            priv->redirect_on_connect_rules,
> +            priv->redirect_on_connect_rules_count) == 0) {
>              /* Note: re-uses spice_usb_device_manager_connect_device_async's
>                 completion handling code! */
>              task = g_task_new(self,
> @@ -1261,14 +1182,14 @@ static void spice_usb_device_manager_check_redir_on_connect(
>  
>              spice_usbredir_channel_connect_device_async(
>                                 SPICE_USBREDIR_CHANNEL(channel),
> -                               libdev, device, NULL,
> +                               dev, device, NULL,
>                                 spice_usb_device_manager_channel_connect_cb,
>                                 task);
> -            libusb_unref_device(libdev);
> +            spice_usb_backend_device_release(dev);
>              return; /* We've taken the channel! */
>          }
>  
> -        libusb_unref_device(libdev);
> +        spice_usb_backend_device_release(dev);
>      }
>  }
>  
> @@ -1292,8 +1213,8 @@ static SpiceUsbredirChannel *spice_usb_device_manager_get_channel_for_dev(
>      for (i = 0; i < priv->channels->len; i++) {
>          SpiceUsbredirChannel *channel = g_ptr_array_index(priv->channels, i);
>          spice_usbredir_channel_lock(channel);
> -        libusb_device *libdev = spice_usbredir_channel_get_device(channel);
> -        if (spice_usb_manager_device_equal_libdev(manager, device, libdev)) {
> +        SpiceUsbBackendDevice *dev = spice_usbredir_channel_get_device(channel);
> +        if (spice_usb_manager_device_equal_bdev(manager, device, dev)) {
>              spice_usbredir_channel_unlock(channel);
>              return channel;
>          }
> @@ -1350,13 +1271,13 @@ GPtrArray* spice_usb_device_manager_get_devices_with_filter(
>          SpiceUsbDevice *device = g_ptr_array_index(priv->devices, i);
>  
>          if (rules) {
> -            libusb_device *libdev =
> -                spice_usb_device_manager_device_to_libdev(self, device);
> +            SpiceUsbBackendDevice *bdev =
> +                spice_usb_device_manager_device_to_bdev(self, device);
>  #ifdef G_OS_WIN32
> -            if (libdev == NULL)
> +            if (bdev == NULL)
>                  continue;
>  #endif
> -            if (usbredirhost_check_device_filter(rules, count, libdev, 0) != 0)
> +            if (spice_usb_backend_device_check_filter(bdev, rules, count) != 0)
>                  continue;
>          }
>          g_ptr_array_add(devices_copy, spice_usb_device_ref(device));
> @@ -1430,7 +1351,7 @@ _spice_usb_device_manager_connect_device_async(SpiceUsbDeviceManager *self,
>      task = g_task_new(self, cancellable, callback, user_data);
>  
>      SpiceUsbDeviceManagerPrivate *priv = self->priv;
> -    libusb_device *libdev;
> +    SpiceUsbBackendDevice *bdev;
>      guint i;
>  
>      if (spice_usb_device_manager_is_device_connected(self, device)) {
> @@ -1446,9 +1367,9 @@ _spice_usb_device_manager_connect_device_async(SpiceUsbDeviceManager *self,
>          if (spice_usbredir_channel_get_device(channel))
>              continue; /* Skip already used channels */
>  
> -        libdev = spice_usb_device_manager_device_to_libdev(self, device);
> +        bdev = spice_usb_device_manager_device_to_bdev(self, device);
>  #ifdef G_OS_WIN32
> -        if (libdev == NULL) {
> +        if (bdev == NULL) {
>              /* Most likely, the device was plugged out at driver installation
>               * time, and its remove-device event was ignored.
>               * So remove the device now
> @@ -1466,12 +1387,12 @@ _spice_usb_device_manager_connect_device_async(SpiceUsbDeviceManager *self,
>          }
>  #endif
>          spice_usbredir_channel_connect_device_async(channel,
> -                                 libdev,
> +                                 bdev,
>                                   device,
>                                   cancellable,
>                                   spice_usb_device_manager_channel_connect_cb,
>                                   task);
> -        libusb_unref_device(libdev);
> +        spice_usb_backend_device_release(bdev);
>          return;
>      }
>  
> @@ -1733,20 +1654,20 @@ spice_usb_device_manager_can_redirect_device(SpiceUsbDeviceManager  *self,
>  
>      if (guest_filter_rules) {
>          gboolean filter_ok;
> -        libusb_device *libdev;
> +        SpiceUsbBackendDevice *bdev;
>  
> -        libdev = spice_usb_device_manager_device_to_libdev(self, device);
> +        bdev = spice_usb_device_manager_device_to_bdev(self, device);
>  #ifdef G_OS_WIN32
> -        if (libdev == NULL) {
> +        if (bdev == NULL) {
>              g_set_error_literal(err, SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
>                                  _("Some USB devices were not found"));
>              return FALSE;
>          }
>  #endif
> -        filter_ok = (usbredirhost_check_device_filter(
> -                            guest_filter_rules, guest_filter_rules_count,
> -                            libdev, 0) == 0);
> -        libusb_unref_device(libdev);
> +        filter_ok = (spice_usb_backend_device_check_filter(
> +                            bdev,
> +                            guest_filter_rules, guest_filter_rules_count) == 0);
> +        spice_usb_backend_device_release(bdev);
>          if (!filter_ok) {
>              g_set_error_literal(err, SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
>                                  _("Some USB devices are blocked by host policy"));
> @@ -1837,64 +1758,30 @@ gchar *spice_usb_device_get_description(SpiceUsbDevice *device, const gchar *for
>  #endif
>  }
>  
> -
> -
>  #ifdef USE_USBREDIR
> -static gboolean probe_isochronous_endpoint(libusb_device *libdev)
> -{
> -    struct libusb_config_descriptor *conf_desc;
> -    gboolean isoc_found = FALSE;
> -    gint i, j, k;
> -
> -    g_return_val_if_fail(libdev != NULL, FALSE);
> -
> -    if (libusb_get_active_config_descriptor(libdev, &conf_desc) != 0) {
> -        g_return_val_if_reached(FALSE);
> -    }
> -
> -    for (i = 0; !isoc_found && i < conf_desc->bNumInterfaces; i++) {
> -        for (j = 0; !isoc_found && j < conf_desc->interface[i].num_altsetting; j++) {
> -            for (k = 0; !isoc_found && k < conf_desc->interface[i].altsetting[j].bNumEndpoints;k++) {
> -                gint attributes = conf_desc->interface[i].altsetting[j].endpoint[k].bmAttributes;
> -                gint type = attributes & LIBUSB_TRANSFER_TYPE_MASK;
> -                if (type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS)
> -                    isoc_found = TRUE;
> -            }
> -        }
> -    }
> -
> -    libusb_free_config_descriptor(conf_desc);
> -    return isoc_found;
> -}
>  
>  /*
>   * SpiceUsbDeviceInfo
>   */
> -static SpiceUsbDeviceInfo *spice_usb_device_new(libusb_device *libdev)
> +static SpiceUsbDeviceInfo *spice_usb_device_new(SpiceUsbBackendDevice *bdev)
>  {
>      SpiceUsbDeviceInfo *info;
> -    int vid, pid;
> -    guint8 bus, addr;
> +    const UsbDeviceInformation *devinfo;
>  
> -    g_return_val_if_fail(libdev != NULL, NULL);
> -
> -    bus = libusb_get_bus_number(libdev);
> -    addr = libusb_get_device_address(libdev);
> -
> -    if (!spice_usb_device_manager_get_libdev_vid_pid(libdev, &vid, &pid)) {
> -        return NULL;
> -    }
> +    g_return_val_if_fail(bdev != NULL, NULL);
> +    devinfo = spice_usb_backend_device_get_info(bdev);
>  
>      info = g_new0(SpiceUsbDeviceInfo, 1);
>  
> -    info->busnum  = bus;
> -    info->devaddr = addr;
> -    info->vid = vid;
> -    info->pid = pid;
> +    info->busnum  = devinfo->bus;
> +    info->devaddr = devinfo->address;
> +    info->vid = devinfo->vid;
> +    info->pid = devinfo->pid;
>      info->ref = 1;
> -    info->isochronous = probe_isochronous_endpoint(libdev);
> +    info->isochronous = devinfo->isochronous;
>  #ifndef G_OS_WIN32
> -    info->libdev = libusb_ref_device(libdev);
> +    info->bdev = bdev;
> +    spice_usb_backend_device_acquire(bdev);
>  #endif
>  
>      return info;
> @@ -2032,50 +1919,54 @@ static void spice_usb_device_unref(SpiceUsbDevice *device)
>      ref_count_is_0 = g_atomic_int_dec_and_test(&info->ref);
>      if (ref_count_is_0) {
>  #ifndef G_OS_WIN32
> -        libusb_unref_device(info->libdev);
> +        if (info->bdev) {
> +            spice_usb_backend_device_release(info->bdev);
> +        }
>  #endif
> +        info->vid = info->pid = 0;
> +        SPICE_DEBUG("%s: deleting %p", __FUNCTION__, info);
>          g_free(info);
>      }
>  }
>  
>  #ifndef G_OS_WIN32 /* Linux -- directly compare libdev */
>  static gboolean
> -spice_usb_manager_device_equal_libdev(SpiceUsbDeviceManager *manager,
> -                                      SpiceUsbDevice *device,
> -                                      libusb_device  *libdev)
> +spice_usb_manager_device_equal_bdev(SpiceUsbDeviceManager *manager,
> +                                    SpiceUsbDevice        *device,
> +                                    SpiceUsbBackendDevice *bdev)
>  {
>      SpiceUsbDeviceInfo *info = (SpiceUsbDeviceInfo *)device;
>  
> -    if ((device == NULL) || (libdev == NULL))
> +    if ((device == NULL) || (bdev == NULL))
>          return FALSE;
>  
> -    return info->libdev == libdev;
> +    return spice_usb_backend_devices_same(info->bdev, bdev);
>  }
>  #else /* Windows -- compare vid:pid of device and libdev */
>  static gboolean
> -spice_usb_manager_device_equal_libdev(SpiceUsbDeviceManager *manager,
> -                                      SpiceUsbDevice *device,
> -                                      libusb_device  *libdev)
> +spice_usb_manager_device_equal_bdev(SpiceUsbDeviceManager *manager,
> +                                    SpiceUsbDevice *device,
> +                                    SpiceUsbBackendDevice  *bdev)
>  {
>      int busnum, devaddr;
>  
> -    if ((device == NULL) || (libdev == NULL))
> +    if ((device == NULL) || (bdev == NULL))
>          return FALSE;
>  
>      busnum = spice_usb_device_get_busnum(device);
>      devaddr = spice_usb_device_get_devaddr(device);
> -    return spice_usb_device_manager_libdev_match(manager, libdev,
> -                                                 busnum, devaddr);
> +    return spice_usb_device_manager_bdev_match(manager, bdev,
> +                                               busnum, devaddr);
>  }
>  #endif
>  
>  /*
> - * Caller must libusb_unref_device the libusb_device returned by this function.
> - * Returns a libusb_device, or NULL upon failure
> + * Caller must spice_usb_backend_device_release the SpiceUsbBackendDevice returned by this function.
> + * Returns a SpiceUsbBackendDevice, or NULL upon failure
>   */
> -static libusb_device *
> -spice_usb_device_manager_device_to_libdev(SpiceUsbDeviceManager *self,
> -                                          SpiceUsbDevice *device)
> +static SpiceUsbBackendDevice *
> +spice_usb_device_manager_device_to_bdev(SpiceUsbDeviceManager *self,
> +                                        SpiceUsbDevice        *device)
>  {
>  #ifdef G_OS_WIN32
>      /*
> @@ -2085,7 +1976,7 @@ spice_usb_device_manager_device_to_libdev(SpiceUsbDeviceManager *self,
>       * driver swap we do under windows invalidates the cached libdev.
>       */
>  
> -    libusb_device *d, **devlist;
> +    SpiceUsbBackendDevice *d, **devlist;
>      int i;
>  
>      g_return_val_if_fail(SPICE_IS_USB_DEVICE_MANAGER(self), NULL);
> @@ -2093,26 +1984,27 @@ spice_usb_device_manager_device_to_libdev(SpiceUsbDeviceManager *self,
>      g_return_val_if_fail(self->priv != NULL, NULL);
>      g_return_val_if_fail(self->priv->context != NULL, NULL);
>  
> -    libusb_get_device_list(self->priv->context, &devlist);
> +    devlist = spice_usb_backend_get_device_list(self->priv->context);
>      if (!devlist)
>          return NULL;
>  
>      for (i = 0; (d = devlist[i]) != NULL; i++) {
> -        if (spice_usb_manager_device_equal_libdev(self, device, d)) {
> -            libusb_ref_device(d);
> +        if (spice_usb_manager_device_equal_bdev(self, device, d)) {
> +            spice_usb_backend_device_acquire(d);
>              break;
>          }
>      }
>  
> -    libusb_free_device_list(devlist, 1);
> +    spice_usb_backend_free_device_list(devlist);
>  
>      return d;
>  
>  #else
>      /* Simply return a ref to the cached libdev */
>      SpiceUsbDeviceInfo *info = (SpiceUsbDeviceInfo *)device;
> -
> -    return libusb_ref_device(info->libdev);
> +    spice_usb_backend_device_acquire(info->bdev);
> +    return info->bdev;
>  #endif
>  }
> +
>  #endif /* USE_USBREDIR */
> diff --git a/src/usb-device-manager.h b/src/usb-device-manager.h
> index 773208f..4ba7b2f 100644
> --- a/src/usb-device-manager.h
> +++ b/src/usb-device-manager.h
> @@ -87,6 +87,7 @@ struct _SpiceUsbDeviceManagerClass
>                                   SpiceUsbDevice *device, GError *error);
>      void (*device_error) (SpiceUsbDeviceManager *manager,
>                            SpiceUsbDevice *device, GError *error);
> +

Spurious whitespace change.

>      /*< private >*/
>      /*
>       * If adding fields to this struct, remove corresponding
> diff --git a/src/usbutil.c b/src/usbutil.c
> index e96ab11..5052ef3 100644
> --- a/src/usbutil.c
> +++ b/src/usbutil.c
> @@ -58,42 +58,6 @@ static GMutex usbids_load_mutex;
>  static int usbids_vendor_count = 0; /* < 0: failed, 0: empty, > 0: loaded */
>  static usb_vendor_info *usbids_vendor_info = NULL;
>  
> -G_GNUC_INTERNAL
> -const char *spice_usbutil_libusb_strerror(enum libusb_error error_code)
> -{
> -    switch (error_code) {
> -    case LIBUSB_SUCCESS:
> -        return "Success";
> -    case LIBUSB_ERROR_IO:
> -        return "Input/output error";
> -    case LIBUSB_ERROR_INVALID_PARAM:
> -        return "Invalid parameter";
> -    case LIBUSB_ERROR_ACCESS:
> -        return "Access denied (insufficient permissions)";
> -    case LIBUSB_ERROR_NO_DEVICE:
> -        return "No such device (it may have been disconnected)";
> -    case LIBUSB_ERROR_NOT_FOUND:
> -        return "Entity not found";
> -    case LIBUSB_ERROR_BUSY:
> -        return "Resource busy";
> -    case LIBUSB_ERROR_TIMEOUT:
> -        return "Operation timed out";
> -    case LIBUSB_ERROR_OVERFLOW:
> -        return "Overflow";
> -    case LIBUSB_ERROR_PIPE:
> -        return "Pipe error";
> -    case LIBUSB_ERROR_INTERRUPTED:
> -        return "System call interrupted (perhaps due to signal)";
> -    case LIBUSB_ERROR_NO_MEM:
> -        return "Insufficient memory";
> -    case LIBUSB_ERROR_NOT_SUPPORTED:
> -        return "Operation not supported or unimplemented on this platform";
> -    case LIBUSB_ERROR_OTHER:
> -        return "Other error";
> -    }
> -    return "Unknown error";
> -}
> -
>  #ifdef __linux__
>  /* <Sigh> libusb does not allow getting the manufacturer and product strings
>     without opening the device, so grab them directly from sysfs */
> diff --git a/src/usbutil.h b/src/usbutil.h
> index de5e92a..d18d688 100644
> --- a/src/usbutil.h
> +++ b/src/usbutil.h
> @@ -24,11 +24,9 @@
>  #include <glib.h>
>  
>  #ifdef USE_USBREDIR
> -#include <libusb.h>
>  
>  G_BEGIN_DECLS
>  
> -const char *spice_usbutil_libusb_strerror(enum libusb_error error_code);
>  void spice_usb_util_get_device_strings(int bus, int address,
>                                         int vendor_id, int product_id,
>                                         gchar **manufacturer, gchar **product);
> diff --git a/src/win-usb-dev.c b/src/win-usb-dev.c
> index 9a130a3..e5b6d62 100644
> --- a/src/win-usb-dev.c
> +++ b/src/win-usb-dev.c
> @@ -23,11 +23,13 @@
>  #include "config.h"
>  
>  #include <windows.h>
> -#include <libusb.h>
>  #include "win-usb-dev.h"
>  #include "spice-marshal.h"
>  #include "spice-util.h"
>  #include "usbutil.h"
> +#include "usb-backend.h"
> +
> +#define USB_CLASS_HUB   9
>  
>  enum {
>      PROP_0,
> @@ -35,7 +37,7 @@ enum {
>  };
>  
>  struct _GUdevClientPrivate {
> -    libusb_context *ctx;
> +    SpiceUsbBackend *ctx;
>      GList *udev_list;
>      HWND hwnd;
>      gboolean redirecting;
> @@ -85,7 +87,7 @@ static GUdevClient *singleton = NULL;
>  
>  static GUdevDevice *g_udev_device_new(GUdevDeviceInfo *udevinfo);
>  static LRESULT CALLBACK wnd_proc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
> -static gboolean get_usb_dev_info(libusb_device *dev, GUdevDeviceInfo *udevinfo);
> +static gboolean get_usb_dev_info(SpiceUsbBackendDevice *dev, GUdevDeviceInfo *udevinfo);
>  
>  //uncomment to debug gudev device lists.
>  //#define DEBUG_GUDEV_DEVICE_LISTS
> @@ -122,8 +124,7 @@ static ssize_t
>  g_udev_client_list_devices(GUdevClient *self, GList **devs,
>                             GError **err, const gchar *name)
>  {
> -    gssize rc;
> -    libusb_device **lusb_list, **dev;
> +    SpiceUsbBackendDevice **lusb_list, **dev;
>      GUdevClientPrivate *priv;
>      GUdevDeviceInfo *udevinfo;
>      GUdevDevice *udevice;
> @@ -136,13 +137,8 @@ g_udev_client_list_devices(GUdevClient *self, GList **devs,
>  
>      g_return_val_if_fail(self->priv->ctx != NULL, -3);
>  
> -    rc = libusb_get_device_list(priv->ctx, &lusb_list);
> -    if (rc < 0) {
> -        const char *errstr = spice_usbutil_libusb_strerror(rc);
> -        g_warning("%s: libusb_get_device_list failed - %s", name, errstr);
> -        g_set_error(err, G_UDEV_CLIENT_ERROR, G_UDEV_CLIENT_LIBUSB_FAILED,
> -                    "%s: Error getting device list from libusb: %s [%"G_GSSIZE_FORMAT"]",
> -                    name, errstr, rc);
> +    lusb_list = spice_usb_backend_get_device_list(priv->ctx);
> +    if (!lusb_list) {
>          return -4;
>      }

Why did you remove the g_set_error?

>  
> @@ -158,7 +154,7 @@ g_udev_client_list_devices(GUdevClient *self, GList **devs,
>          *devs = g_list_prepend(*devs, udevice);
>          n++;
>      }
> -    libusb_free_device_list(lusb_list, 1);
> +    spice_usb_backend_free_device_list(lusb_list);
>  
>      return n;
>  }
> @@ -180,7 +176,6 @@ g_udev_client_initable_init(GInitable *initable, GCancellable *cancellable,
>      GUdevClient *self;
>      GUdevClientPrivate *priv;
>      WNDCLASS wcls;
> -    int rc;
>  
>      g_return_val_if_fail(G_UDEV_IS_CLIENT(initable), FALSE);
>      g_return_val_if_fail(cancellable == NULL, FALSE);
> @@ -188,19 +183,10 @@ g_udev_client_initable_init(GInitable *initable, GCancellable *cancellable,
>      self = G_UDEV_CLIENT(initable);
>      priv = self->priv;
>  
> -    rc = libusb_init(&priv->ctx);
> -    if (rc < 0) {
> -        const char *errstr = spice_usbutil_libusb_strerror(rc);
> -        g_warning("Error initializing USB support: %s [%i]", errstr, rc);
> -        g_set_error(err, G_UDEV_CLIENT_ERROR, G_UDEV_CLIENT_LIBUSB_FAILED,
> -                    "Error initializing USB support: %s [%i]", errstr, rc);
> +    priv->ctx = spice_usb_backend_initialize(err);
> +    if (!priv->ctx) {
>          return FALSE;
>      }
> -#ifdef G_OS_WIN32
> -#if LIBUSB_API_VERSION >= 0x01000106
> -    libusb_set_option(priv->ctx, LIBUSB_OPTION_USE_USBDK);
> -#endif
> -#endif
>  
>      /* get initial device list */
>      if (g_udev_client_list_devices(self, &priv->udev_list, err, __FUNCTION__) < 0) {
> @@ -267,7 +253,7 @@ static void g_udev_client_finalize(GObject *gobject)
>  
>      /* free libusb context initializing by libusb_init() */
>      g_warn_if_fail(priv->ctx != NULL);
> -    libusb_exit(priv->ctx);
> +    spice_usb_backend_finalize(priv->ctx);
>  
>      /* Chain up to the parent class */
>      if (G_OBJECT_CLASS(g_udev_client_parent_class)->finalize)
> @@ -356,23 +342,18 @@ static void g_udev_client_class_init(GUdevClientClass *klass)
>      g_object_class_install_property(gobject_class, PROP_REDIRECTING, pspec);
>  }
>  
> -static gboolean get_usb_dev_info(libusb_device *dev, GUdevDeviceInfo *udevinfo)
> +static gboolean get_usb_dev_info(SpiceUsbBackendDevice *dev, GUdevDeviceInfo *udevinfo)
>  {
> -    struct libusb_device_descriptor desc;
> +    const UsbDeviceInformation* info = spice_usb_backend_device_get_info(dev);
>  
>      g_return_val_if_fail(dev, FALSE);
>      g_return_val_if_fail(udevinfo, FALSE);
>  
> -    if (libusb_get_device_descriptor(dev, &desc) < 0) {
> -        g_warning("cannot get device descriptor %p", dev);
> -        return FALSE;
> -    }
> -
> -    udevinfo->bus   = libusb_get_bus_number(dev);
> -    udevinfo->addr  = libusb_get_device_address(dev);
> -    udevinfo->class = desc.bDeviceClass;
> -    udevinfo->vid   = desc.idVendor;
> -    udevinfo->pid   = desc.idProduct;
> +    udevinfo->bus = info->bus;
> +    udevinfo->addr = info->address;
> +    udevinfo->class = info->class;
> +    udevinfo->vid   = info->vid;
> +    udevinfo->pid   = info->pid;
>      snprintf(udevinfo->sclass, sizeof(udevinfo->sclass), "%d", udevinfo->class);
>      snprintf(udevinfo->sbus,   sizeof(udevinfo->sbus),   "%d", udevinfo->bus);
>      snprintf(udevinfo->saddr,  sizeof(udevinfo->saddr),  "%d", udevinfo->addr);
> @@ -573,7 +554,7 @@ static gboolean g_udev_skip_search(GUdevDevice *udev)
>  #if defined(LIBUSBX_API_VERSION) && (LIBUSBX_API_VERSION >= 0x010000FF)
>              (udevinfo->addr == 1) || /* root hub addr for libusbx >= 1.0.13 */
>  #endif
> -            (udevinfo->class == LIBUSB_CLASS_HUB) || /* hub*/
> +            (udevinfo->class == USB_CLASS_HUB) || /* hub*/
>              (udevinfo->addr == 0)); /* bad address */
>      return skip;
>  }

Christophe

Attachment: signature.asc
Description: PGP signature

_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel

[Index of Archives]     [Linux Virtualization]     [Linux Virtualization]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux OMAP]     [Linux MIPS]     [ECOS]     [Asterisk Internet PBX]     [Linux API]     [Monitors]