qemu-char.c

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