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