/* usbredirhost.c usb network redirection usb host code.

   Copyright 2010-2012 Red Hat, Inc.

   Red Hat Authors:

   Hans de Goede <hdegoede@redhat.com>

   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"

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <stdbool.h>

#include <string.h>

#include <errno.h>

#include <unistd.h>

#include <inttypes.h>

#include "usbredirhost.h"

#define MAX_ENDPOINTS        32

#define MAX_INTERFACES       32 /* Max 32 endpoints and thus interfaces */

#define CTRL_TIMEOUT       5000 /* USB specifies a 5 second max timeout */

#define BULK_TIMEOUT          0 /* No timeout for bulk transfers */

#define ISO_TIMEOUT        1000

#define INTERRUPT_TIMEOUT     0 /* No timeout for interrupt transfers */

#define MAX_TRANSFER_COUNT        16

#define MAX_PACKETS_PER_TRANSFER  32

#define INTERRUPT_TRANSFER_COUNT   5

/* Special packet_idx value indicating a submitted transfer */

#define SUBMITTED_IDX             -1

/* quirk flags */

#define QUIRK_DO_NOT_RESET    0x01

/* Macros to go from an endpoint address to an index for our ep array */

#define EP2I(ep_address) (((ep_address & 0x80) >> 3) | (ep_address & 0x0f))

#define I2EP(i) (((i & 0x10) << 3) | (i & 0x0f))

/* Locking convenience macros */

#define LOCK(host) \

    do { \

        if ((host)->lock) \

            (host)->parser->lock_func((host)->lock); \

    } while (0)

#define UNLOCK(host) \

    do { \

        if ((host)->lock) \

            (host)->parser->unlock_func((host)->lock); \

    } while (0)

#define FLUSH(host) \

    do { \

        if ((host)->flush_writes_func) \

            (host)->flush_writes_func((host)->func_priv); \

    } while (0)

struct usbredirtransfer {

    struct usbredirhost *host;        /* Back pointer to the the redirhost */

    struct libusb_transfer *transfer; /* Back pointer to the libusb transfer */

    uint64_t id;

    uint8_t cancelled;

    int packet_idx;

    union {

        struct usb_redir_control_packet_header control_packet;

        struct usb_redir_bulk_packet_header bulk_packet;

        struct usb_redir_iso_packet_header iso_packet;

        struct usb_redir_interrupt_packet_header interrupt_packet;

    };

    struct usbredirtransfer *next;

    struct usbredirtransfer *prev;

};

struct usbredirhost_ep {

    uint8_t type;

    uint8_t interval;

    uint8_t interface;

    uint8_t warn_on_drop;

    uint8_t stream_started;

    uint8_t pkts_per_transfer;

    uint8_t transfer_count;

    int out_idx;

    int drop_packets;

    int max_packetsize;

    unsigned int max_streams;

    struct usbredirtransfer *transfer[MAX_TRANSFER_COUNT];

};

struct usbredirhost {

    struct usbredirparser *parser;

    void *lock;

    void *disconnect_lock;

    usbredirparser_log log_func;

    usbredirparser_read read_func;

    usbredirparser_write write_func;

    usbredirhost_flush_writes flush_writes_func;

    usbredirhost_buffered_output_size buffered_output_size_func;

    void *func_priv;

    int verbose;

    libusb_context *ctx;

    libusb_device *dev;

    libusb_device_handle *handle;

    struct libusb_device_descriptor desc;

    struct libusb_config_descriptor *config;

    int quirks;

    int restore_config;

    int claimed;

    int reset;

    int disconnected;

    int read_status;

    int cancels_pending;

    int wait_disconnect;

    int connect_pending;

    struct usbredirhost_ep endpoint[MAX_ENDPOINTS];

    uint8_t alt_setting[MAX_INTERFACES];

    struct usbredirtransfer transfers_head;

    struct usbredirfilter_rule *filter_rules;

    int filter_rules_count;

    struct {

        uint64_t higher;

        uint64_t lower;

        bool dropping;

    } iso_threshold;

};

struct usbredirhost_dev_ids {

    int vendor_id;

    int product_id;

};

static const struct usbredirhost_dev_ids usbredirhost_reset_blacklist[] = {

    { 0x1210, 0x001c },

    { 0x2798, 0x0001 },

    { -1, -1 } /* Terminating Entry */

};

static void

#if defined __GNUC__

__attribute__((format(printf, 3, 4)))

#endif

va_log(struct usbredirhost *host, int level, const char *fmt, ...)

{

    char buf[512];

    va_list ap;

    int n;

    if (level > host->verbose) {

        return;

    }

    n = sprintf(buf, "usbredirhost: ");

    va_start(ap, fmt);

    vsnprintf(buf + n, sizeof(buf) - n, fmt, ap);

    va_end(ap);

    host->log_func(host->func_priv, level, buf);

}

#ifdef ERROR /* defined on WIN32 */

#undef ERROR

#endif

#define ERROR(...)   va_log(host, usbredirparser_error, __VA_ARGS__)

#define WARNING(...) va_log(host, usbredirparser_warning, __VA_ARGS__)

#define INFO(...)    va_log(host, usbredirparser_info, __VA_ARGS__)

#define DEBUG(...)   va_log(host, usbredirparser_debug, __VA_ARGS__)

static void usbredirhost_hello(void *priv, struct usb_redir_hello_header *h);

static void usbredirhost_reset(void *priv);

static void usbredirhost_set_configuration(void *priv, uint64_t id,

    struct usb_redir_set_configuration_header *set_configuration);

static void usbredirhost_get_configuration(void *priv, uint64_t id);

static void usbredirhost_set_alt_setting(void *priv, uint64_t id,

    struct usb_redir_set_alt_setting_header *set_alt_setting);

static void usbredirhost_get_alt_setting(void *priv, uint64_t id,

    struct usb_redir_get_alt_setting_header *get_alt_setting);

static void usbredirhost_start_iso_stream(void *priv, uint64_t id,

    struct usb_redir_start_iso_stream_header *start_iso_stream);

static void usbredirhost_stop_iso_stream(void *priv, uint64_t id,

    struct usb_redir_stop_iso_stream_header *stop_iso_stream);

static void usbredirhost_start_interrupt_receiving(void *priv, uint64_t id,

    struct usb_redir_start_interrupt_receiving_header *start_interrupt_receiving);

static void usbredirhost_stop_interrupt_receiving(void *priv, uint64_t id,

    struct usb_redir_stop_interrupt_receiving_header *stop_interrupt_receiving);

static void usbredirhost_alloc_bulk_streams(void *priv, uint64_t id,

    struct usb_redir_alloc_bulk_streams_header *alloc_bulk_streams);

static void usbredirhost_free_bulk_streams(void *priv, uint64_t id,

    struct usb_redir_free_bulk_streams_header *free_bulk_streams);

static void usbredirhost_cancel_data_packet(void *priv, uint64_t id);

static void usbredirhost_filter_reject(void *priv);

static void usbredirhost_filter_filter(void *priv,

    struct usbredirfilter_rule *rules, int rules_count);

static void usbredirhost_device_disconnect_ack(void *priv);

static void usbredirhost_start_bulk_receiving(void *priv, uint64_t id,

    struct usb_redir_start_bulk_receiving_header *start_bulk_receiving);

static void usbredirhost_stop_bulk_receiving(void *priv, uint64_t id,

    struct usb_redir_stop_bulk_receiving_header *stop_bulk_receiving);

static void usbredirhost_control_packet(void *priv, uint64_t id,

    struct usb_redir_control_packet_header *control_packet,

    uint8_t *data, int data_len);

static void usbredirhost_bulk_packet(void *priv, uint64_t id,

    struct usb_redir_bulk_packet_header *bulk_packet,

    uint8_t *data, int data_len);

static void usbredirhost_iso_packet(void *priv, uint64_t id,

    struct usb_redir_iso_packet_header *iso_packet,

    uint8_t *data, int data_len);

static void usbredirhost_interrupt_packet(void *priv, uint64_t id,

    struct usb_redir_interrupt_packet_header *interrupt_packet,

    uint8_t *data, int data_len);

static void LIBUSB_CALL usbredirhost_iso_packet_complete(

    struct libusb_transfer *libusb_transfer);

static void LIBUSB_CALL usbredirhost_buffered_packet_complete(

    struct libusb_transfer *libusb_transfer);

static int usbredirhost_cancel_pending_urbs(struct usbredirhost *host,

                                            int notify_guest);

static void usbredirhost_wait_for_cancel_completion(struct usbredirhost *host);

static void usbredirhost_clear_device(struct usbredirhost *host);

static void usbredirhost_log(void *priv, int level, const char *msg)

{

    struct usbredirhost *host = priv;

    host->log_func(host->func_priv, level, msg);

}

static int usbredirhost_read(void *priv, uint8_t *data, int count)

{

    struct usbredirhost *host = priv;

    if (host->read_status) {

        int ret = host->read_status;

        host->read_status = 0;

        return ret;

    }

    return host->read_func(host->func_priv, data, count);

}

static int usbredirhost_write(void *priv, uint8_t *data, int count)

{

    struct usbredirhost *host = priv;

    return host->write_func(host->func_priv, data, count);

}

/* Can be called both from parser read callbacks as well as from libusb

   packet completion callbacks */

static void usbredirhost_handle_disconnect(struct usbredirhost *host)

{

    /* Disconnect uses its own lock to avoid needing nesting capable locks */

    if (host->disconnect_lock) {

        host->parser->lock_func(host->disconnect_lock);

    }

    if (!host->disconnected) {

        INFO("device disconnected");

        usbredirparser_send_device_disconnect(host->parser);

        if (usbredirparser_peer_has_cap(host->parser,

                                        usb_redir_cap_device_disconnect_ack))

            host->wait_disconnect = 1;

        host->disconnected = 1;

    }

    if (host->disconnect_lock) {

        host->parser->unlock_func(host->disconnect_lock);

    }

}

/* One function to convert either a transfer status code, or a libusb error

   code to a usb_redir status. We handle both in one conversion function so

   that we can pass error codes as status codes to the completion handler

   in case of submission error (the codes don't overlap), using the completion

   handler to report back the status and cleanup as it would on completion of

   a successfully submitted transfer. */

static int libusb_status_or_error_to_redir_status(struct usbredirhost *host,

                                                  int status)

{

    switch (status) {

        case LIBUSB_TRANSFER_COMPLETED:

            return usb_redir_success;

        case LIBUSB_TRANSFER_ERROR:

            return usb_redir_ioerror;

        case LIBUSB_TRANSFER_TIMED_OUT:

            return usb_redir_timeout;

        case LIBUSB_TRANSFER_CANCELLED:

            return usb_redir_cancelled;

        case LIBUSB_TRANSFER_STALL:

            return usb_redir_stall;

        case LIBUSB_TRANSFER_NO_DEVICE:

            usbredirhost_handle_disconnect(host);

            return usb_redir_ioerror;

        case LIBUSB_TRANSFER_OVERFLOW:

            return usb_redir_babble;

        case LIBUSB_ERROR_INVALID_PARAM:

            return usb_redir_inval;

        case LIBUSB_ERROR_NO_DEVICE:

            usbredirhost_handle_disconnect(host);

            return usb_redir_ioerror;

        case LIBUSB_ERROR_TIMEOUT:

            return usb_redir_timeout;

        default:

            return usb_redir_ioerror;

    }

}

static void usbredirhost_set_max_packetsize(struct usbredirhost *host,

    uint8_t ep, uint16_t wMaxPacketSize)

{

    int maxp, mult = 1;

    maxp = wMaxPacketSize & 0x7ff;

    if (libusb_get_device_speed(host->dev) == LIBUSB_SPEED_HIGH &&

             host->endpoint[EP2I(ep)].type == usb_redir_type_iso) {

        switch ((wMaxPacketSize >> 11) & 3) {

        case 1:  mult = 2; break;

        case 2:  mult = 3; break;

        default: mult = 1; break;

        }

    }

    host->endpoint[EP2I(ep)].max_packetsize = maxp * mult;

}

static void usbredirhost_set_max_streams(struct usbredirhost *host,

    const struct libusb_endpoint_descriptor *endp)

{

#if LIBUSBX_API_VERSION >= 0x01000102

    struct libusb_ss_endpoint_companion_descriptor *endp_ss_comp;

    int max_streams, i = EP2I(endp->bEndpointAddress);

    host->endpoint[i].max_streams = 0;

    if (host->endpoint[i].type == usb_redir_type_bulk &&

            libusb_get_ss_endpoint_companion_descriptor(host->ctx, endp,

                &endp_ss_comp) == LIBUSB_SUCCESS) {

        max_streams = endp_ss_comp->bmAttributes & 0x1f;

        if (max_streams)

            host->endpoint[i].max_streams = 1 << max_streams;

        libusb_free_ss_endpoint_companion_descriptor(endp_ss_comp);

    }

#endif

}

/* Called from open/close and parser read callbacks */

static void usbredirhost_send_interface_n_ep_info(struct usbredirhost *host)

{

    int i;

    const struct libusb_interface_descriptor *intf_desc;

    struct usb_redir_ep_info_header ep_info;

    struct usb_redir_interface_info_header interface_info = { 0, };

    if (host->config)

        interface_info.interface_count = host->config->bNumInterfaces;

    for (i = 0; i < interface_info.interface_count; i++) {

        intf_desc =

            &host->config->interface[i].altsetting[host->alt_setting[i]];

        interface_info.interface[i] = intf_desc->bInterfaceNumber;

        interface_info.interface_class[i] = intf_desc->bInterfaceClass;

        interface_info.interface_subclass[i] = intf_desc->bInterfaceSubClass;

        interface_info.interface_protocol[i] = intf_desc->bInterfaceProtocol;

    }

    usbredirparser_send_interface_info(host->parser, &interface_info);

    for (i = 0; i < MAX_ENDPOINTS; i++) {

        ep_info.type[i] = host->endpoint[i].type;

        ep_info.interval[i] = host->endpoint[i].interval;

        ep_info.interface[i] = host->endpoint[i].interface;

        ep_info.max_packet_size[i] = host->endpoint[i].max_packetsize;

        ep_info.max_streams[i] = host->endpoint[i].max_streams;

    }

    usbredirparser_send_ep_info(host->parser, &ep_info);

}

/* Called from open/close and parser read callbacks */

static void usbredirhost_send_device_connect(struct usbredirhost *host)

{

    struct usb_redir_device_connect_header device_connect;

    enum libusb_speed speed;

    if (!host->disconnected) {

        ERROR("internal error sending device_connect but already connected");

        return;

    }

    if (!usbredirparser_have_peer_caps(host->parser) ||

            host->wait_disconnect) {

        host->connect_pending = 1;

        return;

    }

    speed = libusb_get_device_speed(host->dev);

    switch (speed) {

    case LIBUSB_SPEED_LOW:

        device_connect.speed = usb_redir_speed_low; break;

    case LIBUSB_SPEED_FULL:

        device_connect.speed = usb_redir_speed_full; break;

    case LIBUSB_SPEED_HIGH:

        device_connect.speed = usb_redir_speed_high; break;

    case LIBUSB_SPEED_SUPER:

        device_connect.speed = usb_redir_speed_super; break;

    default:

        device_connect.speed = usb_redir_speed_unknown;

    }

    device_connect.device_class = host->desc.bDeviceClass;

    device_connect.device_subclass = host->desc.bDeviceSubClass;

    device_connect.device_protocol = host->desc.bDeviceProtocol;

    device_connect.vendor_id = host->desc.idVendor;

    device_connect.product_id = host->desc.idProduct;

    device_connect.device_version_bcd = host->desc.bcdDevice;

    usbredirhost_send_interface_n_ep_info(host);

    usbredirparser_send_device_connect(host->parser, &device_connect);

    host->connect_pending = 0;

    host->disconnected = 0; /* The guest may now use the device */

    FLUSH(host);

}

/* Called from open/close and parser read callbacks */

static void usbredirhost_parse_interface(struct usbredirhost *host, int i)

{

    int j;

    const struct libusb_interface_descriptor *intf_desc;

    uint8_t ep_address;

    intf_desc =

        &host->config->interface[i].altsetting[host->alt_setting[i]];

    for (j = 0; j < intf_desc->bNumEndpoints; j++) {

        ep_address = intf_desc->endpoint[j].bEndpointAddress;

        host->endpoint[EP2I(ep_address)].type =

            intf_desc->endpoint[j].bmAttributes & LIBUSB_TRANSFER_TYPE_MASK;

        host->endpoint[EP2I(ep_address)].interval =

            intf_desc->endpoint[j].bInterval;

        host->endpoint[EP2I(ep_address)].interface =

            intf_desc->bInterfaceNumber;

        usbredirhost_set_max_packetsize(host, ep_address,

                                        intf_desc->endpoint[j].wMaxPacketSize);

        usbredirhost_set_max_streams(host, &intf_desc->endpoint[j]);

        host->endpoint[EP2I(ep_address)].warn_on_drop = 1;

    }

}

static void usbredirhost_parse_config(struct usbredirhost *host)

{

    int i;

    for (i = 0; i < MAX_ENDPOINTS; i++) {

        if ((i & 0x0f) == 0) {

            host->endpoint[i].type = usb_redir_type_control;

        } else {

            host->endpoint[i].type = usb_redir_type_invalid;

        }

        host->endpoint[i].interval = 0;

        host->endpoint[i].interface = 0;

        host->endpoint[i].max_packetsize = 0;

        host->endpoint[i].max_streams = 0;

    }

    for (i = 0; host->config && i < host->config->bNumInterfaces; i++) {

        usbredirhost_parse_interface(host, i);

    }

}

/* Called from open/close and parser read callbacks */

static int usbredirhost_claim(struct usbredirhost *host, int initial_claim)

{

    int i, n, r;

    if (host->config) {

        libusb_free_config_descriptor(host->config);

        host->config = NULL;

    }

    r = libusb_get_device_descriptor(host->dev, &host->desc);

    if (r < 0) {

        ERROR("could not get device descriptor: %s", libusb_error_name(r));

        return libusb_status_or_error_to_redir_status(host, r);

    }

    r = libusb_get_active_config_descriptor(host->dev, &host->config);

    if (r < 0 && r != LIBUSB_ERROR_NOT_FOUND) {

        ERROR("could not get descriptors for active configuration: %s",

              libusb_error_name(r));

        return libusb_status_or_error_to_redir_status(host, r);

    }

    if (host->config && host->config->bNumInterfaces > MAX_INTERFACES) {

        ERROR("usb decriptor has too much intefaces (%d > %d)",

              (int)host->config->bNumInterfaces, MAX_INTERFACES);

        return usb_redir_ioerror;

    }

    if (initial_claim) {

        if (host->config)

            host->restore_config = host->config->bConfigurationValue;

        else

            host->restore_config = -1; /* unconfigured */

        /* If the device is unconfigured and has only 1 config, we assume

           this is the result of the user doing "safely remove hardware",

           and we try to reset the device configuration to this config when

           we release the device, so that it becomes usable again. */

        if (host->restore_config == -1 && host->desc.bNumConfigurations == 1) {

            struct libusb_config_descriptor *config;

            r = libusb_get_config_descriptor(host->dev, 0, &config);

            if (r == 0) {

                host->restore_config = config->bConfigurationValue;

                libusb_free_config_descriptor(config);

            }

        }

    }

    /* All interfaces begin at alt setting 0 when (re)claimed */

    memset(host->alt_setting, 0, MAX_INTERFACES);

    host->claimed = 1;

#if LIBUSBX_API_VERSION >= 0x01000102

    libusb_set_auto_detach_kernel_driver(host->handle, 1);

#endif

    for (i = 0; host->config && i < host->config->bNumInterfaces; i++) {

        n = host->config->interface[i].altsetting[0].bInterfaceNumber;

#if LIBUSBX_API_VERSION < 0x01000102

        r = libusb_detach_kernel_driver(host->handle, n);

        if (r < 0 && r != LIBUSB_ERROR_NOT_FOUND

                  && r != LIBUSB_ERROR_NOT_SUPPORTED) {

            ERROR("could not detach driver from interface %d (configuration %d): %s",

                  n, host->config->bConfigurationValue, libusb_error_name(r));

            return libusb_status_or_error_to_redir_status(host, r);

        }

#endif

        r = libusb_claim_interface(host->handle, n);

        if (r < 0) {

            if (r == LIBUSB_ERROR_BUSY)

                ERROR("Device is in use by another application");

            else

                ERROR("could not claim interface %d (configuration %d): %s",

                      n, host->config->bConfigurationValue,

                      libusb_error_name(r));

            return libusb_status_or_error_to_redir_status(host, r);

        }

    }

    usbredirhost_parse_config(host);

    return usb_redir_success;

}

/* Called from open/close and parser read callbacks */

static void usbredirhost_release(struct usbredirhost *host, int attach_drivers)

{

    int i, n, r, current_config = -1;

    if (!host->claimed)

        return;

#if LIBUSBX_API_VERSION >= 0x01000102

    /* We want to always do the attach ourselves because:

       1) For compound interfaces such as usb-audio we must first release all

          interfaces before we can attach the driver;

       2) When releasing interfaces before calling libusb_set_configuration,

          we don't want the kernel driver to get attached (our attach_drivers

          parameter is 0 in this case). */

    libusb_set_auto_detach_kernel_driver(host->handle, 0);

#endif

    for (i = 0; host->config && i < host->config->bNumInterfaces; i++) {

        n = host->config->interface[i].altsetting[0].bInterfaceNumber;

        r = libusb_release_interface(host->handle, n);

        if (r < 0 && r != LIBUSB_ERROR_NOT_FOUND

                  && r != LIBUSB_ERROR_NO_DEVICE) {

            ERROR("could not release interface %d (configuration %d): %s",

                  n, host->config->bConfigurationValue, libusb_error_name(r));

        }

    }

    if (!attach_drivers)

        return;

    host->claimed = 0;

    /* reset the device before re-binding the kernel drivers, so that the

       kernel drivers get the device in a clean state. */

    if (!(host->quirks & QUIRK_DO_NOT_RESET)) {

        r = libusb_reset_device(host->handle);

        if (r != 0) {

            /* if we're releasing the device because it was removed, resetting

             * will fail. Don't print a warning in this situation */

            if (r != LIBUSB_ERROR_NO_DEVICE) {

                ERROR("error resetting device: %s", libusb_error_name(r));

            }

            return;

        }

    }

    if (host->config)

        current_config = host->config->bConfigurationValue;

    if (current_config != host->restore_config) {

        r = libusb_set_configuration(host->handle, host->restore_config);

        if (r < 0)

            ERROR("could not restore configuration to %d: %s",

                  host->restore_config, libusb_error_name(r));

        return; /* set_config automatically binds drivers for the new config */

    }

    for (i = 0; host->config && i < host->config->bNumInterfaces; i++) {

        n = host->config->interface[i].altsetting[0].bInterfaceNumber;

        r = libusb_attach_kernel_driver(host->handle, n);

        if (r < 0 && r != LIBUSB_ERROR_NOT_FOUND /* No driver */

                  && r != LIBUSB_ERROR_NO_DEVICE /* Device unplugged */

                  && r != LIBUSB_ERROR_NOT_SUPPORTED /* Not supported */

                  && r != LIBUSB_ERROR_BUSY /* driver rebound already */) {

            ERROR("could not re-attach driver to interface %d (configuration %d): %s",

                  n, host->config->bConfigurationValue, libusb_error_name(r));

        }

    }

}

struct usbredirhost *usbredirhost_open(

    libusb_context *usb_ctx,

    libusb_device_handle *usb_dev_handle,

    usbredirparser_log log_func,

    usbredirparser_read  read_guest_data_func,

    usbredirparser_write write_guest_data_func,

    void *func_priv, const char *version, int verbose, int flags)

{

    return usbredirhost_open_full(usb_ctx, usb_dev_handle, log_func,

                                  read_guest_data_func, write_guest_data_func,

                                  NULL, NULL, NULL, NULL, NULL,

                                  func_priv, version, verbose, flags);

}

struct usbredirhost *usbredirhost_open_full(

    libusb_context *usb_ctx,

    libusb_device_handle *usb_dev_handle,

    usbredirparser_log log_func,

    usbredirparser_read  read_guest_data_func,

    usbredirparser_write write_guest_data_func,

    usbredirhost_flush_writes flush_writes_func,

    usbredirparser_alloc_lock alloc_lock_func,

    usbredirparser_lock lock_func,

    usbredirparser_unlock unlock_func,

    usbredirparser_free_lock free_lock_func,

    void *func_priv, const char *version, int verbose, int flags)

{

    struct usbredirhost *host;

    int parser_flags = usbredirparser_fl_usb_host;

    uint32_t caps[USB_REDIR_CAPS_SIZE] = { 0, };

    host = calloc(1, sizeof(*host));

    if (!host) {

        log_func(func_priv, usbredirparser_error,

            "usbredirhost error: Out of memory allocating usbredirhost");

        libusb_close(usb_dev_handle);

        return NULL;

    }

    host->ctx = usb_ctx;

    host->log_func = log_func;

    host->read_func = read_guest_data_func;

    host->write_func = write_guest_data_func;

    host->flush_writes_func = flush_writes_func;

    host->func_priv = func_priv;

    host->verbose = verbose;

    host->disconnected = 1; /* No device is connected initially */

    host->parser = usbredirparser_create();

    if (!host->parser) {

        log_func(func_priv, usbredirparser_error,

            "usbredirhost error: Out of memory allocating usbredirparser");

        usbredirhost_close(host);

        return NULL;

    }

    host->parser->priv = host;

    host->parser->log_func = usbredirhost_log;

    host->parser->read_func = usbredirhost_read;

    host->parser->write_func = usbredirhost_write;

    host->parser->hello_func = usbredirhost_hello;

    host->parser->reset_func = usbredirhost_reset;

    host->parser->set_configuration_func = usbredirhost_set_configuration;

    host->parser->get_configuration_func = usbredirhost_get_configuration;

    host->parser->set_alt_setting_func = usbredirhost_set_alt_setting;

    host->parser->get_alt_setting_func = usbredirhost_get_alt_setting;

    host->parser->start_iso_stream_func = usbredirhost_start_iso_stream;

    host->parser->stop_iso_stream_func = usbredirhost_stop_iso_stream;

    host->parser->start_interrupt_receiving_func =

        usbredirhost_start_interrupt_receiving;

    host->parser->stop_interrupt_receiving_func =

        usbredirhost_stop_interrupt_receiving;

    host->parser->alloc_bulk_streams_func = usbredirhost_alloc_bulk_streams;

    host->parser->free_bulk_streams_func = usbredirhost_free_bulk_streams;

    host->parser->cancel_data_packet_func = usbredirhost_cancel_data_packet;

    host->parser->filter_reject_func = usbredirhost_filter_reject;

    host->parser->filter_filter_func = usbredirhost_filter_filter;

    host->parser->device_disconnect_ack_func =

        usbredirhost_device_disconnect_ack;

    host->parser->start_bulk_receiving_func =

        usbredirhost_start_bulk_receiving;

    host->parser->stop_bulk_receiving_func =

        usbredirhost_stop_bulk_receiving;

    host->parser->control_packet_func = usbredirhost_control_packet;

    host->parser->bulk_packet_func = usbredirhost_bulk_packet;

    host->parser->iso_packet_func = usbredirhost_iso_packet;

    host->parser->interrupt_packet_func = usbredirhost_interrupt_packet;

    host->parser->alloc_lock_func = alloc_lock_func;

    host->parser->lock_func = lock_func;

    host->parser->unlock_func = unlock_func;

    host->parser->free_lock_func = free_lock_func;

    if (host->parser->alloc_lock_func) {

        host->lock = host->parser->alloc_lock_func();

        host->disconnect_lock = host->parser->alloc_lock_func();

    }

    if (flags & usbredirhost_fl_write_cb_owns_buffer) {

        parser_flags |= usbredirparser_fl_write_cb_owns_buffer;

    }

    usbredirparser_caps_set_cap(caps, usb_redir_cap_connect_device_version);

    usbredirparser_caps_set_cap(caps, usb_redir_cap_filter);

    usbredirparser_caps_set_cap(caps, usb_redir_cap_device_disconnect_ack);

    usbredirparser_caps_set_cap(caps, usb_redir_cap_ep_info_max_packet_size);

    usbredirparser_caps_set_cap(caps, usb_redir_cap_64bits_ids);

    usbredirparser_caps_set_cap(caps, usb_redir_cap_32bits_bulk_length);

    usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_receiving);

#if LIBUSBX_API_VERSION >= 0x01000103

    usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_streams);

#endif

    usbredirparser_init(host->parser, version, caps, USB_REDIR_CAPS_SIZE,

                        parser_flags);

#if LIBUSB_API_VERSION >= 0x01000106

    libusb_set_option(host->ctx, LIBUSB_OPTION_LOG_LEVEL, host->verbose);

#else

    libusb_set_debug(host->ctx, host->verbose);

#endif

    if (usbredirhost_set_device(host, usb_dev_handle) != usb_redir_success) {

        usbredirhost_close(host);

        return NULL;

    }

    FLUSH(host);

    return host;

}

void usbredirhost_close(struct usbredirhost *host)

{

    usbredirhost_clear_device(host);

    if (host->lock) {

        host->parser->free_lock_func(host->lock);

    }

    if (host->disconnect_lock) {

        host->parser->free_lock_func(host->disconnect_lock);

    }

    if (host->parser) {

        usbredirparser_destroy(host->parser);

    }

    free(host->filter_rules);

    free(host);

}

static int usbredirhost_reset_device(struct usbredirhost *host)

{

    int r;

    if (host->quirks & QUIRK_DO_NOT_RESET) {

        return 0;

    }

    r = libusb_reset_device(host->handle);

    if (r != 0) {

        ERROR("error resetting device: %s", libusb_error_name(r));

        usbredirhost_clear_device(host);

        return r;

    }

    host->reset = 1;

    return 0;

}

int usbredirhost_set_device(struct usbredirhost *host,

                             libusb_device_handle *usb_dev_handle)

{

    int i, r, status;

    usbredirhost_clear_device(host);

    if (!usb_dev_handle)

        return usb_redir_success;

    host->dev = libusb_get_device(usb_dev_handle);

    host->handle = usb_dev_handle;

    status = usbredirhost_claim(host, 1);

    if (status != usb_redir_success) {

        usbredirhost_clear_device(host);

        return status;

    }

    for (i = 0; usbredirhost_reset_blacklist[i].vendor_id != -1; i++) {

        if (host->desc.idVendor == usbredirhost_reset_blacklist[i].vendor_id &&

            host->desc.idProduct ==

                                usbredirhost_reset_blacklist[i].product_id) {

            host->quirks |= QUIRK_DO_NOT_RESET;

            break;

        }

    }

    /* The first thing almost any usb-guest does is a (slow) device-reset

       so lets do that before hand */

    r = usbredirhost_reset_device(host);

    if (r != 0) {

        return libusb_status_or_error_to_redir_status(host, r);

    }

    usbredirhost_send_device_connect(host);

    return usb_redir_success;

}

static void usbredirhost_clear_device(struct usbredirhost *host)

{

    if (!host->dev)

        return;

    if (usbredirhost_cancel_pending_urbs(host, 0))

        usbredirhost_wait_for_cancel_completion(host);

    usbredirhost_release(host, 1);

    if (host->config) {

        libusb_free_config_descriptor(host->config);

        host->config = NULL;

    }

    if (host->handle) {

        libusb_close(host->handle);

        host->handle = NULL;

    }

    host->connect_pending = 0;

    host->quirks = 0;

    host->dev = NULL;

    usbredirhost_handle_disconnect(host);

    FLUSH(host);

}

int usbredirhost_read_guest_data(struct usbredirhost *host)

{

    return usbredirparser_do_read(host->parser);

}

int usbredirhost_has_data_to_write(struct usbredirhost *host)

{

    return usbredirparser_has_data_to_write(host->parser);

}