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);
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)
{
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);
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)");
+ }
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);
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;
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',
]
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;
+ void *msc;
+ } d;
+ gboolean is_libusb;
+ gint ref_count;
+ SpiceUsbBackendChannel *attached_to;
+ UsbDeviceInformation device_info;
+};
+
+struct _SpiceUsbBackend
+{
+ libusb_context *libusb_context;
+ usb_hot_plug_callback 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;
+ SpiceUsbBackendChannelInitData channel_data;
+};
+
+// it's unclear why we use this procedure instead of libusb_error_name,
+// which by definition supports any error that libusb returns
+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);
+ 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);
+#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;
+ }
+ }
+ SPICE_DEBUG("%s << %s %d", __FUNCTION__,
+ be->libusb_context ? "libusb" : "no libusb", ok);
+ return ok;
+}
+
+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)
+{
+ 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;
+}
+
+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) {
+ 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);
+ }
+
+ 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;
+
+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;
+} SpiceUsbBackendChannelInitData;
+
+typedef void(*usb_hot_plug_callback)(void *user_data, SpiceUsbBackendDevice *dev, gboolean added);
+
+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
+SpiceUsbBackendDevice pointers.
+The caller must call spice_usb_backend_free_device_list
+after it finishes list processing
+*/
+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");
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 */
+ 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)
{
+ 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)
{
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);
+
/*< 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;
}
@@ -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;
}
--
2.17.0
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel