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