usbredirparser: Add support for buffered bulk input

Signed-off-by: Hans de Goede <hdegoede@redhat.com>

4 files changed, 144 insertions, 2 deletions

diff --git a/ChangeLog b/ChangeLog
index 4367293..3e680ce 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -2,6 +2,8 @@ usbredir-0.6   28 November 2012
 -------------------------------
 -usbredirproto:
  -add support for buffered bulk input
+-usbredirparser:
+ -add support for buffered bulk input
 
 usbredir-0.5.3  7 October 2012
 ------------------------------
diff --git a/configure.ac b/configure.ac
index 35761a5..464f332 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,5 +1,5 @@
 AC_PREREQ(2.63)
-AC_INIT([usbredir], [0.5.3])
+AC_INIT([usbredir], [0.6])
 AC_CONFIG_SRCDIR([configure.ac])
 
 AM_CONFIG_HEADER([config.h])
diff --git a/usbredirparser/usbredirparser.c b/usbredirparser/usbredirparser.c
index 028da73..113ee3a 100644
--- a/usbredirparser/usbredirparser.c
+++ b/usbredirparser/usbredirparser.c
@@ -448,6 +448,24 @@ static int usbredirparser_get_type_header_len(
         } 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:
@@ -463,6 +481,12 @@ static int usbredirparser_get_type_header_len(
         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;
     }
@@ -475,11 +499,12 @@ 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_filter_filter:
+    case usb_redir_buffered_bulk_packet:
         return 1;
     default:
         return 0;
@@ -547,6 +572,26 @@ static int usbredirparser_verify_type_header(
             return 0;
         }
         break;
+    case usb_redir_start_bulk_receiving: {
+        struct usb_redir_start_bulk_receiving_header *start_bulk = header;
+
+        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;
+        }
+        /* Fall through for caps check */
+    }
+    case usb_redir_stop_bulk_receiving:
+    case usb_redir_bulk_receiving_status:
+        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;
+        }
+        break;
     case usb_redir_control_packet:
         length = ((struct usb_redir_control_packet_header *)header)->length;
         ep = ((struct usb_redir_control_packet_header *)header)->endpoint;
@@ -579,6 +624,17 @@ static int usbredirparser_verify_type_header(
         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 ((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) {
@@ -607,6 +663,9 @@ static int usbredirparser_verify_type_header(
                     return 0;
                 }
                 break;
+            case usb_redir_buffered_bulk_packet:
+                ERROR("error buffered bulk packet send in wrong direction");
+                return 0;
             }
         }
     }
@@ -737,6 +796,21 @@ static void usbredirparser_call_type_func(struct usbredirparser *parser_pub)
     case usb_redir_device_disconnect_ack:
         parser->callb.device_disconnect_ack_func(parser->callb.priv);
         break;
+    case usb_redir_start_bulk_receiving:
+        parser->callb.start_bulk_receiving_func(parser->callb.priv, id,
+            (struct usb_redir_start_bulk_receiving_header *)
+            parser->type_header);
+        break;
+    case usb_redir_stop_bulk_receiving:
+        parser->callb.stop_bulk_receiving_func(parser->callb.priv, id,
+            (struct usb_redir_stop_bulk_receiving_header *)
+            parser->type_header);
+        break;
+    case usb_redir_bulk_receiving_status:
+        parser->callb.bulk_receiving_status_func(parser->callb.priv, id,
+            (struct usb_redir_bulk_receiving_status_header *)
+            parser->type_header);
+        break;
     case usb_redir_control_packet:
         parser->callb.control_packet_func(parser->callb.priv, id,
             (struct usb_redir_control_packet_header *)parser->type_header,
@@ -757,6 +831,11 @@ static void usbredirparser_call_type_func(struct usbredirparser *parser_pub)
             (struct usb_redir_interrupt_packet_header *)parser->type_header,
             parser->data, parser->data_len);
         break;
+    case usb_redir_buffered_bulk_packet:
+        parser->callb.buffered_bulk_packet_func(parser->callb.priv, id,
+          (struct usb_redir_buffered_bulk_packet_header *)parser->type_header,
+          parser->data, parser->data_len);
+        break;
     }
 }
 
@@ -1169,6 +1248,30 @@ void usbredirparser_send_filter_filter(struct usbredirparser *parser_pub,
     free(str);
 }
 
+void usbredirparser_send_start_bulk_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_start_bulk_receiving_header *start_bulk_receiving)
+{
+    usbredirparser_queue(parser, usb_redir_start_bulk_receiving, id,
+                         start_bulk_receiving, NULL, 0);
+}
+
+void usbredirparser_send_stop_bulk_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_stop_bulk_receiving_header *stop_bulk_receiving)
+{
+    usbredirparser_queue(parser, usb_redir_stop_bulk_receiving, id,
+                         stop_bulk_receiving, NULL, 0);
+}
+
+void usbredirparser_send_bulk_receiving_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_bulk_receiving_status_header *bulk_receiving_status)
+{
+    usbredirparser_queue(parser, usb_redir_bulk_receiving_status, id,
+                         bulk_receiving_status, NULL, 0);
+}
+
 /* Data packets: */
 void usbredirparser_send_control_packet(struct usbredirparser *parser,
     uint64_t id,
@@ -1206,6 +1309,15 @@ void usbredirparser_send_interrupt_packet(struct usbredirparser *parser,
                          interrupt_header, data, data_len);
 }
 
+void usbredirparser_send_buffered_bulk_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_buffered_bulk_packet_header *buffered_bulk_header,
+    uint8_t *data, int data_len)
+{
+    usbredirparser_queue(parser, usb_redir_buffered_bulk_packet, id,
+                         buffered_bulk_header, data, data_len);
+}
+
 /****** Serialization support ******/
 
 #define USBREDIRPARSER_SERIALIZE_MAGIC        0x55525031
diff --git a/usbredirparser/usbredirparser.h b/usbredirparser/usbredirparser.h
index bf5ebd8..840bbb6 100644
--- a/usbredirparser/usbredirparser.h
+++ b/usbredirparser/usbredirparser.h
@@ -105,6 +105,12 @@ typedef void (*usbredirparser_filter_reject)(void *priv);
 typedef void (*usbredirparser_filter_filter)(void *priv,
     struct usbredirfilter_rule *rules, int rules_count);
 typedef void (*usbredirparser_device_disconnect_ack)(void *priv);
+typedef void (*usbredirparser_start_bulk_receiving)(void *priv,
+    uint64_t id, struct usb_redir_start_bulk_receiving_header *start_bulk_receiving);
+typedef void (*usbredirparser_stop_bulk_receiving)(void *priv,
+    uint64_t id, struct usb_redir_stop_bulk_receiving_header *stop_bulk_receiving);
+typedef void (*usbredirparser_bulk_receiving_status)(void *priv,
+    uint64_t id, struct usb_redir_bulk_receiving_status_header *bulk_receiving_status);
 
 /* Data packets:
 
@@ -123,6 +129,9 @@ typedef void (*usbredirparser_iso_packet)(void *priv,
 typedef void (*usbredirparser_interrupt_packet)(void *priv,
     uint64_t id, struct usb_redir_interrupt_packet_header *interrupt_header,
     uint8_t *data, int data_len);
+typedef void (*usbredirparser_buffered_bulk_packet)(void *priv, uint64_t id,
+    struct usb_redir_buffered_bulk_packet_header *buffered_bulk_header,
+    uint8_t *data, int data_len);
 
 
 /* Public part of the data allocated by usbredirparser_alloc, *never* allocate
@@ -175,6 +184,12 @@ struct usbredirparser {
     usbredirparser_filter_reject filter_reject_func;
     usbredirparser_filter_filter filter_filter_func;
     usbredirparser_device_disconnect_ack device_disconnect_ack_func;
+    /* usbredir 0.6 new control packet complete callbacks */
+    usbredirparser_start_bulk_receiving start_bulk_receiving_func;
+    usbredirparser_stop_bulk_receiving stop_bulk_receiving_func;
+    usbredirparser_bulk_receiving_status bulk_receiving_status_func;
+    /* usbredir 0.6 new data packet complete callbacks */
+    usbredirparser_buffered_bulk_packet buffered_bulk_packet_func;
 };
 
 /* Allocate a usbredirparser, after this the app should set the callback app
@@ -307,6 +322,15 @@ void usbredirparser_send_cancel_data_packet(struct usbredirparser *parser,
 void usbredirparser_send_filter_reject(struct usbredirparser *parser);
 void usbredirparser_send_filter_filter(struct usbredirparser *parser,
     const struct usbredirfilter_rule *rules, int rules_count);
+void usbredirparser_send_start_bulk_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_start_bulk_receiving_header *start_bulk_receiving);
+void usbredirparser_send_stop_bulk_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_stop_bulk_receiving_header *stop_bulk_receiving);
+void usbredirparser_send_bulk_receiving_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_bulk_receiving_status_header *bulk_receiving_status);
 /* Data packets: */
 void usbredirparser_send_control_packet(struct usbredirparser *parser,
     uint64_t id,
@@ -324,6 +348,10 @@ void usbredirparser_send_interrupt_packet(struct usbredirparser *parser,
     uint64_t id,
     struct usb_redir_interrupt_packet_header *interrupt_header,
     uint8_t *data, int data_len);
+void usbredirparser_send_buffered_bulk_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_buffered_bulk_packet_header *buffered_bulk_header,
+    uint8_t *data, int data_len);
 
 
 /* Serialization */