qemu-char.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu-common.h"
  25 #include "monitor/monitor.h"
  26 #include "ui/console.h"
  27 #include "sysemu/sysemu.h"
  28 #include "qemu/timer.h"
  29 #include "char/char.h"
  30 #include "hw/usb.h"
  31 #include "hw/baum.h"
  32 #include "hw/msmouse.h"
  33 #include "qmp-commands.h"
  34
  35 #include <unistd.h>
  36 #include <fcntl.h>
  37 #include <time.h>
  38 #include <errno.h>
  39 #include <sys/time.h>
  40 #include <zlib.h>
  41
  42 #ifndef _WIN32
  43 #include <sys/times.h>
  44 #include <sys/wait.h>
  45 #include <termios.h>
  46 #include <sys/mman.h>
  47 #include <sys/ioctl.h>
  48 #include <sys/resource.h>
  49 #include <sys/socket.h>
  50 #include <netinet/in.h>
  51 #include <net/if.h>
  52 #include <arpa/inet.h>
  53 #include <dirent.h>
  54 #include <netdb.h>
  55 #include <sys/select.h>
  56 #ifdef CONFIG_BSD
  57 #include <sys/stat.h>
  58 #if defined(__GLIBC__)
  59 #include <pty.h>
  60 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
  61 #include <libutil.h>
  62 #else
  63 #include <util.h>
  64 #endif
  65 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  66 #include <dev/ppbus/ppi.h>
  67 #include <dev/ppbus/ppbconf.h>
  68 #elif defined(__DragonFly__)
  69 #include <dev/misc/ppi/ppi.h>
  70 #include <bus/ppbus/ppbconf.h>
  71 #endif
  72 #else
  73 #ifdef __linux__
  74 #include <pty.h>
  75
  76 #include <linux/ppdev.h>
  77 #include <linux/parport.h>
  78 #endif
  79 #ifdef __sun__
  80 #include <sys/stat.h>
  81 #include <sys/ethernet.h>
  82 #include <sys/sockio.h>
  83 #include <netinet/arp.h>
  84 #include <netinet/in.h>
  85 #include <netinet/in_systm.h>
  86 #include <netinet/ip.h>
  87 #include <netinet/ip_icmp.h> // must come after ip.h
  88 #include <netinet/udp.h>
  89 #include <netinet/tcp.h>
  90 #include <net/if.h>
  91 #include <syslog.h>
  92 #include <stropts.h>
  93 #endif
  94 #endif
  95 #endif
  96
  97 #include "qemu/sockets.h"
  98 #include "ui/qemu-spice.h"
  99
 100 #define READ_BUF_LEN 4096
 101
 102 /***********************************************************/
 103 /* character device */
 104
 105 static QTAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs =
 106     QTAILQ_HEAD_INITIALIZER(chardevs);
 107
 108 void qemu_chr_be_event(CharDriverState *s, int event)
 109 {
 110     /* Keep track if the char device is open */
 111     switch (event) {
 112         case CHR_EVENT_OPENED:
 113             s->opened = 1;
 114             break;
 115         case CHR_EVENT_CLOSED:
 116             s->opened = 0;
 117             break;
 118     }
 119
 120     if (!s->chr_event)
 121         return;
 122     s->chr_event(s->handler_opaque, event);
 123 }
 124
 125 static void qemu_chr_fire_open_event(void *opaque)
 126 {
 127     CharDriverState *s = opaque;
 128     qemu_chr_be_event(s, CHR_EVENT_OPENED);
 129     qemu_free_timer(s->open_timer);
 130     s->open_timer = NULL;
 131 }
 132
 133 void qemu_chr_generic_open(CharDriverState *s)
 134 {
 135     if (s->open_timer == NULL) {
 136         s->open_timer = qemu_new_timer_ms(rt_clock,
 137                                           qemu_chr_fire_open_event, s);
 138         qemu_mod_timer(s->open_timer, qemu_get_clock_ms(rt_clock) - 1);
 139     }
 140 }
 141
 142 int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len)
 143 {
 144     return s->chr_write(s, buf, len);
 145 }
 146
 147 int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg)
 148 {
 149     if (!s->chr_ioctl)
 150         return -ENOTSUP;
 151     return s->chr_ioctl(s, cmd, arg);
 152 }
 153
 154 int qemu_chr_be_can_write(CharDriverState *s)
 155 {
 156     if (!s->chr_can_read)
 157         return 0;
 158     return s->chr_can_read(s->handler_opaque);
 159 }
 160
 161 void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len)
 162 {
 163     if (s->chr_read) {
 164         s->chr_read(s->handler_opaque, buf, len);
 165     }
 166 }
 167
 168 int qemu_chr_fe_get_msgfd(CharDriverState *s)
 169 {
 170     return s->get_msgfd ? s->get_msgfd(s) : -1;
 171 }
 172
 173 int qemu_chr_add_client(CharDriverState *s, int fd)
 174 {
 175     return s->chr_add_client ? s->chr_add_client(s, fd) : -1;
 176 }
 177
 178 void qemu_chr_accept_input(CharDriverState *s)
 179 {
 180     if (s->chr_accept_input)
 181         s->chr_accept_input(s);
 182     qemu_notify_event();
 183 }
 184
 185 void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
 186 {
 187     char buf[READ_BUF_LEN];
 188     va_list ap;
 189     va_start(ap, fmt);
 190     vsnprintf(buf, sizeof(buf), fmt, ap);
 191     qemu_chr_fe_write(s, (uint8_t *)buf, strlen(buf));
 192     va_end(ap);
 193 }
 194
 195 void qemu_chr_add_handlers(CharDriverState *s,
 196                            IOCanReadHandler *fd_can_read,
 197                            IOReadHandler *fd_read,
 198                            IOEventHandler *fd_event,
 199                            void *opaque)
 200 {
 201     if (!opaque && !fd_can_read && !fd_read && !fd_event) {
 202         /* chr driver being released. */
 203         ++s->avail_connections;
 204     }
 205     s->chr_can_read = fd_can_read;
 206     s->chr_read = fd_read;
 207     s->chr_event = fd_event;
 208     s->handler_opaque = opaque;
 209     if (s->chr_update_read_handler)
 210         s->chr_update_read_handler(s);
 211
 212     /* We're connecting to an already opened device, so let's make sure we
 213        also get the open event */
 214     if (s->opened) {
 215         qemu_chr_generic_open(s);
 216     }
 217 }
 218
 219 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 220 {
 221     return len;
 222 }
 223
 224 static CharDriverState *qemu_chr_open_null(QemuOpts *opts)
 225 {
 226     CharDriverState *chr;
 227
 228     chr = g_malloc0(sizeof(CharDriverState));
 229     chr->chr_write = null_chr_write;
 230     return chr;
 231 }
 232
 233 /* MUX driver for serial I/O splitting */
 234 #define MAX_MUX 4
 235 #define MUX_BUFFER_SIZE 32      /* Must be a power of 2.  */
 236 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
 237 typedef struct {
 238     IOCanReadHandler *chr_can_read[MAX_MUX];
 239     IOReadHandler *chr_read[MAX_MUX];
 240     IOEventHandler *chr_event[MAX_MUX];
 241     void *ext_opaque[MAX_MUX];
 242     CharDriverState *drv;
 243     int focus;
 244     int mux_cnt;
 245     int term_got_escape;
 246     int max_size;
 247     /* Intermediate input buffer allows to catch escape sequences even if the
 248        currently active device is not accepting any input - but only until it
 249        is full as well. */
 250     unsigned char buffer[MAX_MUX][MUX_BUFFER_SIZE];
 251     int prod[MAX_MUX];
 252     int cons[MAX_MUX];
 253     int timestamps;
 254     int linestart;
 255     int64_t timestamps_start;
 256 } MuxDriver;
 257
 258
 259 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 260 {
 261     MuxDriver *d = chr->opaque;
 262     int ret;
 263     if (!d->timestamps) {
 264         ret = d->drv->chr_write(d->drv, buf, len);
 265     } else {
 266         int i;
 267
 268         ret = 0;
 269         for (i = 0; i < len; i++) {
 270             if (d->linestart) {
 271                 char buf1[64];
 272                 int64_t ti;
 273                 int secs;
 274
 275                 ti = qemu_get_clock_ms(rt_clock);
 276                 if (d->timestamps_start == -1)
 277                     d->timestamps_start = ti;
 278                 ti -= d->timestamps_start;
 279                 secs = ti / 1000;
 280                 snprintf(buf1, sizeof(buf1),
 281                          "[%02d:%02d:%02d.%03d] ",
 282                          secs / 3600,
 283                          (secs / 60) % 60,
 284                          secs % 60,
 285                          (int)(ti % 1000));
 286                 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
 287                 d->linestart = 0;
 288             }
 289             ret += d->drv->chr_write(d->drv, buf+i, 1);
 290             if (buf[i] == '\n') {
 291                 d->linestart = 1;
 292             }
 293         }
 294     }
 295     return ret;
 296 }
 297
 298 static const char * const mux_help[] = {
 299     "% h    print this help\n\r",
 300     "% x    exit emulator\n\r",
 301     "% s    save disk data back to file (if -snapshot)\n\r",
 302     "% t    toggle console timestamps\n\r"
 303     "% b    send break (magic sysrq)\n\r",
 304     "% c    switch between console and monitor\n\r",
 305     "% %  sends %\n\r",
 306     NULL
 307 };
 308
 309 int term_escape_char = 0x01; /* ctrl-a is used for escape */
 310 static void mux_print_help(CharDriverState *chr)
 311 {
 312     int i, j;
 313     char ebuf[15] = "Escape-Char";
 314     char cbuf[50] = "\n\r";
 315
 316     if (term_escape_char > 0 && term_escape_char < 26) {
 317         snprintf(cbuf, sizeof(cbuf), "\n\r");
 318         snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
 319     } else {
 320         snprintf(cbuf, sizeof(cbuf),
 321                  "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
 322                  term_escape_char);
 323     }
 324     chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
 325     for (i = 0; mux_help[i] != NULL; i++) {
 326         for (j=0; mux_help[i][j] != '\0'; j++) {
 327             if (mux_help[i][j] == '%')
 328                 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
 329             else
 330                 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
 331         }
 332     }
 333 }
 334
 335 static void mux_chr_send_event(MuxDriver *d, int mux_nr, int event)
 336 {
 337     if (d->chr_event[mux_nr])
 338         d->chr_event[mux_nr](d->ext_opaque[mux_nr], event);
 339 }
 340
 341 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
 342 {
 343     if (d->term_got_escape) {
 344         d->term_got_escape = 0;
 345         if (ch == term_escape_char)
 346             goto send_char;
 347         switch(ch) {
 348         case '?':
 349         case 'h':
 350             mux_print_help(chr);
 351             break;
 352         case 'x':
 353             {
 354                  const char *term =  "QEMU: Terminated\n\r";
 355                  chr->chr_write(chr,(uint8_t *)term,strlen(term));
 356                  exit(0);
 357                  break;
 358             }
 359         case 's':
 360             bdrv_commit_all();
 361             break;
 362         case 'b':
 363             qemu_chr_be_event(chr, CHR_EVENT_BREAK);
 364             break;
 365         case 'c':
 366             /* Switch to the next registered device */
 367             mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
 368             d->focus++;
 369             if (d->focus >= d->mux_cnt)
 370                 d->focus = 0;
 371             mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
 372             break;
 373         case 't':
 374             d->timestamps = !d->timestamps;
 375             d->timestamps_start = -1;
 376             d->linestart = 0;
 377             break;
 378         }
 379     } else if (ch == term_escape_char) {
 380         d->term_got_escape = 1;
 381     } else {
 382     send_char:
 383         return 1;
 384     }
 385     return 0;
 386 }
 387
 388 static void mux_chr_accept_input(CharDriverState *chr)
 389 {
 390     MuxDriver *d = chr->opaque;
 391     int m = d->focus;
 392
 393     while (d->prod[m] != d->cons[m] &&
 394            d->chr_can_read[m] &&
 395            d->chr_can_read[m](d->ext_opaque[m])) {
 396         d->chr_read[m](d->ext_opaque[m],
 397                        &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);
 398     }
 399 }
 400
 401 static int mux_chr_can_read(void *opaque)
 402 {
 403     CharDriverState *chr = opaque;
 404     MuxDriver *d = chr->opaque;
 405     int m = d->focus;
 406
 407     if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE)
 408         return 1;
 409     if (d->chr_can_read[m])
 410         return d->chr_can_read[m](d->ext_opaque[m]);
 411     return 0;
 412 }
 413
 414 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
 415 {
 416     CharDriverState *chr = opaque;
 417     MuxDriver *d = chr->opaque;
 418     int m = d->focus;
 419     int i;
 420
 421     mux_chr_accept_input (opaque);
 422
 423     for(i = 0; i < size; i++)
 424         if (mux_proc_byte(chr, d, buf[i])) {
 425             if (d->prod[m] == d->cons[m] &&
 426                 d->chr_can_read[m] &&
 427                 d->chr_can_read[m](d->ext_opaque[m]))
 428                 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
 429             else
 430                 d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];
 431         }
 432 }
 433
 434 static void mux_chr_event(void *opaque, int event)
 435 {
 436     CharDriverState *chr = opaque;
 437     MuxDriver *d = chr->opaque;
 438     int i;
 439
 440     /* Send the event to all registered listeners */
 441     for (i = 0; i < d->mux_cnt; i++)
 442         mux_chr_send_event(d, i, event);
 443 }
 444
 445 static void mux_chr_update_read_handler(CharDriverState *chr)
 446 {
 447     MuxDriver *d = chr->opaque;
 448
 449     if (d->mux_cnt >= MAX_MUX) {
 450         fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
 451         return;
 452     }
 453     d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
 454     d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
 455     d->chr_read[d->mux_cnt] = chr->chr_read;
 456     d->chr_event[d->mux_cnt] = chr->chr_event;
 457     /* Fix up the real driver with mux routines */
 458     if (d->mux_cnt == 0) {
 459         qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
 460                               mux_chr_event, chr);
 461     }
 462     if (d->focus != -1) {
 463         mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
 464     }
 465     d->focus = d->mux_cnt;
 466     d->mux_cnt++;
 467     mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
 468 }
 469
 470 static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
 471 {
 472     CharDriverState *chr;
 473     MuxDriver *d;
 474
 475     chr = g_malloc0(sizeof(CharDriverState));
 476     d = g_malloc0(sizeof(MuxDriver));
 477
 478     chr->opaque = d;
 479     d->drv = drv;
 480     d->focus = -1;
 481     chr->chr_write = mux_chr_write;
 482     chr->chr_update_read_handler = mux_chr_update_read_handler;
 483     chr->chr_accept_input = mux_chr_accept_input;
 484     /* Frontend guest-open / -close notification is not support with muxes */
 485     chr->chr_guest_open = NULL;
 486     chr->chr_guest_close = NULL;
 487
 488     /* Muxes are always open on creation */
 489     qemu_chr_generic_open(chr);
 490
 491     return chr;
 492 }
 493
 494
 495 #ifdef _WIN32
 496 int send_all(int fd, const void *buf, int len1)
 497 {
 498     int ret, len;
 499
 500     len = len1;
 501     while (len > 0) {
 502         ret = send(fd, buf, len, 0);
 503         if (ret < 0) {
 504             errno = WSAGetLastError();
 505             if (errno != WSAEWOULDBLOCK) {
 506                 return -1;
 507             }
 508         } else if (ret == 0) {
 509             break;
 510         } else {
 511             buf += ret;
 512             len -= ret;
 513         }
 514     }
 515     return len1 - len;
 516 }
 517
 518 #else
 519
 520 int send_all(int fd, const void *_buf, int len1)
 521 {
 522     int ret, len;
 523     const uint8_t *buf = _buf;
 524
 525     len = len1;
 526     while (len > 0) {
 527         ret = write(fd, buf, len);
 528         if (ret < 0) {
 529             if (errno != EINTR && errno != EAGAIN)
 530                 return -1;
 531         } else if (ret == 0) {
 532             break;
 533         } else {
 534             buf += ret;
 535             len -= ret;
 536         }
 537     }
 538     return len1 - len;
 539 }
 540 #endif /* !_WIN32 */
 541
 542 #ifndef _WIN32
 543
 544 typedef struct IOWatchPoll
 545 {
 546     GSource *src;
 547     int max_size;
 548
 549     IOCanReadHandler *fd_can_read;
 550     void *opaque;
 551
 552     QTAILQ_ENTRY(IOWatchPoll) node;
 553 } IOWatchPoll;
 554
 555 static QTAILQ_HEAD(, IOWatchPoll) io_watch_poll_list =
 556     QTAILQ_HEAD_INITIALIZER(io_watch_poll_list);
 557
 558 static IOWatchPoll *io_watch_poll_from_source(GSource *source)
 559 {
 560     IOWatchPoll *i;
 561
 562     QTAILQ_FOREACH(i, &io_watch_poll_list, node) {
 563         if (i->src == source) {
 564             return i;
 565         }
 566     }
 567
 568     return NULL;
 569 }
 570
 571 static gboolean io_watch_poll_prepare(GSource *source, gint *timeout_)
 572 {
 573     IOWatchPoll *iwp = io_watch_poll_from_source(source);
 574
 575     iwp->max_size = iwp->fd_can_read(iwp->opaque);
 576     if (iwp->max_size == 0) {
 577         return FALSE;
 578     }
 579
 580     return g_io_watch_funcs.prepare(source, timeout_);
 581 }
 582
 583 static gboolean io_watch_poll_check(GSource *source)
 584 {
 585     IOWatchPoll *iwp = io_watch_poll_from_source(source);
 586
 587     if (iwp->max_size == 0) {
 588         return FALSE;
 589     }
 590
 591     return g_io_watch_funcs.check(source);
 592 }
 593
 594 static gboolean io_watch_poll_dispatch(GSource *source, GSourceFunc callback,
 595                                        gpointer user_data)
 596 {
 597     return g_io_watch_funcs.dispatch(source, callback, user_data);
 598 }
 599
 600 static void io_watch_poll_finalize(GSource *source)
 601 {
 602     IOWatchPoll *iwp = io_watch_poll_from_source(source);
 603     QTAILQ_REMOVE(&io_watch_poll_list, iwp, node);
 604     g_io_watch_funcs.finalize(source);
 605 }
 606
 607 static GSourceFuncs io_watch_poll_funcs = {
 608     .prepare = io_watch_poll_prepare,
 609     .check = io_watch_poll_check,
 610     .dispatch = io_watch_poll_dispatch,
 611     .finalize = io_watch_poll_finalize,
 612 };
 613
 614 /* Can only be used for read */
 615 static guint io_add_watch_poll(GIOChannel *channel,
 616                                IOCanReadHandler *fd_can_read,
 617                                GIOFunc fd_read,
 618                                gpointer user_data)
 619 {
 620     IOWatchPoll *iwp;
 621     GSource *src;
 622     guint tag;
 623
 624     src = g_io_create_watch(channel, G_IO_IN | G_IO_ERR | G_IO_HUP);
 625     g_source_set_funcs(src, &io_watch_poll_funcs);
 626     g_source_set_callback(src, (GSourceFunc)fd_read, user_data, NULL);
 627     tag = g_source_attach(src, NULL);
 628     g_source_unref(src);
 629
 630     iwp = g_malloc0(sizeof(*iwp));
 631     iwp->src = src;
 632     iwp->max_size = 0;
 633     iwp->fd_can_read = fd_can_read;
 634     iwp->opaque = user_data;
 635
 636     QTAILQ_INSERT_HEAD(&io_watch_poll_list, iwp, node);
 637
 638     return tag;
 639 }
 640
 641 static GIOChannel *io_channel_from_fd(int fd)
 642 {
 643     GIOChannel *chan;
 644
 645     if (fd == -1) {
 646         return NULL;
 647     }
 648
 649     chan = g_io_channel_unix_new(fd);
 650
 651     g_io_channel_set_encoding(chan, NULL, NULL);
 652     g_io_channel_set_buffered(chan, FALSE);
 653
 654     return chan;
 655 }
 656
 657 static int io_channel_send_all(GIOChannel *fd, const void *_buf, int len1)
 658 {
 659     GIOStatus status;
 660     gsize bytes_written;
 661     int len;
 662     const uint8_t *buf = _buf;
 663
 664     len = len1;
 665     while (len > 0) {
 666         status = g_io_channel_write_chars(fd, (const gchar *)buf, len,
 667                                           &bytes_written, NULL);
 668         if (status != G_IO_STATUS_NORMAL) {
 669             if (status != G_IO_STATUS_AGAIN) {
 670                 return -1;
 671             }
 672         } else if (status == G_IO_STATUS_EOF) {
 673             break;
 674         } else {
 675             buf += bytes_written;
 676             len -= bytes_written;
 677         }
 678     }
 679     return len1 - len;
 680 }
 681
 682 typedef struct FDCharDriver {
 683     CharDriverState *chr;
 684     GIOChannel *fd_in, *fd_out;
 685     guint fd_in_tag;
 686     int max_size;
 687     QTAILQ_ENTRY(FDCharDriver) node;
 688 } FDCharDriver;
 689
 690 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 691 {
 692     FDCharDriver *s = chr->opaque;
 693
 694     return io_channel_send_all(s->fd_out, buf, len);
 695 }
 696
 697 static gboolean fd_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)
 698 {
 699     CharDriverState *chr = opaque;
 700     FDCharDriver *s = chr->opaque;
 701     int len;
 702     uint8_t buf[READ_BUF_LEN];
 703     GIOStatus status;
 704     gsize bytes_read;
 705
 706     len = sizeof(buf);
 707     if (len > s->max_size) {
 708         len = s->max_size;
 709     }
 710     if (len == 0) {
 711         return FALSE;
 712     }
 713
 714     status = g_io_channel_read_chars(chan, (gchar *)buf,
 715                                      len, &bytes_read, NULL);
 716     if (status == G_IO_STATUS_EOF) {
 717         qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 718         return FALSE;
 719     }
 720     if (status == G_IO_STATUS_NORMAL) {
 721         qemu_chr_be_write(chr, buf, bytes_read);
 722     }
 723
 724     return TRUE;
 725 }
 726
 727 static int fd_chr_read_poll(void *opaque)
 728 {
 729     CharDriverState *chr = opaque;
 730     FDCharDriver *s = chr->opaque;
 731
 732     s->max_size = qemu_chr_be_can_write(chr);
 733     return s->max_size;
 734 }
 735
 736 static void fd_chr_update_read_handler(CharDriverState *chr)
 737 {
 738     FDCharDriver *s = chr->opaque;
 739
 740     if (s->fd_in_tag) {
 741         g_source_remove(s->fd_in_tag);
 742     }
 743
 744     if (s->fd_in) {
 745         s->fd_in_tag = io_add_watch_poll(s->fd_in, fd_chr_read_poll, fd_chr_read, chr);
 746     }
 747 }
 748
 749 static void fd_chr_close(struct CharDriverState *chr)
 750 {
 751     FDCharDriver *s = chr->opaque;
 752
 753     if (s->fd_in_tag) {
 754         g_source_remove(s->fd_in_tag);
 755         s->fd_in_tag = 0;
 756     }
 757
 758     if (s->fd_in) {
 759         g_io_channel_unref(s->fd_in);
 760     }
 761     if (s->fd_out) {
 762         g_io_channel_unref(s->fd_out);
 763     }
 764
 765     g_free(s);
 766     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
 767 }
 768
 769 /* open a character device to a unix fd */
 770 static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
 771 {
 772     CharDriverState *chr;
 773     FDCharDriver *s;
 774
 775     chr = g_malloc0(sizeof(CharDriverState));
 776     s = g_malloc0(sizeof(FDCharDriver));
 777     s->fd_in = io_channel_from_fd(fd_in);
 778     s->fd_out = io_channel_from_fd(fd_out);
 779     s->chr = chr;
 780     chr->opaque = s;
 781     chr->chr_write = fd_chr_write;
 782     chr->chr_update_read_handler = fd_chr_update_read_handler;
 783     chr->chr_close = fd_chr_close;
 784
 785     qemu_chr_generic_open(chr);
 786
 787     return chr;
 788 }
 789
 790 static CharDriverState *qemu_chr_open_file_out(QemuOpts *opts)
 791 {
 792     int fd_out;
 793
 794     TFR(fd_out = qemu_open(qemu_opt_get(opts, "path"),
 795                       O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
 796     if (fd_out < 0) {
 797         return NULL;
 798     }
 799     return qemu_chr_open_fd(-1, fd_out);
 800 }
 801
 802 static CharDriverState *qemu_chr_open_pipe(QemuOpts *opts)
 803 {
 804     int fd_in, fd_out;
 805     char filename_in[256], filename_out[256];
 806     const char *filename = qemu_opt_get(opts, "path");
 807
 808     if (filename == NULL) {
 809         fprintf(stderr, "chardev: pipe: no filename given\n");
 810         return NULL;
 811     }
 812
 813     snprintf(filename_in, 256, "%s.in", filename);
 814     snprintf(filename_out, 256, "%s.out", filename);
 815     TFR(fd_in = qemu_open(filename_in, O_RDWR | O_BINARY));
 816     TFR(fd_out = qemu_open(filename_out, O_RDWR | O_BINARY));
 817     if (fd_in < 0 || fd_out < 0) {
 818         if (fd_in >= 0)
 819             close(fd_in);
 820         if (fd_out >= 0)
 821             close(fd_out);
 822         TFR(fd_in = fd_out = qemu_open(filename, O_RDWR | O_BINARY));
 823         if (fd_in < 0) {
 824             return NULL;
 825         }
 826     }
 827     return qemu_chr_open_fd(fd_in, fd_out);
 828 }
 829
 830 /* init terminal so that we can grab keys */
 831 static struct termios oldtty;
 832 static int old_fd0_flags;
 833 static bool stdio_allow_signal;
 834
 835 static void term_exit(void)
 836 {
 837     tcsetattr (0, TCSANOW, &oldtty);
 838     fcntl(0, F_SETFL, old_fd0_flags);
 839 }
 840
 841 static void qemu_chr_set_echo_stdio(CharDriverState *chr, bool echo)
 842 {
 843     struct termios tty;
 844
 845     tty = oldtty;
 846     if (!echo) {
 847         tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 848                           |INLCR|IGNCR|ICRNL|IXON);
 849         tty.c_oflag |= OPOST;
 850         tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 851         tty.c_cflag &= ~(CSIZE|PARENB);
 852         tty.c_cflag |= CS8;
 853         tty.c_cc[VMIN] = 1;
 854         tty.c_cc[VTIME] = 0;
 855     }
 856     /* if graphical mode, we allow Ctrl-C handling */
 857     if (!stdio_allow_signal)
 858         tty.c_lflag &= ~ISIG;
 859
 860     tcsetattr (0, TCSANOW, &tty);
 861 }
 862
 863 static void qemu_chr_close_stdio(struct CharDriverState *chr)
 864 {
 865     term_exit();
 866     fd_chr_close(chr);
 867 }
 868
 869 static CharDriverState *qemu_chr_open_stdio(QemuOpts *opts)
 870 {
 871     CharDriverState *chr;
 872
 873     if (is_daemonized()) {
 874         error_report("cannot use stdio with -daemonize");
 875         return NULL;
 876     }
 877     old_fd0_flags = fcntl(0, F_GETFL);
 878     tcgetattr (0, &oldtty);
 879     fcntl(0, F_SETFL, O_NONBLOCK);
 880     atexit(term_exit);
 881
 882     chr = qemu_chr_open_fd(0, 1);
 883     chr->chr_close = qemu_chr_close_stdio;
 884     chr->chr_set_echo = qemu_chr_set_echo_stdio;
 885     stdio_allow_signal = qemu_opt_get_bool(opts, "signal",
 886                                            display_type != DT_NOGRAPHIC);
 887     qemu_chr_fe_set_echo(chr, false);
 888
 889     return chr;
 890 }
 891
 892 #ifdef __sun__
 893 /* Once Solaris has openpty(), this is going to be removed. */
 894 static int openpty(int *amaster, int *aslave, char *name,
 895                    struct termios *termp, struct winsize *winp)
 896 {
 897         const char *slave;
 898         int mfd = -1, sfd = -1;
 899
 900         *amaster = *aslave = -1;
 901
 902         mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
 903         if (mfd < 0)
 904                 goto err;
 905
 906         if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
 907                 goto err;
 908
 909         if ((slave = ptsname(mfd)) == NULL)
 910                 goto err;
 911
 912         if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
 913                 goto err;
 914
 915         if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
 916             (termp != NULL && tcgetattr(sfd, termp) < 0))
 917                 goto err;
 918
 919         if (amaster)
 920                 *amaster = mfd;
 921         if (aslave)
 922                 *aslave = sfd;
 923         if (winp)
 924                 ioctl(sfd, TIOCSWINSZ, winp);
 925
 926         return 0;
 927
 928 err:
 929         if (sfd != -1)
 930                 close(sfd);
 931         close(mfd);
 932         return -1;
 933 }
 934
 935 static void cfmakeraw (struct termios *termios_p)
 936 {
 937         termios_p->c_iflag &=
 938                 ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
 939         termios_p->c_oflag &= ~OPOST;
 940         termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
 941         termios_p->c_cflag &= ~(CSIZE|PARENB);
 942         termios_p->c_cflag |= CS8;
 943
 944         termios_p->c_cc[VMIN] = 0;
 945         termios_p->c_cc[VTIME] = 0;
 946 }
 947 #endif
 948
 949 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
 950     || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
 951     || defined(__GLIBC__)
 952
 953 #define HAVE_CHARDEV_TTY 1
 954
 955 typedef struct {
 956     int fd;
 957     int connected;
 958     int polling;
 959     int read_bytes;
 960     QEMUTimer *timer;
 961 } PtyCharDriver;
 962
 963 static void pty_chr_update_read_handler(CharDriverState *chr);
 964 static void pty_chr_state(CharDriverState *chr, int connected);
 965
 966 static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 967 {
 968     PtyCharDriver *s = chr->opaque;
 969
 970     if (!s->connected) {
 971         /* guest sends data, check for (re-)connect */
 972         pty_chr_update_read_handler(chr);
 973         return 0;
 974     }
 975     return send_all(s->fd, buf, len);
 976 }
 977
 978 static int pty_chr_read_poll(void *opaque)
 979 {
 980     CharDriverState *chr = opaque;
 981     PtyCharDriver *s = chr->opaque;
 982
 983     s->read_bytes = qemu_chr_be_can_write(chr);
 984     return s->read_bytes;
 985 }
 986
 987 static void pty_chr_read(void *opaque)
 988 {
 989     CharDriverState *chr = opaque;
 990     PtyCharDriver *s = chr->opaque;
 991     int size, len;
 992     uint8_t buf[READ_BUF_LEN];
 993
 994     len = sizeof(buf);
 995     if (len > s->read_bytes)
 996         len = s->read_bytes;
 997     if (len == 0)
 998         return;
 999     size = read(s->fd, buf, len);
1000     if ((size == -1 && errno == EIO) ||
1001         (size == 0)) {
1002         pty_chr_state(chr, 0);
1003         return;
1004     }
1005     if (size > 0) {
1006         pty_chr_state(chr, 1);
1007         qemu_chr_be_write(chr, buf, size);
1008     }
1009 }
1010
1011 static void pty_chr_update_read_handler(CharDriverState *chr)
1012 {
1013     PtyCharDriver *s = chr->opaque;
1014
1015     qemu_set_fd_handler2(s->fd, pty_chr_read_poll,
1016                          pty_chr_read, NULL, chr);
1017     s->polling = 1;
1018     /*
1019      * Short timeout here: just need wait long enougth that qemu makes
1020      * it through the poll loop once.  When reconnected we want a
1021      * short timeout so we notice it almost instantly.  Otherwise
1022      * read() gives us -EIO instantly, making pty_chr_state() reset the
1023      * timeout to the normal (much longer) poll interval before the
1024      * timer triggers.
1025      */
1026     qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 10);
1027 }
1028
1029 static void pty_chr_state(CharDriverState *chr, int connected)
1030 {
1031     PtyCharDriver *s = chr->opaque;
1032
1033     if (!connected) {
1034         qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
1035         s->connected = 0;
1036         s->polling = 0;
1037         /* (re-)connect poll interval for idle guests: once per second.
1038          * We check more frequently in case the guests sends data to
1039          * the virtual device linked to our pty. */
1040         qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 1000);
1041     } else {
1042         if (!s->connected)
1043             qemu_chr_generic_open(chr);
1044         s->connected = 1;
1045     }
1046 }
1047
1048 static void pty_chr_timer(void *opaque)
1049 {
1050     struct CharDriverState *chr = opaque;
1051     PtyCharDriver *s = chr->opaque;
1052
1053     if (s->connected)
1054         return;
1055     if (s->polling) {
1056         /* If we arrive here without polling being cleared due
1057          * read returning -EIO, then we are (re-)connected */
1058         pty_chr_state(chr, 1);
1059         return;
1060     }
1061
1062     /* Next poll ... */
1063     pty_chr_update_read_handler(chr);
1064 }
1065
1066 static void pty_chr_close(struct CharDriverState *chr)
1067 {
1068     PtyCharDriver *s = chr->opaque;
1069
1070     qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
1071     close(s->fd);
1072     qemu_del_timer(s->timer);
1073     qemu_free_timer(s->timer);
1074     g_free(s);
1075     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
1076 }
1077
1078 static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
1079 {
1080     CharDriverState *chr;
1081     PtyCharDriver *s;
1082     struct termios tty;
1083     const char *label;
1084     int master_fd, slave_fd, len;
1085 #if defined(__OpenBSD__) || defined(__DragonFly__)
1086     char pty_name[PATH_MAX];
1087 #define q_ptsname(x) pty_name
1088 #else
1089     char *pty_name = NULL;
1090 #define q_ptsname(x) ptsname(x)
1091 #endif
1092
1093     if (openpty(&master_fd, &slave_fd, pty_name, NULL, NULL) < 0) {
1094         return NULL;
1095     }
1096
1097     /* Set raw attributes on the pty. */
1098     tcgetattr(slave_fd, &tty);
1099     cfmakeraw(&tty);
1100     tcsetattr(slave_fd, TCSAFLUSH, &tty);
1101     close(slave_fd);
1102
1103     chr = g_malloc0(sizeof(CharDriverState));
1104
1105     len = strlen(q_ptsname(master_fd)) + 5;
1106     chr->filename = g_malloc(len);
1107     snprintf(chr->filename, len, "pty:%s", q_ptsname(master_fd));
1108     qemu_opt_set(opts, "path", q_ptsname(master_fd));
1109
1110     label = qemu_opts_id(opts);
1111     fprintf(stderr, "char device redirected to %s%s%s%s\n",
1112             q_ptsname(master_fd),
1113             label ? " (label " : "",
1114             label ? label      : "",
1115             label ? ")"        : "");
1116
1117     s = g_malloc0(sizeof(PtyCharDriver));
1118     chr->opaque = s;
1119     chr->chr_write = pty_chr_write;
1120     chr->chr_update_read_handler = pty_chr_update_read_handler;
1121     chr->chr_close = pty_chr_close;
1122
1123     s->fd = master_fd;
1124     s->timer = qemu_new_timer_ms(rt_clock, pty_chr_timer, chr);
1125
1126     return chr;
1127 }
1128
1129 static void tty_serial_init(int fd, int speed,
1130                             int parity, int data_bits, int stop_bits)
1131 {
1132     struct termios tty;
1133     speed_t spd;
1134
1135 #if 0
1136     printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
1137            speed, parity, data_bits, stop_bits);
1138 #endif
1139     tcgetattr (fd, &tty);
1140
1141 #define check_speed(val) if (speed <= val) { spd = B##val; break; }
1142     speed = speed * 10 / 11;
1143     do {
1144         check_speed(50);
1145         check_speed(75);
1146         check_speed(110);
1147         check_speed(134);
1148         check_speed(150);
1149         check_speed(200);
1150         check_speed(300);
1151         check_speed(600);
1152         check_speed(1200);
1153         check_speed(1800);
1154         check_speed(2400);
1155         check_speed(4800);
1156         check_speed(9600);
1157         check_speed(19200);
1158         check_speed(38400);
1159         /* Non-Posix values follow. They may be unsupported on some systems. */
1160         check_speed(57600);
1161         check_speed(115200);
1162 #ifdef B230400
1163         check_speed(230400);
1164 #endif
1165 #ifdef B460800
1166         check_speed(460800);
1167 #endif
1168 #ifdef B500000
1169         check_speed(500000);
1170 #endif
1171 #ifdef B576000
1172         check_speed(576000);
1173 #endif
1174 #ifdef B921600
1175         check_speed(921600);
1176 #endif
1177 #ifdef B1000000
1178         check_speed(1000000);
1179 #endif
1180 #ifdef B1152000
1181         check_speed(1152000);
1182 #endif
1183 #ifdef B1500000
1184         check_speed(1500000);
1185 #endif
1186 #ifdef B2000000
1187         check_speed(2000000);
1188 #endif
1189 #ifdef B2500000
1190         check_speed(2500000);
1191 #endif
1192 #ifdef B3000000
1193         check_speed(3000000);
1194 #endif
1195 #ifdef B3500000
1196         check_speed(3500000);
1197 #endif
1198 #ifdef B4000000
1199         check_speed(4000000);
1200 #endif
1201         spd = B115200;
1202     } while (0);
1203
1204     cfsetispeed(&tty, spd);
1205     cfsetospeed(&tty, spd);
1206
1207     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1208                           |INLCR|IGNCR|ICRNL|IXON);
1209     tty.c_oflag |= OPOST;
1210     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
1211     tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
1212     switch(data_bits) {
1213     default:
1214     case 8:
1215         tty.c_cflag |= CS8;
1216         break;
1217     case 7:
1218         tty.c_cflag |= CS7;
1219         break;
1220     case 6:
1221         tty.c_cflag |= CS6;
1222         break;
1223     case 5:
1224         tty.c_cflag |= CS5;
1225         break;
1226     }
1227     switch(parity) {
1228     default:
1229     case 'N':
1230         break;
1231     case 'E':
1232         tty.c_cflag |= PARENB;
1233         break;
1234     case 'O':
1235         tty.c_cflag |= PARENB | PARODD;
1236         break;
1237     }
1238     if (stop_bits == 2)
1239         tty.c_cflag |= CSTOPB;
1240
1241     tcsetattr (fd, TCSANOW, &tty);
1242 }
1243
1244 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1245 {
1246     FDCharDriver *s = chr->opaque;
1247
1248     switch(cmd) {
1249     case CHR_IOCTL_SERIAL_SET_PARAMS:
1250         {
1251             QEMUSerialSetParams *ssp = arg;
1252             tty_serial_init(g_io_channel_unix_get_fd(s->fd_in),
1253                             ssp->speed, ssp->parity,
1254                             ssp->data_bits, ssp->stop_bits);
1255         }
1256         break;
1257     case CHR_IOCTL_SERIAL_SET_BREAK:
1258         {
1259             int enable = *(int *)arg;
1260             if (enable) {
1261                 tcsendbreak(g_io_channel_unix_get_fd(s->fd_in), 1);
1262             }
1263         }
1264         break;
1265     case CHR_IOCTL_SERIAL_GET_TIOCM:
1266         {
1267             int sarg = 0;
1268             int *targ = (int *)arg;
1269             ioctl(g_io_channel_unix_get_fd(s->fd_in), TIOCMGET, &sarg);
1270             *targ = 0;
1271             if (sarg & TIOCM_CTS)
1272                 *targ |= CHR_TIOCM_CTS;
1273             if (sarg & TIOCM_CAR)
1274                 *targ |= CHR_TIOCM_CAR;
1275             if (sarg & TIOCM_DSR)
1276                 *targ |= CHR_TIOCM_DSR;
1277             if (sarg & TIOCM_RI)
1278                 *targ |= CHR_TIOCM_RI;
1279             if (sarg & TIOCM_DTR)
1280                 *targ |= CHR_TIOCM_DTR;
1281             if (sarg & TIOCM_RTS)
1282                 *targ |= CHR_TIOCM_RTS;
1283         }
1284         break;
1285     case CHR_IOCTL_SERIAL_SET_TIOCM:
1286         {
1287             int sarg = *(int *)arg;
1288             int targ = 0;
1289             ioctl(g_io_channel_unix_get_fd(s->fd_in), TIOCMGET, &targ);
1290             targ &= ~(CHR_TIOCM_CTS | CHR_TIOCM_CAR | CHR_TIOCM_DSR
1291                      | CHR_TIOCM_RI | CHR_TIOCM_DTR | CHR_TIOCM_RTS);
1292             if (sarg & CHR_TIOCM_CTS)
1293                 targ |= TIOCM_CTS;
1294             if (sarg & CHR_TIOCM_CAR)
1295                 targ |= TIOCM_CAR;
1296             if (sarg & CHR_TIOCM_DSR)
1297                 targ |= TIOCM_DSR;
1298             if (sarg & CHR_TIOCM_RI)
1299                 targ |= TIOCM_RI;
1300             if (sarg & CHR_TIOCM_DTR)
1301                 targ |= TIOCM_DTR;
1302             if (sarg & CHR_TIOCM_RTS)
1303                 targ |= TIOCM_RTS;
1304             ioctl(g_io_channel_unix_get_fd(s->fd_in), TIOCMSET, &targ);
1305         }
1306         break;
1307     default:
1308         return -ENOTSUP;
1309     }
1310     return 0;
1311 }
1312
1313 static void qemu_chr_close_tty(CharDriverState *chr)
1314 {
1315     FDCharDriver *s = chr->opaque;
1316     int fd = -1;
1317
1318     if (s) {
1319         fd = g_io_channel_unix_get_fd(s->fd_in);
1320     }
1321
1322     fd_chr_close(chr);
1323
1324     if (fd >= 0) {
1325         close(fd);
1326     }
1327 }
1328
1329 static CharDriverState *qemu_chr_open_tty_fd(int fd)
1330 {
1331     CharDriverState *chr;
1332
1333     tty_serial_init(fd, 115200, 'N', 8, 1);
1334     chr = qemu_chr_open_fd(fd, fd);
1335     chr->chr_ioctl = tty_serial_ioctl;
1336     chr->chr_close = qemu_chr_close_tty;
1337     return chr;
1338 }
1339
1340 static CharDriverState *qemu_chr_open_tty(QemuOpts *opts)
1341 {
1342     const char *filename = qemu_opt_get(opts, "path");
1343     int fd;
1344
1345     TFR(fd = qemu_open(filename, O_RDWR | O_NONBLOCK));
1346     if (fd < 0) {
1347         return NULL;
1348     }
1349     return qemu_chr_open_tty_fd(fd);
1350 }
1351 #endif /* __linux__ || __sun__ */
1352
1353 #if defined(__linux__)
1354
1355 #define HAVE_CHARDEV_PARPORT 1
1356
1357 typedef struct {
1358     int fd;
1359     int mode;
1360 } ParallelCharDriver;
1361
1362 static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
1363 {
1364     if (s->mode != mode) {
1365         int m = mode;
1366         if (ioctl(s->fd, PPSETMODE, &m) < 0)
1367             return 0;
1368         s->mode = mode;
1369     }
1370     return 1;
1371 }
1372
1373 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1374 {
1375     ParallelCharDriver *drv = chr->opaque;
1376     int fd = drv->fd;
1377     uint8_t b;
1378
1379     switch(cmd) {
1380     case CHR_IOCTL_PP_READ_DATA:
1381         if (ioctl(fd, PPRDATA, &b) < 0)
1382             return -ENOTSUP;
1383         *(uint8_t *)arg = b;
1384         break;
1385     case CHR_IOCTL_PP_WRITE_DATA:
1386         b = *(uint8_t *)arg;
1387         if (ioctl(fd, PPWDATA, &b) < 0)
1388             return -ENOTSUP;
1389         break;
1390     case CHR_IOCTL_PP_READ_CONTROL:
1391         if (ioctl(fd, PPRCONTROL, &b) < 0)
1392             return -ENOTSUP;
1393         /* Linux gives only the lowest bits, and no way to know data
1394            direction! For better compatibility set the fixed upper
1395            bits. */
1396         *(uint8_t *)arg = b | 0xc0;
1397         break;
1398     case CHR_IOCTL_PP_WRITE_CONTROL:
1399         b = *(uint8_t *)arg;
1400         if (ioctl(fd, PPWCONTROL, &b) < 0)
1401             return -ENOTSUP;
1402         break;
1403     case CHR_IOCTL_PP_READ_STATUS:
1404         if (ioctl(fd, PPRSTATUS, &b) < 0)
1405             return -ENOTSUP;
1406         *(uint8_t *)arg = b;
1407         break;
1408     case CHR_IOCTL_PP_DATA_DIR:
1409         if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
1410             return -ENOTSUP;
1411         break;
1412     case CHR_IOCTL_PP_EPP_READ_ADDR:
1413         if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
1414             struct ParallelIOArg *parg = arg;
1415             int n = read(fd, parg->buffer, parg->count);
1416             if (n != parg->count) {
1417                 return -EIO;
1418             }
1419         }
1420         break;
1421     case CHR_IOCTL_PP_EPP_READ:
1422         if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
1423             struct ParallelIOArg *parg = arg;
1424             int n = read(fd, parg->buffer, parg->count);
1425             if (n != parg->count) {
1426                 return -EIO;
1427             }
1428         }
1429         break;
1430     case CHR_IOCTL_PP_EPP_WRITE_ADDR:
1431         if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
1432             struct ParallelIOArg *parg = arg;
1433             int n = write(fd, parg->buffer, parg->count);
1434             if (n != parg->count) {
1435                 return -EIO;
1436             }
1437         }
1438         break;
1439     case CHR_IOCTL_PP_EPP_WRITE:
1440         if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
1441             struct ParallelIOArg *parg = arg;
1442             int n = write(fd, parg->buffer, parg->count);
1443             if (n != parg->count) {
1444                 return -EIO;
1445             }
1446         }
1447         break;
1448     default:
1449         return -ENOTSUP;
1450     }
1451     return 0;
1452 }
1453
1454 static void pp_close(CharDriverState *chr)
1455 {
1456     ParallelCharDriver *drv = chr->opaque;
1457     int fd = drv->fd;
1458
1459     pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
1460     ioctl(fd, PPRELEASE);
1461     close(fd);
1462     g_free(drv);
1463     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
1464 }
1465
1466 static CharDriverState *qemu_chr_open_pp_fd(int fd)
1467 {
1468     CharDriverState *chr;
1469     ParallelCharDriver *drv;
1470
1471     if (ioctl(fd, PPCLAIM) < 0) {
1472         close(fd);
1473         return NULL;
1474     }
1475
1476     drv = g_malloc0(sizeof(ParallelCharDriver));
1477     drv->fd = fd;
1478     drv->mode = IEEE1284_MODE_COMPAT;
1479
1480     chr = g_malloc0(sizeof(CharDriverState));
1481     chr->chr_write = null_chr_write;
1482     chr->chr_ioctl = pp_ioctl;
1483     chr->chr_close = pp_close;
1484     chr->opaque = drv;
1485
1486     qemu_chr_generic_open(chr);
1487
1488     return chr;
1489 }
1490 #endif /* __linux__ */
1491
1492 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
1493
1494 #define HAVE_CHARDEV_PARPORT 1
1495
1496 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1497 {
1498     int fd = (int)(intptr_t)chr->opaque;
1499     uint8_t b;
1500
1501     switch(cmd) {
1502     case CHR_IOCTL_PP_READ_DATA:
1503         if (ioctl(fd, PPIGDATA, &b) < 0)
1504             return -ENOTSUP;
1505         *(uint8_t *)arg = b;
1506         break;
1507     case CHR_IOCTL_PP_WRITE_DATA:
1508         b = *(uint8_t *)arg;
1509         if (ioctl(fd, PPISDATA, &b) < 0)
1510             return -ENOTSUP;
1511         break;
1512     case CHR_IOCTL_PP_READ_CONTROL:
1513         if (ioctl(fd, PPIGCTRL, &b) < 0)
1514             return -ENOTSUP;
1515         *(uint8_t *)arg = b;
1516         break;
1517     case CHR_IOCTL_PP_WRITE_CONTROL:
1518         b = *(uint8_t *)arg;
1519         if (ioctl(fd, PPISCTRL, &b) < 0)
1520             return -ENOTSUP;
1521         break;
1522     case CHR_IOCTL_PP_READ_STATUS:
1523         if (ioctl(fd, PPIGSTATUS, &b) < 0)
1524             return -ENOTSUP;
1525         *(uint8_t *)arg = b;
1526         break;
1527     default:
1528         return -ENOTSUP;
1529     }
1530     return 0;
1531 }
1532
1533 static CharDriverState *qemu_chr_open_pp_fd(int fd)
1534 {
1535     CharDriverState *chr;
1536
1537     chr = g_malloc0(sizeof(CharDriverState));
1538     chr->opaque = (void *)(intptr_t)fd;
1539     chr->chr_write = null_chr_write;
1540     chr->chr_ioctl = pp_ioctl;
1541     return chr;
1542 }
1543 #endif
1544
1545 #else /* _WIN32 */
1546
1547 typedef struct {
1548     int max_size;
1549     HANDLE hcom, hrecv, hsend;
1550     OVERLAPPED orecv, osend;
1551     BOOL fpipe;
1552     DWORD len;
1553 } WinCharState;
1554
1555 typedef struct {
1556     HANDLE  hStdIn;
1557     HANDLE  hInputReadyEvent;
1558     HANDLE  hInputDoneEvent;
1559     HANDLE  hInputThread;
1560     uint8_t win_stdio_buf;
1561 } WinStdioCharState;
1562
1563 #define NSENDBUF 2048
1564 #define NRECVBUF 2048
1565 #define MAXCONNECT 1
1566 #define NTIMEOUT 5000
1567
1568 static int win_chr_poll(void *opaque);
1569 static int win_chr_pipe_poll(void *opaque);
1570
1571 static void win_chr_close(CharDriverState *chr)
1572 {
1573     WinCharState *s = chr->opaque;
1574
1575     if (s->hsend) {
1576         CloseHandle(s->hsend);
1577         s->hsend = NULL;
1578     }
1579     if (s->hrecv) {
1580         CloseHandle(s->hrecv);
1581         s->hrecv = NULL;
1582     }
1583     if (s->hcom) {
1584         CloseHandle(s->hcom);
1585         s->hcom = NULL;
1586     }
1587     if (s->fpipe)
1588         qemu_del_polling_cb(win_chr_pipe_poll, chr);
1589     else
1590         qemu_del_polling_cb(win_chr_poll, chr);
1591
1592     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
1593 }
1594
1595 static int win_chr_init(CharDriverState *chr, const char *filename)
1596 {
1597     WinCharState *s = chr->opaque;
1598     COMMCONFIG comcfg;
1599     COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
1600     COMSTAT comstat;
1601     DWORD size;
1602     DWORD err;
1603
1604     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1605     if (!s->hsend) {
1606         fprintf(stderr, "Failed CreateEvent\n");
1607         goto fail;
1608     }
1609     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1610     if (!s->hrecv) {
1611         fprintf(stderr, "Failed CreateEvent\n");
1612         goto fail;
1613     }
1614
1615     s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
1616                       OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
1617     if (s->hcom == INVALID_HANDLE_VALUE) {
1618         fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
1619         s->hcom = NULL;
1620         goto fail;
1621     }
1622
1623     if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
1624         fprintf(stderr, "Failed SetupComm\n");
1625         goto fail;
1626     }
1627
1628     ZeroMemory(&comcfg, sizeof(COMMCONFIG));
1629     size = sizeof(COMMCONFIG);
1630     GetDefaultCommConfig(filename, &comcfg, &size);
1631     comcfg.dcb.DCBlength = sizeof(DCB);
1632     CommConfigDialog(filename, NULL, &comcfg);
1633
1634     if (!SetCommState(s->hcom, &comcfg.dcb)) {
1635         fprintf(stderr, "Failed SetCommState\n");
1636         goto fail;
1637     }
1638
1639     if (!SetCommMask(s->hcom, EV_ERR)) {
1640         fprintf(stderr, "Failed SetCommMask\n");
1641         goto fail;
1642     }
1643
1644     cto.ReadIntervalTimeout = MAXDWORD;
1645     if (!SetCommTimeouts(s->hcom, &cto)) {
1646         fprintf(stderr, "Failed SetCommTimeouts\n");
1647         goto fail;
1648     }
1649
1650     if (!ClearCommError(s->hcom, &err, &comstat)) {
1651         fprintf(stderr, "Failed ClearCommError\n");
1652         goto fail;
1653     }
1654     qemu_add_polling_cb(win_chr_poll, chr);
1655     return 0;
1656
1657  fail:
1658     win_chr_close(chr);
1659     return -1;
1660 }
1661
1662 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
1663 {
1664     WinCharState *s = chr->opaque;
1665     DWORD len, ret, size, err;
1666
1667     len = len1;
1668     ZeroMemory(&s->osend, sizeof(s->osend));
1669     s->osend.hEvent = s->hsend;
1670     while (len > 0) {
1671         if (s->hsend)
1672             ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
1673         else
1674             ret = WriteFile(s->hcom, buf, len, &size, NULL);
1675         if (!ret) {
1676             err = GetLastError();
1677             if (err == ERROR_IO_PENDING) {
1678                 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
1679                 if (ret) {
1680                     buf += size;
1681                     len -= size;
1682                 } else {
1683                     break;
1684                 }
1685             } else {
1686                 break;
1687             }
1688         } else {
1689             buf += size;
1690             len -= size;
1691         }
1692     }
1693     return len1 - len;
1694 }
1695
1696 static int win_chr_read_poll(CharDriverState *chr)
1697 {
1698     WinCharState *s = chr->opaque;
1699
1700     s->max_size = qemu_chr_be_can_write(chr);
1701     return s->max_size;
1702 }
1703
1704 static void win_chr_readfile(CharDriverState *chr)
1705 {
1706     WinCharState *s = chr->opaque;
1707     int ret, err;
1708     uint8_t buf[READ_BUF_LEN];
1709     DWORD size;
1710
1711     ZeroMemory(&s->orecv, sizeof(s->orecv));
1712     s->orecv.hEvent = s->hrecv;
1713     ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
1714     if (!ret) {
1715         err = GetLastError();
1716         if (err == ERROR_IO_PENDING) {
1717             ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
1718         }
1719     }
1720
1721     if (size > 0) {
1722         qemu_chr_be_write(chr, buf, size);
1723     }
1724 }
1725
1726 static void win_chr_read(CharDriverState *chr)
1727 {
1728     WinCharState *s = chr->opaque;
1729
1730     if (s->len > s->max_size)
1731         s->len = s->max_size;
1732     if (s->len == 0)
1733         return;
1734
1735     win_chr_readfile(chr);
1736 }
1737
1738 static int win_chr_poll(void *opaque)
1739 {
1740     CharDriverState *chr = opaque;
1741     WinCharState *s = chr->opaque;
1742     COMSTAT status;
1743     DWORD comerr;
1744
1745     ClearCommError(s->hcom, &comerr, &status);
1746     if (status.cbInQue > 0) {
1747         s->len = status.cbInQue;
1748         win_chr_read_poll(chr);
1749         win_chr_read(chr);
1750         return 1;
1751     }
1752     return 0;
1753 }
1754
1755 static CharDriverState *qemu_chr_open_win_path(const char *filename)
1756 {
1757     CharDriverState *chr;
1758     WinCharState *s;
1759
1760     chr = g_malloc0(sizeof(CharDriverState));
1761     s = g_malloc0(sizeof(WinCharState));
1762     chr->opaque = s;
1763     chr->chr_write = win_chr_write;
1764     chr->chr_close = win_chr_close;
1765
1766     if (win_chr_init(chr, filename) < 0) {
1767         g_free(s);
1768         g_free(chr);
1769         return NULL;
1770     }
1771     qemu_chr_generic_open(chr);
1772     return chr;
1773 }
1774
1775 static CharDriverState *qemu_chr_open_win(QemuOpts *opts)
1776 {
1777     return qemu_chr_open_win_path(qemu_opt_get(opts, "path"));
1778 }
1779
1780 static int win_chr_pipe_poll(void *opaque)
1781 {
1782     CharDriverState *chr = opaque;
1783     WinCharState *s = chr->opaque;
1784     DWORD size;
1785
1786     PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
1787     if (size > 0) {
1788         s->len = size;
1789         win_chr_read_poll(chr);
1790         win_chr_read(chr);
1791         return 1;
1792     }
1793     return 0;
1794 }
1795
1796 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
1797 {
1798     WinCharState *s = chr->opaque;
1799     OVERLAPPED ov;
1800     int ret;
1801     DWORD size;
1802     char openname[256];
1803
1804     s->fpipe = TRUE;
1805
1806     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1807     if (!s->hsend) {
1808         fprintf(stderr, "Failed CreateEvent\n");
1809         goto fail;
1810     }
1811     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1812     if (!s->hrecv) {
1813         fprintf(stderr, "Failed CreateEvent\n");
1814         goto fail;
1815     }
1816
1817     snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
1818     s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
1819                               PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
1820                               PIPE_WAIT,
1821                               MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
1822     if (s->hcom == INVALID_HANDLE_VALUE) {
1823         fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
1824         s->hcom = NULL;
1825         goto fail;
1826     }
1827
1828     ZeroMemory(&ov, sizeof(ov));
1829     ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
1830     ret = ConnectNamedPipe(s->hcom, &ov);
1831     if (ret) {
1832         fprintf(stderr, "Failed ConnectNamedPipe\n");
1833         goto fail;
1834     }
1835
1836     ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
1837     if (!ret) {
1838         fprintf(stderr, "Failed GetOverlappedResult\n");
1839         if (ov.hEvent) {
1840             CloseHandle(ov.hEvent);
1841             ov.hEvent = NULL;
1842         }
1843         goto fail;
1844     }
1845
1846     if (ov.hEvent) {
1847         CloseHandle(ov.hEvent);
1848         ov.hEvent = NULL;
1849     }
1850     qemu_add_polling_cb(win_chr_pipe_poll, chr);
1851     return 0;
1852
1853  fail:
1854     win_chr_close(chr);
1855     return -1;
1856 }
1857
1858
1859 static CharDriverState *qemu_chr_open_win_pipe(QemuOpts *opts)
1860 {
1861     const char *filename = qemu_opt_get(opts, "path");
1862     CharDriverState *chr;
1863     WinCharState *s;
1864
1865     chr = g_malloc0(sizeof(CharDriverState));
1866     s = g_malloc0(sizeof(WinCharState));
1867     chr->opaque = s;
1868     chr->chr_write = win_chr_write;
1869     chr->chr_close = win_chr_close;
1870
1871     if (win_chr_pipe_init(chr, filename) < 0) {
1872         g_free(s);
1873         g_free(chr);
1874         return NULL;
1875     }
1876     qemu_chr_generic_open(chr);
1877     return chr;
1878 }
1879
1880 static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
1881 {
1882     CharDriverState *chr;
1883     WinCharState *s;
1884
1885     chr = g_malloc0(sizeof(CharDriverState));
1886     s = g_malloc0(sizeof(WinCharState));
1887     s->hcom = fd_out;
1888     chr->opaque = s;
1889     chr->chr_write = win_chr_write;
1890     qemu_chr_generic_open(chr);
1891     return chr;
1892 }
1893
1894 static CharDriverState *qemu_chr_open_win_con(QemuOpts *opts)
1895 {
1896     return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
1897 }
1898
1899 static CharDriverState *qemu_chr_open_win_file_out(QemuOpts *opts)
1900 {
1901     const char *file_out = qemu_opt_get(opts, "path");
1902     HANDLE fd_out;
1903
1904     fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
1905                         OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1906     if (fd_out == INVALID_HANDLE_VALUE) {
1907         return NULL;
1908     }
1909
1910     return qemu_chr_open_win_file(fd_out);
1911 }
1912
1913 static int win_stdio_write(CharDriverState *chr, const uint8_t *buf, int len)
1914 {
1915     HANDLE  hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
1916     DWORD   dwSize;
1917     int     len1;
1918
1919     len1 = len;
1920
1921     while (len1 > 0) {
1922         if (!WriteFile(hStdOut, buf, len1, &dwSize, NULL)) {
1923             break;
1924         }
1925         buf  += dwSize;
1926         len1 -= dwSize;
1927     }
1928
1929     return len - len1;
1930 }
1931
1932 static void win_stdio_wait_func(void *opaque)
1933 {
1934     CharDriverState   *chr   = opaque;
1935     WinStdioCharState *stdio = chr->opaque;
1936     INPUT_RECORD       buf[4];
1937     int                ret;
1938     DWORD              dwSize;
1939     int                i;
1940
1941     ret = ReadConsoleInput(stdio->hStdIn, buf, sizeof(buf) / sizeof(*buf),
1942                            &dwSize);
1943
1944     if (!ret) {
1945         /* Avoid error storm */
1946         qemu_del_wait_object(stdio->hStdIn, NULL, NULL);
1947         return;
1948     }
1949
1950     for (i = 0; i < dwSize; i++) {
1951         KEY_EVENT_RECORD *kev = &buf[i].Event.KeyEvent;
1952
1953         if (buf[i].EventType == KEY_EVENT && kev->bKeyDown) {
1954             int j;
1955             if (kev->uChar.AsciiChar != 0) {
1956                 for (j = 0; j < kev->wRepeatCount; j++) {
1957                     if (qemu_chr_be_can_write(chr)) {
1958                         uint8_t c = kev->uChar.AsciiChar;
1959                         qemu_chr_be_write(chr, &c, 1);
1960                     }
1961                 }
1962             }
1963         }
1964     }
1965 }
1966
1967 static DWORD WINAPI win_stdio_thread(LPVOID param)
1968 {
1969     CharDriverState   *chr   = param;
1970     WinStdioCharState *stdio = chr->opaque;
1971     int                ret;
1972     DWORD              dwSize;
1973
1974     while (1) {
1975
1976         /* Wait for one byte */
1977         ret = ReadFile(stdio->hStdIn, &stdio->win_stdio_buf, 1, &dwSize, NULL);
1978
1979         /* Exit in case of error, continue if nothing read */
1980         if (!ret) {
1981             break;
1982         }
1983         if (!dwSize) {
1984             continue;
1985         }
1986
1987         /* Some terminal emulator returns \r\n for Enter, just pass \n */
1988         if (stdio->win_stdio_buf == '\r') {
1989             continue;
1990         }
1991
1992         /* Signal the main thread and wait until the byte was eaten */
1993         if (!SetEvent(stdio->hInputReadyEvent)) {
1994             break;
1995         }
1996         if (WaitForSingleObject(stdio->hInputDoneEvent, INFINITE)
1997             != WAIT_OBJECT_0) {
1998             break;
1999         }
2000     }
2001
2002     qemu_del_wait_object(stdio->hInputReadyEvent, NULL, NULL);
2003     return 0;
2004 }
2005
2006 static void win_stdio_thread_wait_func(void *opaque)
2007 {
2008     CharDriverState   *chr   = opaque;
2009     WinStdioCharState *stdio = chr->opaque;
2010
2011     if (qemu_chr_be_can_write(chr)) {
2012         qemu_chr_be_write(chr, &stdio->win_stdio_buf, 1);
2013     }
2014
2015     SetEvent(stdio->hInputDoneEvent);
2016 }
2017
2018 static void qemu_chr_set_echo_win_stdio(CharDriverState *chr, bool echo)
2019 {
2020     WinStdioCharState *stdio  = chr->opaque;
2021     DWORD              dwMode = 0;
2022
2023     GetConsoleMode(stdio->hStdIn, &dwMode);
2024
2025     if (echo) {
2026         SetConsoleMode(stdio->hStdIn, dwMode | ENABLE_ECHO_INPUT);
2027     } else {
2028         SetConsoleMode(stdio->hStdIn, dwMode & ~ENABLE_ECHO_INPUT);
2029     }
2030 }
2031
2032 static void win_stdio_close(CharDriverState *chr)
2033 {
2034     WinStdioCharState *stdio = chr->opaque;
2035
2036     if (stdio->hInputReadyEvent != INVALID_HANDLE_VALUE) {
2037         CloseHandle(stdio->hInputReadyEvent);
2038     }
2039     if (stdio->hInputDoneEvent != INVALID_HANDLE_VALUE) {
2040         CloseHandle(stdio->hInputDoneEvent);
2041     }
2042     if (stdio->hInputThread != INVALID_HANDLE_VALUE) {
2043         TerminateThread(stdio->hInputThread, 0);
2044     }
2045
2046     g_free(chr->opaque);
2047     g_free(chr);
2048 }
2049
2050 static CharDriverState *qemu_chr_open_win_stdio(QemuOpts *opts)
2051 {
2052     CharDriverState   *chr;
2053     WinStdioCharState *stdio;
2054     DWORD              dwMode;
2055     int                is_console = 0;
2056
2057     chr   = g_malloc0(sizeof(CharDriverState));
2058     stdio = g_malloc0(sizeof(WinStdioCharState));
2059
2060     stdio->hStdIn = GetStdHandle(STD_INPUT_HANDLE);
2061     if (stdio->hStdIn == INVALID_HANDLE_VALUE) {
2062         fprintf(stderr, "cannot open stdio: invalid handle\n");
2063         exit(1);
2064     }
2065
2066     is_console = GetConsoleMode(stdio->hStdIn, &dwMode) != 0;
2067
2068     chr->opaque    = stdio;
2069     chr->chr_write = win_stdio_write;
2070     chr->chr_close = win_stdio_close;
2071
2072     if (is_console) {
2073         if (qemu_add_wait_object(stdio->hStdIn,
2074                                  win_stdio_wait_func, chr)) {
2075             fprintf(stderr, "qemu_add_wait_object: failed\n");
2076         }
2077     } else {
2078         DWORD   dwId;
2079
2080         stdio->hInputReadyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
2081         stdio->hInputDoneEvent  = CreateEvent(NULL, FALSE, FALSE, NULL);
2082         stdio->hInputThread     = CreateThread(NULL, 0, win_stdio_thread,
2083                                                chr, 0, &dwId);
2084
2085         if (stdio->hInputThread == INVALID_HANDLE_VALUE
2086             || stdio->hInputReadyEvent == INVALID_HANDLE_VALUE
2087             || stdio->hInputDoneEvent == INVALID_HANDLE_VALUE) {
2088             fprintf(stderr, "cannot create stdio thread or event\n");
2089             exit(1);
2090         }
2091         if (qemu_add_wait_object(stdio->hInputReadyEvent,
2092                                  win_stdio_thread_wait_func, chr)) {
2093             fprintf(stderr, "qemu_add_wait_object: failed\n");
2094         }
2095     }
2096
2097     dwMode |= ENABLE_LINE_INPUT;
2098
2099     if (is_console) {
2100         /* set the terminal in raw mode */
2101         /* ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS */
2102         dwMode |= ENABLE_PROCESSED_INPUT;
2103     }
2104
2105     SetConsoleMode(stdio->hStdIn, dwMode);
2106
2107     chr->chr_set_echo = qemu_chr_set_echo_win_stdio;
2108     qemu_chr_fe_set_echo(chr, false);
2109
2110     return chr;
2111 }
2112 #endif /* !_WIN32 */
2113
2114 /***********************************************************/
2115 /* UDP Net console */
2116
2117 typedef struct {
2118     int fd;
2119     uint8_t buf[READ_BUF_LEN];
2120     int bufcnt;
2121     int bufptr;
2122     int max_size;
2123 } NetCharDriver;
2124
2125 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2126 {
2127     NetCharDriver *s = chr->opaque;
2128
2129     return send(s->fd, (const void *)buf, len, 0);
2130 }
2131
2132 static int udp_chr_read_poll(void *opaque)
2133 {
2134     CharDriverState *chr = opaque;
2135     NetCharDriver *s = chr->opaque;
2136
2137     s->max_size = qemu_chr_be_can_write(chr);
2138
2139     /* If there were any stray characters in the queue process them
2140      * first
2141      */
2142     while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2143         qemu_chr_be_write(chr, &s->buf[s->bufptr], 1);
2144         s->bufptr++;
2145         s->max_size = qemu_chr_be_can_write(chr);
2146     }
2147     return s->max_size;
2148 }
2149
2150 static void udp_chr_read(void *opaque)
2151 {
2152     CharDriverState *chr = opaque;
2153     NetCharDriver *s = chr->opaque;
2154
2155     if (s->max_size == 0)
2156         return;
2157     s->bufcnt = qemu_recv(s->fd, s->buf, sizeof(s->buf), 0);
2158     s->bufptr = s->bufcnt;
2159     if (s->bufcnt <= 0)
2160         return;
2161
2162     s->bufptr = 0;
2163     while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2164         qemu_chr_be_write(chr, &s->buf[s->bufptr], 1);
2165         s->bufptr++;
2166         s->max_size = qemu_chr_be_can_write(chr);
2167     }
2168 }
2169
2170 static void udp_chr_update_read_handler(CharDriverState *chr)
2171 {
2172     NetCharDriver *s = chr->opaque;
2173
2174     if (s->fd >= 0) {
2175         qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
2176                              udp_chr_read, NULL, chr);
2177     }
2178 }
2179
2180 static void udp_chr_close(CharDriverState *chr)
2181 {
2182     NetCharDriver *s = chr->opaque;
2183     if (s->fd >= 0) {
2184         qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2185         closesocket(s->fd);
2186     }
2187     g_free(s);
2188     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
2189 }
2190
2191 static CharDriverState *qemu_chr_open_udp(QemuOpts *opts)
2192 {
2193     CharDriverState *chr = NULL;
2194     NetCharDriver *s = NULL;
2195     Error *local_err = NULL;
2196     int fd = -1;
2197
2198     chr = g_malloc0(sizeof(CharDriverState));
2199     s = g_malloc0(sizeof(NetCharDriver));
2200
2201     fd = inet_dgram_opts(opts, &local_err);
2202     if (fd < 0) {
2203         goto return_err;
2204     }
2205
2206     s->fd = fd;
2207     s->bufcnt = 0;
2208     s->bufptr = 0;
2209     chr->opaque = s;
2210     chr->chr_write = udp_chr_write;
2211     chr->chr_update_read_handler = udp_chr_update_read_handler;
2212     chr->chr_close = udp_chr_close;
2213     return chr;
2214
2215 return_err:
2216     if (local_err) {
2217         qerror_report_err(local_err);
2218         error_free(local_err);
2219     }
2220     g_free(chr);
2221     g_free(s);
2222     if (fd >= 0) {
2223         closesocket(fd);
2224     }
2225     return NULL;
2226 }
2227
2228 /***********************************************************/
2229 /* TCP Net console */
2230
2231 typedef struct {
2232     int fd, listen_fd;
2233     int connected;
2234     int max_size;
2235     int do_telnetopt;
2236     int do_nodelay;
2237     int is_unix;
2238     int msgfd;
2239 } TCPCharDriver;
2240
2241 static void tcp_chr_accept(void *opaque);
2242
2243 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2244 {
2245     TCPCharDriver *s = chr->opaque;
2246     if (s->connected) {
2247         return send_all(s->fd, buf, len);
2248     } else {
2249         /* XXX: indicate an error ? */
2250         return len;
2251     }
2252 }
2253
2254 static int tcp_chr_read_poll(void *opaque)
2255 {
2256     CharDriverState *chr = opaque;
2257     TCPCharDriver *s = chr->opaque;
2258     if (!s->connected)
2259         return 0;
2260     s->max_size = qemu_chr_be_can_write(chr);
2261     return s->max_size;
2262 }
2263
2264 #define IAC 255
2265 #define IAC_BREAK 243
2266 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
2267                                       TCPCharDriver *s,
2268                                       uint8_t *buf, int *size)
2269 {
2270     /* Handle any telnet client's basic IAC options to satisfy char by
2271      * char mode with no echo.  All IAC options will be removed from
2272      * the buf and the do_telnetopt variable will be used to track the
2273      * state of the width of the IAC information.
2274      *
2275      * IAC commands come in sets of 3 bytes with the exception of the
2276      * "IAC BREAK" command and the double IAC.
2277      */
2278
2279     int i;
2280     int j = 0;
2281
2282     for (i = 0; i < *size; i++) {
2283         if (s->do_telnetopt > 1) {
2284             if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
2285                 /* Double IAC means send an IAC */
2286                 if (j != i)
2287                     buf[j] = buf[i];
2288                 j++;
2289                 s->do_telnetopt = 1;
2290             } else {
2291                 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
2292                     /* Handle IAC break commands by sending a serial break */
2293                     qemu_chr_be_event(chr, CHR_EVENT_BREAK);
2294                     s->do_telnetopt++;
2295                 }
2296                 s->do_telnetopt++;
2297             }
2298             if (s->do_telnetopt >= 4) {
2299                 s->do_telnetopt = 1;
2300             }
2301         } else {
2302             if ((unsigned char)buf[i] == IAC) {
2303                 s->do_telnetopt = 2;
2304             } else {
2305                 if (j != i)
2306                     buf[j] = buf[i];
2307                 j++;
2308             }
2309         }
2310     }
2311     *size = j;
2312 }
2313
2314 static int tcp_get_msgfd(CharDriverState *chr)
2315 {
2316     TCPCharDriver *s = chr->opaque;
2317     int fd = s->msgfd;
2318     s->msgfd = -1;
2319     return fd;
2320 }
2321
2322 #ifndef _WIN32
2323 static void unix_process_msgfd(CharDriverState *chr, struct msghdr *msg)
2324 {
2325     TCPCharDriver *s = chr->opaque;
2326     struct cmsghdr *cmsg;
2327
2328     for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
2329         int fd;
2330
2331         if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)) ||
2332             cmsg->cmsg_level != SOL_SOCKET ||
2333             cmsg->cmsg_type != SCM_RIGHTS)
2334             continue;
2335
2336         fd = *((int *)CMSG_DATA(cmsg));
2337         if (fd < 0)
2338             continue;
2339
2340 #ifndef MSG_CMSG_CLOEXEC
2341         qemu_set_cloexec(fd);
2342 #endif
2343         if (s->msgfd != -1)
2344             close(s->msgfd);
2345         s->msgfd = fd;
2346     }
2347 }
2348
2349 static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
2350 {
2351     TCPCharDriver *s = chr->opaque;
2352     struct msghdr msg = { NULL, };
2353     struct iovec iov[1];
2354     union {
2355         struct cmsghdr cmsg;
2356         char control[CMSG_SPACE(sizeof(int))];
2357     } msg_control;
2358     int flags = 0;
2359     ssize_t ret;
2360
2361     iov[0].iov_base = buf;
2362     iov[0].iov_len = len;
2363
2364     msg.msg_iov = iov;
2365     msg.msg_iovlen = 1;
2366     msg.msg_control = &msg_control;
2367     msg.msg_controllen = sizeof(msg_control);
2368
2369 #ifdef MSG_CMSG_CLOEXEC
2370     flags |= MSG_CMSG_CLOEXEC;
2371 #endif
2372     ret = recvmsg(s->fd, &msg, flags);
2373     if (ret > 0 && s->is_unix) {
2374         unix_process_msgfd(chr, &msg);
2375     }
2376
2377     return ret;
2378 }
2379 #else
2380 static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
2381 {
2382     TCPCharDriver *s = chr->opaque;
2383     return qemu_recv(s->fd, buf, len, 0);
2384 }
2385 #endif
2386
2387 static void tcp_chr_read(void *opaque)
2388 {
2389     CharDriverState *chr = opaque;
2390     TCPCharDriver *s = chr->opaque;
2391     uint8_t buf[READ_BUF_LEN];
2392     int len, size;
2393
2394     if (!s->connected || s->max_size <= 0)
2395         return;
2396     len = sizeof(buf);
2397     if (len > s->max_size)
2398         len = s->max_size;
2399     size = tcp_chr_recv(chr, (void *)buf, len);
2400     if (size == 0) {
2401         /* connection closed */
2402         s->connected = 0;
2403         if (s->listen_fd >= 0) {
2404             qemu_set_fd_handler2(s->listen_fd, NULL, tcp_chr_accept, NULL, chr);
2405         }
2406         qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2407         closesocket(s->fd);
2408         s->fd = -1;
2409         qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
2410     } else if (size > 0) {
2411         if (s->do_telnetopt)
2412             tcp_chr_process_IAC_bytes(chr, s, buf, &size);
2413         if (size > 0)
2414             qemu_chr_be_write(chr, buf, size);
2415     }
2416 }
2417
2418 #ifndef _WIN32
2419 CharDriverState *qemu_chr_open_eventfd(int eventfd)
2420 {
2421     return qemu_chr_open_fd(eventfd, eventfd);
2422 }
2423 #endif
2424
2425 static void tcp_chr_connect(void *opaque)
2426 {
2427     CharDriverState *chr = opaque;
2428     TCPCharDriver *s = chr->opaque;
2429
2430     s->connected = 1;
2431     if (s->fd >= 0) {
2432         qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
2433                              tcp_chr_read, NULL, chr);
2434     }
2435     qemu_chr_generic_open(chr);
2436 }
2437
2438 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
2439 static void tcp_chr_telnet_init(int fd)
2440 {
2441     char buf[3];
2442     /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
2443     IACSET(buf, 0xff, 0xfb, 0x01);  /* IAC WILL ECHO */
2444     send(fd, (char *)buf, 3, 0);
2445     IACSET(buf, 0xff, 0xfb, 0x03);  /* IAC WILL Suppress go ahead */
2446     send(fd, (char *)buf, 3, 0);
2447     IACSET(buf, 0xff, 0xfb, 0x00);  /* IAC WILL Binary */
2448     send(fd, (char *)buf, 3, 0);
2449     IACSET(buf, 0xff, 0xfd, 0x00);  /* IAC DO Binary */
2450     send(fd, (char *)buf, 3, 0);
2451 }
2452
2453 static int tcp_chr_add_client(CharDriverState *chr, int fd)
2454 {
2455     TCPCharDriver *s = chr->opaque;
2456     if (s->fd != -1)
2457         return -1;
2458
2459     socket_set_nonblock(fd);
2460     if (s->do_nodelay)
2461         socket_set_nodelay(fd);
2462     s->fd = fd;
2463     qemu_set_fd_handler2(s->listen_fd, NULL, NULL, NULL, NULL);
2464     tcp_chr_connect(chr);
2465
2466     return 0;
2467 }
2468
2469 static void tcp_chr_accept(void *opaque)
2470 {
2471     CharDriverState *chr = opaque;
2472     TCPCharDriver *s = chr->opaque;
2473     struct sockaddr_in saddr;
2474 #ifndef _WIN32
2475     struct sockaddr_un uaddr;
2476 #endif
2477     struct sockaddr *addr;
2478     socklen_t len;
2479     int fd;
2480
2481     for(;;) {
2482 #ifndef _WIN32
2483         if (s->is_unix) {
2484             len = sizeof(uaddr);
2485             addr = (struct sockaddr *)&uaddr;
2486         } else
2487 #endif
2488         {
2489             len = sizeof(saddr);
2490             addr = (struct sockaddr *)&saddr;
2491         }
2492         fd = qemu_accept(s->listen_fd, addr, &len);
2493         if (fd < 0 && errno != EINTR) {
2494             return;
2495         } else if (fd >= 0) {
2496             if (s->do_telnetopt)
2497                 tcp_chr_telnet_init(fd);
2498             break;
2499         }
2500     }
2501     if (tcp_chr_add_client(chr, fd) < 0)
2502         close(fd);
2503 }
2504
2505 static void tcp_chr_close(CharDriverState *chr)
2506 {
2507     TCPCharDriver *s = chr->opaque;
2508     if (s->fd >= 0) {
2509         qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2510         closesocket(s->fd);
2511     }
2512     if (s->listen_fd >= 0) {
2513         qemu_set_fd_handler2(s->listen_fd, NULL, NULL, NULL, NULL);
2514         closesocket(s->listen_fd);
2515     }
2516     g_free(s);
2517     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
2518 }
2519
2520 static CharDriverState *qemu_chr_open_socket_fd(int fd, bool do_nodelay,
2521                                                 bool is_listen, bool is_telnet,
2522                                                 bool is_waitconnect,
2523                                                 Error **errp)
2524 {
2525     CharDriverState *chr = NULL;
2526     TCPCharDriver *s = NULL;
2527     char host[NI_MAXHOST], serv[NI_MAXSERV];
2528     const char *left = "", *right = "";
2529     struct sockaddr_storage ss;
2530     socklen_t ss_len = sizeof(ss);
2531
2532     memset(&ss, 0, ss_len);
2533     if (getsockname(fd, (struct sockaddr *) &ss, &ss_len) != 0) {
2534         error_setg(errp, "getsockname: %s", strerror(errno));
2535         return NULL;
2536     }
2537
2538     chr = g_malloc0(sizeof(CharDriverState));
2539     s = g_malloc0(sizeof(TCPCharDriver));
2540
2541     s->connected = 0;
2542     s->fd = -1;
2543     s->listen_fd = -1;
2544     s->msgfd = -1;
2545
2546     chr->filename = g_malloc(256);
2547     switch (ss.ss_family) {
2548 #ifndef _WIN32
2549     case AF_UNIX:
2550         s->is_unix = 1;
2551         snprintf(chr->filename, 256, "unix:%s%s",
2552                  ((struct sockaddr_un *)(&ss))->sun_path,
2553                  is_listen ? ",server" : "");
2554         break;
2555 #endif
2556     case AF_INET6:
2557         left  = "[";
2558         right = "]";
2559         /* fall through */
2560     case AF_INET:
2561         s->do_nodelay = do_nodelay;
2562         getnameinfo((struct sockaddr *) &ss, ss_len, host, sizeof(host),
2563                     serv, sizeof(serv), NI_NUMERICHOST | NI_NUMERICSERV);
2564         snprintf(chr->filename, 256, "%s:%s:%s%s%s%s",
2565                  is_telnet ? "telnet" : "tcp",
2566                  left, host, right, serv,
2567                  is_listen ? ",server" : "");
2568         break;
2569     }
2570
2571     chr->opaque = s;
2572     chr->chr_write = tcp_chr_write;
2573     chr->chr_close = tcp_chr_close;
2574     chr->get_msgfd = tcp_get_msgfd;
2575     chr->chr_add_client = tcp_chr_add_client;
2576
2577     if (is_listen) {
2578         s->listen_fd = fd;
2579         qemu_set_fd_handler2(s->listen_fd, NULL, tcp_chr_accept, NULL, chr);
2580         if (is_telnet) {
2581             s->do_telnetopt = 1;
2582         }
2583     } else {
2584         s->connected = 1;
2585         s->fd = fd;
2586         socket_set_nodelay(fd);
2587         tcp_chr_connect(chr);
2588     }
2589
2590     if (is_listen && is_waitconnect) {
2591         printf("QEMU waiting for connection on: %s\n",
2592                chr->filename);
2593         tcp_chr_accept(chr);
2594         socket_set_nonblock(s->listen_fd);
2595     }
2596     return chr;
2597 }
2598
2599 static CharDriverState *qemu_chr_open_socket(QemuOpts *opts)
2600 {
2601     CharDriverState *chr = NULL;
2602     Error *local_err = NULL;
2603     int fd = -1;
2604     int is_listen;
2605     int is_waitconnect;
2606     int do_nodelay;
2607     int is_unix;
2608     int is_telnet;
2609
2610     is_listen      = qemu_opt_get_bool(opts, "server", 0);
2611     is_waitconnect = qemu_opt_get_bool(opts, "wait", 1);
2612     is_telnet      = qemu_opt_get_bool(opts, "telnet", 0);
2613     do_nodelay     = !qemu_opt_get_bool(opts, "delay", 1);
2614     is_unix        = qemu_opt_get(opts, "path") != NULL;
2615     if (!is_listen)
2616         is_waitconnect = 0;
2617
2618     if (is_unix) {
2619         if (is_listen) {
2620             fd = unix_listen_opts(opts, &local_err);
2621         } else {
2622             fd = unix_connect_opts(opts, &local_err, NULL, NULL);
2623         }
2624     } else {
2625         if (is_listen) {
2626             fd = inet_listen_opts(opts, 0, &local_err);
2627         } else {
2628             fd = inet_connect_opts(opts, &local_err, NULL, NULL);
2629         }
2630     }
2631     if (fd < 0) {
2632         goto fail;
2633     }
2634
2635     if (!is_waitconnect)
2636         socket_set_nonblock(fd);
2637
2638     chr = qemu_chr_open_socket_fd(fd, do_nodelay, is_listen, is_telnet,
2639                                   is_waitconnect, &local_err);
2640     if (error_is_set(&local_err)) {
2641         goto fail;
2642     }
2643     return chr;
2644
2645
2646  fail:
2647     if (local_err) {
2648         qerror_report_err(local_err);
2649         error_free(local_err);
2650     }
2651     if (fd >= 0) {
2652         closesocket(fd);
2653     }
2654     if (chr) {
2655         g_free(chr->opaque);
2656         g_free(chr);
2657     }
2658     return NULL;
2659 }
2660
2661 /***********************************************************/
2662 /* Memory chardev */
2663 typedef struct {
2664     size_t outbuf_size;
2665     size_t outbuf_capacity;
2666     uint8_t *outbuf;
2667 } MemoryDriver;
2668
2669 static int mem_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2670 {
2671     MemoryDriver *d = chr->opaque;
2672
2673     /* TODO: the QString implementation has the same code, we should
2674      * introduce a generic way to do this in cutils.c */
2675     if (d->outbuf_capacity < d->outbuf_size + len) {
2676         /* grow outbuf */
2677         d->outbuf_capacity += len;
2678         d->outbuf_capacity *= 2;
2679         d->outbuf = g_realloc(d->outbuf, d->outbuf_capacity);
2680     }
2681
2682     memcpy(d->outbuf + d->outbuf_size, buf, len);
2683     d->outbuf_size += len;
2684
2685     return len;
2686 }
2687
2688 void qemu_chr_init_mem(CharDriverState *chr)
2689 {
2690     MemoryDriver *d;
2691
2692     d = g_malloc(sizeof(*d));
2693     d->outbuf_size = 0;
2694     d->outbuf_capacity = 4096;
2695     d->outbuf = g_malloc0(d->outbuf_capacity);
2696
2697     memset(chr, 0, sizeof(*chr));
2698     chr->opaque = d;
2699     chr->chr_write = mem_chr_write;
2700 }
2701
2702 QString *qemu_chr_mem_to_qs(CharDriverState *chr)
2703 {
2704     MemoryDriver *d = chr->opaque;
2705     return qstring_from_substr((char *) d->outbuf, 0, d->outbuf_size - 1);
2706 }
2707
2708 /* NOTE: this driver can not be closed with qemu_chr_delete()! */
2709 void qemu_chr_close_mem(CharDriverState *chr)
2710 {
2711     MemoryDriver *d = chr->opaque;
2712
2713     g_free(d->outbuf);
2714     g_free(chr->opaque);
2715     chr->opaque = NULL;
2716     chr->chr_write = NULL;
2717 }
2718
2719 size_t qemu_chr_mem_osize(const CharDriverState *chr)
2720 {
2721     const MemoryDriver *d = chr->opaque;
2722     return d->outbuf_size;
2723 }
2724
2725 /*********************************************************/
2726 /* Ring buffer chardev */
2727
2728 typedef struct {
2729     size_t size;
2730     size_t prod;
2731     size_t cons;
2732     uint8_t *cbuf;
2733 } RingBufCharDriver;
2734
2735 static size_t ringbuf_count(const CharDriverState *chr)
2736 {
2737     const RingBufCharDriver *d = chr->opaque;
2738
2739     return d->prod - d->cons;
2740 }
2741
2742 static int ringbuf_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2743 {
2744     RingBufCharDriver *d = chr->opaque;
2745     int i;
2746
2747     if (!buf || (len < 0)) {
2748         return -1;
2749     }
2750
2751     for (i = 0; i < len; i++ ) {
2752         d->cbuf[d->prod++ & (d->size - 1)] = buf[i];
2753         if (d->prod - d->cons > d->size) {
2754             d->cons = d->prod - d->size;
2755         }
2756     }
2757
2758     return 0;
2759 }
2760
2761 static int ringbuf_chr_read(CharDriverState *chr, uint8_t *buf, int len)
2762 {
2763     RingBufCharDriver *d = chr->opaque;
2764     int i;
2765
2766     for (i = 0; i < len && d->cons != d->prod; i++) {
2767         buf[i] = d->cbuf[d->cons++ & (d->size - 1)];
2768     }
2769
2770     return i;
2771 }
2772
2773 static void ringbuf_chr_close(struct CharDriverState *chr)
2774 {
2775     RingBufCharDriver *d = chr->opaque;
2776
2777     g_free(d->cbuf);
2778     g_free(d);
2779     chr->opaque = NULL;
2780 }
2781
2782 static CharDriverState *qemu_chr_open_ringbuf(QemuOpts *opts)
2783 {
2784     CharDriverState *chr;
2785     RingBufCharDriver *d;
2786
2787     chr = g_malloc0(sizeof(CharDriverState));
2788     d = g_malloc(sizeof(*d));
2789
2790     d->size = qemu_opt_get_size(opts, "size", 0);
2791     if (d->size == 0) {
2792         d->size = 65536;
2793     }
2794
2795     /* The size must be power of 2 */
2796     if (d->size & (d->size - 1)) {
2797         error_report("size of ringbuf device must be power of two");
2798         goto fail;
2799     }
2800
2801     d->prod = 0;
2802     d->cons = 0;
2803     d->cbuf = g_malloc0(d->size);
2804
2805     chr->opaque = d;
2806     chr->chr_write = ringbuf_chr_write;
2807     chr->chr_close = ringbuf_chr_close;
2808
2809     return chr;
2810
2811 fail:
2812     g_free(d);
2813     g_free(chr);
2814     return NULL;
2815 }
2816
2817 static bool chr_is_ringbuf(const CharDriverState *chr)
2818 {
2819     return chr->chr_write == ringbuf_chr_write;
2820 }
2821
2822 void qmp_ringbuf_write(const char *device, const char *data,
2823                        bool has_format, enum DataFormat format,
2824                        Error **errp)
2825 {
2826     CharDriverState *chr;
2827     const uint8_t *write_data;
2828     int ret;
2829     size_t write_count;
2830
2831     chr = qemu_chr_find(device);
2832     if (!chr) {
2833         error_setg(errp, "Device '%s' not found", device);
2834         return;
2835     }
2836
2837     if (!chr_is_ringbuf(chr)) {
2838         error_setg(errp,"%s is not a ringbuf device", device);
2839         return;
2840     }
2841
2842     if (has_format && (format == DATA_FORMAT_BASE64)) {
2843         write_data = g_base64_decode(data, &write_count);
2844     } else {
2845         write_data = (uint8_t *)data;
2846         write_count = strlen(data);
2847     }
2848
2849     ret = ringbuf_chr_write(chr, write_data, write_count);
2850
2851     if (write_data != (uint8_t *)data) {
2852         g_free((void *)write_data);
2853     }
2854
2855     if (ret < 0) {
2856         error_setg(errp, "Failed to write to device %s", device);
2857         return;
2858     }
2859 }
2860
2861 char *qmp_ringbuf_read(const char *device, int64_t size,
2862                        bool has_format, enum DataFormat format,
2863                        Error **errp)
2864 {
2865     CharDriverState *chr;
2866     uint8_t *read_data;
2867     size_t count;
2868     char *data;
2869
2870     chr = qemu_chr_find(device);
2871     if (!chr) {
2872         error_setg(errp, "Device '%s' not found", device);
2873         return NULL;
2874     }
2875
2876     if (!chr_is_ringbuf(chr)) {
2877         error_setg(errp,"%s is not a ringbuf device", device);
2878         return NULL;
2879     }
2880
2881     if (size <= 0) {
2882         error_setg(errp, "size must be greater than zero");
2883         return NULL;
2884     }
2885
2886     count = ringbuf_count(chr);
2887     size = size > count ? count : size;
2888     read_data = g_malloc(size + 1);
2889
2890     ringbuf_chr_read(chr, read_data, size);
2891
2892     if (has_format && (format == DATA_FORMAT_BASE64)) {
2893         data = g_base64_encode(read_data, size);
2894         g_free(read_data);
2895     } else {
2896         /*
2897          * FIXME should read only complete, valid UTF-8 characters up
2898          * to @size bytes.  Invalid sequences should be replaced by a
2899          * suitable replacement character.  Except when (and only
2900          * when) ring buffer lost characters since last read, initial
2901          * continuation characters should be dropped.
2902          */
2903         read_data[size] = 0;
2904         data = (char *)read_data;
2905     }
2906
2907     return data;
2908 }
2909
2910 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
2911 {
2912     char host[65], port[33], width[8], height[8];
2913     int pos;
2914     const char *p;
2915     QemuOpts *opts;
2916     Error *local_err = NULL;
2917
2918     opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
2919     if (error_is_set(&local_err)) {
2920         qerror_report_err(local_err);
2921         error_free(local_err);
2922         return NULL;
2923     }
2924
2925     if (strstart(filename, "mon:", &p)) {
2926         filename = p;
2927         qemu_opt_set(opts, "mux", "on");
2928     }
2929
2930     if (strcmp(filename, "null")    == 0 ||
2931         strcmp(filename, "pty")     == 0 ||
2932         strcmp(filename, "msmouse") == 0 ||
2933         strcmp(filename, "braille") == 0 ||
2934         strcmp(filename, "stdio")   == 0) {
2935         qemu_opt_set(opts, "backend", filename);
2936         return opts;
2937     }
2938     if (strstart(filename, "vc", &p)) {
2939         qemu_opt_set(opts, "backend", "vc");
2940         if (*p == ':') {
2941             if (sscanf(p+1, "%8[0-9]x%8[0-9]", width, height) == 2) {
2942                 /* pixels */
2943                 qemu_opt_set(opts, "width", width);
2944                 qemu_opt_set(opts, "height", height);
2945             } else if (sscanf(p+1, "%8[0-9]Cx%8[0-9]C", width, height) == 2) {
2946                 /* chars */
2947                 qemu_opt_set(opts, "cols", width);
2948                 qemu_opt_set(opts, "rows", height);
2949             } else {
2950                 goto fail;
2951             }
2952         }
2953         return opts;
2954     }
2955     if (strcmp(filename, "con:") == 0) {
2956         qemu_opt_set(opts, "backend", "console");
2957         return opts;
2958     }
2959     if (strstart(filename, "COM", NULL)) {
2960         qemu_opt_set(opts, "backend", "serial");
2961         qemu_opt_set(opts, "path", filename);
2962         return opts;
2963     }
2964     if (strstart(filename, "file:", &p)) {
2965         qemu_opt_set(opts, "backend", "file");
2966         qemu_opt_set(opts, "path", p);
2967         return opts;
2968     }
2969     if (strstart(filename, "pipe:", &p)) {
2970         qemu_opt_set(opts, "backend", "pipe");
2971         qemu_opt_set(opts, "path", p);
2972         return opts;
2973     }
2974     if (strstart(filename, "tcp:", &p) ||
2975         strstart(filename, "telnet:", &p)) {
2976         if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
2977             host[0] = 0;
2978             if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
2979                 goto fail;
2980         }
2981         qemu_opt_set(opts, "backend", "socket");
2982         qemu_opt_set(opts, "host", host);
2983         qemu_opt_set(opts, "port", port);
2984         if (p[pos] == ',') {
2985             if (qemu_opts_do_parse(opts, p+pos+1, NULL) != 0)
2986                 goto fail;
2987         }
2988         if (strstart(filename, "telnet:", &p))
2989             qemu_opt_set(opts, "telnet", "on");
2990         return opts;
2991     }
2992     if (strstart(filename, "udp:", &p)) {
2993         qemu_opt_set(opts, "backend", "udp");
2994         if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
2995             host[0] = 0;
2996             if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
2997                 goto fail;
2998             }
2999         }
3000         qemu_opt_set(opts, "host", host);
3001         qemu_opt_set(opts, "port", port);
3002         if (p[pos] == '@') {
3003             p += pos + 1;
3004             if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
3005                 host[0] = 0;
3006                 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
3007                     goto fail;
3008                 }
3009             }
3010             qemu_opt_set(opts, "localaddr", host);
3011             qemu_opt_set(opts, "localport", port);
3012         }
3013         return opts;
3014     }
3015     if (strstart(filename, "unix:", &p)) {
3016         qemu_opt_set(opts, "backend", "socket");
3017         if (qemu_opts_do_parse(opts, p, "path") != 0)
3018             goto fail;
3019         return opts;
3020     }
3021     if (strstart(filename, "/dev/parport", NULL) ||
3022         strstart(filename, "/dev/ppi", NULL)) {
3023         qemu_opt_set(opts, "backend", "parport");
3024         qemu_opt_set(opts, "path", filename);
3025         return opts;
3026     }
3027     if (strstart(filename, "/dev/", NULL)) {
3028         qemu_opt_set(opts, "backend", "tty");
3029         qemu_opt_set(opts, "path", filename);
3030         return opts;
3031     }
3032
3033 fail:
3034     qemu_opts_del(opts);
3035     return NULL;
3036 }
3037
3038 #ifdef HAVE_CHARDEV_PARPORT
3039
3040 static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
3041 {
3042     const char *filename = qemu_opt_get(opts, "path");
3043     int fd;
3044
3045     fd = qemu_open(filename, O_RDWR);
3046     if (fd < 0) {
3047         return NULL;
3048     }
3049     return qemu_chr_open_pp_fd(fd);
3050 }
3051
3052 #endif
3053
3054 static const struct {
3055     const char *name;
3056     CharDriverState *(*open)(QemuOpts *opts);
3057 } backend_table[] = {
3058     { .name = "null",      .open = qemu_chr_open_null },
3059     { .name = "socket",    .open = qemu_chr_open_socket },
3060     { .name = "udp",       .open = qemu_chr_open_udp },
3061     { .name = "msmouse",   .open = qemu_chr_open_msmouse },
3062     { .name = "vc",        .open = vc_init },
3063     { .name = "memory",    .open = qemu_chr_open_ringbuf },
3064 #ifdef _WIN32
3065     { .name = "file",      .open = qemu_chr_open_win_file_out },
3066     { .name = "pipe",      .open = qemu_chr_open_win_pipe },
3067     { .name = "console",   .open = qemu_chr_open_win_con },
3068     { .name = "serial",    .open = qemu_chr_open_win },
3069     { .name = "stdio",     .open = qemu_chr_open_win_stdio },
3070 #else
3071     { .name = "file",      .open = qemu_chr_open_file_out },
3072     { .name = "pipe",      .open = qemu_chr_open_pipe },
3073     { .name = "stdio",     .open = qemu_chr_open_stdio },
3074 #endif
3075 #ifdef CONFIG_BRLAPI
3076     { .name = "braille",   .open = chr_baum_init },
3077 #endif
3078 #ifdef HAVE_CHARDEV_TTY
3079     { .name = "tty",       .open = qemu_chr_open_tty },
3080     { .name = "serial",    .open = qemu_chr_open_tty },
3081     { .name = "pty",       .open = qemu_chr_open_pty },
3082 #endif
3083 #ifdef HAVE_CHARDEV_PARPORT
3084     { .name = "parallel",  .open = qemu_chr_open_pp },
3085     { .name = "parport",   .open = qemu_chr_open_pp },
3086 #endif
3087 #ifdef CONFIG_SPICE
3088     { .name = "spicevmc",     .open = qemu_chr_open_spice },
3089 #if SPICE_SERVER_VERSION >= 0x000c02
3090     { .name = "spiceport",    .open = qemu_chr_open_spice_port },
3091 #endif
3092 #endif
3093 };
3094
3095 CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
3096                                     void (*init)(struct CharDriverState *s),
3097                                     Error **errp)
3098 {
3099     CharDriverState *chr;
3100     int i;
3101
3102     if (qemu_opts_id(opts) == NULL) {
3103         error_setg(errp, "chardev: no id specified");
3104         goto err;
3105     }
3106
3107     if (qemu_opt_get(opts, "backend") == NULL) {
3108         error_setg(errp, "chardev: \"%s\" missing backend",
3109                    qemu_opts_id(opts));
3110         goto err;
3111     }
3112     for (i = 0; i < ARRAY_SIZE(backend_table); i++) {
3113         if (strcmp(backend_table[i].name, qemu_opt_get(opts, "backend")) == 0)
3114             break;
3115     }
3116     if (i == ARRAY_SIZE(backend_table)) {
3117         error_setg(errp, "chardev: backend \"%s\" not found",
3118                    qemu_opt_get(opts, "backend"));
3119         goto err;
3120     }
3121
3122     chr = backend_table[i].open(opts);
3123     if (!chr) {
3124         error_setg(errp, "chardev: opening backend \"%s\" failed",
3125                    qemu_opt_get(opts, "backend"));
3126         goto err;
3127     }
3128
3129     if (!chr->filename)
3130         chr->filename = g_strdup(qemu_opt_get(opts, "backend"));
3131     chr->init = init;
3132     QTAILQ_INSERT_TAIL(&chardevs, chr, next);
3133
3134     if (qemu_opt_get_bool(opts, "mux", 0)) {
3135         CharDriverState *base = chr;
3136         int len = strlen(qemu_opts_id(opts)) + 6;
3137         base->label = g_malloc(len);
3138         snprintf(base->label, len, "%s-base", qemu_opts_id(opts));
3139         chr = qemu_chr_open_mux(base);
3140         chr->filename = base->filename;
3141         chr->avail_connections = MAX_MUX;
3142         QTAILQ_INSERT_TAIL(&chardevs, chr, next);
3143     } else {
3144         chr->avail_connections = 1;
3145     }
3146     chr->label = g_strdup(qemu_opts_id(opts));
3147     chr->opts = opts;
3148     return chr;
3149
3150 err:
3151     qemu_opts_del(opts);
3152     return NULL;
3153 }
3154
3155 CharDriverState *qemu_chr_new(const char *label, const char *filename, void (*init)(struct CharDriverState *s))
3156 {
3157     const char *p;
3158     CharDriverState *chr;
3159     QemuOpts *opts;
3160     Error *err = NULL;
3161
3162     if (strstart(filename, "chardev:", &p)) {
3163         return qemu_chr_find(p);
3164     }
3165
3166     opts = qemu_chr_parse_compat(label, filename);
3167     if (!opts)
3168         return NULL;
3169
3170     chr = qemu_chr_new_from_opts(opts, init, &err);
3171     if (error_is_set(&err)) {
3172         fprintf(stderr, "%s\n", error_get_pretty(err));
3173         error_free(err);
3174     }
3175     if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
3176         monitor_init(chr, MONITOR_USE_READLINE);
3177     }
3178     return chr;
3179 }
3180
3181 void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo)
3182 {
3183     if (chr->chr_set_echo) {
3184         chr->chr_set_echo(chr, echo);
3185     }
3186 }
3187
3188 void qemu_chr_fe_open(struct CharDriverState *chr)
3189 {
3190     if (chr->chr_guest_open) {
3191         chr->chr_guest_open(chr);
3192     }
3193 }
3194
3195 void qemu_chr_fe_close(struct CharDriverState *chr)
3196 {
3197     if (chr->chr_guest_close) {
3198         chr->chr_guest_close(chr);
3199     }
3200 }
3201
3202 void qemu_chr_delete(CharDriverState *chr)
3203 {
3204     QTAILQ_REMOVE(&chardevs, chr, next);
3205     if (chr->chr_close) {
3206         chr->chr_close(chr);
3207     }
3208     g_free(chr->filename);
3209     g_free(chr->label);
3210     if (chr->opts) {
3211         qemu_opts_del(chr->opts);
3212     }
3213     g_free(chr);
3214 }
3215
3216 ChardevInfoList *qmp_query_chardev(Error **errp)
3217 {
3218     ChardevInfoList *chr_list = NULL;
3219     CharDriverState *chr;
3220
3221     QTAILQ_FOREACH(chr, &chardevs, next) {
3222         ChardevInfoList *info = g_malloc0(sizeof(*info));
3223         info->value = g_malloc0(sizeof(*info->value));
3224         info->value->label = g_strdup(chr->label);
3225         info->value->filename = g_strdup(chr->filename);
3226
3227         info->next = chr_list;
3228         chr_list = info;
3229     }
3230
3231     return chr_list;
3232 }
3233
3234 CharDriverState *qemu_chr_find(const char *name)
3235 {
3236     CharDriverState *chr;
3237
3238     QTAILQ_FOREACH(chr, &chardevs, next) {
3239         if (strcmp(chr->label, name) != 0)
3240             continue;
3241         return chr;
3242     }
3243     return NULL;
3244 }
3245
3246 /* Get a character (serial) device interface.  */
3247 CharDriverState *qemu_char_get_next_serial(void)
3248 {
3249     static int next_serial;
3250
3251     /* FIXME: This function needs to go away: use chardev properties!  */
3252     return serial_hds[next_serial++];
3253 }
3254
3255 QemuOptsList qemu_chardev_opts = {
3256     .name = "chardev",
3257     .implied_opt_name = "backend",
3258     .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
3259     .desc = {
3260         {
3261             .name = "backend",
3262             .type = QEMU_OPT_STRING,
3263         },{
3264             .name = "path",
3265             .type = QEMU_OPT_STRING,
3266         },{
3267             .name = "host",
3268             .type = QEMU_OPT_STRING,
3269         },{
3270             .name = "port",
3271             .type = QEMU_OPT_STRING,
3272         },{
3273             .name = "localaddr",
3274             .type = QEMU_OPT_STRING,
3275         },{
3276             .name = "localport",
3277             .type = QEMU_OPT_STRING,
3278         },{
3279             .name = "to",
3280             .type = QEMU_OPT_NUMBER,
3281         },{
3282             .name = "ipv4",
3283             .type = QEMU_OPT_BOOL,
3284         },{
3285             .name = "ipv6",
3286             .type = QEMU_OPT_BOOL,
3287         },{
3288             .name = "wait",
3289             .type = QEMU_OPT_BOOL,
3290         },{
3291             .name = "server",
3292             .type = QEMU_OPT_BOOL,
3293         },{
3294             .name = "delay",
3295             .type = QEMU_OPT_BOOL,
3296         },{
3297             .name = "telnet",
3298             .type = QEMU_OPT_BOOL,
3299         },{
3300             .name = "width",
3301             .type = QEMU_OPT_NUMBER,
3302         },{
3303             .name = "height",
3304             .type = QEMU_OPT_NUMBER,
3305         },{
3306             .name = "cols",
3307             .type = QEMU_OPT_NUMBER,
3308         },{
3309             .name = "rows",
3310             .type = QEMU_OPT_NUMBER,
3311         },{
3312             .name = "mux",
3313             .type = QEMU_OPT_BOOL,
3314         },{
3315             .name = "signal",
3316             .type = QEMU_OPT_BOOL,
3317         },{
3318             .name = "name",
3319             .type = QEMU_OPT_STRING,
3320         },{
3321             .name = "debug",
3322             .type = QEMU_OPT_NUMBER,
3323         },{
3324             .name = "size",
3325             .type = QEMU_OPT_SIZE,
3326         },
3327         { /* end of list */ }
3328     },
3329 };
3330
3331 #ifdef _WIN32
3332
3333 static CharDriverState *qmp_chardev_open_file(ChardevFile *file, Error **errp)
3334 {
3335     HANDLE out;
3336
3337     if (file->in) {
3338         error_setg(errp, "input file not supported");
3339         return NULL;
3340     }
3341
3342     out = CreateFile(file->out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
3343                      OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
3344     if (out == INVALID_HANDLE_VALUE) {
3345         error_setg(errp, "open %s failed", file->out);
3346         return NULL;
3347     }
3348     return qemu_chr_open_win_file(out);
3349 }
3350
3351 static CharDriverState *qmp_chardev_open_serial(ChardevHostdev *serial,
3352                                                 Error **errp)
3353 {
3354     return qemu_chr_open_win_path(serial->device);
3355 }
3356
3357 static CharDriverState *qmp_chardev_open_parallel(ChardevHostdev *parallel,
3358                                                   Error **errp)
3359 {
3360     error_setg(errp, "character device backend type 'parallel' not supported");
3361     return NULL;
3362 }
3363
3364 #else /* WIN32 */
3365
3366 static int qmp_chardev_open_file_source(char *src, int flags,
3367                                         Error **errp)
3368 {
3369     int fd = -1;
3370
3371     TFR(fd = qemu_open(src, flags, 0666));
3372     if (fd == -1) {
3373         error_setg(errp, "open %s: %s", src, strerror(errno));
3374     }
3375     return fd;
3376 }
3377
3378 static CharDriverState *qmp_chardev_open_file(ChardevFile *file, Error **errp)
3379 {
3380     int flags, in = -1, out = -1;
3381
3382     flags = O_WRONLY | O_TRUNC | O_CREAT | O_BINARY;
3383     out = qmp_chardev_open_file_source(file->out, flags, errp);
3384     if (error_is_set(errp)) {
3385         return NULL;
3386     }
3387
3388     if (file->in) {
3389         flags = O_RDONLY;
3390         in = qmp_chardev_open_file_source(file->in, flags, errp);
3391         if (error_is_set(errp)) {
3392             qemu_close(out);
3393             return NULL;
3394         }
3395     }
3396
3397     return qemu_chr_open_fd(in, out);
3398 }
3399
3400 static CharDriverState *qmp_chardev_open_serial(ChardevHostdev *serial,
3401                                                 Error **errp)
3402 {
3403 #ifdef HAVE_CHARDEV_TTY
3404     int fd;
3405
3406     fd = qmp_chardev_open_file_source(serial->device, O_RDWR, errp);
3407     if (error_is_set(errp)) {
3408         return NULL;
3409     }
3410     socket_set_nonblock(fd);
3411     return qemu_chr_open_tty_fd(fd);
3412 #else
3413     error_setg(errp, "character device backend type 'serial' not supported");
3414     return NULL;
3415 #endif
3416 }
3417
3418 static CharDriverState *qmp_chardev_open_parallel(ChardevHostdev *parallel,
3419                                                   Error **errp)
3420 {
3421 #ifdef HAVE_CHARDEV_PARPORT
3422     int fd;
3423
3424     fd = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp);
3425     if (error_is_set(errp)) {
3426         return NULL;
3427     }
3428     return qemu_chr_open_pp_fd(fd);
3429 #else
3430     error_setg(errp, "character device backend type 'parallel' not supported");
3431     return NULL;
3432 #endif
3433 }
3434
3435 #endif /* WIN32 */
3436
3437 static CharDriverState *qmp_chardev_open_socket(ChardevSocket *sock,
3438                                                 Error **errp)
3439 {
3440     SocketAddress *addr = sock->addr;
3441     bool do_nodelay     = sock->has_nodelay ? sock->nodelay : false;
3442     bool is_listen      = sock->has_server  ? sock->server  : true;
3443     bool is_telnet      = sock->has_telnet  ? sock->telnet  : false;
3444     bool is_waitconnect = sock->has_wait    ? sock->wait    : false;
3445     int fd;
3446
3447     if (is_listen) {
3448         fd = socket_listen(addr, errp);
3449     } else {
3450         fd = socket_connect(addr, errp, NULL, NULL);
3451     }
3452     if (error_is_set(errp)) {
3453         return NULL;
3454     }
3455     return qemu_chr_open_socket_fd(fd, do_nodelay, is_listen,
3456                                    is_telnet, is_waitconnect, errp);
3457 }
3458
3459 ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
3460                                Error **errp)
3461 {
3462     ChardevReturn *ret = g_new0(ChardevReturn, 1);
3463     CharDriverState *chr = NULL;
3464
3465     chr = qemu_chr_find(id);
3466     if (chr) {
3467         error_setg(errp, "Chardev '%s' already exists", id);
3468         g_free(ret);
3469         return NULL;
3470     }
3471
3472     switch (backend->kind) {
3473     case CHARDEV_BACKEND_KIND_FILE:
3474         chr = qmp_chardev_open_file(backend->file, errp);
3475         break;
3476     case CHARDEV_BACKEND_KIND_SERIAL:
3477         chr = qmp_chardev_open_serial(backend->serial, errp);
3478         break;
3479     case CHARDEV_BACKEND_KIND_PARALLEL:
3480         chr = qmp_chardev_open_parallel(backend->parallel, errp);
3481         break;
3482     case CHARDEV_BACKEND_KIND_SOCKET:
3483         chr = qmp_chardev_open_socket(backend->socket, errp);
3484         break;
3485 #ifdef HAVE_CHARDEV_TTY
3486     case CHARDEV_BACKEND_KIND_PTY:
3487     {
3488         /* qemu_chr_open_pty sets "path" in opts */
3489         QemuOpts *opts;
3490         opts = qemu_opts_create_nofail(qemu_find_opts("chardev"));
3491         chr = qemu_chr_open_pty(opts);
3492         ret->pty = g_strdup(qemu_opt_get(opts, "path"));
3493         ret->has_pty = true;
3494         qemu_opts_del(opts);
3495         break;
3496     }
3497 #endif
3498     case CHARDEV_BACKEND_KIND_NULL:
3499         chr = qemu_chr_open_null(NULL);
3500         break;
3501     default:
3502         error_setg(errp, "unknown chardev backend (%d)", backend->kind);
3503         break;
3504     }
3505
3506     if (chr == NULL && !error_is_set(errp)) {
3507         error_setg(errp, "Failed to create chardev");
3508     }
3509     if (chr) {
3510         chr->label = g_strdup(id);
3511         chr->avail_connections = 1;
3512         QTAILQ_INSERT_TAIL(&chardevs, chr, next);
3513         return ret;
3514     } else {
3515         g_free(ret);
3516         return NULL;
3517     }
3518 }
3519
3520 void qmp_chardev_remove(const char *id, Error **errp)
3521 {
3522     CharDriverState *chr;
3523
3524     chr = qemu_chr_find(id);
3525     if (NULL == chr) {
3526         error_setg(errp, "Chardev '%s' not found", id);
3527         return;
3528     }
3529     if (chr->chr_can_read || chr->chr_read ||
3530         chr->chr_event || chr->handler_opaque) {
3531         error_setg(errp, "Chardev '%s' is busy", id);
3532         return;
3533     }
3534     qemu_chr_delete(chr);
3535 }