hw/usb/redirect.c

   1 /*
   2  * USB redirector usb-guest
   3  *
   4  * Copyright (c) 2011-2012 Red Hat, Inc.
   5  *
   6  * Red Hat Authors:
   7  * Hans de Goede <[email protected]>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy
  10  * of this software and associated documentation files (the "Software"), to deal
  11  * in the Software without restriction, including without limitation the rights
  12  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the Software is
  14  * furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  22  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  25  * THE SOFTWARE.
  26  */
  27
  28 #include "qemu-common.h"
  29 #include "qemu-timer.h"
  30 #include "monitor.h"
  31 #include "sysemu.h"
  32
  33 #include <dirent.h>
  34 #include <sys/ioctl.h>
  35 #include <signal.h>
  36 #include <usbredirparser.h>
  37 #include <usbredirfilter.h>
  38
  39 #include "hw/usb.h"
  40
  41 #define MAX_ENDPOINTS 32
  42 #define NO_INTERFACE_INFO 255 /* Valid interface_count always <= 32 */
  43 #define EP2I(ep_address) (((ep_address & 0x80) >> 3) | (ep_address & 0x0f))
  44 #define I2EP(i) (((i & 0x10) << 3) | (i & 0x0f))
  45
  46 typedef struct Cancelled Cancelled;
  47 typedef struct USBRedirDevice USBRedirDevice;
  48
  49 /* Struct to hold buffered packets (iso or int input packets) */
  50 struct buf_packet {
  51     uint8_t *data;
  52     int len;
  53     int status;
  54     QTAILQ_ENTRY(buf_packet)next;
  55 };
  56
  57 struct endp_data {
  58     uint8_t type;
  59     uint8_t interval;
  60     uint8_t interface; /* bInterfaceNumber this ep belongs to */
  61     uint8_t iso_started;
  62     uint8_t iso_error; /* For reporting iso errors to the HC */
  63     uint8_t interrupt_started;
  64     uint8_t interrupt_error;
  65     uint8_t bufpq_prefilled;
  66     uint8_t bufpq_dropping_packets;
  67     QTAILQ_HEAD(, buf_packet) bufpq;
  68     int bufpq_size;
  69     int bufpq_target_size;
  70 };
  71
  72 struct USBRedirDevice {
  73     USBDevice dev;
  74     /* Properties */
  75     CharDriverState *cs;
  76     uint8_t debug;
  77     char *filter_str;
  78     int32_t bootindex;
  79     /* Data passed from chardev the fd_read cb to the usbredirparser read cb */
  80     const uint8_t *read_buf;
  81     int read_buf_size;
  82     /* For async handling of close */
  83     QEMUBH *chardev_close_bh;
  84     /* To delay the usb attach in case of quick chardev close + open */
  85     QEMUTimer *attach_timer;
  86     int64_t next_attach_time;
  87     struct usbredirparser *parser;
  88     struct endp_data endpoint[MAX_ENDPOINTS];
  89     QTAILQ_HEAD(, Cancelled) cancelled;
  90     /* Data for device filtering */
  91     struct usb_redir_device_connect_header device_info;
  92     struct usb_redir_interface_info_header interface_info;
  93     struct usbredirfilter_rule *filter_rules;
  94     int filter_rules_count;
  95 };
  96
  97 struct Cancelled {
  98     uint64_t id;
  99     QTAILQ_ENTRY(Cancelled)next;
 100 };
 101
 102 static void usbredir_hello(void *priv, struct usb_redir_hello_header *h);
 103 static void usbredir_device_connect(void *priv,
 104     struct usb_redir_device_connect_header *device_connect);
 105 static void usbredir_device_disconnect(void *priv);
 106 static void usbredir_interface_info(void *priv,
 107     struct usb_redir_interface_info_header *interface_info);
 108 static void usbredir_ep_info(void *priv,
 109     struct usb_redir_ep_info_header *ep_info);
 110 static void usbredir_configuration_status(void *priv, uint64_t id,
 111     struct usb_redir_configuration_status_header *configuration_status);
 112 static void usbredir_alt_setting_status(void *priv, uint64_t id,
 113     struct usb_redir_alt_setting_status_header *alt_setting_status);
 114 static void usbredir_iso_stream_status(void *priv, uint64_t id,
 115     struct usb_redir_iso_stream_status_header *iso_stream_status);
 116 static void usbredir_interrupt_receiving_status(void *priv, uint64_t id,
 117     struct usb_redir_interrupt_receiving_status_header
 118     *interrupt_receiving_status);
 119 static void usbredir_bulk_streams_status(void *priv, uint64_t id,
 120     struct usb_redir_bulk_streams_status_header *bulk_streams_status);
 121 static void usbredir_control_packet(void *priv, uint64_t id,
 122     struct usb_redir_control_packet_header *control_packet,
 123     uint8_t *data, int data_len);
 124 static void usbredir_bulk_packet(void *priv, uint64_t id,
 125     struct usb_redir_bulk_packet_header *bulk_packet,
 126     uint8_t *data, int data_len);
 127 static void usbredir_iso_packet(void *priv, uint64_t id,
 128     struct usb_redir_iso_packet_header *iso_packet,
 129     uint8_t *data, int data_len);
 130 static void usbredir_interrupt_packet(void *priv, uint64_t id,
 131     struct usb_redir_interrupt_packet_header *interrupt_header,
 132     uint8_t *data, int data_len);
 133
 134 static int usbredir_handle_status(USBRedirDevice *dev,
 135                                        int status, int actual_len);
 136
 137 /*
 138  * Logging stuff
 139  */
 140
 141 #define ERROR(...) \
 142     do { \
 143         if (dev->debug >= usbredirparser_error) { \
 144             error_report("usb-redir error: " __VA_ARGS__); \
 145         } \
 146     } while (0)
 147 #define WARNING(...) \
 148     do { \
 149         if (dev->debug >= usbredirparser_warning) { \
 150             error_report("usb-redir warning: " __VA_ARGS__); \
 151         } \
 152     } while (0)
 153 #define INFO(...) \
 154     do { \
 155         if (dev->debug >= usbredirparser_info) { \
 156             error_report("usb-redir: " __VA_ARGS__); \
 157         } \
 158     } while (0)
 159 #define DPRINTF(...) \
 160     do { \
 161         if (dev->debug >= usbredirparser_debug) { \
 162             error_report("usb-redir: " __VA_ARGS__); \
 163         } \
 164     } while (0)
 165 #define DPRINTF2(...) \
 166     do { \
 167         if (dev->debug >= usbredirparser_debug_data) { \
 168             error_report("usb-redir: " __VA_ARGS__); \
 169         } \
 170     } while (0)
 171
 172 static void usbredir_log(void *priv, int level, const char *msg)
 173 {
 174     USBRedirDevice *dev = priv;
 175
 176     if (dev->debug < level) {
 177         return;
 178     }
 179
 180     error_report("%s", msg);
 181 }
 182
 183 static void usbredir_log_data(USBRedirDevice *dev, const char *desc,
 184     const uint8_t *data, int len)
 185 {
 186     int i, j, n;
 187
 188     if (dev->debug < usbredirparser_debug_data) {
 189         return;
 190     }
 191
 192     for (i = 0; i < len; i += j) {
 193         char buf[128];
 194
 195         n = sprintf(buf, "%s", desc);
 196         for (j = 0; j < 8 && i + j < len; j++) {
 197             n += sprintf(buf + n, " %02X", data[i + j]);
 198         }
 199         error_report("%s", buf);
 200     }
 201 }
 202
 203 /*
 204  * usbredirparser io functions
 205  */
 206
 207 static int usbredir_read(void *priv, uint8_t *data, int count)
 208 {
 209     USBRedirDevice *dev = priv;
 210
 211     if (dev->read_buf_size < count) {
 212         count = dev->read_buf_size;
 213     }
 214
 215     memcpy(data, dev->read_buf, count);
 216
 217     dev->read_buf_size -= count;
 218     if (dev->read_buf_size) {
 219         dev->read_buf += count;
 220     } else {
 221         dev->read_buf = NULL;
 222     }
 223
 224     return count;
 225 }
 226
 227 static int usbredir_write(void *priv, uint8_t *data, int count)
 228 {
 229     USBRedirDevice *dev = priv;
 230
 231     if (!dev->cs->opened) {
 232         return 0;
 233     }
 234
 235     return qemu_chr_fe_write(dev->cs, data, count);
 236 }
 237
 238 /*
 239  * Cancelled and buffered packets helpers
 240  */
 241
 242 static void usbredir_cancel_packet(USBDevice *udev, USBPacket *p)
 243 {
 244     USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
 245     Cancelled *c;
 246
 247     DPRINTF("cancel packet id %"PRIu64"\n", p->id);
 248
 249     c = g_malloc0(sizeof(Cancelled));
 250     c->id = p->id;
 251     QTAILQ_INSERT_TAIL(&dev->cancelled, c, next);
 252
 253     usbredirparser_send_cancel_data_packet(dev->parser, p->id);
 254     usbredirparser_do_write(dev->parser);
 255 }
 256
 257 static int usbredir_is_cancelled(USBRedirDevice *dev, uint64_t id)
 258 {
 259     Cancelled *c;
 260
 261     if (!dev->dev.attached) {
 262         return 1; /* Treat everything as cancelled after a disconnect */
 263     }
 264
 265     QTAILQ_FOREACH(c, &dev->cancelled, next) {
 266         if (c->id == id) {
 267             QTAILQ_REMOVE(&dev->cancelled, c, next);
 268             g_free(c);
 269             return 1;
 270         }
 271     }
 272     return 0;
 273 }
 274
 275 static USBPacket *usbredir_find_packet_by_id(USBRedirDevice *dev,
 276     uint8_t ep, uint64_t id)
 277 {
 278     USBPacket *p;
 279
 280     if (usbredir_is_cancelled(dev, id)) {
 281         return NULL;
 282     }
 283
 284     p = usb_ep_find_packet_by_id(&dev->dev,
 285                             (ep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT,
 286                             ep & 0x0f, id);
 287     if (p == NULL) {
 288         ERROR("could not find packet with id %"PRIu64"\n", id);
 289     }
 290     return p;
 291 }
 292
 293 static void bufp_alloc(USBRedirDevice *dev,
 294     uint8_t *data, int len, int status, uint8_t ep)
 295 {
 296     struct buf_packet *bufp;
 297
 298     if (!dev->endpoint[EP2I(ep)].bufpq_dropping_packets &&
 299         dev->endpoint[EP2I(ep)].bufpq_size >
 300             2 * dev->endpoint[EP2I(ep)].bufpq_target_size) {
 301         DPRINTF("bufpq overflow, dropping packets ep %02X\n", ep);
 302         dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 1;
 303     }
 304     /* Since we're interupting the stream anyways, drop enough packets to get
 305        back to our target buffer size */
 306     if (dev->endpoint[EP2I(ep)].bufpq_dropping_packets) {
 307         if (dev->endpoint[EP2I(ep)].bufpq_size >
 308                 dev->endpoint[EP2I(ep)].bufpq_target_size) {
 309             free(data);
 310             return;
 311         }
 312         dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0;
 313     }
 314
 315     bufp = g_malloc(sizeof(struct buf_packet));
 316     bufp->data   = data;
 317     bufp->len    = len;
 318     bufp->status = status;
 319     QTAILQ_INSERT_TAIL(&dev->endpoint[EP2I(ep)].bufpq, bufp, next);
 320     dev->endpoint[EP2I(ep)].bufpq_size++;
 321 }
 322
 323 static void bufp_free(USBRedirDevice *dev, struct buf_packet *bufp,
 324     uint8_t ep)
 325 {
 326     QTAILQ_REMOVE(&dev->endpoint[EP2I(ep)].bufpq, bufp, next);
 327     dev->endpoint[EP2I(ep)].bufpq_size--;
 328     free(bufp->data);
 329     g_free(bufp);
 330 }
 331
 332 static void usbredir_free_bufpq(USBRedirDevice *dev, uint8_t ep)
 333 {
 334     struct buf_packet *buf, *buf_next;
 335
 336     QTAILQ_FOREACH_SAFE(buf, &dev->endpoint[EP2I(ep)].bufpq, next, buf_next) {
 337         bufp_free(dev, buf, ep);
 338     }
 339 }
 340
 341 /*
 342  * USBDevice callbacks
 343  */
 344
 345 static void usbredir_handle_reset(USBDevice *udev)
 346 {
 347     USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
 348
 349     DPRINTF("reset device\n");
 350     usbredirparser_send_reset(dev->parser);
 351     usbredirparser_do_write(dev->parser);
 352 }
 353
 354 static int usbredir_handle_iso_data(USBRedirDevice *dev, USBPacket *p,
 355                                      uint8_t ep)
 356 {
 357     int status, len;
 358     if (!dev->endpoint[EP2I(ep)].iso_started &&
 359             !dev->endpoint[EP2I(ep)].iso_error) {
 360         struct usb_redir_start_iso_stream_header start_iso = {
 361             .endpoint = ep,
 362         };
 363         int pkts_per_sec;
 364
 365         if (dev->dev.speed == USB_SPEED_HIGH) {
 366             pkts_per_sec = 8000 / dev->endpoint[EP2I(ep)].interval;
 367         } else {
 368             pkts_per_sec = 1000 / dev->endpoint[EP2I(ep)].interval;
 369         }
 370         /* Testing has shown that we need circa 60 ms buffer */
 371         dev->endpoint[EP2I(ep)].bufpq_target_size = (pkts_per_sec * 60) / 1000;
 372
 373         /* Aim for approx 100 interrupts / second on the client to
 374            balance latency and interrupt load */
 375         start_iso.pkts_per_urb = pkts_per_sec / 100;
 376         if (start_iso.pkts_per_urb < 1) {
 377             start_iso.pkts_per_urb = 1;
 378         } else if (start_iso.pkts_per_urb > 32) {
 379             start_iso.pkts_per_urb = 32;
 380         }
 381
 382         start_iso.no_urbs = (dev->endpoint[EP2I(ep)].bufpq_target_size +
 383                              start_iso.pkts_per_urb - 1) /
 384                             start_iso.pkts_per_urb;
 385         /* Output endpoints pre-fill only 1/2 of the packets, keeping the rest
 386            as overflow buffer. Also see the usbredir protocol documentation */
 387         if (!(ep & USB_DIR_IN)) {
 388             start_iso.no_urbs *= 2;
 389         }
 390         if (start_iso.no_urbs > 16) {
 391             start_iso.no_urbs = 16;
 392         }
 393
 394         /* No id, we look at the ep when receiving a status back */
 395         usbredirparser_send_start_iso_stream(dev->parser, 0, &start_iso);
 396         usbredirparser_do_write(dev->parser);
 397         DPRINTF("iso stream started pkts/sec %d pkts/urb %d urbs %d ep %02X\n",
 398                 pkts_per_sec, start_iso.pkts_per_urb, start_iso.no_urbs, ep);
 399         dev->endpoint[EP2I(ep)].iso_started = 1;
 400         dev->endpoint[EP2I(ep)].bufpq_prefilled = 0;
 401         dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0;
 402     }
 403
 404     if (ep & USB_DIR_IN) {
 405         struct buf_packet *isop;
 406
 407         if (dev->endpoint[EP2I(ep)].iso_started &&
 408                 !dev->endpoint[EP2I(ep)].bufpq_prefilled) {
 409             if (dev->endpoint[EP2I(ep)].bufpq_size <
 410                     dev->endpoint[EP2I(ep)].bufpq_target_size) {
 411                 return usbredir_handle_status(dev, 0, 0);
 412             }
 413             dev->endpoint[EP2I(ep)].bufpq_prefilled = 1;
 414         }
 415
 416         isop = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq);
 417         if (isop == NULL) {
 418             DPRINTF("iso-token-in ep %02X, no isop, iso_error: %d\n",
 419                     ep, dev->endpoint[EP2I(ep)].iso_error);
 420             /* Re-fill the buffer */
 421             dev->endpoint[EP2I(ep)].bufpq_prefilled = 0;
 422             /* Check iso_error for stream errors, otherwise its an underrun */
 423             status = dev->endpoint[EP2I(ep)].iso_error;
 424             dev->endpoint[EP2I(ep)].iso_error = 0;
 425             return status ? USB_RET_IOERROR : 0;
 426         }
 427         DPRINTF2("iso-token-in ep %02X status %d len %d queue-size: %d\n", ep,
 428                  isop->status, isop->len, dev->endpoint[EP2I(ep)].bufpq_size);
 429
 430         status = isop->status;
 431         if (status != usb_redir_success) {
 432             bufp_free(dev, isop, ep);
 433             return USB_RET_IOERROR;
 434         }
 435
 436         len = isop->len;
 437         if (len > p->iov.size) {
 438             ERROR("received iso data is larger then packet ep %02X (%d > %d)\n",
 439                   ep, len, (int)p->iov.size);
 440             bufp_free(dev, isop, ep);
 441             return USB_RET_BABBLE;
 442         }
 443         usb_packet_copy(p, isop->data, len);
 444         bufp_free(dev, isop, ep);
 445         return len;
 446     } else {
 447         /* If the stream was not started because of a pending error don't
 448            send the packet to the usb-host */
 449         if (dev->endpoint[EP2I(ep)].iso_started) {
 450             struct usb_redir_iso_packet_header iso_packet = {
 451                 .endpoint = ep,
 452                 .length = p->iov.size
 453             };
 454             uint8_t buf[p->iov.size];
 455             /* No id, we look at the ep when receiving a status back */
 456             usb_packet_copy(p, buf, p->iov.size);
 457             usbredirparser_send_iso_packet(dev->parser, 0, &iso_packet,
 458                                            buf, p->iov.size);
 459             usbredirparser_do_write(dev->parser);
 460         }
 461         status = dev->endpoint[EP2I(ep)].iso_error;
 462         dev->endpoint[EP2I(ep)].iso_error = 0;
 463         DPRINTF2("iso-token-out ep %02X status %d len %zd\n", ep, status,
 464                  p->iov.size);
 465         return usbredir_handle_status(dev, status, p->iov.size);
 466     }
 467 }
 468
 469 static void usbredir_stop_iso_stream(USBRedirDevice *dev, uint8_t ep)
 470 {
 471     struct usb_redir_stop_iso_stream_header stop_iso_stream = {
 472         .endpoint = ep
 473     };
 474     if (dev->endpoint[EP2I(ep)].iso_started) {
 475         usbredirparser_send_stop_iso_stream(dev->parser, 0, &stop_iso_stream);
 476         DPRINTF("iso stream stopped ep %02X\n", ep);
 477         dev->endpoint[EP2I(ep)].iso_started = 0;
 478     }
 479     dev->endpoint[EP2I(ep)].iso_error = 0;
 480     usbredir_free_bufpq(dev, ep);
 481 }
 482
 483 static int usbredir_handle_bulk_data(USBRedirDevice *dev, USBPacket *p,
 484                                       uint8_t ep)
 485 {
 486     struct usb_redir_bulk_packet_header bulk_packet;
 487
 488     DPRINTF("bulk-out ep %02X len %zd id %"PRIu64"\n", ep, p->iov.size, p->id);
 489
 490     bulk_packet.endpoint  = ep;
 491     bulk_packet.length    = p->iov.size;
 492     bulk_packet.stream_id = 0;
 493
 494     if (ep & USB_DIR_IN) {
 495         usbredirparser_send_bulk_packet(dev->parser, p->id,
 496                                         &bulk_packet, NULL, 0);
 497     } else {
 498         uint8_t buf[p->iov.size];
 499         usb_packet_copy(p, buf, p->iov.size);
 500         usbredir_log_data(dev, "bulk data out:", buf, p->iov.size);
 501         usbredirparser_send_bulk_packet(dev->parser, p->id,
 502                                         &bulk_packet, buf, p->iov.size);
 503     }
 504     usbredirparser_do_write(dev->parser);
 505     return USB_RET_ASYNC;
 506 }
 507
 508 static int usbredir_handle_interrupt_data(USBRedirDevice *dev,
 509                                            USBPacket *p, uint8_t ep)
 510 {
 511     if (ep & USB_DIR_IN) {
 512         /* Input interrupt endpoint, buffered packet input */
 513         struct buf_packet *intp;
 514         int status, len;
 515
 516         if (!dev->endpoint[EP2I(ep)].interrupt_started &&
 517                 !dev->endpoint[EP2I(ep)].interrupt_error) {
 518             struct usb_redir_start_interrupt_receiving_header start_int = {
 519                 .endpoint = ep,
 520             };
 521             /* No id, we look at the ep when receiving a status back */
 522             usbredirparser_send_start_interrupt_receiving(dev->parser, 0,
 523                                                           &start_int);
 524             usbredirparser_do_write(dev->parser);
 525             DPRINTF("interrupt recv started ep %02X\n", ep);
 526             dev->endpoint[EP2I(ep)].interrupt_started = 1;
 527             /* We don't really want to drop interrupt packets ever, but
 528                having some upper limit to how much we buffer is good. */
 529             dev->endpoint[EP2I(ep)].bufpq_target_size = 1000;
 530             dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0;
 531         }
 532
 533         intp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq);
 534         if (intp == NULL) {
 535             DPRINTF2("interrupt-token-in ep %02X, no intp\n", ep);
 536             /* Check interrupt_error for stream errors */
 537             status = dev->endpoint[EP2I(ep)].interrupt_error;
 538             dev->endpoint[EP2I(ep)].interrupt_error = 0;
 539             if (status) {
 540                 return usbredir_handle_status(dev, status, 0);
 541             }
 542             return USB_RET_NAK;
 543         }
 544         DPRINTF("interrupt-token-in ep %02X status %d len %d\n", ep,
 545                 intp->status, intp->len);
 546
 547         status = intp->status;
 548         if (status != usb_redir_success) {
 549             bufp_free(dev, intp, ep);
 550             return usbredir_handle_status(dev, status, 0);
 551         }
 552
 553         len = intp->len;
 554         if (len > p->iov.size) {
 555             ERROR("received int data is larger then packet ep %02X\n", ep);
 556             bufp_free(dev, intp, ep);
 557             return USB_RET_BABBLE;
 558         }
 559         usb_packet_copy(p, intp->data, len);
 560         bufp_free(dev, intp, ep);
 561         return len;
 562     } else {
 563         /* Output interrupt endpoint, normal async operation */
 564         struct usb_redir_interrupt_packet_header interrupt_packet;
 565         uint8_t buf[p->iov.size];
 566
 567         DPRINTF("interrupt-out ep %02X len %zd id %"PRIu64"\n", ep,
 568                 p->iov.size, p->id);
 569
 570         interrupt_packet.endpoint  = ep;
 571         interrupt_packet.length    = p->iov.size;
 572
 573         usb_packet_copy(p, buf, p->iov.size);
 574         usbredir_log_data(dev, "interrupt data out:", buf, p->iov.size);
 575         usbredirparser_send_interrupt_packet(dev->parser, p->id,
 576                                         &interrupt_packet, buf, p->iov.size);
 577         usbredirparser_do_write(dev->parser);
 578         return USB_RET_ASYNC;
 579     }
 580 }
 581
 582 static void usbredir_stop_interrupt_receiving(USBRedirDevice *dev,
 583     uint8_t ep)
 584 {
 585     struct usb_redir_stop_interrupt_receiving_header stop_interrupt_recv = {
 586         .endpoint = ep
 587     };
 588     if (dev->endpoint[EP2I(ep)].interrupt_started) {
 589         usbredirparser_send_stop_interrupt_receiving(dev->parser, 0,
 590                                                      &stop_interrupt_recv);
 591         DPRINTF("interrupt recv stopped ep %02X\n", ep);
 592         dev->endpoint[EP2I(ep)].interrupt_started = 0;
 593     }
 594     dev->endpoint[EP2I(ep)].interrupt_error = 0;
 595     usbredir_free_bufpq(dev, ep);
 596 }
 597
 598 static int usbredir_handle_data(USBDevice *udev, USBPacket *p)
 599 {
 600     USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
 601     uint8_t ep;
 602
 603     ep = p->ep->nr;
 604     if (p->pid == USB_TOKEN_IN) {
 605         ep |= USB_DIR_IN;
 606     }
 607
 608     switch (dev->endpoint[EP2I(ep)].type) {
 609     case USB_ENDPOINT_XFER_CONTROL:
 610         ERROR("handle_data called for control transfer on ep %02X\n", ep);
 611         return USB_RET_NAK;
 612     case USB_ENDPOINT_XFER_ISOC:
 613         return usbredir_handle_iso_data(dev, p, ep);
 614     case USB_ENDPOINT_XFER_BULK:
 615         return usbredir_handle_bulk_data(dev, p, ep);
 616     case USB_ENDPOINT_XFER_INT:
 617         return usbredir_handle_interrupt_data(dev, p, ep);
 618     default:
 619         ERROR("handle_data ep %02X has unknown type %d\n", ep,
 620               dev->endpoint[EP2I(ep)].type);
 621         return USB_RET_NAK;
 622     }
 623 }
 624
 625 static int usbredir_set_config(USBRedirDevice *dev, USBPacket *p,
 626                                 int config)
 627 {
 628     struct usb_redir_set_configuration_header set_config;
 629     int i;
 630
 631     DPRINTF("set config %d id %"PRIu64"\n", config, p->id);
 632
 633     for (i = 0; i < MAX_ENDPOINTS; i++) {
 634         switch (dev->endpoint[i].type) {
 635         case USB_ENDPOINT_XFER_ISOC:
 636             usbredir_stop_iso_stream(dev, I2EP(i));
 637             break;
 638         case USB_ENDPOINT_XFER_INT:
 639             if (i & 0x10) {
 640                 usbredir_stop_interrupt_receiving(dev, I2EP(i));
 641             }
 642             break;
 643         }
 644         usbredir_free_bufpq(dev, I2EP(i));
 645     }
 646
 647     set_config.configuration = config;
 648     usbredirparser_send_set_configuration(dev->parser, p->id, &set_config);
 649     usbredirparser_do_write(dev->parser);
 650     return USB_RET_ASYNC;
 651 }
 652
 653 static int usbredir_get_config(USBRedirDevice *dev, USBPacket *p)
 654 {
 655     DPRINTF("get config id %"PRIu64"\n", p->id);
 656
 657     usbredirparser_send_get_configuration(dev->parser, p->id);
 658     usbredirparser_do_write(dev->parser);
 659     return USB_RET_ASYNC;
 660 }
 661
 662 static int usbredir_set_interface(USBRedirDevice *dev, USBPacket *p,
 663                                    int interface, int alt)
 664 {
 665     struct usb_redir_set_alt_setting_header set_alt;
 666     int i;
 667
 668     DPRINTF("set interface %d alt %d id %"PRIu64"\n", interface, alt, p->id);
 669
 670     for (i = 0; i < MAX_ENDPOINTS; i++) {
 671         if (dev->endpoint[i].interface == interface) {
 672             switch (dev->endpoint[i].type) {
 673             case USB_ENDPOINT_XFER_ISOC:
 674                 usbredir_stop_iso_stream(dev, I2EP(i));
 675                 break;
 676             case USB_ENDPOINT_XFER_INT:
 677                 if (i & 0x10) {
 678                     usbredir_stop_interrupt_receiving(dev, I2EP(i));
 679                 }
 680                 break;
 681             }
 682             usbredir_free_bufpq(dev, I2EP(i));
 683         }
 684     }
 685
 686     set_alt.interface = interface;
 687     set_alt.alt = alt;
 688     usbredirparser_send_set_alt_setting(dev->parser, p->id, &set_alt);
 689     usbredirparser_do_write(dev->parser);
 690     return USB_RET_ASYNC;
 691 }
 692
 693 static int usbredir_get_interface(USBRedirDevice *dev, USBPacket *p,
 694                                    int interface)
 695 {
 696     struct usb_redir_get_alt_setting_header get_alt;
 697
 698     DPRINTF("get interface %d id %"PRIu64"\n", interface, p->id);
 699
 700     get_alt.interface = interface;
 701     usbredirparser_send_get_alt_setting(dev->parser, p->id, &get_alt);
 702     usbredirparser_do_write(dev->parser);
 703     return USB_RET_ASYNC;
 704 }
 705
 706 static int usbredir_handle_control(USBDevice *udev, USBPacket *p,
 707         int request, int value, int index, int length, uint8_t *data)
 708 {
 709     USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
 710     struct usb_redir_control_packet_header control_packet;
 711
 712     /* Special cases for certain standard device requests */
 713     switch (request) {
 714     case DeviceOutRequest | USB_REQ_SET_ADDRESS:
 715         DPRINTF("set address %d\n", value);
 716         dev->dev.addr = value;
 717         return 0;
 718     case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
 719         return usbredir_set_config(dev, p, value & 0xff);
 720     case DeviceRequest | USB_REQ_GET_CONFIGURATION:
 721         return usbredir_get_config(dev, p);
 722     case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
 723         return usbredir_set_interface(dev, p, index, value);
 724     case InterfaceRequest | USB_REQ_GET_INTERFACE:
 725         return usbredir_get_interface(dev, p, index);
 726     }
 727
 728     /* Normal ctrl requests, note request is (bRequestType << 8) | bRequest */
 729     DPRINTF(
 730         "ctrl-out type 0x%x req 0x%x val 0x%x index %d len %d id %"PRIu64"\n",
 731         request >> 8, request & 0xff, value, index, length, p->id);
 732
 733     control_packet.request     = request & 0xFF;
 734     control_packet.requesttype = request >> 8;
 735     control_packet.endpoint    = control_packet.requesttype & USB_DIR_IN;
 736     control_packet.value       = value;
 737     control_packet.index       = index;
 738     control_packet.length      = length;
 739
 740     if (control_packet.requesttype & USB_DIR_IN) {
 741         usbredirparser_send_control_packet(dev->parser, p->id,
 742                                            &control_packet, NULL, 0);
 743     } else {
 744         usbredir_log_data(dev, "ctrl data out:", data, length);
 745         usbredirparser_send_control_packet(dev->parser, p->id,
 746                                            &control_packet, data, length);
 747     }
 748     usbredirparser_do_write(dev->parser);
 749     return USB_RET_ASYNC;
 750 }
 751
 752 /*
 753  * Close events can be triggered by usbredirparser_do_write which gets called
 754  * from within the USBDevice data / control packet callbacks and doing a
 755  * usb_detach from within these callbacks is not a good idea.
 756  *
 757  * So we use a bh handler to take care of close events.
 758  */
 759 static void usbredir_chardev_close_bh(void *opaque)
 760 {
 761     USBRedirDevice *dev = opaque;
 762
 763     usbredir_device_disconnect(dev);
 764
 765     if (dev->parser) {
 766         usbredirparser_destroy(dev->parser);
 767         dev->parser = NULL;
 768     }
 769 }
 770
 771 static void usbredir_chardev_open(USBRedirDevice *dev)
 772 {
 773     uint32_t caps[USB_REDIR_CAPS_SIZE] = { 0, };
 774     char version[32];
 775
 776     /* Make sure any pending closes are handled (no-op if none pending) */
 777     usbredir_chardev_close_bh(dev);
 778     qemu_bh_cancel(dev->chardev_close_bh);
 779
 780     strcpy(version, "qemu usb-redir guest ");
 781     pstrcat(version, sizeof(version), qemu_get_version());
 782
 783     dev->parser = qemu_oom_check(usbredirparser_create());
 784     dev->parser->priv = dev;
 785     dev->parser->log_func = usbredir_log;
 786     dev->parser->read_func = usbredir_read;
 787     dev->parser->write_func = usbredir_write;
 788     dev->parser->hello_func = usbredir_hello;
 789     dev->parser->device_connect_func = usbredir_device_connect;
 790     dev->parser->device_disconnect_func = usbredir_device_disconnect;
 791     dev->parser->interface_info_func = usbredir_interface_info;
 792     dev->parser->ep_info_func = usbredir_ep_info;
 793     dev->parser->configuration_status_func = usbredir_configuration_status;
 794     dev->parser->alt_setting_status_func = usbredir_alt_setting_status;
 795     dev->parser->iso_stream_status_func = usbredir_iso_stream_status;
 796     dev->parser->interrupt_receiving_status_func =
 797         usbredir_interrupt_receiving_status;
 798     dev->parser->bulk_streams_status_func = usbredir_bulk_streams_status;
 799     dev->parser->control_packet_func = usbredir_control_packet;
 800     dev->parser->bulk_packet_func = usbredir_bulk_packet;
 801     dev->parser->iso_packet_func = usbredir_iso_packet;
 802     dev->parser->interrupt_packet_func = usbredir_interrupt_packet;
 803     dev->read_buf = NULL;
 804     dev->read_buf_size = 0;
 805
 806     usbredirparser_caps_set_cap(caps, usb_redir_cap_connect_device_version);
 807     usbredirparser_caps_set_cap(caps, usb_redir_cap_filter);
 808     usbredirparser_caps_set_cap(caps, usb_redir_cap_ep_info_max_packet_size);
 809     usbredirparser_caps_set_cap(caps, usb_redir_cap_64bits_ids);
 810     usbredirparser_init(dev->parser, version, caps, USB_REDIR_CAPS_SIZE, 0);
 811     usbredirparser_do_write(dev->parser);
 812 }
 813
 814 static void usbredir_reject_device(USBRedirDevice *dev)
 815 {
 816     usbredir_device_disconnect(dev);
 817     if (usbredirparser_peer_has_cap(dev->parser, usb_redir_cap_filter)) {
 818         usbredirparser_send_filter_reject(dev->parser);
 819         usbredirparser_do_write(dev->parser);
 820     }
 821 }
 822
 823 static void usbredir_do_attach(void *opaque)
 824 {
 825     USBRedirDevice *dev = opaque;
 826
 827     if (usb_device_attach(&dev->dev) != 0) {
 828         usbredir_reject_device(dev);
 829     }
 830 }
 831
 832 /*
 833  * chardev callbacks
 834  */
 835
 836 static int usbredir_chardev_can_read(void *opaque)
 837 {
 838     USBRedirDevice *dev = opaque;
 839
 840     if (!dev->parser) {
 841         WARNING("chardev_can_read called on non open chardev!\n");
 842         return 0;
 843     }
 844
 845     /* usbredir_parser_do_read will consume *all* data we give it */
 846     return 1024 * 1024;
 847 }
 848
 849 static void usbredir_chardev_read(void *opaque, const uint8_t *buf, int size)
 850 {
 851     USBRedirDevice *dev = opaque;
 852
 853     /* No recursion allowed! */
 854     assert(dev->read_buf == NULL);
 855
 856     dev->read_buf = buf;
 857     dev->read_buf_size = size;
 858
 859     usbredirparser_do_read(dev->parser);
 860     /* Send any acks, etc. which may be queued now */
 861     usbredirparser_do_write(dev->parser);
 862 }
 863
 864 static void usbredir_chardev_event(void *opaque, int event)
 865 {
 866     USBRedirDevice *dev = opaque;
 867
 868     switch (event) {
 869     case CHR_EVENT_OPENED:
 870         usbredir_chardev_open(dev);
 871         break;
 872     case CHR_EVENT_CLOSED:
 873         qemu_bh_schedule(dev->chardev_close_bh);
 874         break;
 875     }
 876 }
 877
 878 /*
 879  * init + destroy
 880  */
 881
 882 static int usbredir_initfn(USBDevice *udev)
 883 {
 884     USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
 885     int i;
 886
 887     if (dev->cs == NULL) {
 888         qerror_report(QERR_MISSING_PARAMETER, "chardev");
 889         return -1;
 890     }
 891
 892     if (dev->filter_str) {
 893         i = usbredirfilter_string_to_rules(dev->filter_str, ":", "|",
 894                                            &dev->filter_rules,
 895                                            &dev->filter_rules_count);
 896         if (i) {
 897             qerror_report(QERR_INVALID_PARAMETER_VALUE, "filter",
 898                           "a usb device filter string");
 899             return -1;
 900         }
 901     }
 902
 903     dev->chardev_close_bh = qemu_bh_new(usbredir_chardev_close_bh, dev);
 904     dev->attach_timer = qemu_new_timer_ms(vm_clock, usbredir_do_attach, dev);
 905
 906     QTAILQ_INIT(&dev->cancelled);
 907     for (i = 0; i < MAX_ENDPOINTS; i++) {
 908         QTAILQ_INIT(&dev->endpoint[i].bufpq);
 909     }
 910
 911     /* We'll do the attach once we receive the speed from the usb-host */
 912     udev->auto_attach = 0;
 913
 914     /* Let the backend know we are ready */
 915     qemu_chr_fe_open(dev->cs);
 916     qemu_chr_add_handlers(dev->cs, usbredir_chardev_can_read,
 917                           usbredir_chardev_read, usbredir_chardev_event, dev);
 918
 919     add_boot_device_path(dev->bootindex, &udev->qdev, NULL);
 920     return 0;
 921 }
 922
 923 static void usbredir_cleanup_device_queues(USBRedirDevice *dev)
 924 {
 925     Cancelled *c, *next_c;
 926     int i;
 927
 928     QTAILQ_FOREACH_SAFE(c, &dev->cancelled, next, next_c) {
 929         QTAILQ_REMOVE(&dev->cancelled, c, next);
 930         g_free(c);
 931     }
 932     for (i = 0; i < MAX_ENDPOINTS; i++) {
 933         usbredir_free_bufpq(dev, I2EP(i));
 934     }
 935 }
 936
 937 static void usbredir_handle_destroy(USBDevice *udev)
 938 {
 939     USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
 940
 941     qemu_chr_fe_close(dev->cs);
 942     qemu_chr_delete(dev->cs);
 943     /* Note must be done after qemu_chr_close, as that causes a close event */
 944     qemu_bh_delete(dev->chardev_close_bh);
 945
 946     qemu_del_timer(dev->attach_timer);
 947     qemu_free_timer(dev->attach_timer);
 948
 949     usbredir_cleanup_device_queues(dev);
 950
 951     if (dev->parser) {
 952         usbredirparser_destroy(dev->parser);
 953     }
 954
 955     free(dev->filter_rules);
 956 }
 957
 958 static int usbredir_check_filter(USBRedirDevice *dev)
 959 {
 960     if (dev->interface_info.interface_count == NO_INTERFACE_INFO) {
 961         ERROR("No interface info for device\n");
 962         goto error;
 963     }
 964
 965     if (dev->filter_rules) {
 966         if (!usbredirparser_peer_has_cap(dev->parser,
 967                                     usb_redir_cap_connect_device_version)) {
 968             ERROR("Device filter specified and peer does not have the "
 969                   "connect_device_version capability\n");
 970             goto error;
 971         }
 972
 973         if (usbredirfilter_check(
 974                 dev->filter_rules,
 975                 dev->filter_rules_count,
 976                 dev->device_info.device_class,
 977                 dev->device_info.device_subclass,
 978                 dev->device_info.device_protocol,
 979                 dev->interface_info.interface_class,
 980                 dev->interface_info.interface_subclass,
 981                 dev->interface_info.interface_protocol,
 982                 dev->interface_info.interface_count,
 983                 dev->device_info.vendor_id,
 984                 dev->device_info.product_id,
 985                 dev->device_info.device_version_bcd,
 986                 0) != 0) {
 987             goto error;
 988         }
 989     }
 990
 991     return 0;
 992
 993 error:
 994     usbredir_reject_device(dev);
 995     return -1;
 996 }
 997
 998 /*
 999  * usbredirparser packet complete callbacks
1000  */
1001
1002 static int usbredir_handle_status(USBRedirDevice *dev,
1003                                        int status, int actual_len)
1004 {
1005     switch (status) {
1006     case usb_redir_success:
1007         return actual_len;
1008     case usb_redir_stall:
1009         return USB_RET_STALL;
1010     case usb_redir_cancelled:
1011         /*
1012          * When the usbredir-host unredirects a device, it will report a status
1013          * of cancelled for all pending packets, followed by a disconnect msg.
1014          */
1015         return USB_RET_IOERROR;
1016     case usb_redir_inval:
1017         WARNING("got invalid param error from usb-host?\n");
1018         return USB_RET_IOERROR;
1019     case usb_redir_babble:
1020         return USB_RET_BABBLE;
1021     case usb_redir_ioerror:
1022     case usb_redir_timeout:
1023     default:
1024         return USB_RET_IOERROR;
1025     }
1026 }
1027
1028 static void usbredir_hello(void *priv, struct usb_redir_hello_header *h)
1029 {
1030     USBRedirDevice *dev = priv;
1031
1032     /* Try to send the filter info now that we've the usb-host's caps */
1033     if (usbredirparser_peer_has_cap(dev->parser, usb_redir_cap_filter) &&
1034             dev->filter_rules) {
1035         usbredirparser_send_filter_filter(dev->parser, dev->filter_rules,
1036                                           dev->filter_rules_count);
1037         usbredirparser_do_write(dev->parser);
1038     }
1039 }
1040
1041 static void usbredir_device_connect(void *priv,
1042     struct usb_redir_device_connect_header *device_connect)
1043 {
1044     USBRedirDevice *dev = priv;
1045     const char *speed;
1046
1047     if (qemu_timer_pending(dev->attach_timer) || dev->dev.attached) {
1048         ERROR("Received device connect while already connected\n");
1049         return;
1050     }
1051
1052     switch (device_connect->speed) {
1053     case usb_redir_speed_low:
1054         speed = "low speed";
1055         dev->dev.speed = USB_SPEED_LOW;
1056         break;
1057     case usb_redir_speed_full:
1058         speed = "full speed";
1059         dev->dev.speed = USB_SPEED_FULL;
1060         break;
1061     case usb_redir_speed_high:
1062         speed = "high speed";
1063         dev->dev.speed = USB_SPEED_HIGH;
1064         break;
1065     case usb_redir_speed_super:
1066         speed = "super speed";
1067         dev->dev.speed = USB_SPEED_SUPER;
1068         break;
1069     default:
1070         speed = "unknown speed";
1071         dev->dev.speed = USB_SPEED_FULL;
1072     }
1073
1074     if (usbredirparser_peer_has_cap(dev->parser,
1075                                     usb_redir_cap_connect_device_version)) {
1076         INFO("attaching %s device %04x:%04x version %d.%d class %02x\n",
1077              speed, device_connect->vendor_id, device_connect->product_id,
1078              ((device_connect->device_version_bcd & 0xf000) >> 12) * 10 +
1079              ((device_connect->device_version_bcd & 0x0f00) >>  8),
1080              ((device_connect->device_version_bcd & 0x00f0) >>  4) * 10 +
1081              ((device_connect->device_version_bcd & 0x000f) >>  0),
1082              device_connect->device_class);
1083     } else {
1084         INFO("attaching %s device %04x:%04x class %02x\n", speed,
1085              device_connect->vendor_id, device_connect->product_id,
1086              device_connect->device_class);
1087     }
1088
1089     dev->dev.speedmask = (1 << dev->dev.speed);
1090     dev->device_info = *device_connect;
1091
1092     if (usbredir_check_filter(dev)) {
1093         WARNING("Device %04x:%04x rejected by device filter, not attaching\n",
1094                 device_connect->vendor_id, device_connect->product_id);
1095         return;
1096     }
1097
1098     qemu_mod_timer(dev->attach_timer, dev->next_attach_time);
1099 }
1100
1101 static void usbredir_device_disconnect(void *priv)
1102 {
1103     USBRedirDevice *dev = priv;
1104     int i;
1105
1106     /* Stop any pending attaches */
1107     qemu_del_timer(dev->attach_timer);
1108
1109     if (dev->dev.attached) {
1110         usb_device_detach(&dev->dev);
1111         /*
1112          * Delay next usb device attach to give the guest a chance to see
1113          * see the detach / attach in case of quick close / open succession
1114          */
1115         dev->next_attach_time = qemu_get_clock_ms(vm_clock) + 200;
1116     }
1117
1118     /* Reset state so that the next dev connected starts with a clean slate */
1119     usbredir_cleanup_device_queues(dev);
1120     memset(dev->endpoint, 0, sizeof(dev->endpoint));
1121     for (i = 0; i < MAX_ENDPOINTS; i++) {
1122         QTAILQ_INIT(&dev->endpoint[i].bufpq);
1123     }
1124     usb_ep_init(&dev->dev);
1125     dev->interface_info.interface_count = NO_INTERFACE_INFO;
1126     dev->dev.addr = 0;
1127     dev->dev.speed = 0;
1128 }
1129
1130 static void usbredir_interface_info(void *priv,
1131     struct usb_redir_interface_info_header *interface_info)
1132 {
1133     USBRedirDevice *dev = priv;
1134
1135     dev->interface_info = *interface_info;
1136
1137     /*
1138      * If we receive interface info after the device has already been
1139      * connected (ie on a set_config), re-check the filter.
1140      */
1141     if (qemu_timer_pending(dev->attach_timer) || dev->dev.attached) {
1142         if (usbredir_check_filter(dev)) {
1143             ERROR("Device no longer matches filter after interface info "
1144                   "change, disconnecting!\n");
1145         }
1146     }
1147 }
1148
1149 static void usbredir_ep_info(void *priv,
1150     struct usb_redir_ep_info_header *ep_info)
1151 {
1152     USBRedirDevice *dev = priv;
1153     struct USBEndpoint *usb_ep;
1154     int i;
1155
1156     for (i = 0; i < MAX_ENDPOINTS; i++) {
1157         dev->endpoint[i].type = ep_info->type[i];
1158         dev->endpoint[i].interval = ep_info->interval[i];
1159         dev->endpoint[i].interface = ep_info->interface[i];
1160         switch (dev->endpoint[i].type) {
1161         case usb_redir_type_invalid:
1162             break;
1163         case usb_redir_type_iso:
1164         case usb_redir_type_interrupt:
1165             if (dev->endpoint[i].interval == 0) {
1166                 ERROR("Received 0 interval for isoc or irq endpoint\n");
1167                 usbredir_device_disconnect(dev);
1168             }
1169             /* Fall through */
1170         case usb_redir_type_control:
1171         case usb_redir_type_bulk:
1172             DPRINTF("ep: %02X type: %d interface: %d\n", I2EP(i),
1173                     dev->endpoint[i].type, dev->endpoint[i].interface);
1174             break;
1175         default:
1176             ERROR("Received invalid endpoint type\n");
1177             usbredir_device_disconnect(dev);
1178             return;
1179         }
1180         usb_ep = usb_ep_get(&dev->dev,
1181                             (i & 0x10) ? USB_TOKEN_IN : USB_TOKEN_OUT,
1182                             i & 0x0f);
1183         usb_ep->type = dev->endpoint[i].type;
1184         usb_ep->ifnum = dev->endpoint[i].interface;
1185         if (usbredirparser_peer_has_cap(dev->parser,
1186                                      usb_redir_cap_ep_info_max_packet_size)) {
1187             usb_ep->max_packet_size = ep_info->max_packet_size[i];
1188         }
1189     }
1190 }
1191
1192 static void usbredir_configuration_status(void *priv, uint64_t id,
1193     struct usb_redir_configuration_status_header *config_status)
1194 {
1195     USBRedirDevice *dev = priv;
1196     USBPacket *p;
1197     int len = 0;
1198
1199     DPRINTF("set config status %d config %d id %"PRIu64"\n",
1200             config_status->status, config_status->configuration, id);
1201
1202     p = usbredir_find_packet_by_id(dev, 0, id);
1203     if (p) {
1204         if (dev->dev.setup_buf[0] & USB_DIR_IN) {
1205             dev->dev.data_buf[0] = config_status->configuration;
1206             len = 1;
1207         }
1208         p->result = usbredir_handle_status(dev, config_status->status, len);
1209         usb_generic_async_ctrl_complete(&dev->dev, p);
1210     }
1211 }
1212
1213 static void usbredir_alt_setting_status(void *priv, uint64_t id,
1214     struct usb_redir_alt_setting_status_header *alt_setting_status)
1215 {
1216     USBRedirDevice *dev = priv;
1217     USBPacket *p;
1218     int len = 0;
1219
1220     DPRINTF("alt status %d intf %d alt %d id: %"PRIu64"\n",
1221             alt_setting_status->status, alt_setting_status->interface,
1222             alt_setting_status->alt, id);
1223
1224     p = usbredir_find_packet_by_id(dev, 0, id);
1225     if (p) {
1226         if (dev->dev.setup_buf[0] & USB_DIR_IN) {
1227             dev->dev.data_buf[0] = alt_setting_status->alt;
1228             len = 1;
1229         }
1230         p->result =
1231             usbredir_handle_status(dev, alt_setting_status->status, len);
1232         usb_generic_async_ctrl_complete(&dev->dev, p);
1233     }
1234 }
1235
1236 static void usbredir_iso_stream_status(void *priv, uint64_t id,
1237     struct usb_redir_iso_stream_status_header *iso_stream_status)
1238 {
1239     USBRedirDevice *dev = priv;
1240     uint8_t ep = iso_stream_status->endpoint;
1241
1242     DPRINTF("iso status %d ep %02X id %"PRIu64"\n", iso_stream_status->status,
1243             ep, id);
1244
1245     if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].iso_started) {
1246         return;
1247     }
1248
1249     dev->endpoint[EP2I(ep)].iso_error = iso_stream_status->status;
1250     if (iso_stream_status->status == usb_redir_stall) {
1251         DPRINTF("iso stream stopped by peer ep %02X\n", ep);
1252         dev->endpoint[EP2I(ep)].iso_started = 0;
1253     }
1254 }
1255
1256 static void usbredir_interrupt_receiving_status(void *priv, uint64_t id,
1257     struct usb_redir_interrupt_receiving_status_header
1258     *interrupt_receiving_status)
1259 {
1260     USBRedirDevice *dev = priv;
1261     uint8_t ep = interrupt_receiving_status->endpoint;
1262
1263     DPRINTF("interrupt recv status %d ep %02X id %"PRIu64"\n",
1264             interrupt_receiving_status->status, ep, id);
1265
1266     if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].interrupt_started) {
1267         return;
1268     }
1269
1270     dev->endpoint[EP2I(ep)].interrupt_error =
1271         interrupt_receiving_status->status;
1272     if (interrupt_receiving_status->status == usb_redir_stall) {
1273         DPRINTF("interrupt receiving stopped by peer ep %02X\n", ep);
1274         dev->endpoint[EP2I(ep)].interrupt_started = 0;
1275     }
1276 }
1277
1278 static void usbredir_bulk_streams_status(void *priv, uint64_t id,
1279     struct usb_redir_bulk_streams_status_header *bulk_streams_status)
1280 {
1281 }
1282
1283 static void usbredir_control_packet(void *priv, uint64_t id,
1284     struct usb_redir_control_packet_header *control_packet,
1285     uint8_t *data, int data_len)
1286 {
1287     USBRedirDevice *dev = priv;
1288     USBPacket *p;
1289     int len = control_packet->length;
1290
1291     DPRINTF("ctrl-in status %d len %d id %"PRIu64"\n", control_packet->status,
1292             len, id);
1293
1294     p = usbredir_find_packet_by_id(dev, 0, id);
1295     if (p) {
1296         len = usbredir_handle_status(dev, control_packet->status, len);
1297         if (len > 0) {
1298             usbredir_log_data(dev, "ctrl data in:", data, data_len);
1299             if (data_len <= sizeof(dev->dev.data_buf)) {
1300                 memcpy(dev->dev.data_buf, data, data_len);
1301             } else {
1302                 ERROR("ctrl buffer too small (%d > %zu)\n",
1303                       data_len, sizeof(dev->dev.data_buf));
1304                 len = USB_RET_STALL;
1305             }
1306         }
1307         p->result = len;
1308         usb_generic_async_ctrl_complete(&dev->dev, p);
1309     }
1310     free(data);
1311 }
1312
1313 static void usbredir_bulk_packet(void *priv, uint64_t id,
1314     struct usb_redir_bulk_packet_header *bulk_packet,
1315     uint8_t *data, int data_len)
1316 {
1317     USBRedirDevice *dev = priv;
1318     uint8_t ep = bulk_packet->endpoint;
1319     int len = bulk_packet->length;
1320     USBPacket *p;
1321
1322     DPRINTF("bulk-in status %d ep %02X len %d id %"PRIu64"\n",
1323             bulk_packet->status, ep, len, id);
1324
1325     p = usbredir_find_packet_by_id(dev, ep, id);
1326     if (p) {
1327         len = usbredir_handle_status(dev, bulk_packet->status, len);
1328         if (len > 0) {
1329             usbredir_log_data(dev, "bulk data in:", data, data_len);
1330             if (data_len <= p->iov.size) {
1331                 usb_packet_copy(p, data, data_len);
1332             } else {
1333                 ERROR("bulk got more data then requested (%d > %zd)\n",
1334                       data_len, p->iov.size);
1335                 len = USB_RET_BABBLE;
1336             }
1337         }
1338         p->result = len;
1339         usb_packet_complete(&dev->dev, p);
1340     }
1341     free(data);
1342 }
1343
1344 static void usbredir_iso_packet(void *priv, uint64_t id,
1345     struct usb_redir_iso_packet_header *iso_packet,
1346     uint8_t *data, int data_len)
1347 {
1348     USBRedirDevice *dev = priv;
1349     uint8_t ep = iso_packet->endpoint;
1350
1351     DPRINTF2("iso-in status %d ep %02X len %d id %"PRIu64"\n",
1352              iso_packet->status, ep, data_len, id);
1353
1354     if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_ISOC) {
1355         ERROR("received iso packet for non iso endpoint %02X\n", ep);
1356         free(data);
1357         return;
1358     }
1359
1360     if (dev->endpoint[EP2I(ep)].iso_started == 0) {
1361         DPRINTF("received iso packet for non started stream ep %02X\n", ep);
1362         free(data);
1363         return;
1364     }
1365
1366     /* bufp_alloc also adds the packet to the ep queue */
1367     bufp_alloc(dev, data, data_len, iso_packet->status, ep);
1368 }
1369
1370 static void usbredir_interrupt_packet(void *priv, uint64_t id,
1371     struct usb_redir_interrupt_packet_header *interrupt_packet,
1372     uint8_t *data, int data_len)
1373 {
1374     USBRedirDevice *dev = priv;
1375     uint8_t ep = interrupt_packet->endpoint;
1376
1377     DPRINTF("interrupt-in status %d ep %02X len %d id %"PRIu64"\n",
1378             interrupt_packet->status, ep, data_len, id);
1379
1380     if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_INT) {
1381         ERROR("received int packet for non interrupt endpoint %02X\n", ep);
1382         free(data);
1383         return;
1384     }
1385
1386     if (ep & USB_DIR_IN) {
1387         if (dev->endpoint[EP2I(ep)].interrupt_started == 0) {
1388             DPRINTF("received int packet while not started ep %02X\n", ep);
1389             free(data);
1390             return;
1391         }
1392
1393         /* bufp_alloc also adds the packet to the ep queue */
1394         bufp_alloc(dev, data, data_len, interrupt_packet->status, ep);
1395     } else {
1396         int len = interrupt_packet->length;
1397
1398         USBPacket *p = usbredir_find_packet_by_id(dev, ep, id);
1399         if (p) {
1400             p->result = usbredir_handle_status(dev,
1401                                                interrupt_packet->status, len);
1402             usb_packet_complete(&dev->dev, p);
1403         }
1404     }
1405 }
1406
1407 static Property usbredir_properties[] = {
1408     DEFINE_PROP_CHR("chardev", USBRedirDevice, cs),
1409     DEFINE_PROP_UINT8("debug", USBRedirDevice, debug, 0),
1410     DEFINE_PROP_STRING("filter", USBRedirDevice, filter_str),
1411     DEFINE_PROP_INT32("bootindex", USBRedirDevice, bootindex, -1),
1412     DEFINE_PROP_END_OF_LIST(),
1413 };
1414
1415 static void usbredir_class_initfn(ObjectClass *klass, void *data)
1416 {
1417     USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
1418     DeviceClass *dc = DEVICE_CLASS(klass);
1419
1420     uc->init           = usbredir_initfn;
1421     uc->product_desc   = "USB Redirection Device";
1422     uc->handle_destroy = usbredir_handle_destroy;
1423     uc->cancel_packet  = usbredir_cancel_packet;
1424     uc->handle_reset   = usbredir_handle_reset;
1425     uc->handle_data    = usbredir_handle_data;
1426     uc->handle_control = usbredir_handle_control;
1427     dc->props          = usbredir_properties;
1428 }
1429
1430 static TypeInfo usbredir_dev_info = {
1431     .name          = "usb-redir",
1432     .parent        = TYPE_USB_DEVICE,
1433     .instance_size = sizeof(USBRedirDevice),
1434     .class_init    = usbredir_class_initfn,
1435 };
1436
1437 static void usbredir_register_types(void)
1438 {
1439     type_register_static(&usbredir_dev_info);
1440 }
1441
1442 type_init(usbredir_register_types)