Regarding the new widget:
New widget introduced in order to keep the backward compatibility.
There is an option (described in the commit comment) to keep the old look of the widget (this will suppress the cd-sharing, of course).
I do not take the responsibility to decide that the old widget is not needed anymore.
When such decision is taken, it is possible to remove the old file in simple future commit.
Regarding additional split of the 2/2 to 'backend' and 'cd-sharing'
I've checked this option before preparing the combined commit and found that the content
of 'cd-sharing' changes in 2/2 is not more than 10% and splitting will add significant time
to test the intermediate patch (as everything shall work without regression after each patch)
which still stays intermediate as the main motivation of 'backend' part is the 'cd-sharing' feature.
If there are no very strong reasons for spending time for preparing/testing such intermediate patch
I'd suggest to continue reviewing the combined patch.
Thanks,
Yuri Benditovich
On Thu, Sep 13, 2018 at 10:43 AM, Christophe Fergeau <cfergeau@xxxxxxxxxx> wrote:
On Mon, Sep 10, 2018 at 02:33:45PM +0300, Yuri Benditovich wrote:
> This commit contains modified files related to CD sharing feature.
> The feature adds ability to share one or more CD images
> (or local CD-DVD devices) with the guest by emulating
> USB CD devices connected to guest system.
My feeling is that these commits are very big. For example, a big part
of the changes in this file seem to be to replace direct libusb_device
use with SpiceUsbBackendDevice. Have you considered starting by
reworking the existing code to switch so SpiceUsbBackendDevice
(introducing the needed new files at the same time), and then adding the
cd redirection stuff on top of that?
I'm also not quite clear why a brand new widget is introduced rather
than changing the existing widget to the new look, and then adding the
CD redirection bits on top of it?
And btw, s/RedHat/Red Hat/ in src/usb-device-manager.c :)
Christophe
>
> Prerequisites:
> Guest system shall have USB2 or USB3 controller and one or more
> USB redirection channels. Each emulated CD device currently
> uses one USB redirection channel.
> Usage from GUI:
> New USB device redirection widget includes 'Add CD' button that
> allows selection of ISO file which will be used for emulation
> of USB CD drive.
> Usage from command line:
> Added command line option '--spice-share-cd=filename' which
> allows to create one or more emulated CD drives.
> Sharing local CD drive:
> For sharing local CD drive use file name of respective device,
> it depends on the operating system of client machine.
> Example for Windows clients - d:
> Example for Linux clients - /dev/cdrom
> Build backward compatibility:
> The feature can be disabled by build configuration:
> --enable-cdsharing=no disables CD sharing (USB redirection
> GUI uses new USB redirection widget)
> --enable-newusbwidget=no also disables CD sharing (USB
> redirection GUI uses old USB widget)
> Notes for Windows build of 'VirtViewer':
> In order to show proper icons in new USB redirection widget
> the installation package of VirtViewer shall include
> following icons:
> "media-optical", "network-transmit-receive", "network-offline",
> "dialog-warning", "dialog-information",
> "preferences-system","system-lock-screen","media-eject",
> "edit-delete", "list-add"
> Automatic redirection of emulated CD devices:
> Same as one for local USB drives:
> - shared CD devices created by command line redirected
> according to 'redirect-on-connect' filter
> - shared CD devices created during session redirected
> according to 'auto-redirect' filter
> Disable redirection of emulated CD devices on server side:
> Same as for redirection of local USB drives:
> -device usb-redir,filter=<filter> option of qemu
>
> Signed-off-by: Yuri Benditovich <yuri.benditovich@xxxxxxxxxx>
> ---
> configure.ac | 27 ++
> src/Makefile.am | 15 +-
> src/channel-usbredir-priv.h | 9 +-
> src/channel-usbredir.c | 267 ++++++------------
> src/map-file | 9 +
> src/spice-option.c | 15 ++
> src/usb-device-manager-priv.h | 5 +-
> src/usb-device-manager.c | 615 +++++++++++++++++++++++++-----------------
> src/usb-device-manager.h | 107 +++++++-
> src/usb-device-widget.c | 5 +
> src/usbutil.c | 52 +---
> src/usbutil.h | 5 +-
> src/win-usb-dev.c | 66 ++---
> src/win-usb-dev.h | 2 +
> 14 files changed, 682 insertions(+), 517 deletions(-)
>
> diff --git a/configure.ac b/configure.ac
> index 7b32e29..1e977b3 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -349,6 +349,32 @@ else
> fi
> AM_CONDITIONAL([WITH_USBREDIR], [test "x$have_usbredir" = "xyes"])
>
> +AC_ARG_ENABLE([newusbwidget],
> + AS_HELP_STRING([--enable-newusbwidget=@<:@yes/no@:>@],
> + [Use new USB devices widget @<:@default=yes@:>@]),
> + [],
> + [enable_newusbwidget="yes"])
> +
> +AC_ARG_ENABLE([cdsharing],
> + AS_HELP_STRING([--enable-cdsharing=@<:@auto/yes/no@:>@] ,
> + [Enable CD charing feature @<:@default=auto@:>@]),
> + [],
> + [enable_cdsharing="auto"])
> +
> +if test "x$enable_newusbwidget" = "xno" || test "x$have_usbredir" != "xyes" ; then
> + have_newusbwidget="no"
> +else
> + have_newusbwidget="yes"
> + AC_DEFINE([USE_NEW_USB_WIDGET], [1], [Define if new USB widget should be used])
> +fi
> +
> +if test "x$enable_cdsharing" = "xno" || test "x$have_newusbwidget" = "xno"; then
> + have_cdsharing="no"
> +else
> + have_cdsharing="yes"
> + AC_DEFINE([USE_CD_SHARING], [1], [Define if supporting cd sharing via usbredir])
> +fi
> +
> AC_ARG_ENABLE([polkit],
> AS_HELP_STRING([--enable-polkit=@<:@auto/yes/no@:>@],
> [Enable PolicyKit support (for the usb acl helper)@<:@default=auto@:>@]),
> @@ -605,6 +631,7 @@ AC_MSG_NOTICE([
> SASL support: ${have_sasl}
> Smartcard support: ${have_smartcard}
> USB redirection support: ${have_usbredir} ${with_usbredir_hotplug}
> + CD sharing support: ${have_cdsharing} new widget: ${have_newusbwidget}
> DBus: ${have_dbus}
> WebDAV support: ${have_phodav}
> LZ4 support: ${have_lz4}
> diff --git a/src/Makefile.am b/src/Makefile.am
> index 4dd657d..c23e7da 100644
> --- a/src/Makefile.am
> +++ b/src/Makefile.am
> @@ -127,7 +127,8 @@ SPICE_GTK_SOURCES_COMMON = \
> spice-grabsequence-priv.h \
> desktop-integration.c \
> desktop-integration.h \
> - usb-device-widget.c \
> + usb-device-redir-widget.c \
> + usb-device-widget.c \
> $(NULL)
>
> nodist_SPICE_GTK_SOURCES_COMMON = \
> @@ -249,6 +250,15 @@ libspice_client_glib_2_0_la_SOURCES = \
> spice-uri-priv.h \
> usb-device-manager.c \
> usb-device-manager-priv.h \
> + usb-backend-common.c \
> + usb-backend.h \
> + cd-usb-bulk-msd.c \
> + cd-usb-bulk-msd.h \
> + cd-scsi.c \
> + cd-scsi.h \
> + cd-device.h \
> + cd-device-win.c \
> + cd-device-linux.c \
> usbutil.c \
> usbutil.h \
> $(USB_ACL_HELPER_SRCS) \
> @@ -536,7 +546,8 @@ gtk_introspection_files = \
> spice-gtk-session.c \
> spice-widget.c \
> spice-grabsequence.c \
> - usb-device-widget.c \
> + usb-device-redir-widget.c \
> + usb-device-widget.c \
> $(NULL)
>
> SpiceClientGLib-2.0.gir: libspice-client-glib-2.0.la
> diff --git a/src/channel-usbredir-priv.h b/src/channel-usbredir-priv.h
> index 17e9716..2c3e705 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 1d9c380..ffdf9b1 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_log(void *user_data, const char *msg, gboolean error);
> 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)
>
> 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 */
> @@ -228,7 +216,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
> @@ -252,33 +240,24 @@ 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.log = usbredir_log;
> + init_data.write_callback = usbredir_write_callback;
> + init_data.debug = spice_util_get_debug();
>
> 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);
> - if (!priv->host)
> - g_error("Out of memory allocating usbredirhost");
> + priv->host = spice_usb_backend_channel_initialize(context, &init_data);
>
> -#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
> @@ -289,9 +268,8 @@ static gboolean spice_usbredir_channel_open_device(
> {
> SpiceUsbredirChannelPrivate *priv = channel->priv;
> SpiceSession *session;
> - libusb_device_handle *handle = NULL;
> - int rc, status;
> SpiceUsbDeviceManager *manager;
> + const char *msg = NULL;
>
> g_return_val_if_fail(priv->state == STATE_DISCONNECTED
> #ifdef USE_POLKIT
> @@ -299,29 +277,28 @@ 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, &msg)) {
> + priv->catch_error = NULL;
> + if (*err == NULL) {
> + if (!msg) {
> + msg = "Exact error not reported";
> + }
> + g_set_error(err, SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
> + "Error attaching device: %s", msg);
> + }
> return FALSE;
> }
> + priv->catch_error = NULL;
>
> session = spice_channel_get_session(SPICE_CHANNEL(channel));
> manager = spice_usb_device_manager_get(session, NULL);
> g_return_val_if_fail(manager != NULL, FALSE);
>
> 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);
> + if (spice_usb_backend_device_need_thread(priv->device) &&
> + !spice_usb_device_manager_start_event_listening(priv-> usb_device_manager, err)) {
> + spice_usb_backend_channel_attach(priv->host, NULL, NULL);
> return FALSE;
> }
>
> @@ -352,8 +329,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;
> @@ -370,7 +346,6 @@ static void spice_usbredir_channel_open_acl_cb(
> }
> #endif
>
> -#ifndef USE_POLKIT
> static void
> _open_device_async_cb(GTask *task,
> gpointer object,
> @@ -384,8 +359,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;
> }
> @@ -398,18 +372,20 @@ _open_device_async_cb(GTask *task,
> g_task_return_boolean(task, TRUE);
> }
> }
> -#endif
>
> 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));
> @@ -436,25 +412,28 @@ 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
> - priv->task = task;
> - priv->state = STATE_WAITING_FOR_ACL_HELPER;
> - priv->acl_helper = spice_usb_acl_helper_new();
> - 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),
> - cancellable,
> - spice_usbredir_channel_open_acl_cb,
> - channel);
> - return;
> -#else
> - g_task_run_in_thread(task, _open_device_async_cb);
> + // avoid calling ACL helper for emulated CD devices
> + if (info->max_luns == 0) {
> + priv->task = task;
> + priv->state = STATE_WAITING_FOR_ACL_HELPER;
> + priv->acl_helper = spice_usb_acl_helper_new();
> + 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,
> + info->bus,
> + info->address,
> + cancellable,
> + spice_usbredir_channel_open_acl_cb,
> + channel);
> + return;
> + }
> #endif
> + g_task_run_in_thread(task, _open_device_async_cb);
>
> done:
> g_object_unref(task);
> @@ -501,13 +480,14 @@ void spice_usbredir_channel_disconnect_device( SpiceUsbredirChannel *channel)
> * libusb_handle_events call in the thread.
> */
> g_warn_if_fail(priv->usb_device_manager != NULL);
> - spice_usb_device_manager_stop_event_listening(priv->usb_ device_manager);
> + if (spice_usb_backend_device_need_thread(priv->device)) {
> + spice_usb_device_manager_stop_event_listening(priv->usb_ device_manager);
> + }
> 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_attach(priv->host, NULL, 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;
> @@ -558,7 +538,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;
> }
> @@ -573,85 +553,46 @@ 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;
> + return FALSE;
>
> - usbredirhost_write_guest_data(priv->host);
> + return TRUE;
> }
>
> -static void usbredir_log(void *user_data, int level, const char *msg)
> +static void usbredir_log(void *user_data, const char *msg, gboolean error)
> {
> SpiceUsbredirChannel *channel = user_data;
> SpiceUsbredirChannelPrivate *priv = channel->priv;
>
> - if (priv->catch_error && level == usbredirparser_error) {
> - CHANNEL_DEBUG(channel, "%s", msg);
> + CHANNEL_DEBUG(channel, "%s", msg);
> + if (priv->catch_error && error) {
> /* 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);
> + SPICE_CLIENT_ERROR_FAILED, msg + 14);
> else
> g_set_error_literal(priv->catch_error, SPICE_CLIENT_ERROR,
> - SPICE_CLIENT_ERROR_FAILED, msg);
> - return;
> + SPICE_CLIENT_ERROR_FAILED, msg);
> + priv->catch_error = NULL;
> }
> -
> - switch (level) {
> - case usbredirparser_error:
> - g_critical("%s", msg);
> - break;
> - case usbredirparser_warning:
> - g_warning("%s", msg);
> - break;
> - default:
> - CHANNEL_DEBUG(channel, "%s", msg);
> - }
> -}
> -
> -static int usbredir_read_callback(void *user_data, uint8_t *data, int count)
> -{
> - 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;
> - }
> -
> - return count;
> }
>
> static void usbredir_free_write_cb_data(uint8_t *data, void *user_data)
> @@ -659,7 +600,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
> @@ -731,7 +672,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
> @@ -744,15 +685,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)
> {
> @@ -765,25 +697,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 {
> @@ -819,10 +732,14 @@ static void spice_usbredir_channel_up(SpiceChannel *c)
> {
> SpiceUsbredirChannel *channel = SPICE_USBREDIR_CHANNEL(c);
> SpiceUsbredirChannelPrivate *priv = channel->priv;
> + SpiceSession *session = spice_channel_get_session(c);
> + SpiceUsbDeviceManager *manager = spice_usb_device_manager_get(session, NULL);
>
> g_return_if_fail(priv->host != NULL);
> /* Flush any pending writes */
> - usbredirhost_write_guest_data(priv->host);
> + spice_usb_backend_channel_up(priv->host);
> + /* Check which existing device can be redirected right now */
> + spice_usb_device_manager_check_redir_on_connect( manager, c);
> }
>
> static int try_handle_compressed_msg(SpiceMsgCompressedData *compressed_data_msg,
> @@ -872,26 +789,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;
> @@ -905,16 +816,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/map-file b/src/map-file
> index cdb81c3..154fd08 100644
> --- a/src/map-file
> +++ b/src/map-file
> @@ -156,6 +156,7 @@ spice_uri_set_scheme;
> spice_uri_set_user;
> spice_uri_to_string;
> spice_usb_device_get_description;
> +spice_usb_device_get_info;
> spice_usb_device_get_libusb_device;
> spice_usb_device_get_type;
> spice_usb_device_manager_can_redirect_device;
> @@ -178,6 +179,14 @@ spice_util_get_version_string;
> spice_util_set_debug;
> spice_uuid_to_string;
> spice_webdav_channel_get_type;
> +spice_usb_device_manager_is_device_cd;
> +spice_usb_device_manager_get_device_luns;
> +spice_usb_device_manager_add_cd_lun;
> +spice_usb_device_manager_device_lun_get_info;
> +spice_usb_device_manager_device_lun_lock;
> +spice_usb_device_manager_device_lun_load;
> +spice_usb_device_manager_device_lun_change_media;
> +spice_usb_device_manager_device_lun_remove;
> local:
> *;
> };
> diff --git a/src/spice-option.c b/src/spice-option.c
> index 6b400bc..dfa7335 100644
> --- a/src/spice-option.c
> +++ b/src/spice-option.c
> @@ -33,6 +33,7 @@ static char *smartcard_db = NULL;
> static char *smartcard_certificates = NULL;
> static char *usbredir_auto_redirect_filter = NULL;
> static char *usbredir_redirect_on_connect = NULL;
> +static gchar **cd_share_files = NULL;
> static gboolean smartcard = FALSE;
> static gboolean disable_audio = FALSE;
> static gboolean disable_usbredir = FALSE;
> @@ -218,6 +219,8 @@ GOptionGroup* spice_get_option_group(void)
> N_("Filter selecting USB devices to be auto-redirected when plugged in"), N_("<filter-string>") },
> { "spice-usbredir-redirect-on-connect", '\0', 0, G_OPTION_ARG_STRING, &usbredir_redirect_on_connect,
> N_("Filter selecting USB devices to redirect on connect"), N_("<filter-string>") },
> + { "spice-share-cd", '\0', 0, G_OPTION_ARG_STRING_ARRAY, &cd_share_files,
> + N_("Name of ISO file or CD/DVD device to share"), N_("<filename> (repeat allowed)") },
> { "spice-cache-size", '\0', 0, G_OPTION_ARG_INT, &cache_size,
> N_("Image cache size (deprecated)"), N_("<bytes>") },
> { "spice-glz-window-size", '\0', 0, G_OPTION_ARG_INT, &glz_window_size,
> @@ -308,6 +311,18 @@ void spice_set_session_option(SpiceSession *session)
> g_object_set(m, "redirect-on-connect",
> usbredir_redirect_on_connect, NULL);
> }
> + if (cd_share_files) {
> + SpiceUsbDeviceManager *m = spice_usb_device_manager_get(session, NULL);
> + if (m) {
> + gchar **name = cd_share_files;
> + while (name && *name) {
> + g_object_set(m, "share-cd", *name, NULL);
> + name++;
> + }
> + }
> + g_strfreev(cd_share_files);
> + cd_share_files = NULL;
> + }
> if (disable_usbredir)
> g_object_set(session, "enable-usbredir", FALSE, NULL);
> if (disable_audio)
> diff --git a/src/usb-device-manager-priv.h b/src/usb-device-manager-priv. h
> index 83884d7..53149fb 100644
> --- a/src/usb-device-manager-priv.h
> +++ b/src/usb-device-manager-priv.h
> @@ -32,9 +32,12 @@ void spice_usb_device_manager_stop_event_listening(
> SpiceUsbDeviceManager *manager);
>
> #ifdef USE_USBREDIR
> -#include <libusb.h>
> +#include "usb-backend.h"
> void spice_usb_device_manager_device_error(
> SpiceUsbDeviceManager *manager, SpiceUsbDevice *device, GError *err);
> +void spice_usb_device_manager_check_redir_on_connect(
> + SpiceUsbDeviceManager *manager, SpiceChannel *channel);
> +
>
> guint8 spice_usb_device_get_busnum(const SpiceUsbDevice *device);
> guint8 spice_usb_device_get_devaddr(const SpiceUsbDevice *device);
> diff --git a/src/usb-device-manager.c b/src/usb-device-manager.c
> index 50fb491..05b38ae 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"
> @@ -58,6 +59,9 @@
> #define DEV_ID_FMT "0x%04x:0x%04x"
> #endif
>
> +#define CD_SHARE_VENDOR "RedHat Inc."
> +#define CD_SHARE_PRODUCT "Spice CD drive"
> +
> /**
> * SECTION:usb-device-manager
> * @short_description: USB device management
> @@ -85,6 +89,7 @@ enum {
> PROP_AUTO_CONNECT_FILTER,
> PROP_REDIRECT_ON_CONNECT,
> PROP_FREE_CHANNELS,
> + PROP_SHARE_CD
> };
>
> enum
> @@ -93,6 +98,7 @@ enum
> DEVICE_REMOVED,
> AUTO_CONNECT_FAILED,
> DEVICE_ERROR,
> + DEVICE_CHANGED,
> LAST_SIGNAL,
> };
>
> @@ -102,7 +108,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 +118,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;
> @@ -139,6 +144,7 @@ enum {
>
> #ifdef USE_USBREDIR
>
> +// this is the structure behind SpiceUsbDevice
> typedef struct _SpiceUsbDeviceInfo {
> guint8 busnum;
> guint8 devaddr;
> @@ -148,7 +154,7 @@ typedef struct _SpiceUsbDeviceInfo {
> #ifdef G_OS_WIN32
> guint8 state;
> #else
> - libusb_device *libdev;
> + SpiceUsbBackendDevice *bdev;
> #endif
> gint ref;
> } SpiceUsbDeviceInfo;
> @@ -166,15 +172,13 @@ 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);
>
> @@ -183,11 +187,11 @@ 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,
> +static gboolean spice_usb_manager_device_equal_bdev( SpiceUsbDeviceManager *manager,
> SpiceUsbDevice *device,
> - libusb_device *libdev);
> -static libusb_device *
> -spice_usb_device_manager_device_to_libdev( SpiceUsbDeviceManager *self,
> + SpiceUsbBackendDevice *bdev);
> +static SpiceUsbBackendDevice*
> +spice_usb_device_manager_device_to_bdev( SpiceUsbDeviceManager *self,
> SpiceUsbDevice *device);
>
> static void
> @@ -205,6 +209,9 @@ static
> void disconnect_device_sync(SpiceUsbDeviceManager *self,
> SpiceUsbDevice *device);
>
> +static
> +void on_device_change(void *self, SpiceUsbBackendDevice *bdev);
> +
> G_DEFINE_BOXED_TYPE(SpiceUsbDevice, spice_usb_device,
> (GBoxedCopyFunc)spice_usb_device_ref,
> (GBoxedFreeFunc)spice_usb_device_unref)
> @@ -288,26 +295,17 @@ 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();
> + 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
> + spice_usb_backend_set_device_change_callback(priv->context,
> + self, on_device_change);
>
> /* Start listening for usb devices plug / unplug */
> #ifdef USE_GUDEV
> @@ -319,26 +317,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);
> @@ -369,20 +361,20 @@ 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;
> + // TODO: check in case the initial spice_usb_backend_handle_hotplug fails
> +
> + 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) {
> @@ -411,8 +403,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
> @@ -455,6 +448,10 @@ static void spice_usb_device_manager_get_property(GObject *gobject,
> case PROP_REDIRECT_ON_CONNECT:
> g_value_set_string(value, priv->redirect_on_connect);
> break;
> + case PROP_SHARE_CD:
> + /* get_property is not needed */
> + g_value_set_string(value, "");
> + break;
> case PROP_FREE_CHANNELS: {
> int free_channels = 0;
> #ifdef USE_USBREDIR
> @@ -545,6 +542,20 @@ static void spice_usb_device_manager_set_property(GObject *gobject,
> priv->redirect_on_connect = g_strdup(filter);
> break;
> }
> + case PROP_SHARE_CD:
> + {
> +#ifdef USE_USBREDIR
> + SpiceUsbDeviceLunInfo info = { 0 };
> + const gchar *name = g_value_get_string(value);
> + /* the string is temporary, no need to keep it */
> + SPICE_DEBUG("share_cd set to %s", name);
> + info.started = TRUE;
> + info.loaded = TRUE;
> + info.file_path = name;
> + spice_usb_backend_add_cd_lun(priv->context, &info);
> +#endif
> + break;
> + }
> default:
> G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, pspec);
> break;
> @@ -636,6 +647,18 @@ static void spice_usb_device_manager_class_init( SpiceUsbDeviceManagerClass *klas
> pspec);
>
> /**
> + * SpiceUsbDeviceManager:share-cd: