/* usbredirparser.c usb redirection protocol parser

   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 <string.h>

#include "usbredirproto-compat.h"

#include "usbredirparser.h"

#include "usbredirfilter.h"

/* Put *some* upper limit on bulk transfer sizes */

#define MAX_BULK_TRANSFER_SIZE (128u * 1024u * 1024u)

/* Locking convenience macros */

#define LOCK(parser) \

    do { \

        if ((parser)->lock) \

            (parser)->callb.lock_func((parser)->lock); \

    } while (0)

#define UNLOCK(parser) \

    do { \

        if ((parser)->lock) \

            (parser)->callb.unlock_func((parser)->lock); \

    } while (0)

struct usbredirparser_buf {

    uint8_t *buf;

    int pos;

    int len;

    struct usbredirparser_buf *next;

};

struct usbredirparser_priv {

    struct usbredirparser callb;

    int flags;

    int have_peer_caps;

    uint32_t our_caps[USB_REDIR_CAPS_SIZE];

    uint32_t peer_caps[USB_REDIR_CAPS_SIZE];

    void *lock;

    union {

        struct usb_redir_header header;

        struct usb_redir_header_32bit_id header_32bit_id;

    };

    uint8_t type_header[288];

    int header_read;

    int type_header_len;

    int type_header_read;

    uint8_t *data;

    int data_len;

    int data_read;

    int to_skip;

    struct usbredirparser_buf *write_buf;

    int write_buf_count;

};

static void

#if defined __GNUC__

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

#endif

va_log(struct usbredirparser_priv *parser, int verbose, const char *fmt, ...)

{

    char buf[512];

    va_list ap;

    int n;

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

    va_start(ap, fmt);

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

    va_end(ap);

    parser->callb.log_func(parser->callb.priv, verbose, buf);

}

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

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

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

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

#if 0 /* Can be enabled and called from random place to test serialization */

static void serialize_test(struct usbredirparser *parser_pub)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    struct usbredirparser_buf *wbuf, *next_wbuf;

    uint8_t *data;

    int len;

    if (usbredirparser_serialize(parser_pub, &data, &len))

        return;

    wbuf = parser->write_buf;

    while (wbuf) {

        next_wbuf = wbuf->next;

        free(wbuf->buf);

        free(wbuf);

        wbuf = next_wbuf;

    }

    parser->write_buf = NULL;

    parser->write_buf_count = 0;

    free(parser->data);

    parser->data = NULL;

    parser->type_header_len = parser->data_len = parser->have_peer_caps = 0;

    usbredirparser_unserialize(parser_pub, data, len);

    free(data);

}

#endif

static void usbredirparser_queue(struct usbredirparser *parser, uint32_t type,

    uint64_t id, void *type_header_in, uint8_t *data_in, int data_len);

static int usbredirparser_caps_get_cap(struct usbredirparser_priv *parser,

    uint32_t *caps, int cap);

struct usbredirparser *usbredirparser_create(void)

{

    return calloc(1, sizeof(struct usbredirparser_priv));

}

static void usbredirparser_verify_caps(struct usbredirparser_priv *parser,

    uint32_t *caps, const char *desc)

{

    if (usbredirparser_caps_get_cap(parser, caps,

                                    usb_redir_cap_bulk_streams) &&

        !usbredirparser_caps_get_cap(parser, caps,

                                     usb_redir_cap_ep_info_max_packet_size)) {

        ERROR("error %s caps contains cap_bulk_streams without"

              "cap_ep_info_max_packet_size", desc);

        caps[0] &= ~(1 << usb_redir_cap_bulk_streams);

    }

}

void usbredirparser_init(struct usbredirparser *parser_pub,

    const char *version, uint32_t *caps, int caps_len, int flags)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    struct usb_redir_hello_header hello = { { 0 }, };

    parser->flags = (flags & ~usbredirparser_fl_no_hello);

    if (parser->callb.alloc_lock_func) {

        parser->lock = parser->callb.alloc_lock_func();

    }

    snprintf(hello.version, sizeof(hello.version), "%s", version);

    if (caps_len > USB_REDIR_CAPS_SIZE) {

        caps_len = USB_REDIR_CAPS_SIZE;

    }

    memcpy(parser->our_caps, caps, caps_len * sizeof(uint32_t));

    /* libusbredirparser handles sending the ack internally */

    if (!(flags & usbredirparser_fl_usb_host))

        usbredirparser_caps_set_cap(parser->our_caps,

                                    usb_redir_cap_device_disconnect_ack);

    usbredirparser_verify_caps(parser, parser->our_caps, "our");

    if (!(flags & usbredirparser_fl_no_hello))

        usbredirparser_queue(parser_pub, usb_redir_hello, 0, &hello,

                             (uint8_t *)parser->our_caps,

                             USB_REDIR_CAPS_SIZE * sizeof(uint32_t));

}

void usbredirparser_destroy(struct usbredirparser *parser_pub)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    struct usbredirparser_buf *wbuf, *next_wbuf;

    wbuf = parser->write_buf;

    while (wbuf) {

        next_wbuf = wbuf->next;

        free(wbuf->buf);

        free(wbuf);

        wbuf = next_wbuf;

    }

    if (parser->lock)

        parser->callb.free_lock_func(parser->lock);

    free(parser);

}

static int usbredirparser_caps_get_cap(struct usbredirparser_priv *parser,

    uint32_t *caps, int cap)

{

    if (cap / 32 >= USB_REDIR_CAPS_SIZE) {

        ERROR("error request for out of bounds cap: %d", cap);

        return 0;

    }

    if (caps[cap / 32] & (1 << (cap % 32))) {

        return 1;

    } else {

        return 0;

    }

}

void usbredirparser_caps_set_cap(uint32_t *caps, int cap)

{

    caps[cap / 32] |= 1 << (cap % 32);

}

int usbredirparser_have_peer_caps(struct usbredirparser *parser_pub)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    return parser->have_peer_caps;

}

int usbredirparser_peer_has_cap(struct usbredirparser *parser_pub, int cap)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    return usbredirparser_caps_get_cap(parser, parser->peer_caps, cap);

}

int usbredirparser_have_cap(struct usbredirparser *parser_pub, int cap)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    return usbredirparser_caps_get_cap(parser, parser->our_caps, cap);

}

static int usbredirparser_using_32bits_ids(struct usbredirparser *parser_pub)

{

    return !usbredirparser_have_cap(parser_pub, usb_redir_cap_64bits_ids) ||

           !usbredirparser_peer_has_cap(parser_pub, usb_redir_cap_64bits_ids);

}

static void usbredirparser_handle_hello(struct usbredirparser *parser_pub,

    struct usb_redir_hello_header *hello, uint8_t *data, int data_len)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    uint32_t *peer_caps = (uint32_t *)data;

    char buf[64];

    int i;

    if (parser->have_peer_caps) {

        ERROR("Received second hello message, ignoring");

        return;

    }

    /* In case hello->version is not 0 terminated (which would be a protocol

       violation)_ */

    strncpy(buf, hello->version, sizeof(buf));

    buf[sizeof(buf)-1] = '\0';

    memset(parser->peer_caps, 0, sizeof(parser->peer_caps));

    if (data_len > sizeof(parser->peer_caps)) {

        data_len = sizeof(parser->peer_caps);

    }

    for (i = 0; i < data_len / sizeof(uint32_t); i++) {

        parser->peer_caps[i] = peer_caps[i];

    }

    usbredirparser_verify_caps(parser, parser->peer_caps, "peer");

    parser->have_peer_caps = 1;

    free(data);

    INFO("Peer version: %s, using %d-bits ids", buf,

         usbredirparser_using_32bits_ids(parser_pub) ? 32 : 64);

    /* Added in 0.3.2, so no guarantee it is there */

    if (parser->callb.hello_func)

        parser->callb.hello_func(parser->callb.priv, hello);

}

static int usbredirparser_get_header_len(struct usbredirparser *parser_pub)

{

    if (usbredirparser_using_32bits_ids(parser_pub))

        return sizeof(struct usb_redir_header_32bit_id);

    else

        return sizeof(struct usb_redir_header);

}

static int usbredirparser_get_type_header_len(

    struct usbredirparser *parser_pub, int32_t type, int send)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    int command_for_host = 0;

    if (parser->flags & usbredirparser_fl_usb_host) {

        command_for_host = 1;

    }

    if (send) {

        command_for_host = !command_for_host;

    }

    switch (type) {

    case usb_redir_hello:

        return sizeof(struct usb_redir_hello_header);

    case usb_redir_device_connect:

        if (!command_for_host) {

            if (usbredirparser_have_cap(parser_pub,

                                    usb_redir_cap_connect_device_version) &&

                usbredirparser_peer_has_cap(parser_pub,

                                    usb_redir_cap_connect_device_version)) {

                return sizeof(struct usb_redir_device_connect_header);

            } else {

                return sizeof(struct usb_redir_device_connect_header_no_device_version);

            }

        } else {

            return -1;

        }

    case usb_redir_device_disconnect:

        if (!command_for_host) {

            return 0;

        } else {

            return -1;

        }

    case usb_redir_reset:

        if (command_for_host) {

            return 0; /* No packet type specific header */

        } else {

            return -1;

        }

    case usb_redir_interface_info:

        if (!command_for_host) {

            return sizeof(struct usb_redir_interface_info_header);

        } else {

            return -1;

        }

    case usb_redir_ep_info:

        if (!command_for_host) {

            if (usbredirparser_have_cap(parser_pub,

                                    usb_redir_cap_bulk_streams) &&

                usbredirparser_peer_has_cap(parser_pub,

                                    usb_redir_cap_bulk_streams)) {

                return sizeof(struct usb_redir_ep_info_header);

            } else if (usbredirparser_have_cap(parser_pub,

                                    usb_redir_cap_ep_info_max_packet_size) &&

                       usbredirparser_peer_has_cap(parser_pub,

                                    usb_redir_cap_ep_info_max_packet_size)) {

                return sizeof(struct usb_redir_ep_info_header_no_max_streams);

            } else {

                return sizeof(struct usb_redir_ep_info_header_no_max_pktsz);

            }

        } else {

            return -1;

        }

    case usb_redir_set_configuration:

        if (command_for_host) {

            return sizeof(struct usb_redir_set_configuration_header);

        } else {

            return -1; /* Should never be send to a guest */

        }

    case usb_redir_get_configuration:

        if (command_for_host) {

            return 0; /* No packet type specific header */

        } else {

            return -1;

        }

    case usb_redir_configuration_status:

        if (!command_for_host) {

            return sizeof(struct usb_redir_configuration_status_header);

        } else {

            return -1;

        }

    case usb_redir_set_alt_setting:

        if (command_for_host) {

            return sizeof(struct usb_redir_set_alt_setting_header);

        } else {

            return -1;

        }

    case usb_redir_get_alt_setting:

        if (command_for_host) {

            return sizeof(struct usb_redir_get_alt_setting_header);

        } else {

            return -1;

        }

    case usb_redir_alt_setting_status:

        if (!command_for_host) {

            return sizeof(struct usb_redir_alt_setting_status_header);

        } else {

            return -1;

        }

    case usb_redir_start_iso_stream:

        if (command_for_host) {

            return sizeof(struct usb_redir_start_iso_stream_header);

        } else {

            return -1;

        }

    case usb_redir_stop_iso_stream:

        if (command_for_host) {

            return sizeof(struct usb_redir_stop_iso_stream_header);

        } else {

            return -1;

        }

    case usb_redir_iso_stream_status:

        if (!command_for_host) {

            return sizeof(struct usb_redir_iso_stream_status_header);

        } else {

            return -1;

        }

    case usb_redir_start_interrupt_receiving:

        if (command_for_host) {

            return sizeof(struct usb_redir_start_interrupt_receiving_header);

        } else {

            return -1;

        }

    case usb_redir_stop_interrupt_receiving:

        if (command_for_host) {

            return sizeof(struct usb_redir_stop_interrupt_receiving_header);

        } else {

            return -1;

        }

    case usb_redir_interrupt_receiving_status:

        if (!command_for_host) {

            return sizeof(struct usb_redir_interrupt_receiving_status_header);

        } else {

            return -1;

        }

    case usb_redir_alloc_bulk_streams:

        if (command_for_host) {

            return sizeof(struct usb_redir_alloc_bulk_streams_header);

        } else {

            return -1;

        }

    case usb_redir_free_bulk_streams:

        if (command_for_host) {

            return sizeof(struct usb_redir_free_bulk_streams_header);

        } else {

            return -1;

        }

    case usb_redir_bulk_streams_status:

        if (!command_for_host) {

            return sizeof(struct usb_redir_bulk_streams_status_header);

        } else {

            return -1;

        }

    case usb_redir_cancel_data_packet:

        if (command_for_host) {

            return 0; /* No packet type specific header */

        } else {

            return -1;

        }

    case usb_redir_filter_reject:

        if (command_for_host) {

            return 0;

        } else {

            return -1;

        }

    case usb_redir_filter_filter:

        return 0;

    case usb_redir_device_disconnect_ack:

        if (command_for_host) {

            return 0;

        } else {

            return -1;

        }

    case usb_redir_start_bulk_receiving:

        if (command_for_host) {

            return sizeof(struct usb_redir_start_bulk_receiving_header);

        } else {

            return -1;

        }

    case usb_redir_stop_bulk_receiving:

        if (command_for_host) {

            return sizeof(struct usb_redir_stop_bulk_receiving_header);

        } else {

            return -1;

        }

    case usb_redir_bulk_receiving_status:

        if (!command_for_host) {

            return sizeof(struct usb_redir_bulk_receiving_status_header);

        } else {

            return -1;

        }

    case usb_redir_control_packet:

        return sizeof(struct usb_redir_control_packet_header);

    case usb_redir_bulk_packet:

        if (usbredirparser_have_cap(parser_pub,

                                usb_redir_cap_32bits_bulk_length) &&

            usbredirparser_peer_has_cap(parser_pub,

                                usb_redir_cap_32bits_bulk_length)) {

            return sizeof(struct usb_redir_bulk_packet_header);

        } else {

            return sizeof(struct usb_redir_bulk_packet_header_16bit_length);

        }

    case usb_redir_iso_packet:

        return sizeof(struct usb_redir_iso_packet_header);

    case usb_redir_interrupt_packet:

        return sizeof(struct usb_redir_interrupt_packet_header);

    case usb_redir_buffered_bulk_packet:

        if (!command_for_host) {

            return sizeof(struct usb_redir_buffered_bulk_packet_header);

        } else {

            return -1;

        }

    default:

        return -1;

    }

}

/* Note this function only checks if extra data is allowed for the

   packet type being read at all, a check if it is actually allowed

   given the direction of the packet + ep is done in _erify_type_header */

static int usbredirparser_expect_extra_data(struct usbredirparser_priv *parser)

{

    switch (parser->header.type) {

    case usb_redir_hello: /* For the variable length capabilities array */

    case usb_redir_filter_filter:

    case usb_redir_control_packet:

    case usb_redir_bulk_packet:

    case usb_redir_iso_packet:

    case usb_redir_interrupt_packet:

    case usb_redir_buffered_bulk_packet:

        return 1;

    default:

        return 0;

    }

}

static int usbredirparser_verify_bulk_recv_cap(

    struct usbredirparser *parser_pub, int send)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    if ((send && !usbredirparser_peer_has_cap(parser_pub,

                                              usb_redir_cap_bulk_receiving)) ||

        (!send && !usbredirparser_have_cap(parser_pub,

                                           usb_redir_cap_bulk_receiving))) {

        ERROR("error bulk_receiving without cap_bulk_receiving");

        return 0;

    }

    return 1; /* Verify ok */

}

static int usbredirparser_verify_type_header(

    struct usbredirparser *parser_pub,

    int32_t type, void *header, uint8_t *data, int data_len, int send)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    int command_for_host = 0, expect_extra_data = 0;

    int length = 0, ep = -1;

    if (parser->flags & usbredirparser_fl_usb_host) {

        command_for_host = 1;

    }

    if (send) {

        command_for_host = !command_for_host;

    }

    switch (type) {

    case usb_redir_interface_info: {

        struct usb_redir_interface_info_header *intf_info = header;

        if (intf_info->interface_count > 32) {

            ERROR("error interface_count > 32");

            return 0;

        }

        break;

    }

    case usb_redir_start_interrupt_receiving: {

        struct usb_redir_start_interrupt_receiving_header *start_int = header;

        if (!(start_int->endpoint & 0x80)) {

            ERROR("start int receiving on non input ep %02x",

                  start_int->endpoint);

            return 0;

        }

        break;

    }

    case usb_redir_stop_interrupt_receiving: {

        struct usb_redir_stop_interrupt_receiving_header *stop_int = header;

        if (!(stop_int->endpoint & 0x80)) {

            ERROR("stop int receiving on non input ep %02x",

                  stop_int->endpoint);

            return 0;

        }

        break;

    }

    case usb_redir_interrupt_receiving_status: {

        struct usb_redir_interrupt_receiving_status_header *int_status = header;

        if (!(int_status->endpoint & 0x80)) {

            ERROR("int receiving status for non input ep %02x",

                  int_status->endpoint);

            return 0;

        }

        break;

    }

    case usb_redir_filter_reject:

        if ((send && !usbredirparser_peer_has_cap(parser_pub,

                                             usb_redir_cap_filter)) ||

            (!send && !usbredirparser_have_cap(parser_pub,

                                             usb_redir_cap_filter))) {

            ERROR("error filter_reject without cap_filter");

            return 0;

        }

        break;

    case usb_redir_filter_filter:

        if ((send && !usbredirparser_peer_has_cap(parser_pub,

                                             usb_redir_cap_filter)) ||

            (!send && !usbredirparser_have_cap(parser_pub,

                                             usb_redir_cap_filter))) {

            ERROR("error filter_filter without cap_filter");

            return 0;

        }

        if (data_len < 1) {

            ERROR("error filter_filter without data");

            return 0;

        }

        if (data[data_len - 1] != 0) {

            ERROR("error non 0 terminated filter_filter data");

            return 0;

        }

        break;

    case usb_redir_device_disconnect_ack:

        if ((send && !usbredirparser_peer_has_cap(parser_pub,

                                     usb_redir_cap_device_disconnect_ack)) ||

            (!send && !usbredirparser_have_cap(parser_pub,

                                     usb_redir_cap_device_disconnect_ack))) {

            ERROR("error device_disconnect_ack without cap_device_disconnect_ack");

            return 0;

        }

        break;

    case usb_redir_start_bulk_receiving: {

        struct usb_redir_start_bulk_receiving_header *start_bulk = header;

        if (!usbredirparser_verify_bulk_recv_cap(parser_pub, send)) {

            return 0;

        }

        if (start_bulk->bytes_per_transfer > MAX_BULK_TRANSFER_SIZE) {

            ERROR("start bulk receiving length exceeds limits %u > %u",

                  start_bulk->bytes_per_transfer, MAX_BULK_TRANSFER_SIZE);

            return 0;

        }

        if (!(start_bulk->endpoint & 0x80)) {

            ERROR("start bulk receiving on non input ep %02x",

                  start_bulk->endpoint);

            return 0;

        }

        break;

    }

    case usb_redir_stop_bulk_receiving: {

        struct usb_redir_stop_bulk_receiving_header *stop_bulk = header;

        if (!usbredirparser_verify_bulk_recv_cap(parser_pub, send)) {

            return 0;

        }

        if (!(stop_bulk->endpoint & 0x80)) {

            ERROR("stop bulk receiving on non input ep %02x",

                  stop_bulk->endpoint);

            return 0;

        }

        break;

    }

    case usb_redir_bulk_receiving_status: {

        struct usb_redir_bulk_receiving_status_header *bulk_status = header;

        if (!usbredirparser_verify_bulk_recv_cap(parser_pub, send)) {

            return 0;

        }

        if (!(bulk_status->endpoint & 0x80)) {

            ERROR("bulk receiving status for non input ep %02x",

                  bulk_status->endpoint);

            return 0;

        }

        break;

    }

    case usb_redir_control_packet:

        length = ((struct usb_redir_control_packet_header *)header)->length;

        ep = ((struct usb_redir_control_packet_header *)header)->endpoint;

        break;

    case usb_redir_bulk_packet: {

        struct usb_redir_bulk_packet_header *bulk_packet = header;

        if (usbredirparser_have_cap(parser_pub,

                                usb_redir_cap_32bits_bulk_length) &&

            usbredirparser_peer_has_cap(parser_pub,

                                usb_redir_cap_32bits_bulk_length)) {

            length = (bulk_packet->length_high << 16) | bulk_packet->length;

        } else {

            length = bulk_packet->length;

            if (!send)

                bulk_packet->length_high = 0;

        }

        if ((uint32_t)length > MAX_BULK_TRANSFER_SIZE) {

            ERROR("bulk transfer length exceeds limits %u > %u",

                  (uint32_t)length, MAX_BULK_TRANSFER_SIZE);

            return 0;

        }

        ep = bulk_packet->endpoint;

        break;

    }

    case usb_redir_iso_packet:

        length = ((struct usb_redir_iso_packet_header *)header)->length;

        ep = ((struct usb_redir_iso_packet_header *)header)->endpoint;

        break;

    case usb_redir_interrupt_packet:

        length = ((struct usb_redir_interrupt_packet_header *)header)->length;

        ep = ((struct usb_redir_interrupt_packet_header *)header)->endpoint;

        break;

    case usb_redir_buffered_bulk_packet: {

        struct usb_redir_buffered_bulk_packet_header *buf_bulk_pkt = header;

        length = buf_bulk_pkt->length;

        if (!usbredirparser_verify_bulk_recv_cap(parser_pub, send)) {

            return 0;

        }

        if ((uint32_t)length > MAX_BULK_TRANSFER_SIZE) {

            ERROR("buffered bulk transfer length exceeds limits %u > %u",

                  (uint32_t)length, MAX_BULK_TRANSFER_SIZE);

            return 0;

        }

        ep = buf_bulk_pkt->endpoint;

        break;

    }

    }

    if (ep != -1) {

        if (((ep & 0x80) && !command_for_host) ||

            (!(ep & 0x80) && command_for_host)) {

            expect_extra_data = 1;

        }

        if (expect_extra_data) {

            if (data_len != length) {

                ERROR("error data len %d != header len %d ep %02X",

                      data_len, length, ep);

                return 0;

            }

        } else {

            if (data || data_len) {

                ERROR("error unexpected extra data ep %02X", ep);

                return 0;

            }

            switch (type) {

            case usb_redir_iso_packet:

                ERROR("error iso packet send in wrong direction");

                return 0;

            case usb_redir_interrupt_packet:

                if (command_for_host) {

                    ERROR("error interrupt packet send in wrong direction");

                    return 0;

                }

                break;

            case usb_redir_buffered_bulk_packet:

                ERROR("error buffered bulk packet send in wrong direction");

                return 0;

            }

        }

    }

    return 1; /* Verify ok */

}

static void usbredirparser_call_type_func(struct usbredirparser *parser_pub)

{

    struct usbredirparser_priv *parser =

        (struct usbredirparser_priv *)parser_pub;

    uint64_t id;

    if (usbredirparser_using_32bits_ids(parser_pub))

        id = parser->header_32bit_id.id;

    else

        id = parser->header.id;

    switch (parser->header.type) {

    case usb_redir_hello:

        usbredirparser_handle_hello(parser_pub,

            (struct usb_redir_hello_header *)parser->type_header,

            parser->data, parser->data_len);

        break;

    case usb_redir_device_connect:

        parser->callb.device_connect_func(parser->callb.priv,

            (struct usb_redir_device_connect_header *)parser->type_header);

        break;

    case usb_redir_device_disconnect:

        parser->callb.device_disconnect_func(parser->callb.priv);

        if (usbredirparser_peer_has_cap(parser_pub,

                                        usb_redir_cap_device_disconnect_ack))

            usbredirparser_queue(parser_pub, usb_redir_device_disconnect_ack,

                                 0, NULL, NULL, 0);

        break;

    case usb_redir_reset:

        parser->callb.reset_func(parser->callb.priv);

        break;

    case usb_redir_interface_info:

        parser->callb.interface_info_func(parser->callb.priv,

            (struct usb_redir_interface_info_header *)parser->type_header);

        break;

    case usb_redir_ep_info:

        parser->callb.ep_info_func(parser->callb.priv,

            (struct usb_redir_ep_info_header *)parser->type_header);

        break;

    case usb_redir_set_configuration:

        parser->callb.set_configuration_func(parser->callb.priv, id,

            (struct usb_redir_set_configuration_header *)parser->type_header);

        break;

    case usb_redir_get_configuration:

        parser->callb.get_configuration_func(parser->callb.priv, id);

        break;

    case usb_redir_configuration_status:

        parser->callb.configuration_status_func(parser->callb.priv, id,

          (struct usb_redir_configuration_status_header *)parser->type_header);

        break;

    case usb_redir_set_alt_setting:

        parser->callb.set_alt_setting_func(parser->callb.priv, id,

            (struct usb_redir_set_alt_setting_header *)parser->type_header);

        break;

    case usb_redir_get_alt_setting:

        parser->callb.get_alt_setting_func(parser->callb.priv, id,

            (struct usb_redir_get_alt_setting_header *)parser->type_header);

        break;

    case usb_redir_alt_setting_status:

        parser->callb.alt_setting_status_func(parser->callb.priv, id,

            (struct usb_redir_alt_setting_status_header *)parser->type_header);

        break;

    case usb_redir_start_iso_stream:

        parser->callb.start_iso_stream_func(parser->callb.priv, id,

            (struct usb_redir_start_iso_stream_header *)parser->type_header);

        break;

    case usb_redir_stop_iso_stream:

        parser->callb.stop_iso_stream_func(parser->callb.priv, id,

            (struct usb_redir_stop_iso_stream_header *)parser->type_header);

        break;

    case usb_redir_iso_stream_status:

        parser->callb.iso_stream_status_func(parser->callb.priv, id,

            (struct usb_redir_iso_stream_status_header *)parser->type_header);

        break;

    case usb_redir_start_interrupt_receiving:

        parser->callb.start_interrupt_receiving_func(parser->callb.priv, id,

            (struct usb_redir_start_interrupt_receiving_header *)

            parser->type_header);

        break;

    case usb_redir_stop_interrupt_receiving:

        parser->callb.stop_interrupt_receiving_func(parser->callb.priv, id,

            (struct usb_redir_stop_interrupt_receiving_header *)

            parser->type_header);

        break;

    case usb_redir_interrupt_receiving_status:

        parser->callb.interrupt_receiving_status_func(parser->callb.priv, id,

            (struct usb_redir_interrupt_receiving_status_header *)

            parser->type_header);

        break;

    case usb_redir_alloc_bulk_streams:

        parser->callb.alloc_bulk_streams_func(parser->callb.priv, id,

            (struct usb_redir_alloc_bulk_streams_header *)parser->type_header);

        break;

    case usb_redir_free_bulk_streams:

        parser->callb.free_bulk_streams_func(parser->callb.priv, id,

            (struct usb_redir_free_bulk_streams_header *)parser->type_header);

        break;

    case usb_redir_bulk_streams_status:

        parser->callb.bulk_streams_status_func(parser->callb.priv, id,

          (struct usb_redir_bulk_streams_status_header *)parser->type_header);

        break;

    case usb_redir_cancel_data_packet:

        parser->callb.cancel_data_packet_func(parser->callb.priv, id);

        break;

    case usb_redir_filter_reject:

        parser->callb.filter_reject_func(parser->callb.priv);

        break;